diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/buffer_sharing.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/buffer_sharing.h
new file mode 100644
index 0000000000000000000000000000000000000000..5867dd8d03193a5b95adf9ea45e3de1b61007527
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/buffer_sharing.h
@@ -0,0 +1,36 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_BUFFER_SHARING_H_
+#define XLA_SERVICE_GPU_BUFFER_SHARING_H_
+
+#include <optional>
+
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/shape_util.h"
+
+namespace xla {
+namespace gpu {
+std::optional<bool> FusionCanShareBufferHint(const HloInstruction* user,
+                                             const HloInstruction* operand,
+                                             const ShapeIndex& user_index);
+
+std::optional<bool> CanShareBufferHint(const HloInstruction* user,
+                                       const HloInstruction* operand,
+                                       const ShapeIndex& user_index);
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_BUFFER_SHARING_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/compile_module_to_llvm_ir.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/compile_module_to_llvm_ir.h
new file mode 100644
index 0000000000000000000000000000000000000000..64d73b81700f96b394368b39dd7f1610bd3deaed
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/compile_module_to_llvm_ir.h
@@ -0,0 +1,81 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_COMPILE_MODULE_TO_LLVM_IR_H_
+#define XLA_SERVICE_GPU_COMPILE_MODULE_TO_LLVM_IR_H_
+
+#include <memory>
+#include <optional>
+#include <string>
+#include <variant>
+#include <vector>
+
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/service/buffer_value.h"
+#include "xla/service/gpu/executable.pb.h"
+#include "xla/service/gpu/gpu_executable.h"
+#include "xla/service/hlo.pb.h"
+#include "xla/service/hlo_dataflow_analysis.h"
+#include "xla/statusor.h"
+#include "xla/stream_executor/device_description.h"
+#include "xla/stream_executor/stream_executor.h"
+#include "xla/util.h"
+
+namespace xla {
+namespace gpu {
+
+struct CompileModuleResults {
+  std::unique_ptr<llvm::Module> llvm_module;
+  std::unique_ptr<BufferAssignment> buffer_assignment;
+  std::vector<BufferAllocation> allocations;
+  std::variant<GpuExecutable::OwnedThunkSequence,
+               GpuExecutable::OwnedGpuRuntimeProgram,
+               GpuExecutable::OwnedGpu2RuntimeProgram>
+      executable;
+  EntryFunctionAttributes entry_func_attrs;
+  std::vector<GpuExecutable::ConstantInfo> constants;
+  absl::flat_hash_map<ShapeIndex, GpuExecutable::OutputInfo> output_info;
+  Shape output_shape;
+  std::string module_name;
+};
+
+// Removes all globals from the given module that are both uninitialized and
+// have no uses within that module.
+void RemoveUnusedAndUninitializedGlobals(
+    llvm::Module* llvm_module,
+    const std::vector<GpuExecutable::ConstantInfo>& constants);
+
+// Compile `hlo_module` using XLA GPU and return the LLVM module thus generated.
+// The GpuExecutable (and the Thunks that are part of it) are not returned.
+StatusOr<std::unique_ptr<llvm::Module>> CompileModuleToLlvmIr(
+    HloModule* hlo_module, llvm::LLVMContext* llvm_context,
+    const std::string& target_triple, const std::string& data_layout,
+    const std::string& platform_name, se::Platform::Id platform_id,
+    const se::DeviceDescription& gpu_device_info,
+    const BufferValue::SizeFunction& buffer_size_bytes_function);
+
+Status CompileModuleToLlvmIrImpl(
+    HloModule* hlo_module, llvm::LLVMContext* llvm_context,
+    const std::string& target_triple, const std::string& data_layout,
+    const std::string& platform_name, se::Platform::Id platform_id,
+    const se::DeviceDescription& gpu_device_info,
+    const HloDataflowAnalysis::CanShareBuffer& can_share_buffer_function,
+    const BufferValue::SizeFunction& buffer_size_bytes_function,
+    CompileModuleResults* results, se::StreamExecutor* stream_exec = nullptr);
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_COMPILE_MODULE_TO_LLVM_IR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/conditional_thunk.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/conditional_thunk.h
new file mode 100644
index 0000000000000000000000000000000000000000..044275b4b88848d1cf4cfaa3e2dab7a54d88fae9
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/conditional_thunk.h
@@ -0,0 +1,72 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_CONDITIONAL_THUNK_H_
+#define XLA_SERVICE_GPU_CONDITIONAL_THUNK_H_
+
+#include <memory>
+#include <vector>
+
+#include "absl/types/span.h"
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/service/gpu/buffer_allocations.h"
+#include "xla/service/gpu/sequential_thunk.h"
+#include "xla/service/gpu/thunk.h"
+#include "xla/stream_executor/stream_executor.h"
+
+namespace xla {
+namespace gpu {
+
+struct ConditionalThunkConfig {
+  bool branch_index_is_bool;
+  int64_t branch_count;
+  std::vector<std::unique_ptr<SequentialThunk>> branch_thunks;
+};
+
+// ConditionalThunk implements the conditional instruction on GPU by reading the
+// predicate of the conditional and executing the true or the false computation
+// depending on the value of the predicate.
+//
+// ConditionalThunk assumes that the buffers of the conditional result and the
+// result of the true and false computations share the same allocation. Also,
+// the buffers of the true operand of the conditional and that of the parameter
+// instruction of the true computation share the same allocation. Similarly, the
+// buffers of the false operand and that of the parameter instruction of the
+// false computation share the same allocation.
+class ConditionalThunk : public Thunk {
+ public:
+  ConditionalThunk(ThunkInfo thunk_info, ConditionalThunkConfig config,
+                   const BufferAllocation::Slice& branch_index_buffer_index);
+
+  ConditionalThunk(const ConditionalThunk&) = delete;
+  ConditionalThunk& operator=(const ConditionalThunk&) = delete;
+
+  Status Initialize(const GpuExecutable& executable,
+                    se::StreamExecutor* executor) override;
+  Status ExecuteOnStream(const ExecuteParams& params) override;
+
+  absl::Span<const std::unique_ptr<SequentialThunk>> branch_thunks() {
+    return config_.branch_thunks;
+  }
+
+ private:
+  const ConditionalThunkConfig config_;
+  BufferAllocation::Slice branch_index_buffer_index_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_CONDITIONAL_THUNK_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/conv_algorithm_picker.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/conv_algorithm_picker.h
new file mode 100644
index 0000000000000000000000000000000000000000..2850c0609e70a7eeeef3444d1c577875a4cae712
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/conv_algorithm_picker.h
@@ -0,0 +1,164 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_CONV_ALGORITHM_PICKER_H_
+#define XLA_SERVICE_GPU_CONV_ALGORITHM_PICKER_H_
+
+#include <optional>
+#include <string>
+#include <string_view>
+#include <vector>
+
+#include "xla/autotune_results.pb.h"
+#include "xla/autotuning.pb.h"
+#include "xla/hlo/ir/hlo_instructions.h"
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/service/gpu/autotuner_util.h"
+#include "xla/service/gpu/gpu_conv_runner.h"
+#include "xla/service/hlo_pass_interface.h"
+#include "xla/service/service_executable_run_options.h"
+#include "xla/stream_executor/device_memory_allocator.h"
+#include "xla/stream_executor/stream_executor.h"
+
+#if (defined(GOOGLE_CUDA) && GOOGLE_CUDA)
+#include "xla/stream_executor/gpu/redzone_allocator.h"
+#endif
+
+namespace xla {
+namespace gpu {
+
+// Choose the fastest algorithm for each conv.
+// Modifies CustomCalls to cudnn convolutions, choosing the best algorithm for
+// each and adding explicit scratch space to the CustomCalls.
+//
+// We pick the algorithm before fusion so that we can generate better HLO. After
+// GpuConvRewriter, our convolutions are CustomCalls which return a
+// tuple (conv_result, scratch_memory), and the each conv uses 0 bytes of
+// scratch:
+//
+//   customcall = (f32[...], f32[0])
+//   return gte(customcall, 0)
+//
+// The algorithm picker then chooses the best algorithm, and potentially
+// increases the scratch space.  It replaces customcall with new_tuple,
+// giving us the following:
+//
+//   new_customcall = (f32[...], f32[N])
+//   new_tuple = tuple(gte(new_customcall, 0), constant f32[0])
+//   return gte(new_tuple, 0)
+//
+// The new tuple and gte instructions can be simplified away, because
+// nobody is expected to use the scratch value.
+//
+// However, if we were to run GpuConvAlgorithmPicker after fusion
+// the gte(customcall, 0) would probably already be into a fusion node.  We
+// can't simplify across HloComputation boundaries, so in this case we
+// wouldn't be able to simplify away the new_tuple bits.
+//
+// It supports two modes: device and deviceless.
+// In device mode, we run autotuning on the device and store autotune results.
+//
+// In deviceless mode, we pass in some information related to the device and
+// use stored autotune results to rewrite convolutions. If the required autotune
+// result is not stored, then the performance of convolution will be suboptimal.
+class GpuConvAlgorithmPicker : public HloModulePass {
+ public:
+  explicit GpuConvAlgorithmPicker(AutotuneConfig config) : config_(config) {}
+
+  absl::string_view name() const override {
+    return "gpu-conv-algorithm-picker";
+  }
+
+  static bool IsEnabled(const HloModule* module) {
+    return module->config().debug_options().xla_gpu_autotune_level() != 0;
+  }
+
+  static bool IsCandidate(const HloInstruction* instr) {
+    return IsCustomCallToDnnConvolution(*instr);
+  }
+
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+
+  // Run autotuning on allocated buffers and pick the best algorithm.
+  StatusOr<AutotuneResult> PickBestAlgorithmWithAllocatedBuffer(
+      const AutotuneConfig& config, GpuConvConfig conv_config,
+      const ServiceExecutableRunOptions* run_options,
+      const DebugOptions& debug_options,
+      std::vector<se::DeviceMemoryBase> buffers,
+      std::vector<se::DeviceMemoryBase> result_buffers);
+
+ private:
+  StatusOr<bool> RunOnComputation(HloComputation* computation);
+  StatusOr<bool> RunOnInstruction(HloInstruction* instr);
+
+  StatusOr<AutotuneResult> PickBestAlgorithm(
+      const HloCustomCallInstruction* instr);
+  StatusOr<AutotuneResult> PickBestAlgorithmNoCache(
+      const HloCustomCallInstruction* instr);
+
+#if (defined(GOOGLE_CUDA) && GOOGLE_CUDA)
+  // Simple bundle of an algorithm and its output, for comparing results across
+  // autotuned algorithms.
+  struct ReferenceResult {
+    stream_executor::dnn::AlgorithmDesc algorithm;
+    std::vector<stream_executor::DeviceMemoryBase> buffers;
+  };
+
+  // Execution environment for autotuning. Runtime autotuning requires runtime
+  // information such as input/output buffers in order to run. It can be
+  // constructed from the autotuned instruction by FromInstruction.
+  struct AutotuneRuntimeArguments {
+    const Shape result_shape;
+    const HloModuleConfig hlo_module_config;
+    std::vector<se::DeviceMemoryBase> operand_buffers;
+    std::vector<se::DeviceMemoryBase> result_buffers;
+    se::RedzoneAllocator* input_output_allocator;
+    const GpuConvConfig gpu_conv_config;
+    std::optional<std::string> canonical_hlo;
+
+    static StatusOr<AutotuneRuntimeArguments> FromInstruction(
+        const HloCustomCallInstruction* instr,
+        se::DeviceMemoryAllocator* allocator, se::StreamExecutor* stream,
+        se::RedzoneAllocator* input_output_allocator);
+  };
+
+  StatusOr<AutotuneResult> AutotuneOneConvRunner(
+      se::Stream* stream, GenericConvRunner* runner,
+      std::optional<ReferenceResult>* reference_result,
+      absl::Span<const stream_executor::dnn::AlgorithmDesc> disabled_algos,
+      std::optional<AutotuneCacheKey> instruction_info,
+      const AutotuneRuntimeArguments& runtime_arguments);
+
+  // Pick the best algorithm for CUDA platform.
+  StatusOr<AutotuneResult> PickBestAlgorithmNoCacheCuda(
+      const HloCustomCallInstruction* instr, se::Stream* stream,
+      std::optional<AutotuneCacheKey> instruction_info,
+      const AutotuneRuntimeArguments& runtime_arguments);
+#endif
+
+  StatusOr<AutotuneResult> PickBestAlgorithmNoCacheRocm(
+      const HloCustomCallInstruction* instr,
+      se::DeviceMemoryAllocator* allocator, se::Stream* stream);
+
+ private:
+  AutotuneConfig config_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+#endif  // XLA_SERVICE_GPU_CONV_ALGORITHM_PICKER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/conv_layout_normalization.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/conv_layout_normalization.h
new file mode 100644
index 0000000000000000000000000000000000000000..52fd26c1fbf95b60e73f14f0646eecd03f2b726d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/conv_layout_normalization.h
@@ -0,0 +1,37 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_CONV_LAYOUT_NORMALIZATION_H_
+#define XLA_SERVICE_GPU_CONV_LAYOUT_NORMALIZATION_H_
+
+#include <functional>
+#include <optional>
+#include <utility>
+
+#include "absl/strings/string_view.h"
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/hlo/ir/hlo_instructions.h"
+#include "xla/statusor.h"
+
+namespace xla {
+namespace gpu {
+
+StatusOr<std::optional<HloInstruction*>> NormalizeLayoutForGpuCustomCalls(
+    HloCustomCallInstruction*);
+
+}  // end namespace gpu
+}  // end namespace xla
+
+#endif  // XLA_SERVICE_GPU_CONV_LAYOUT_NORMALIZATION_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/convolution_thunk.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/convolution_thunk.h
new file mode 100644
index 0000000000000000000000000000000000000000..d7f731302c1a949314725a837910618c109b4ff5
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/convolution_thunk.h
@@ -0,0 +1,95 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_CONVOLUTION_THUNK_H_
+#define XLA_SERVICE_GPU_CONVOLUTION_THUNK_H_
+
+#include <memory>
+#include <optional>
+
+#include "absl/container/flat_hash_map.h"
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/hlo/ir/hlo_instructions.h"
+#include "xla/service/buffer_assignment.h"
+#include "xla/service/gpu/buffer_allocations.h"
+#include "xla/service/gpu/gpu_conv_runner.h"
+#include "xla/service/gpu/gpu_executable.h"
+#include "xla/service/gpu/thunk.h"
+#include "xla/stream_executor/stream_executor.h"
+#include "xla/types.h"
+#include "xla/xla_data.pb.h"
+#include "tsl/platform/status.h"
+
+namespace xla {
+namespace gpu {
+
+// This class stores everything that StreamExecutor needs to launch a DNN
+// convolution. It is generated by IrEmitter.
+//
+// This is thread-compatible.
+class ConvolutionThunk : public Thunk {
+ public:
+  // Constructs a thunk for launching a DNN convolution.
+  //
+  // operand_slices should be in the same order as cudnn_call->operands().
+  ConvolutionThunk(ThunkInfo thunk_info, GpuConvConfig config,
+                   std::vector<BufferAllocation::Slice> operand_slices,
+                   std::vector<BufferAllocation::Slice> result_slices,
+                   BufferAllocation::Slice scratch_slice);
+
+  ConvolutionThunk(const ConvolutionThunk&) = delete;
+  ConvolutionThunk& operator=(const ConvolutionThunk&) = delete;
+
+  Status ExecuteOnStream(const ExecuteParams& params) override;
+
+ private:
+  std::vector<BufferAllocation::Slice> operand_buffers_;
+  std::vector<BufferAllocation::Slice> result_buffers_;
+  BufferAllocation::Slice scratch_buffer_;
+  GenericConvRunner& GetOrCreateRunner(const stream_executor::Stream* stream);
+
+  // Convolution config
+  const GpuConvConfig config_;
+  absl::Mutex mu_;
+  absl::flat_hash_map<const stream_executor::Stream*,
+                      std::unique_ptr<GenericConvRunner>>
+      runner_cache_ ABSL_GUARDED_BY(mu_);
+};
+
+// Launches the kernel that reorders input data for int8x32 convolutions.
+class ConvolutionReorderThunk : public Thunk {
+ public:
+  ConvolutionReorderThunk(ThunkInfo thunk_info, absl::Span<int64_t> filter_nchw,
+                          std::vector<BufferAllocation::Slice> operand_slices,
+                          std::vector<BufferAllocation::Slice> result_slices);
+
+  ConvolutionReorderThunk(const ConvolutionReorderThunk&) = delete;
+  ConvolutionReorderThunk& operator=(const ConvolutionReorderThunk&) = delete;
+
+  Status ExecuteOnStream(const ExecuteParams& params) override;
+
+ private:
+  static se::dnn::FilterDescriptor CreateFilterDescriptor(
+      absl::Span<int64_t> filter_nchw);
+
+  const se::dnn::FilterDescriptor filter_descriptor_;
+  std::vector<BufferAllocation::Slice> operand_buffers_;
+  std::vector<BufferAllocation::Slice> result_buffers_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_CONVOLUTION_THUNK_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/copy_fusion.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/copy_fusion.h
new file mode 100644
index 0000000000000000000000000000000000000000..fa9306ce7e3fde7bc1485161e2036a6766a62b46
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/copy_fusion.h
@@ -0,0 +1,46 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_COPY_FUSION_H_
+#define XLA_SERVICE_GPU_COPY_FUSION_H_
+
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/service/hlo_pass_interface.h"
+#include "xla/statusor.h"
+
+namespace xla {
+namespace gpu {
+
+// CopyFusion checks if a fusion is followed by multiple copies and if so, adds
+// those copies to the fusion, replacing the copies with get_tuple_elements.
+class CopyFusion : public HloModulePass {
+ public:
+  CopyFusion() = default;
+
+  absl::string_view name() const override { return "copy_fusion"; }
+
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+
+ private:
+  StatusOr<bool> DoCopyFusion(HloComputation* computation);
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_COPY_FUSION_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/copy_thunk.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/copy_thunk.h
new file mode 100644
index 0000000000000000000000000000000000000000..7576c81ca98ec652ed8d4c18828eadd7ee30d45b
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/copy_thunk.h
@@ -0,0 +1,70 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_COPY_THUNK_H_
+#define XLA_SERVICE_GPU_COPY_THUNK_H_
+
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/service/buffer_assignment.h"
+#include "xla/service/gpu/buffer_allocations.h"
+#include "xla/service/gpu/thunk.h"
+#include "xla/stream_executor/stream_executor.h"
+
+namespace xla {
+namespace gpu {
+
+// A thunk that copies data from a device buffer to another device buffer.
+class DeviceToDeviceCopyThunk : public Thunk {
+ public:
+  // Constructs a CopyThunk that copies host data from `source_buffer` to the
+  // device buffer `destination_buffer`. `mem_size` is the size of the data in
+  // bytes.
+  DeviceToDeviceCopyThunk(ThunkInfo thunk_info,
+                          const BufferAllocation::Slice& source_buffer,
+                          const BufferAllocation::Slice& destination_buffer,
+                          uint64_t mem_size, mlir::Value source_value,
+                          mlir::Value destination_value);
+
+  DeviceToDeviceCopyThunk(const DeviceToDeviceCopyThunk&) = delete;
+  DeviceToDeviceCopyThunk& operator=(const DeviceToDeviceCopyThunk&) = delete;
+
+  Status ExecuteOnStream(const ExecuteParams& params) override;
+
+  void ClearCompileTimeInfo() override {
+    Thunk::ClearCompileTimeInfo();
+    source_value_ = nullptr;
+    destination_value_ = nullptr;
+  }
+
+  const BufferAllocation::Slice& source() const { return source_buffer_; }
+  const BufferAllocation::Slice& destination() const {
+    return destination_buffer_;
+  }
+  uint64_t size_bytes() const { return mem_size_; }
+  mlir::Value source_value() const { return source_value_; }
+  mlir::Value destination_value() const { return destination_value_; }
+
+ private:
+  const BufferAllocation::Slice source_buffer_;
+  const BufferAllocation::Slice destination_buffer_;
+  const uint64_t mem_size_;
+  mlir::Value source_value_;
+  mlir::Value destination_value_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_COPY_THUNK_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/cublas_cudnn.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/cublas_cudnn.h
new file mode 100644
index 0000000000000000000000000000000000000000..4feaf28bb1f51c467b413912b9b51a8ff332e02f
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/cublas_cudnn.h
@@ -0,0 +1,205 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_CUBLAS_CUDNN_H_
+#define XLA_SERVICE_GPU_CUBLAS_CUDNN_H_
+
+#include "absl/strings/string_view.h"
+#include "xla/hlo/ir/hlo_instructions.h"
+#include "xla/hlo/ir/hlo_module.h"
+#include "tsl/platform/statusor.h"
+
+namespace xla {
+namespace gpu {
+
+// Different types of convolutions supported by cudnn.
+//
+// A way to think about these is that a convolution is defined by three arrays
+// -- the "input", the "filter", and the "output" -- and given any two of these,
+// we can compute the third.  For example, a backward-input convolution takes as
+// input a filter and an "output" and produces an "input" such that if one were
+// to do a forward convolution of "input" using filter, the result would be
+// something with the same shape as "output".
+//
+// This way of thinking is not correct if you look at the values produced. For
+// example, a backward-input convolution is not actually the mathematical
+// inverse of a forward convolution.  But it's right as far as the shapes and
+// "connectivity" (i.e. which elements of the input affect which elements of
+// the output) are concerned.
+enum class CudnnConvKind {
+  kForward,            // input  + filter => output
+  kBackwardInput,      // filter + output => input
+  kBackwardFilter,     // input  + output => filter
+  kForwardActivation,  // activation(conv(input, filter) + broadcast(bias) +
+                       // (optionally) side_input) => output
+  kForwardGraph,       // pointwise(...pointwise(conv(input, filter))...)
+                       // => output
+};
+
+enum class CudnnfMHAKind {
+  kBmmBmm,
+  kScaleBiasMaskSoftmax,
+  kScaleBiasMaskSoftmaxDropout,
+  kScaleMaskSoftmax,
+  kScaleMaskSoftmaxDropout,
+  kSoftmaxDropout,
+  kSoftmax,
+  kScaleBiasSoftmax,
+  kScaleBiasSoftmaxDropout,
+  kBackwardBmmBmm,
+  kBackwardScaleBiasMaskSoftmax,
+  kBackwardScaleBiasMaskSoftmaxDropout,
+  kBackwardScaleMaskSoftmax,
+  kBackwardScaleMaskSoftmaxDropout,
+  kBackwardSoftmaxDropout,
+  kBackwardSoftmax,
+  kBackwardScaleBiasSoftmax,
+  kBackwardScaleBiasSoftmaxDropout,
+};
+
+StatusOr<CudnnConvKind> GetCudnnConvKind(const HloCustomCallInstruction* instr);
+
+// Converts a CudnnConvKind value to a string.
+std::string CudnnConvKindToString(CudnnConvKind kind);
+
+// Matrix multiplication rewritten into a GEMM custom call.
+// All matrix multiplications should be rewritten as such custom calls
+// after a GemmRewriter lowering pass.
+bool IsCublasGemm(const HloInstruction& hlo);
+
+// Matrix multiplication that calls into legacy cublas.
+bool IsLegacyCublasMatmul(const HloInstruction& hlo);
+
+// Matrix multiplication that calls into cublasLt.
+bool IsCublasLtMatmul(const HloInstruction& hlo);
+
+// Scaled matrix multiplication in FP8. Calls into cublasLt.
+bool IsCublasLtMatmulF8(const HloInstruction& hlo);
+
+// A call to cuBLAS general matrix multiplication API.
+extern const absl::string_view kGemmCallTarget;
+
+// A call to cuBLAS Lt API matrix multiplication.
+extern const absl::string_view kCublasLtMatmulCallTarget;
+
+// A call to cuBLASLt for scaled matrix multiplication in FP8.
+extern const absl::string_view kCublasLtMatmulF8CallTarget;
+
+// A call to cuBLAS for a triangular solve.
+//
+// Like cudnn convolutions, this op returns a tuple (result, scratch_memory).
+extern const absl::string_view kTriangularSolveCallTarget;
+
+// A call to cuDNN for convolution (forward, backward filter, or backward input)
+// is represented as a CustomCall HLO with a call target equal to one of these
+// strings.
+//
+// These CustomCalls have window() and convolution_dimension_numbers() set like
+// regular convolution ops.  They have the same LHS and RHS operands, plus two
+// additional constant operands: an int64_t operand for the cudnn algorithm and
+// a bool operand for whether tensor_ops is enabled. A value of -1 for the cudnn
+// algorithm means that the implementation is free to choose the best algorithm
+// it can.
+//
+// These calls output a tuple (conv_result, scratch_memory), where conv_result
+// is the actual result of the convolution, and scratch_memory is temporary
+// memory used by cudnn.  Callers shouldn't inspect scratch_memory, as its value
+// is not well-defined.
+//
+// GpuConvRewriter lowers kConvolution HLOs to these custom calls.
+// When it does so, it chooses algorithm -1 and 0 bytes of scratch space.  Later
+// on in the pipeline, CudnnConvAlgorithmChooser chooses an explicit
+// algorithm for each conv and sets the amount of scratch space needed.
+//
+// (Representing the scratch memory as an output may seem strange at first, but
+// it's quite sensible, from a certain point of view.  The scratch buffer is a
+// location in memory that the conv can write into, but which it can't legally
+// read from, at least until it's written something first.  But that's exactly
+// the definition of an output buffer.)
+extern const absl::string_view kCudnnConvForwardCallTarget;
+extern const absl::string_view kCudnnConvBackwardInputCallTarget;
+extern const absl::string_view kCudnnConvBackwardFilterCallTarget;
+extern const absl::string_view kCudnnConvBiasActivationForwardCallTarget;
+extern const absl::string_view kCudnnConvForwardGraphCallTarget;
+
+// cuDNN specific convolution helper (emitted together with a int8x32
+// convolution, if reordering is required).
+extern const absl::string_view kCudnnConvReorderFilterCallTarget;
+extern const absl::string_view kCudnnConvReorderFilterAndBiasCallTarget;
+
+// Returns true if `hlo` will be implemented as a call to a cuDNN convolution
+// routine.
+//
+// This returns true if `hlo` is a CustomCall HLO with a call target equal to
+// one of the kCudnnConvFoo constants above, but returns *false* for HLOs with a
+// kConvolution opcode.
+bool IsCustomCallToDnnConvolution(const HloInstruction& hlo);
+
+// Returns true if `hlo` will be implemented as a call to cuDNN convolution
+// reordering helper (required for int8x32 convolutions).
+bool IsCudnnConvolutionReorder(const HloInstruction& hlo);
+
+// The fused_mha_rewriter phase where each of the MHA signatures are pattern
+// matched and rewritten into a custom-call with specific custom-call target.
+// The custom-call target specifies the MHA signature. For example,  BMM1 - Bias
+// - Scale - Mask - Softmax - BMM2 pattern can have the target as
+// cudnn$fmhaBiasScaleMaskSoftmax.
+// The fMHA signatures currently supported by cudnn are:
+// 1.BMM1 - BMM2
+// 2. BMM1 - Scale - Bias - Mask - Softmax - BMM2
+// 3. BMM1 - Scale - Bias - Mask - Softmax - Dropout - BMM2
+// 4. BMM1 - Scale - Mask - Softmax - BMM2
+// 5. BMM1 - Scale - Mask - Softmax - Dropout - BMM2
+// 6. BMM1 - Softmax - Dropout - BMM2
+// 7. BMM1 - Softmax - BMM2
+// 8. BMM1 - scale - Bias - Softmax - BMM2
+// Forward calls
+extern const absl::string_view kCudnnfMHABmmBmmCallTarget;
+extern const absl::string_view kCudnnfMHASoftmaxCallTarget;
+extern const absl::string_view kCudnnfMHAScaleBiasMaskSoftmaxCallTarget;
+extern const absl::string_view kCudnnfMHAScaleBiasMaskSoftmaxDropoutCallTarget;
+extern const absl::string_view kCudnnfMHAScaleMaskSoftmaxCallTarget;
+extern const absl::string_view kCudnnfMHAScaleMaskSoftmaxDropoutCallTarget;
+extern const absl::string_view kCudnnfMHASoftmaxDropoutCallTarget;
+extern const absl::string_view kCudnnfMHAScaleBiasSoftmaxDropoutCallTarget;
+extern const absl::string_view kCudnnfMHAScaleBiasSoftmaxCallTarget;
+// Backward calls
+extern const absl::string_view kCudnnfMHABmmBmmBackwardCallTarget;
+extern const absl::string_view kCudnnfMHASoftmaxBackwardCallTarget;
+extern const absl::string_view kCudnnfMHAScaleBiasMaskSoftmaxBackwardCallTarget;
+extern const absl::string_view
+    kCudnnfMHAScaleBiasMaskSoftmaxDropoutBackwardCallTarget;
+extern const absl::string_view kCudnnfMHAScaleMaskSoftmaxBackwardCallTarget;
+extern const absl::string_view
+    kCudnnfMHAScaleMaskSoftmaxDropoutBackwardCallTarget;
+extern const absl::string_view kCudnnfMHASoftmaxDropoutBackwardCallTarget;
+extern const absl::string_view
+    kCudnnfMHAScaleBiasSoftmaxDropoutBackwardCallTarget;
+extern const absl::string_view kCudnnfMHAScaleBiasSoftmaxBackwardCallTarget;
+
+bool IsFwdCustomCallTofMHA(const HloInstruction& hlo);
+bool IsBwdCustomCallTofMHA(const HloInstruction& hlo);
+bool IsCustomCallTofMHA(const HloInstruction& hlo);
+
+StatusOr<CudnnfMHAKind> GetCudnnfMHAKind(const HloCustomCallInstruction* instr);
+
+std::string CudnnfMHAKindToString(CudnnfMHAKind kind);
+Status SetFMHAInstructionName(HloModule* module, HloInstruction* fmha);
+
+bool MHACallHasDropout(absl::string_view fmha_call_name);
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_CUBLAS_CUDNN_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/cublas_lt_matmul_thunk.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/cublas_lt_matmul_thunk.h
new file mode 100644
index 0000000000000000000000000000000000000000..3098d18687d35aec6590366480a3a3dd7d3bc27e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/cublas_lt_matmul_thunk.h
@@ -0,0 +1,85 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_CUBLAS_LT_MATMUL_THUNK_H_
+#define XLA_SERVICE_GPU_CUBLAS_LT_MATMUL_THUNK_H_
+
+#include <memory>
+#include <optional>
+#include <utility>
+
+#include "xla/service/buffer_assignment.h"
+#include "xla/service/gpu/matmul_utils.h"
+#include "xla/service/gpu/thunk.h"
+#include "xla/status.h"
+#include "tsl/platform/statusor.h"
+#if GOOGLE_CUDA
+#include "xla/stream_executor/cuda/cuda_blas_lt.h"
+#else
+#include "rocm/rocm_config.h"
+#include "xla/stream_executor/rocm/hip_blas_lt.h"
+#endif  // GOOGLE_CUDA
+
+namespace xla {
+namespace gpu {
+
+class CublasLtMatmulThunk : public Thunk {
+ public:
+  CublasLtMatmulThunk(ThunkInfo thunk_info, GemmConfig gemm_config,
+                      se::gpu::BlasLt::Epilogue epilogue, int64_t algorithm_idx,
+                      BufferAllocation::Slice a_buffer,
+                      BufferAllocation::Slice b_buffer,
+                      BufferAllocation::Slice c_buffer,
+                      BufferAllocation::Slice d_buffer,
+                      BufferAllocation::Slice bias_buffer /* may be null */,
+                      BufferAllocation::Slice aux_buffer /* may be null */,
+                      BufferAllocation::Slice a_scale_buffer /* may be null */,
+                      BufferAllocation::Slice b_scale_buffer /* may be null */,
+                      BufferAllocation::Slice c_scale_buffer /* may be null */,
+                      BufferAllocation::Slice d_scale_buffer /* may be null */,
+                      BufferAllocation::Slice d_amax_buffer /* may be null */);
+
+  Status ExecuteOnStream(const ExecuteParams& params) override;
+
+ private:
+  StatusOr<cublas_lt::MatmulPlan*> GetMatmulPlan(
+      const stream_executor::Stream* stream);
+
+  absl::Mutex matmul_plans_cache_mutex_;
+  absl::flat_hash_map<const stream_executor::Stream*,
+                      std::unique_ptr<cublas_lt::MatmulPlan>>
+      matmul_plans_cache_ ABSL_GUARDED_BY(matmul_plans_cache_mutex_);
+
+  GemmConfig gemm_config_;
+  se::gpu::BlasLt::Epilogue epilogue_;
+  int64_t algorithm_idx_;
+  BufferAllocation::Slice a_buffer_;
+  BufferAllocation::Slice b_buffer_;
+  BufferAllocation::Slice c_buffer_;
+  BufferAllocation::Slice d_buffer_;
+  BufferAllocation::Slice bias_buffer_;
+  BufferAllocation::Slice aux_buffer_;
+  BufferAllocation::Slice a_scale_buffer_;
+  BufferAllocation::Slice b_scale_buffer_;
+  BufferAllocation::Slice c_scale_buffer_;
+  BufferAllocation::Slice d_scale_buffer_;
+  BufferAllocation::Slice d_amax_buffer_;
+  std::optional<se::gpu::BlasLt::MatmulAlgorithm> algorithm_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_CUBLAS_LT_MATMUL_THUNK_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/cublas_pad_for_gemms.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/cublas_pad_for_gemms.h
new file mode 100644
index 0000000000000000000000000000000000000000..758949c91eb9fb0bb37398bf34ee47db92b97c35
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/cublas_pad_for_gemms.h
@@ -0,0 +1,56 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_CUBLAS_PAD_FOR_GEMMS_H_
+#define XLA_SERVICE_GPU_CUBLAS_PAD_FOR_GEMMS_H_
+
+#include "xla/service/hlo_pass_interface.h"
+
+namespace xla {
+namespace gpu {
+
+// Adds padding to dot operations to make them run faster on GPUs.
+//
+//
+// This can be used to pad f16 dots on tensor cores, or s8 dots to multiples of
+// four.
+//
+// This pass depends on xla::DotDecomposer pass,
+// so it should go strictly later.
+class CublasPadForGemms : public HloModulePass {
+ public:
+  CublasPadForGemms(const se::CudaComputeCapability cuda_compute_capability,
+                    PrimitiveType datatype, int32_t pad_to_multiple_of)
+      : cuda_compute_capability_(cuda_compute_capability),
+        datatype_(datatype),
+        pad_to_multiple_of_(pad_to_multiple_of) {}
+
+  absl::string_view name() const override { return "cublas-pad-for-gemms"; }
+
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+
+ private:
+  const se::CudaComputeCapability cuda_compute_capability_;
+  PrimitiveType datatype_;
+  int32_t pad_to_multiple_of_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_CUBLAS_PAD_FOR_GEMMS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/cublas_padding_requirements.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/cublas_padding_requirements.h
new file mode 100644
index 0000000000000000000000000000000000000000..b0b44e61b57bbe68c29834d295a6ca5f4ddbc3c6
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/cublas_padding_requirements.h
@@ -0,0 +1,47 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_CUBLAS_PADDING_REQUIREMENTS_H_
+#define XLA_SERVICE_GPU_CUBLAS_PADDING_REQUIREMENTS_H_
+
+#include <array>
+#include <vector>
+
+#include "xla/hlo/ir/hlo_instructions.h"
+#include "xla/stream_executor/device_description.h"
+
+namespace xla {
+namespace gpu {
+
+struct CublasPaddingRequirement {
+  int min_compute_capability;
+  PrimitiveType data_type;
+  int multiple_of;
+};
+
+// List of padding requirements per compute capability and data type.
+constexpr std::array<CublasPaddingRequirement, 3> CublasPaddingRequirements{
+    {{se::CudaComputeCapability::VOLTA, S8, 4},
+     {se::CudaComputeCapability::VOLTA, F16, 8},
+     {se::CudaComputeCapability::AMPERE, BF16, 8}}};
+
+// Tell if either of the operands of the dot requires padding.
+bool CublasRequiresPadding(const HloDotInstruction& dot,
+                           se::CudaComputeCapability cc);
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_CUBLAS_PADDING_REQUIREMENTS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/cudnn_fused_conv_rewriter.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/cudnn_fused_conv_rewriter.h
new file mode 100644
index 0000000000000000000000000000000000000000..67c40792df08ad4527f8687afe4bace7d8fd1f23
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/cudnn_fused_conv_rewriter.h
@@ -0,0 +1,116 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_CUDNN_FUSED_CONV_REWRITER_H_
+#define XLA_SERVICE_GPU_CUDNN_FUSED_CONV_REWRITER_H_
+
+#include "xla/hlo/ir/hlo_instructions.h"
+#include "xla/service/hlo_pass_interface.h"
+
+namespace xla {
+namespace gpu {
+
+// Rewrites custom-calls targeting cudnnConvolutionForward to
+// cudnnConvolutionBiasActivationForward by fusing operations following forward
+// convolution.  This transform must run after cudnn_conv_rewriter.
+//
+// Semantics of underlying cudnn ops:
+//
+// https://docs.nvidia.com/deeplearning/cudnn/api/index.html#cudnnConvolutionBiasActivationForward
+// https://docs.nvidia.com/deeplearning/cudnn/developer-guide/index.html#scaling-parameters
+//
+// ## Floating-point convs
+//
+// A "complete" fused floating-point conv has the form
+//
+//   max(0, alpha1 * conv(x, w) + alpha2 * side_input + broadcast(bias)),
+//
+// which we fuse to
+//
+//   cudnnConvolutionBiasActivationForward(x, w, bias, side_input).
+//
+// You can leave out side_input, bias, alpha1, alpha2, and max(x, 0) and still
+// get a fused convolution.  alpha1/2 must be broadcasts of scalar constants.
+//
+// f16 convs accumulate in f32.  We represent this in HLO as an f32 convolution
+// whose inputs can be converted to f16 without loss of precision and whose
+// output is immediately converted to f16.  A fused f16 conv must follow one of
+// the following idioms.
+//
+//   1. convert_f16(conv_f32(x_f32, w_f32)) +
+//      side_input_f16 + broadcast(bias_f16)
+//
+//   2. convert_f16(conv_f32(x_f32, w_f32) +
+//                  side_input_f32 + broadcast(bias_f32))
+//
+// (These are not strictly mathematically equivalent, but cudnn doesn't tell us
+// which one it does, and we deem them "close enough".)
+//
+// The foo_f32 HLOs must all be losslessly-convertible to f16.  Some valid
+// examples:
+//
+//   - foo_f32 = convert_f32(foo_f16)
+//   - foo_f32 = an f32 constant whose values all fit within f16
+//   - foo_f32 = broadcast/transpose/reshape(one of the above)
+//
+// If you have a relu, it can appear before or after the convert_f16.
+//
+// Note that here `bias` must be losslessly-convertible to f16; this is
+// different than for s8 convolutions, where bias is f32.
+//
+// ## Integer convs
+//
+// In pure HLO, a "complete" integer conv is spelled as one of the following
+// `result`s.
+//
+//   base = alpha1_f32 * convert_f32(conv_s32(input_s32, filter_s32)) +
+//          alpha2_f32 * side_input +
+//          bias_f32
+//
+//   result_f32        = max(result_f32, 0)
+//   result_s8_option1 = max(convert_s8(clamp(-128, base, 127)), 0)
+//   result_s8_option2 = convert_s8(clamp(-128, max(base, 0), 127))
+//
+// The foo_s32 HLOs must be losslessly-convertible to s8.  If the `result_s8`
+// case, side_input should be an f32 HLO that's losslessly-convertible to s8;
+// otherwise, it should be losslessly-convertible to f32.
+//
+// In the `result_s8` case where there's no bias, side-input, or alpha1, you can
+// skip the convert_f32 on conv.
+//
+// If you have an integer convolution that doesn't fit one of these idioms, this
+// pass returns an error -- cudnn will not be able to run it.
+class CudnnFusedConvRewriter : public HloModulePass {
+ public:
+  explicit CudnnFusedConvRewriter(se::CudaComputeCapability cc)
+      : compute_capability_(cc) {}
+
+  absl::string_view name() const override {
+    return "cudnn-fused-convolution-rewriter";
+  }
+
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+
+ private:
+  const se::CudaComputeCapability compute_capability_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_CUDNN_FUSED_CONV_REWRITER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/cudnn_fused_mha_rewriter.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/cudnn_fused_mha_rewriter.h
new file mode 100644
index 0000000000000000000000000000000000000000..76704ff06ae1c4dd215dba8e6e0634df250fe654
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/cudnn_fused_mha_rewriter.h
@@ -0,0 +1,54 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_CUDNN_FUSED_MHA_REWRITER_H_
+#define XLA_SERVICE_GPU_CUDNN_FUSED_MHA_REWRITER_H_
+
+#include "xla/hlo/ir/hlo_instructions.h"
+#include "xla/service/hlo_pass_interface.h"
+#include "xla/stream_executor/dnn.h"
+
+namespace xla {
+namespace gpu {
+
+class CudnnFusedMHARewriter : public HloModulePass {
+ public:
+  explicit CudnnFusedMHARewriter(se::CudaComputeCapability cc,
+                                 se::StreamExecutor* stream_executor)
+      : compute_capability_(cc), stream_executor_(stream_executor) {}
+
+  explicit CudnnFusedMHARewriter(se::CudaComputeCapability cc,
+                                 se::dnn::VersionInfo cudnn_version)
+      : compute_capability_(cc), cudnn_version_(cudnn_version) {}
+
+  absl::string_view name() const override {
+    return "cudnn-fused-multi-headed-attention-rewriter";
+  }
+
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+
+ private:
+  const se::CudaComputeCapability compute_capability_;
+  se::StreamExecutor* stream_executor_ = nullptr;
+  const se::dnn::VersionInfo cudnn_version_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_CUDNN_FUSED_MHA_REWRITER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/cudnn_fused_mha_transpose_fusion.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/cudnn_fused_mha_transpose_fusion.h
new file mode 100644
index 0000000000000000000000000000000000000000..2cbdc041e82a68419d7581a950f6d7d135ccfe73
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/cudnn_fused_mha_transpose_fusion.h
@@ -0,0 +1,42 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_CUDNN_FUSED_MHA_TRANSPOSE_FUSION_H_
+#define XLA_SERVICE_GPU_CUDNN_FUSED_MHA_TRANSPOSE_FUSION_H_
+
+#include "xla/hlo/ir/hlo_instructions.h"
+#include "xla/service/hlo_pass_interface.h"
+
+namespace xla {
+namespace gpu {
+
+class CudnnFusedMHATransposeFusion : public HloModulePass {
+ public:
+  CudnnFusedMHATransposeFusion() = default;
+
+  absl::string_view name() const override {
+    return "cudnn-fused-multi-headed-attention-transpose-fusion";
+  }
+
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_CUDNN_FUSED_MHA_TRANSPOSE_FUSION_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/cudnn_pad_for_convolutions.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/cudnn_pad_for_convolutions.h
new file mode 100644
index 0000000000000000000000000000000000000000..dc403112632eec742e9dd1fdd36928c1d30c4961
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/cudnn_pad_for_convolutions.h
@@ -0,0 +1,53 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_CUDNN_PAD_FOR_CONVOLUTIONS_H_
+#define XLA_SERVICE_GPU_CUDNN_PAD_FOR_CONVOLUTIONS_H_
+
+#include "xla/hlo/ir/hlo_casting_utils.h"
+#include "xla/literal_util.h"
+#include "xla/service/gpu/ir_emission_utils.h"
+#include "xla/service/hlo_pass_interface.h"
+#include "xla/util.h"
+#include "xla/window_util.h"
+
+namespace xla {
+namespace gpu {
+
+// Two zero-paddings for CuDNN thunking are done in this transform: padding for
+// tensor cores and padding for integer convolutions.  This transform also
+// add slice instruction to remove unnecessary output features.
+class CudnnPadForConvolutions : public HloModulePass {
+ public:
+  explicit CudnnPadForConvolutions(se::CudaComputeCapability compute_capability)
+      : compute_capability_(compute_capability) {}
+
+  absl::string_view name() const override {
+    return "cudnn_pad_for_convolutions";
+  }
+  // Run PadForConvolutions on the given module and return if any change is made
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+
+ private:
+  const se::CudaComputeCapability compute_capability_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_CUDNN_PAD_FOR_CONVOLUTIONS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/cudnn_simplify_padding.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/cudnn_simplify_padding.h
new file mode 100644
index 0000000000000000000000000000000000000000..67b5d37316ec72ece02622f1275dc74cd75feb0d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/cudnn_simplify_padding.h
@@ -0,0 +1,64 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_CUDNN_SIMPLIFY_PADDING_H_
+#define XLA_SERVICE_GPU_CUDNN_SIMPLIFY_PADDING_H_
+
+#include "xla/service/hlo_pass_interface.h"
+#include "xla/statusor.h"
+
+namespace xla::gpu {
+
+// Simplifies or eliminates padding introduced by CudnnPadForConvolutions and
+// CudnnVectorizeConvolutions.
+//
+// CudnnVectorizeConvolutions will generate code that does the following.
+//  - pad input and output features to a multiple of 32 (or 4),
+//  - reshape input from [N,C,H,W] to [N,C/32,H,W,32] and reshape kernel from
+//    [I,O,H,W] to [I/32,32,O,H,W],
+//  - run the conv,
+//  - reshape output from [N,C/32,H,W,32] to [N,C,H,W], and finally
+//  - slice off the padding on the C channel.
+//
+// But if this is followed by another convolution (very common), then the slice
+// is immediately followed by another pad. This may be redundant; we know that
+// the trailing channels sliced off from the first conv are 0.
+//
+// Ideally we can eliminate the whole reshape+slice+pad+reshape sequence between
+// the two convolutions.
+//
+// Specifically, this pass tries to merge the slice at the end of the sequence
+// above into the pad from the next convolution (when we can prove that the
+// sliced-off elements are all 0). We then rely on algsimp to remove the pad if
+// it's a nop and then to merge and eliminate the remaining reshapes.
+//
+// This pass should run after CudnnVectorizeConvolutions and there should be no
+// simplification passes in between that modify the reshape-transpose-reshape
+// introduced by int8x32 convolution filter reordering.
+class CudnnSimplifyPadding : public HloModulePass {
+ public:
+  CudnnSimplifyPadding() = default;
+
+  absl::string_view name() const override { return "cudnn_simplify_padding"; }
+
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+};
+
+}  // namespace xla::gpu
+
+#endif  // XLA_SERVICE_GPU_CUDNN_SIMPLIFY_PADDING_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/cudnn_support_utils.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/cudnn_support_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..0ed4a88bdd21fc17ceeb5ef1966e61e81e19cab9
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/cudnn_support_utils.h
@@ -0,0 +1,74 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_CUDNN_SUPPORT_UTILS_H_
+#define XLA_SERVICE_GPU_CUDNN_SUPPORT_UTILS_H_
+
+#include <vector>
+
+#include "xla/hlo/ir/hlo_instructions.h"
+#include "xla/shape.h"
+#include "xla/stream_executor/device_description.h"
+#include "tsl/platform/status.h"
+
+namespace xla {
+namespace gpu {
+
+// Indicates whether the `compute_capability` supports an optimized integer
+// implementation of the given `conv` operation vectorized to `vector_size`.
+//
+// This function does not guarantee that a convolution will be padded and/or
+// vectorized. It only checks that it is a valid candiate for such optimization.
+StatusOr<bool> CudnnSupportsOptimizedIntegerConvolution(
+    const se::CudaComputeCapability& compute_capability,
+    HloCustomCallInstruction& conv, int vector_size);
+
+// Represents configuration for the reshape-transpose-reshape operations that
+// are equivalent to `cudnnReorderFilterAndBias`. This is used by int8x32
+// vectorized convolutions.
+//
+// For filter reordering the equivalent HLO is:
+//   %reshape = s8[$S] reshape(%input)
+//   %transpose = s8[I/32,H,W,O/8,2,8,4,4] transpose(%reshape), dimensions={$D}
+//   %result = s8[O,I/32,H,W,32] reshape(%transpose)
+//
+// For bias reordering the HLO is similar, but the op shapes are s8[O/32,4,2,4]
+// for %transpose, and s8[O/32,2,4,4] for %result.
+//
+// The helper functions below calculate the shape $S (transpose_shape) and
+// dimensions $D (permutation) from the convolution dimensions numbers config.
+// The result_shape is fixed and is present for the convenience.
+struct CudnnReorderTransposeConfig {
+  Shape transpose_shape;
+  Shape result_shape;
+  std::vector<int64_t> permutation;
+};
+
+// Create a transposition for an int8x32 convolution filter that effectively
+// does the same thing as cudnnReorderFilterAndBias, but could also be constant
+// folded or fused.
+StatusOr<CudnnReorderTransposeConfig> CudnnInferTransposeForFilterReordering(
+    const Shape& shape, const ConvolutionDimensionNumbers& dimension_numbers);
+
+// Create a transposition for an int8x32 convolution bias that effectively
+// does the same thing as cudnnReorderFilterAndBias, but could also be constant
+// folded or fused.
+StatusOr<CudnnReorderTransposeConfig> CudnnInferTransposeForBiasReordering(
+    const Shape& shape);
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_CUDNN_SUPPORT_UTILS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/cudnn_vectorize_convolutions.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/cudnn_vectorize_convolutions.h
new file mode 100644
index 0000000000000000000000000000000000000000..9721125cf23751c25eb5946a5e9a1466aed92bd4
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/cudnn_vectorize_convolutions.h
@@ -0,0 +1,71 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_CUDNN_VECTORIZE_CONVOLUTIONS_H_
+#define XLA_SERVICE_GPU_CUDNN_VECTORIZE_CONVOLUTIONS_H_
+
+#include <utility>
+
+#include "xla/service/hlo_pass_interface.h"
+#include "xla/statusor.h"
+#include "xla/stream_executor/dnn.h"
+
+namespace xla {
+namespace gpu {
+
+// Changes the shape of cudnn convolutions to allow faster "vectorized"
+// algorithms.
+//
+// On sm61+ will convert int8_t convolutions from
+//
+//   - [N, C, H, W] to [N, C/4, H, W, 4],
+//
+// assuming C is divisible by 4.
+//
+// On sm75+ will convert int8_t convolutions from
+//
+//   - [N, C, H, W]      to [N, C/32, H, W, 32],
+//   - [N, C/4, H, W, 4] to [N, C/32, H, W, 32], and
+//   - [N, C, H, W]      to [N,  C/4, H, W,  4] (same as sm61+),
+//
+// assuming C is divisible by 4 or 32.
+//
+// This pass will not pad the channel dim to a multiple of 4 or 32, so you
+// should run CudnnPadForConvolutions before this.
+class CudnnVectorizeConvolutions : public HloModulePass {
+ public:
+  explicit CudnnVectorizeConvolutions(
+      se::CudaComputeCapability compute_capability,
+      se::dnn::VersionInfo cudnn_version)
+      : compute_capability_(compute_capability),
+        cudnn_version_(cudnn_version) {}
+
+  absl::string_view name() const override {
+    return "cudnn_vectorize_convolutions";
+  }
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+
+ private:
+  const se::CudaComputeCapability compute_capability_;
+  const se::dnn::VersionInfo cudnn_version_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_CUDNN_VECTORIZE_CONVOLUTIONS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/cusolver_context.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/cusolver_context.h
new file mode 100644
index 0000000000000000000000000000000000000000..63138f5fd601585f2bf116af811f8e219682b6f6
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/cusolver_context.h
@@ -0,0 +1,110 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_CUSOLVER_CONTEXT_H_
+#define XLA_SERVICE_GPU_CUSOLVER_CONTEXT_H_
+
+#include <complex>
+#include <memory>
+
+#define TENSORFLOW_USE_HIPSOLVER \
+  (TENSORFLOW_USE_ROCM && (TF_ROCM_VERSION >= 40500))
+#define TENSORFLOW_USE_ROCSOLVER \
+  (TENSORFLOW_USE_ROCM && (TF_ROCM_VERSION < 40500))
+#define TENSORFLOW_USE_CUSOLVER_OR_HIPSOLVER \
+  (!TENSORFLOW_USE_ROCM || TENSORFLOW_USE_HIPSOLVER)
+
+#if !TENSORFLOW_USE_ROCM
+#include "third_party/gpus/cuda/include/cusolverDn.h"
+using gpusolverHandle_t = cusolverDnHandle_t;
+#else
+#include "rocm/rocm_config.h"
+// Macros to ease the transition from rocsolver to hipsolver.
+#if TENSORFLOW_USE_HIPSOLVER
+#include "xla/stream_executor/rocm/hipsolver_wrapper.h"
+using gpusolverHandle_t = hipsolverHandle_t;
+#else  // TENSORFLOW_USE_ROCSOLVER
+#include "xla/stream_executor/rocm/rocblas_wrapper.h"
+#include "xla/stream_executor/rocm/rocsolver_wrapper.h"
+using gpusolverHandle_t = rocblas_handle;
+#endif  // TF_ROCM_VERSION >= 40500
+#endif  // TENSORFLOW_USE_ROCM
+
+#include "xla/statusor.h"
+#include "xla/stream_executor/blas.h"
+#include "xla/stream_executor/stream_executor.h"
+#include "xla/xla_data.pb.h"
+
+namespace xla {
+namespace gpu {
+
+namespace se = ::stream_executor;
+
+class GpuSolverContext {
+ public:
+  static StatusOr<GpuSolverContext> Create();
+
+  Status SetStream(se::Stream* stream);
+
+  // Computes the Cholesky factorization of multiple matrices.  See
+  // https://docs.nvidia.com/cuda/cusolver/index.html#cuSolverDN-lt-t-gt-batchpotrf
+  //
+  // `as` is a list of pointers to the batch_size individual n x n matricies
+  // that make up the input array.
+  Status PotrfBatched(se::blas::UpperLower uplo, int n,
+                      se::DeviceMemory<float*> as, int lda,
+                      se::DeviceMemory<int> lapack_info, int batch_size);
+  Status PotrfBatched(se::blas::UpperLower uplo, int n,
+                      se::DeviceMemory<double*> as, int lda,
+                      se::DeviceMemory<int> lapack_info, int batch_size);
+  Status PotrfBatched(se::blas::UpperLower uplo, int n,
+                      se::DeviceMemory<std::complex<float>*> as, int lda,
+                      se::DeviceMemory<int> lapack_info, int batch_size);
+  Status PotrfBatched(se::blas::UpperLower uplo, int n,
+                      se::DeviceMemory<std::complex<double>*> as, int lda,
+                      se::DeviceMemory<int> lapack_info, int batch_size);
+
+  // Returns the max size of the `workspace` required by Potrf and PotrfBatched,
+  // in number of elements of `type`.
+  //
+  // (cusolver's PotrfBatched doesn't require a workspace per se -- it uses the
+  // input array as scratch.  But we do need to materialize the `as` input, and
+  // we do this in the workspace.)
+  //
+  // This is a bit of a hack; we could instead split it up into two functions.
+  // But at the moment, it's an implementation detail of CholeskyThunk whether
+  // it calls Potrf or PotrfBatched, so we need to allocate enough scratch space
+  // for either.
+  //
+  // In practice, this does not result in a notable increase in scratch space
+  // needed, because both cases require a relatively small amount of scratch.
+  StatusOr<int64_t> PotrfBufferSize(PrimitiveType type,
+                                    se::blas::UpperLower uplo, int n, int lda,
+                                    int batch_size);
+
+ private:
+  explicit GpuSolverContext(gpusolverHandle_t handle);
+
+  struct Deleter {
+    void operator()(gpusolverHandle_t handle);
+  };
+
+  std::unique_ptr<std::remove_pointer_t<gpusolverHandle_t>, Deleter> handle_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_CUSOLVER_CONTEXT_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/cusolver_rewriter.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/cusolver_rewriter.h
new file mode 100644
index 0000000000000000000000000000000000000000..9d68cfa15bae1424f6903cfbdd7e9206d2700290
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/cusolver_rewriter.h
@@ -0,0 +1,47 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_CUSOLVER_REWRITER_H_
+#define XLA_SERVICE_GPU_CUSOLVER_REWRITER_H_
+
+#include "xla/hlo/ir/hlo_computation.h"
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/service/gpu/cusolver_context.h"
+#include "xla/service/hlo_pass_interface.h"
+#include "xla/stream_executor/device_memory_allocator.h"
+#include "xla/stream_executor/stream_executor.h"
+
+namespace xla {
+namespace gpu {
+
+// Rewrites Cholesky calls into CustomCall HLOs that call into cuSolver.
+class GpusolverRewriter : public HloModulePass {
+ public:
+  GpusolverRewriter();
+  absl::string_view name() const override { return "gpusolver-rewriter"; }
+
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+
+ private:
+  StatusOr<bool> RunOnComputation(HloComputation* computation);
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_CUSOLVER_REWRITER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/custom_call_thunk.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/custom_call_thunk.h
new file mode 100644
index 0000000000000000000000000000000000000000..329dbf02dfa8f09e341f75e4c7524a6a8cff4632
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/custom_call_thunk.h
@@ -0,0 +1,70 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_CUSTOM_CALL_THUNK_H_
+#define XLA_SERVICE_GPU_CUSTOM_CALL_THUNK_H_
+
+#include "xla/service/custom_call_status_internal.h"
+#include "xla/service/gpu/buffer_allocations.h"
+#include "xla/service/gpu/thunk.h"
+
+#if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+#include "xla/stream_executor/gpu/gpu_types.h"
+#endif
+
+namespace xla {
+namespace gpu {
+
+// Thunk to run a GPU custom call.
+//
+// This thunk's `ExecuteOnStream` implementation executes a host function
+// `call_target` which is expected to enqueue operations onto the GPU.
+//
+// Note that not all kCustomCall HLOs in XLA:GPU end up being run by this thunk.
+// XLA itself creates kCustomCall instructions when lowering kConvolution HLOs
+// into calls to cudnn.  These internally-created custom-calls are run using
+// ConvolutionThunk, not CustomCallThunk.  There's no ambiguity because they
+// have special call target names (e.g. "__cudnn$convForward") that only the
+// compiler is allowed to create.
+class CustomCallThunk : public Thunk {
+ public:
+  using OptionalSlice = ::std::optional<BufferAllocation::Slice>;
+
+#if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+  using Stream = stream_executor::gpu::GpuStreamHandle;
+#else   //  GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+  using Stream = void*;
+#endif  //  GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+
+  using CustomCallTarget = std::function<void(Stream, void**, const char*,
+                                              size_t, XlaCustomCallStatus*)>;
+  CustomCallThunk(ThunkInfo thunk_info, CustomCallTarget call_target,
+                  std::vector<OptionalSlice> operands,
+                  std::vector<OptionalSlice> results,
+                  const std::string& opaque);
+
+  Status ExecuteOnStream(const ExecuteParams& params) override;
+
+ private:
+  const CustomCallTarget call_target_;
+  const std::vector<OptionalSlice> operands_;
+  const std::vector<OptionalSlice> results_;
+  const std::string opaque_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_CUSTOM_CALL_THUNK_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/dot_dimension_sorter.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/dot_dimension_sorter.h
new file mode 100644
index 0000000000000000000000000000000000000000..0a2e19542f0b7429bff4a8fa2e52216a9c468db8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/dot_dimension_sorter.h
@@ -0,0 +1,49 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_DOT_DIMENSION_SORTER_H_
+#define XLA_SERVICE_GPU_DOT_DIMENSION_SORTER_H_
+
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/service/hlo_pass_interface.h"
+
+namespace xla {
+namespace gpu {
+
+// Sorts contracting dimensions of dot() operands when this reduces the
+// number of transposes. Example:
+// dot(p0, p1), lhs_contracting_dims={3,2}, rhs_contracting_dims={2,1}  ->
+// dot(p0, p1), lhs_contracting_dims={2,3}, rhs_contracting_dims={1,2}
+// The first case gets transposes inserted by dot_decomposer, the second one
+// does not and thus is generally more efficient.
+
+// TODO(b/265688934): do the same for batch dimensions?
+
+class DotDimensionSorter : public HloModulePass {
+ public:
+  absl::string_view name() const override { return "dot_dimension_sorter"; }
+
+  // Run the pass on computations in 'module'.
+  // Returns whether the 'module' was changed.
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_DOT_DIMENSION_SORTER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/elemental_ir_emitter.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/elemental_ir_emitter.h
new file mode 100644
index 0000000000000000000000000000000000000000..f97861ba2e7afc1e0064452a29726ac4c3409685
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/elemental_ir_emitter.h
@@ -0,0 +1,137 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_ELEMENTAL_IR_EMITTER_H_
+#define XLA_SERVICE_GPU_ELEMENTAL_IR_EMITTER_H_
+
+#include <string>
+
+#include "absl/types/span.h"
+#include "llvm/IR/IRBuilder.h"
+#include "llvm/IR/Value.h"
+#include "xla/hlo/ir/hlo_computation.h"
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/service/elemental_ir_emitter.h"
+#include "xla/service/gpu/ir_emitter_context.h"
+#include "xla/service/gpu/target_util.h"
+#include "xla/service/hlo_module_config.h"
+#include "xla/statusor.h"
+#include "xla/xla_data.pb.h"
+
+namespace xla {
+namespace gpu {
+
+class GpuElementalIrEmitter : public ElementalIrEmitter {
+ public:
+  GpuElementalIrEmitter(IrEmitterContext& ir_emitter_context,
+                        llvm::IRBuilder<>* b);
+
+ protected:
+  llvm_ir::IrArray::Index GetSourceIndexOfBitcast(
+      const llvm_ir::IrArray::Index& index, const HloInstruction* hlo) override;
+
+  StatusOr<llvm::Value*> EmitFloatBinaryOp(const HloInstruction* op,
+                                           llvm::Value* lhs_value,
+                                           llvm::Value* rhs_value) override;
+
+  StatusOr<llvm::Value*> EmitLog(PrimitiveType prim_type,
+                                 llvm::Value* value) override;
+
+  StatusOr<llvm::Value*> EmitLog1p(PrimitiveType prim_type,
+                                   llvm::Value* value) override;
+
+  StatusOr<llvm::Value*> EmitSin(PrimitiveType prim_type,
+                                 llvm::Value* value) override;
+
+  StatusOr<llvm::Value*> EmitCos(PrimitiveType prim_type,
+                                 llvm::Value* value) override;
+
+  StatusOr<llvm::Value*> EmitTan(PrimitiveType prim_type,
+                                 llvm::Value* value) override;
+
+  StatusOr<llvm::Value*> EmitExp(PrimitiveType prim_type, llvm::Value* value,
+                                 absl::string_view name) override;
+
+  StatusOr<llvm::Value*> EmitExpm1(PrimitiveType prim_type,
+                                   llvm::Value* value) override;
+
+  StatusOr<llvm::Value*> EmitSqrt(PrimitiveType prim_type,
+                                  llvm::Value* value) override;
+
+  StatusOr<llvm::Value*> EmitRsqrt(PrimitiveType prim_type,
+                                   llvm::Value* value) override;
+
+  StatusOr<llvm::Value*> EmitPow(PrimitiveType prim_type, llvm::Value* lhs,
+                                 llvm::Value* rhs,
+                                 absl::string_view name) override;
+
+  StatusOr<llvm::Value*> EmitAtan2(PrimitiveType prim_type, llvm::Value* lhs,
+                                   llvm::Value* rhs,
+                                   absl::string_view name) override;
+
+  StatusOr<llvm::Value*> EmitTanh(PrimitiveType prim_type,
+                                  llvm::Value* value) override;
+
+  StatusOr<llvm::Value*> EmitComplexAbs(PrimitiveType prim_type,
+                                        llvm::Value* value) override;
+
+  StatusOr<llvm::Value*> EmitCbrt(PrimitiveType prim_type,
+                                  llvm::Value* value) override;
+
+  StatusOr<std::vector<llvm::Value*>> EmitThreadLocalCall(
+      const HloComputation& callee, absl::Span<llvm::Value* const> parameters,
+      absl::string_view, bool /*is_reducer*/) override;
+
+  llvm::Value* EmitThreadId() override;
+
+  bool fast_min_max() override {
+    return ir_emitter_context_.debug_options().xla_gpu_enable_fast_min_max();
+  }
+
+ private:
+  // Emits IR for op, which must have opcode kPower.
+  StatusOr<llvm::Value*> EmitPowerOp(const HloInstruction* op,
+                                     llvm::Value* lhs_value,
+                                     llvm::Value* rhs_value);
+
+  // Emits IR to call an LLVM intrinsic of type [T] -> T.  Adjusts
+  // callee_name according to T.  Returns the IR value that represents the
+  // return value of the function.
+  StatusOr<llvm::Value*> EmitLlvmIntrinsicMathCall(
+      const std::string& callee_name, absl::Span<llvm::Value* const> operands,
+      absl::Span<const PrimitiveType> input_types, PrimitiveType output_type);
+
+  // Emits IR to call a device function of type [T] -> T.  Adjusts
+  // callee_name according to T.  Returns the IR value that represents the
+  // return value of the function.
+  StatusOr<llvm::Value*> EmitDeviceMathCall(
+      TargetDeviceFunctionID funcid, absl::Span<llvm::Value* const> operands,
+      absl::Span<const PrimitiveType> input_types, PrimitiveType output_type,
+      absl::string_view name = "");
+
+  // Emits IR to call a function of type [T] -> T.  Does not munge callee_name.
+  // Returns the IR value that represents the return value of the function.
+  StatusOr<llvm::Value*> EmitMathCall(
+      const std::string& callee_name, absl::Span<llvm::Value* const> operands,
+      absl::Span<const PrimitiveType> input_types, PrimitiveType output_type,
+      absl::string_view name = "");
+
+  IrEmitterContext& ir_emitter_context_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_ELEMENTAL_IR_EMITTER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/executable.pb.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/executable.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..6840eaebe1d68afcf732afac015a58c161b6330e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/executable.pb.h
@@ -0,0 +1,935 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: xla/service/gpu/executable.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_xla_2fservice_2fgpu_2fexecutable_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_xla_2fservice_2fgpu_2fexecutable_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3021000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3021009 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+#include "xla/service/hlo.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_xla_2fservice_2fgpu_2fexecutable_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_xla_2fservice_2fgpu_2fexecutable_2eproto {
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_xla_2fservice_2fgpu_2fexecutable_2eproto;
+namespace xla {
+namespace gpu {
+class XlaRuntimeGpuExecutableProto;
+struct XlaRuntimeGpuExecutableProtoDefaultTypeInternal;
+extern XlaRuntimeGpuExecutableProtoDefaultTypeInternal _XlaRuntimeGpuExecutableProto_default_instance_;
+class XlaRuntimeGpuExecutableProto_ConstantInfoProto;
+struct XlaRuntimeGpuExecutableProto_ConstantInfoProtoDefaultTypeInternal;
+extern XlaRuntimeGpuExecutableProto_ConstantInfoProtoDefaultTypeInternal _XlaRuntimeGpuExecutableProto_ConstantInfoProto_default_instance_;
+}  // namespace gpu
+}  // namespace xla
+PROTOBUF_NAMESPACE_OPEN
+template<> ::xla::gpu::XlaRuntimeGpuExecutableProto* Arena::CreateMaybeMessage<::xla::gpu::XlaRuntimeGpuExecutableProto>(Arena*);
+template<> ::xla::gpu::XlaRuntimeGpuExecutableProto_ConstantInfoProto* Arena::CreateMaybeMessage<::xla::gpu::XlaRuntimeGpuExecutableProto_ConstantInfoProto>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace xla {
+namespace gpu {
+
+// ===================================================================
+
+class XlaRuntimeGpuExecutableProto_ConstantInfoProto final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.gpu.XlaRuntimeGpuExecutableProto.ConstantInfoProto) */ {
+ public:
+  inline XlaRuntimeGpuExecutableProto_ConstantInfoProto() : XlaRuntimeGpuExecutableProto_ConstantInfoProto(nullptr) {}
+  ~XlaRuntimeGpuExecutableProto_ConstantInfoProto() override;
+  explicit PROTOBUF_CONSTEXPR XlaRuntimeGpuExecutableProto_ConstantInfoProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  XlaRuntimeGpuExecutableProto_ConstantInfoProto(const XlaRuntimeGpuExecutableProto_ConstantInfoProto& from);
+  XlaRuntimeGpuExecutableProto_ConstantInfoProto(XlaRuntimeGpuExecutableProto_ConstantInfoProto&& from) noexcept
+    : XlaRuntimeGpuExecutableProto_ConstantInfoProto() {
+    *this = ::std::move(from);
+  }
+
+  inline XlaRuntimeGpuExecutableProto_ConstantInfoProto& operator=(const XlaRuntimeGpuExecutableProto_ConstantInfoProto& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline XlaRuntimeGpuExecutableProto_ConstantInfoProto& operator=(XlaRuntimeGpuExecutableProto_ConstantInfoProto&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const XlaRuntimeGpuExecutableProto_ConstantInfoProto& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const XlaRuntimeGpuExecutableProto_ConstantInfoProto* internal_default_instance() {
+    return reinterpret_cast<const XlaRuntimeGpuExecutableProto_ConstantInfoProto*>(
+               &_XlaRuntimeGpuExecutableProto_ConstantInfoProto_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(XlaRuntimeGpuExecutableProto_ConstantInfoProto& a, XlaRuntimeGpuExecutableProto_ConstantInfoProto& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(XlaRuntimeGpuExecutableProto_ConstantInfoProto* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(XlaRuntimeGpuExecutableProto_ConstantInfoProto* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  XlaRuntimeGpuExecutableProto_ConstantInfoProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<XlaRuntimeGpuExecutableProto_ConstantInfoProto>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const XlaRuntimeGpuExecutableProto_ConstantInfoProto& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const XlaRuntimeGpuExecutableProto_ConstantInfoProto& from) {
+    XlaRuntimeGpuExecutableProto_ConstantInfoProto::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(XlaRuntimeGpuExecutableProto_ConstantInfoProto* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "xla.gpu.XlaRuntimeGpuExecutableProto.ConstantInfoProto";
+  }
+  protected:
+  explicit XlaRuntimeGpuExecutableProto_ConstantInfoProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kSymbolNameFieldNumber = 1,
+    kContentFieldNumber = 2,
+    kAllocationIndexFieldNumber = 3,
+  };
+  // string symbol_name = 1;
+  void clear_symbol_name();
+  const std::string& symbol_name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_symbol_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_symbol_name();
+  PROTOBUF_NODISCARD std::string* release_symbol_name();
+  void set_allocated_symbol_name(std::string* symbol_name);
+  private:
+  const std::string& _internal_symbol_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_symbol_name(const std::string& value);
+  std::string* _internal_mutable_symbol_name();
+  public:
+
+  // bytes content = 2;
+  void clear_content();
+  const std::string& content() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_content(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_content();
+  PROTOBUF_NODISCARD std::string* release_content();
+  void set_allocated_content(std::string* content);
+  private:
+  const std::string& _internal_content() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_content(const std::string& value);
+  std::string* _internal_mutable_content();
+  public:
+
+  // int32 allocation_index = 3;
+  void clear_allocation_index();
+  int32_t allocation_index() const;
+  void set_allocation_index(int32_t value);
+  private:
+  int32_t _internal_allocation_index() const;
+  void _internal_set_allocation_index(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:xla.gpu.XlaRuntimeGpuExecutableProto.ConstantInfoProto)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr symbol_name_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr content_;
+    int32_t allocation_index_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_xla_2fservice_2fgpu_2fexecutable_2eproto;
+};
+// -------------------------------------------------------------------
+
+class XlaRuntimeGpuExecutableProto final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.gpu.XlaRuntimeGpuExecutableProto) */ {
+ public:
+  inline XlaRuntimeGpuExecutableProto() : XlaRuntimeGpuExecutableProto(nullptr) {}
+  ~XlaRuntimeGpuExecutableProto() override;
+  explicit PROTOBUF_CONSTEXPR XlaRuntimeGpuExecutableProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  XlaRuntimeGpuExecutableProto(const XlaRuntimeGpuExecutableProto& from);
+  XlaRuntimeGpuExecutableProto(XlaRuntimeGpuExecutableProto&& from) noexcept
+    : XlaRuntimeGpuExecutableProto() {
+    *this = ::std::move(from);
+  }
+
+  inline XlaRuntimeGpuExecutableProto& operator=(const XlaRuntimeGpuExecutableProto& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline XlaRuntimeGpuExecutableProto& operator=(XlaRuntimeGpuExecutableProto&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const XlaRuntimeGpuExecutableProto& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const XlaRuntimeGpuExecutableProto* internal_default_instance() {
+    return reinterpret_cast<const XlaRuntimeGpuExecutableProto*>(
+               &_XlaRuntimeGpuExecutableProto_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(XlaRuntimeGpuExecutableProto& a, XlaRuntimeGpuExecutableProto& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(XlaRuntimeGpuExecutableProto* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(XlaRuntimeGpuExecutableProto* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  XlaRuntimeGpuExecutableProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<XlaRuntimeGpuExecutableProto>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const XlaRuntimeGpuExecutableProto& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const XlaRuntimeGpuExecutableProto& from) {
+    XlaRuntimeGpuExecutableProto::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(XlaRuntimeGpuExecutableProto* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "xla.gpu.XlaRuntimeGpuExecutableProto";
+  }
+  protected:
+  explicit XlaRuntimeGpuExecutableProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef XlaRuntimeGpuExecutableProto_ConstantInfoProto ConstantInfoProto;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kConstantsFieldNumber = 5,
+    kGpuAsmTextFieldNumber = 3,
+    kGpuBinaryFieldNumber = 4,
+    kXlaRuntimeExecutableFieldNumber = 1,
+    kEntryFuncAttrsFieldNumber = 2,
+  };
+  // repeated .xla.gpu.XlaRuntimeGpuExecutableProto.ConstantInfoProto constants = 5;
+  int constants_size() const;
+  private:
+  int _internal_constants_size() const;
+  public:
+  void clear_constants();
+  ::xla::gpu::XlaRuntimeGpuExecutableProto_ConstantInfoProto* mutable_constants(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::gpu::XlaRuntimeGpuExecutableProto_ConstantInfoProto >*
+      mutable_constants();
+  private:
+  const ::xla::gpu::XlaRuntimeGpuExecutableProto_ConstantInfoProto& _internal_constants(int index) const;
+  ::xla::gpu::XlaRuntimeGpuExecutableProto_ConstantInfoProto* _internal_add_constants();
+  public:
+  const ::xla::gpu::XlaRuntimeGpuExecutableProto_ConstantInfoProto& constants(int index) const;
+  ::xla::gpu::XlaRuntimeGpuExecutableProto_ConstantInfoProto* add_constants();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::gpu::XlaRuntimeGpuExecutableProto_ConstantInfoProto >&
+      constants() const;
+
+  // string gpu_asm_text = 3;
+  void clear_gpu_asm_text();
+  const std::string& gpu_asm_text() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_gpu_asm_text(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_gpu_asm_text();
+  PROTOBUF_NODISCARD std::string* release_gpu_asm_text();
+  void set_allocated_gpu_asm_text(std::string* gpu_asm_text);
+  private:
+  const std::string& _internal_gpu_asm_text() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_gpu_asm_text(const std::string& value);
+  std::string* _internal_mutable_gpu_asm_text();
+  public:
+
+  // bytes gpu_binary = 4;
+  void clear_gpu_binary();
+  const std::string& gpu_binary() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_gpu_binary(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_gpu_binary();
+  PROTOBUF_NODISCARD std::string* release_gpu_binary();
+  void set_allocated_gpu_binary(std::string* gpu_binary);
+  private:
+  const std::string& _internal_gpu_binary() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_gpu_binary(const std::string& value);
+  std::string* _internal_mutable_gpu_binary();
+  public:
+
+  // .xla.XlaRuntimeExecutableProto xla_runtime_executable = 1;
+  bool has_xla_runtime_executable() const;
+  private:
+  bool _internal_has_xla_runtime_executable() const;
+  public:
+  void clear_xla_runtime_executable();
+  const ::xla::XlaRuntimeExecutableProto& xla_runtime_executable() const;
+  PROTOBUF_NODISCARD ::xla::XlaRuntimeExecutableProto* release_xla_runtime_executable();
+  ::xla::XlaRuntimeExecutableProto* mutable_xla_runtime_executable();
+  void set_allocated_xla_runtime_executable(::xla::XlaRuntimeExecutableProto* xla_runtime_executable);
+  private:
+  const ::xla::XlaRuntimeExecutableProto& _internal_xla_runtime_executable() const;
+  ::xla::XlaRuntimeExecutableProto* _internal_mutable_xla_runtime_executable();
+  public:
+  void unsafe_arena_set_allocated_xla_runtime_executable(
+      ::xla::XlaRuntimeExecutableProto* xla_runtime_executable);
+  ::xla::XlaRuntimeExecutableProto* unsafe_arena_release_xla_runtime_executable();
+
+  // .xla.EntryFunctionAttributes entry_func_attrs = 2;
+  bool has_entry_func_attrs() const;
+  private:
+  bool _internal_has_entry_func_attrs() const;
+  public:
+  void clear_entry_func_attrs();
+  const ::xla::EntryFunctionAttributes& entry_func_attrs() const;
+  PROTOBUF_NODISCARD ::xla::EntryFunctionAttributes* release_entry_func_attrs();
+  ::xla::EntryFunctionAttributes* mutable_entry_func_attrs();
+  void set_allocated_entry_func_attrs(::xla::EntryFunctionAttributes* entry_func_attrs);
+  private:
+  const ::xla::EntryFunctionAttributes& _internal_entry_func_attrs() const;
+  ::xla::EntryFunctionAttributes* _internal_mutable_entry_func_attrs();
+  public:
+  void unsafe_arena_set_allocated_entry_func_attrs(
+      ::xla::EntryFunctionAttributes* entry_func_attrs);
+  ::xla::EntryFunctionAttributes* unsafe_arena_release_entry_func_attrs();
+
+  // @@protoc_insertion_point(class_scope:xla.gpu.XlaRuntimeGpuExecutableProto)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::gpu::XlaRuntimeGpuExecutableProto_ConstantInfoProto > constants_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr gpu_asm_text_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr gpu_binary_;
+    ::xla::XlaRuntimeExecutableProto* xla_runtime_executable_;
+    ::xla::EntryFunctionAttributes* entry_func_attrs_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_xla_2fservice_2fgpu_2fexecutable_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// XlaRuntimeGpuExecutableProto_ConstantInfoProto
+
+// string symbol_name = 1;
+inline void XlaRuntimeGpuExecutableProto_ConstantInfoProto::clear_symbol_name() {
+  _impl_.symbol_name_.ClearToEmpty();
+}
+inline const std::string& XlaRuntimeGpuExecutableProto_ConstantInfoProto::symbol_name() const {
+  // @@protoc_insertion_point(field_get:xla.gpu.XlaRuntimeGpuExecutableProto.ConstantInfoProto.symbol_name)
+  return _internal_symbol_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void XlaRuntimeGpuExecutableProto_ConstantInfoProto::set_symbol_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.symbol_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:xla.gpu.XlaRuntimeGpuExecutableProto.ConstantInfoProto.symbol_name)
+}
+inline std::string* XlaRuntimeGpuExecutableProto_ConstantInfoProto::mutable_symbol_name() {
+  std::string* _s = _internal_mutable_symbol_name();
+  // @@protoc_insertion_point(field_mutable:xla.gpu.XlaRuntimeGpuExecutableProto.ConstantInfoProto.symbol_name)
+  return _s;
+}
+inline const std::string& XlaRuntimeGpuExecutableProto_ConstantInfoProto::_internal_symbol_name() const {
+  return _impl_.symbol_name_.Get();
+}
+inline void XlaRuntimeGpuExecutableProto_ConstantInfoProto::_internal_set_symbol_name(const std::string& value) {
+  
+  _impl_.symbol_name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* XlaRuntimeGpuExecutableProto_ConstantInfoProto::_internal_mutable_symbol_name() {
+  
+  return _impl_.symbol_name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* XlaRuntimeGpuExecutableProto_ConstantInfoProto::release_symbol_name() {
+  // @@protoc_insertion_point(field_release:xla.gpu.XlaRuntimeGpuExecutableProto.ConstantInfoProto.symbol_name)
+  return _impl_.symbol_name_.Release();
+}
+inline void XlaRuntimeGpuExecutableProto_ConstantInfoProto::set_allocated_symbol_name(std::string* symbol_name) {
+  if (symbol_name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.symbol_name_.SetAllocated(symbol_name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.symbol_name_.IsDefault()) {
+    _impl_.symbol_name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:xla.gpu.XlaRuntimeGpuExecutableProto.ConstantInfoProto.symbol_name)
+}
+
+// bytes content = 2;
+inline void XlaRuntimeGpuExecutableProto_ConstantInfoProto::clear_content() {
+  _impl_.content_.ClearToEmpty();
+}
+inline const std::string& XlaRuntimeGpuExecutableProto_ConstantInfoProto::content() const {
+  // @@protoc_insertion_point(field_get:xla.gpu.XlaRuntimeGpuExecutableProto.ConstantInfoProto.content)
+  return _internal_content();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void XlaRuntimeGpuExecutableProto_ConstantInfoProto::set_content(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.content_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:xla.gpu.XlaRuntimeGpuExecutableProto.ConstantInfoProto.content)
+}
+inline std::string* XlaRuntimeGpuExecutableProto_ConstantInfoProto::mutable_content() {
+  std::string* _s = _internal_mutable_content();
+  // @@protoc_insertion_point(field_mutable:xla.gpu.XlaRuntimeGpuExecutableProto.ConstantInfoProto.content)
+  return _s;
+}
+inline const std::string& XlaRuntimeGpuExecutableProto_ConstantInfoProto::_internal_content() const {
+  return _impl_.content_.Get();
+}
+inline void XlaRuntimeGpuExecutableProto_ConstantInfoProto::_internal_set_content(const std::string& value) {
+  
+  _impl_.content_.Set(value, GetArenaForAllocation());
+}
+inline std::string* XlaRuntimeGpuExecutableProto_ConstantInfoProto::_internal_mutable_content() {
+  
+  return _impl_.content_.Mutable(GetArenaForAllocation());
+}
+inline std::string* XlaRuntimeGpuExecutableProto_ConstantInfoProto::release_content() {
+  // @@protoc_insertion_point(field_release:xla.gpu.XlaRuntimeGpuExecutableProto.ConstantInfoProto.content)
+  return _impl_.content_.Release();
+}
+inline void XlaRuntimeGpuExecutableProto_ConstantInfoProto::set_allocated_content(std::string* content) {
+  if (content != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.content_.SetAllocated(content, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.content_.IsDefault()) {
+    _impl_.content_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:xla.gpu.XlaRuntimeGpuExecutableProto.ConstantInfoProto.content)
+}
+
+// int32 allocation_index = 3;
+inline void XlaRuntimeGpuExecutableProto_ConstantInfoProto::clear_allocation_index() {
+  _impl_.allocation_index_ = 0;
+}
+inline int32_t XlaRuntimeGpuExecutableProto_ConstantInfoProto::_internal_allocation_index() const {
+  return _impl_.allocation_index_;
+}
+inline int32_t XlaRuntimeGpuExecutableProto_ConstantInfoProto::allocation_index() const {
+  // @@protoc_insertion_point(field_get:xla.gpu.XlaRuntimeGpuExecutableProto.ConstantInfoProto.allocation_index)
+  return _internal_allocation_index();
+}
+inline void XlaRuntimeGpuExecutableProto_ConstantInfoProto::_internal_set_allocation_index(int32_t value) {
+  
+  _impl_.allocation_index_ = value;
+}
+inline void XlaRuntimeGpuExecutableProto_ConstantInfoProto::set_allocation_index(int32_t value) {
+  _internal_set_allocation_index(value);
+  // @@protoc_insertion_point(field_set:xla.gpu.XlaRuntimeGpuExecutableProto.ConstantInfoProto.allocation_index)
+}
+
+// -------------------------------------------------------------------
+
+// XlaRuntimeGpuExecutableProto
+
+// .xla.XlaRuntimeExecutableProto xla_runtime_executable = 1;
+inline bool XlaRuntimeGpuExecutableProto::_internal_has_xla_runtime_executable() const {
+  return this != internal_default_instance() && _impl_.xla_runtime_executable_ != nullptr;
+}
+inline bool XlaRuntimeGpuExecutableProto::has_xla_runtime_executable() const {
+  return _internal_has_xla_runtime_executable();
+}
+inline const ::xla::XlaRuntimeExecutableProto& XlaRuntimeGpuExecutableProto::_internal_xla_runtime_executable() const {
+  const ::xla::XlaRuntimeExecutableProto* p = _impl_.xla_runtime_executable_;
+  return p != nullptr ? *p : reinterpret_cast<const ::xla::XlaRuntimeExecutableProto&>(
+      ::xla::_XlaRuntimeExecutableProto_default_instance_);
+}
+inline const ::xla::XlaRuntimeExecutableProto& XlaRuntimeGpuExecutableProto::xla_runtime_executable() const {
+  // @@protoc_insertion_point(field_get:xla.gpu.XlaRuntimeGpuExecutableProto.xla_runtime_executable)
+  return _internal_xla_runtime_executable();
+}
+inline void XlaRuntimeGpuExecutableProto::unsafe_arena_set_allocated_xla_runtime_executable(
+    ::xla::XlaRuntimeExecutableProto* xla_runtime_executable) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.xla_runtime_executable_);
+  }
+  _impl_.xla_runtime_executable_ = xla_runtime_executable;
+  if (xla_runtime_executable) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.gpu.XlaRuntimeGpuExecutableProto.xla_runtime_executable)
+}
+inline ::xla::XlaRuntimeExecutableProto* XlaRuntimeGpuExecutableProto::release_xla_runtime_executable() {
+  
+  ::xla::XlaRuntimeExecutableProto* temp = _impl_.xla_runtime_executable_;
+  _impl_.xla_runtime_executable_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::xla::XlaRuntimeExecutableProto* XlaRuntimeGpuExecutableProto::unsafe_arena_release_xla_runtime_executable() {
+  // @@protoc_insertion_point(field_release:xla.gpu.XlaRuntimeGpuExecutableProto.xla_runtime_executable)
+  
+  ::xla::XlaRuntimeExecutableProto* temp = _impl_.xla_runtime_executable_;
+  _impl_.xla_runtime_executable_ = nullptr;
+  return temp;
+}
+inline ::xla::XlaRuntimeExecutableProto* XlaRuntimeGpuExecutableProto::_internal_mutable_xla_runtime_executable() {
+  
+  if (_impl_.xla_runtime_executable_ == nullptr) {
+    auto* p = CreateMaybeMessage<::xla::XlaRuntimeExecutableProto>(GetArenaForAllocation());
+    _impl_.xla_runtime_executable_ = p;
+  }
+  return _impl_.xla_runtime_executable_;
+}
+inline ::xla::XlaRuntimeExecutableProto* XlaRuntimeGpuExecutableProto::mutable_xla_runtime_executable() {
+  ::xla::XlaRuntimeExecutableProto* _msg = _internal_mutable_xla_runtime_executable();
+  // @@protoc_insertion_point(field_mutable:xla.gpu.XlaRuntimeGpuExecutableProto.xla_runtime_executable)
+  return _msg;
+}
+inline void XlaRuntimeGpuExecutableProto::set_allocated_xla_runtime_executable(::xla::XlaRuntimeExecutableProto* xla_runtime_executable) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.xla_runtime_executable_);
+  }
+  if (xla_runtime_executable) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(xla_runtime_executable));
+    if (message_arena != submessage_arena) {
+      xla_runtime_executable = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, xla_runtime_executable, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.xla_runtime_executable_ = xla_runtime_executable;
+  // @@protoc_insertion_point(field_set_allocated:xla.gpu.XlaRuntimeGpuExecutableProto.xla_runtime_executable)
+}
+
+// .xla.EntryFunctionAttributes entry_func_attrs = 2;
+inline bool XlaRuntimeGpuExecutableProto::_internal_has_entry_func_attrs() const {
+  return this != internal_default_instance() && _impl_.entry_func_attrs_ != nullptr;
+}
+inline bool XlaRuntimeGpuExecutableProto::has_entry_func_attrs() const {
+  return _internal_has_entry_func_attrs();
+}
+inline const ::xla::EntryFunctionAttributes& XlaRuntimeGpuExecutableProto::_internal_entry_func_attrs() const {
+  const ::xla::EntryFunctionAttributes* p = _impl_.entry_func_attrs_;
+  return p != nullptr ? *p : reinterpret_cast<const ::xla::EntryFunctionAttributes&>(
+      ::xla::_EntryFunctionAttributes_default_instance_);
+}
+inline const ::xla::EntryFunctionAttributes& XlaRuntimeGpuExecutableProto::entry_func_attrs() const {
+  // @@protoc_insertion_point(field_get:xla.gpu.XlaRuntimeGpuExecutableProto.entry_func_attrs)
+  return _internal_entry_func_attrs();
+}
+inline void XlaRuntimeGpuExecutableProto::unsafe_arena_set_allocated_entry_func_attrs(
+    ::xla::EntryFunctionAttributes* entry_func_attrs) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.entry_func_attrs_);
+  }
+  _impl_.entry_func_attrs_ = entry_func_attrs;
+  if (entry_func_attrs) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.gpu.XlaRuntimeGpuExecutableProto.entry_func_attrs)
+}
+inline ::xla::EntryFunctionAttributes* XlaRuntimeGpuExecutableProto::release_entry_func_attrs() {
+  
+  ::xla::EntryFunctionAttributes* temp = _impl_.entry_func_attrs_;
+  _impl_.entry_func_attrs_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::xla::EntryFunctionAttributes* XlaRuntimeGpuExecutableProto::unsafe_arena_release_entry_func_attrs() {
+  // @@protoc_insertion_point(field_release:xla.gpu.XlaRuntimeGpuExecutableProto.entry_func_attrs)
+  
+  ::xla::EntryFunctionAttributes* temp = _impl_.entry_func_attrs_;
+  _impl_.entry_func_attrs_ = nullptr;
+  return temp;
+}
+inline ::xla::EntryFunctionAttributes* XlaRuntimeGpuExecutableProto::_internal_mutable_entry_func_attrs() {
+  
+  if (_impl_.entry_func_attrs_ == nullptr) {
+    auto* p = CreateMaybeMessage<::xla::EntryFunctionAttributes>(GetArenaForAllocation());
+    _impl_.entry_func_attrs_ = p;
+  }
+  return _impl_.entry_func_attrs_;
+}
+inline ::xla::EntryFunctionAttributes* XlaRuntimeGpuExecutableProto::mutable_entry_func_attrs() {
+  ::xla::EntryFunctionAttributes* _msg = _internal_mutable_entry_func_attrs();
+  // @@protoc_insertion_point(field_mutable:xla.gpu.XlaRuntimeGpuExecutableProto.entry_func_attrs)
+  return _msg;
+}
+inline void XlaRuntimeGpuExecutableProto::set_allocated_entry_func_attrs(::xla::EntryFunctionAttributes* entry_func_attrs) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.entry_func_attrs_);
+  }
+  if (entry_func_attrs) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(entry_func_attrs));
+    if (message_arena != submessage_arena) {
+      entry_func_attrs = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, entry_func_attrs, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.entry_func_attrs_ = entry_func_attrs;
+  // @@protoc_insertion_point(field_set_allocated:xla.gpu.XlaRuntimeGpuExecutableProto.entry_func_attrs)
+}
+
+// string gpu_asm_text = 3;
+inline void XlaRuntimeGpuExecutableProto::clear_gpu_asm_text() {
+  _impl_.gpu_asm_text_.ClearToEmpty();
+}
+inline const std::string& XlaRuntimeGpuExecutableProto::gpu_asm_text() const {
+  // @@protoc_insertion_point(field_get:xla.gpu.XlaRuntimeGpuExecutableProto.gpu_asm_text)
+  return _internal_gpu_asm_text();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void XlaRuntimeGpuExecutableProto::set_gpu_asm_text(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.gpu_asm_text_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:xla.gpu.XlaRuntimeGpuExecutableProto.gpu_asm_text)
+}
+inline std::string* XlaRuntimeGpuExecutableProto::mutable_gpu_asm_text() {
+  std::string* _s = _internal_mutable_gpu_asm_text();
+  // @@protoc_insertion_point(field_mutable:xla.gpu.XlaRuntimeGpuExecutableProto.gpu_asm_text)
+  return _s;
+}
+inline const std::string& XlaRuntimeGpuExecutableProto::_internal_gpu_asm_text() const {
+  return _impl_.gpu_asm_text_.Get();
+}
+inline void XlaRuntimeGpuExecutableProto::_internal_set_gpu_asm_text(const std::string& value) {
+  
+  _impl_.gpu_asm_text_.Set(value, GetArenaForAllocation());
+}
+inline std::string* XlaRuntimeGpuExecutableProto::_internal_mutable_gpu_asm_text() {
+  
+  return _impl_.gpu_asm_text_.Mutable(GetArenaForAllocation());
+}
+inline std::string* XlaRuntimeGpuExecutableProto::release_gpu_asm_text() {
+  // @@protoc_insertion_point(field_release:xla.gpu.XlaRuntimeGpuExecutableProto.gpu_asm_text)
+  return _impl_.gpu_asm_text_.Release();
+}
+inline void XlaRuntimeGpuExecutableProto::set_allocated_gpu_asm_text(std::string* gpu_asm_text) {
+  if (gpu_asm_text != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.gpu_asm_text_.SetAllocated(gpu_asm_text, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.gpu_asm_text_.IsDefault()) {
+    _impl_.gpu_asm_text_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:xla.gpu.XlaRuntimeGpuExecutableProto.gpu_asm_text)
+}
+
+// bytes gpu_binary = 4;
+inline void XlaRuntimeGpuExecutableProto::clear_gpu_binary() {
+  _impl_.gpu_binary_.ClearToEmpty();
+}
+inline const std::string& XlaRuntimeGpuExecutableProto::gpu_binary() const {
+  // @@protoc_insertion_point(field_get:xla.gpu.XlaRuntimeGpuExecutableProto.gpu_binary)
+  return _internal_gpu_binary();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void XlaRuntimeGpuExecutableProto::set_gpu_binary(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.gpu_binary_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:xla.gpu.XlaRuntimeGpuExecutableProto.gpu_binary)
+}
+inline std::string* XlaRuntimeGpuExecutableProto::mutable_gpu_binary() {
+  std::string* _s = _internal_mutable_gpu_binary();
+  // @@protoc_insertion_point(field_mutable:xla.gpu.XlaRuntimeGpuExecutableProto.gpu_binary)
+  return _s;
+}
+inline const std::string& XlaRuntimeGpuExecutableProto::_internal_gpu_binary() const {
+  return _impl_.gpu_binary_.Get();
+}
+inline void XlaRuntimeGpuExecutableProto::_internal_set_gpu_binary(const std::string& value) {
+  
+  _impl_.gpu_binary_.Set(value, GetArenaForAllocation());
+}
+inline std::string* XlaRuntimeGpuExecutableProto::_internal_mutable_gpu_binary() {
+  
+  return _impl_.gpu_binary_.Mutable(GetArenaForAllocation());
+}
+inline std::string* XlaRuntimeGpuExecutableProto::release_gpu_binary() {
+  // @@protoc_insertion_point(field_release:xla.gpu.XlaRuntimeGpuExecutableProto.gpu_binary)
+  return _impl_.gpu_binary_.Release();
+}
+inline void XlaRuntimeGpuExecutableProto::set_allocated_gpu_binary(std::string* gpu_binary) {
+  if (gpu_binary != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.gpu_binary_.SetAllocated(gpu_binary, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.gpu_binary_.IsDefault()) {
+    _impl_.gpu_binary_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:xla.gpu.XlaRuntimeGpuExecutableProto.gpu_binary)
+}
+
+// repeated .xla.gpu.XlaRuntimeGpuExecutableProto.ConstantInfoProto constants = 5;
+inline int XlaRuntimeGpuExecutableProto::_internal_constants_size() const {
+  return _impl_.constants_.size();
+}
+inline int XlaRuntimeGpuExecutableProto::constants_size() const {
+  return _internal_constants_size();
+}
+inline void XlaRuntimeGpuExecutableProto::clear_constants() {
+  _impl_.constants_.Clear();
+}
+inline ::xla::gpu::XlaRuntimeGpuExecutableProto_ConstantInfoProto* XlaRuntimeGpuExecutableProto::mutable_constants(int index) {
+  // @@protoc_insertion_point(field_mutable:xla.gpu.XlaRuntimeGpuExecutableProto.constants)
+  return _impl_.constants_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::gpu::XlaRuntimeGpuExecutableProto_ConstantInfoProto >*
+XlaRuntimeGpuExecutableProto::mutable_constants() {
+  // @@protoc_insertion_point(field_mutable_list:xla.gpu.XlaRuntimeGpuExecutableProto.constants)
+  return &_impl_.constants_;
+}
+inline const ::xla::gpu::XlaRuntimeGpuExecutableProto_ConstantInfoProto& XlaRuntimeGpuExecutableProto::_internal_constants(int index) const {
+  return _impl_.constants_.Get(index);
+}
+inline const ::xla::gpu::XlaRuntimeGpuExecutableProto_ConstantInfoProto& XlaRuntimeGpuExecutableProto::constants(int index) const {
+  // @@protoc_insertion_point(field_get:xla.gpu.XlaRuntimeGpuExecutableProto.constants)
+  return _internal_constants(index);
+}
+inline ::xla::gpu::XlaRuntimeGpuExecutableProto_ConstantInfoProto* XlaRuntimeGpuExecutableProto::_internal_add_constants() {
+  return _impl_.constants_.Add();
+}
+inline ::xla::gpu::XlaRuntimeGpuExecutableProto_ConstantInfoProto* XlaRuntimeGpuExecutableProto::add_constants() {
+  ::xla::gpu::XlaRuntimeGpuExecutableProto_ConstantInfoProto* _add = _internal_add_constants();
+  // @@protoc_insertion_point(field_add:xla.gpu.XlaRuntimeGpuExecutableProto.constants)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::gpu::XlaRuntimeGpuExecutableProto_ConstantInfoProto >&
+XlaRuntimeGpuExecutableProto::constants() const {
+  // @@protoc_insertion_point(field_list:xla.gpu.XlaRuntimeGpuExecutableProto.constants)
+  return _impl_.constants_;
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace gpu
+}  // namespace xla
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_xla_2fservice_2fgpu_2fexecutable_2eproto
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/fft_thunk.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/fft_thunk.h
new file mode 100644
index 0000000000000000000000000000000000000000..6b2224a7b13f01070c36d2ee8bb32896096491dc
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/fft_thunk.h
@@ -0,0 +1,100 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_FFT_THUNK_H_
+#define XLA_SERVICE_GPU_FFT_THUNK_H_
+
+#include <optional>
+
+#include "absl/container/flat_hash_map.h"
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/service/buffer_assignment.h"
+#include "xla/service/gpu/buffer_allocations.h"
+#include "xla/service/gpu/thunk.h"
+#include "xla/stream_executor/stream_executor.h"
+#include "xla/types.h"
+#include "xla/xla_data.pb.h"
+#include "tsl/platform/status.h"
+
+namespace xla {
+namespace gpu {
+
+struct FftPlan {
+  // CuFFT thread-safety requires that separate host threads not share plans;
+  // protect each plan with a mutex.
+  absl::Mutex mu;
+  std::unique_ptr<se::fft::Plan> plan ABSL_GUARDED_BY(mu);
+  float scale_factor ABSL_GUARDED_BY(mu);
+};
+
+class FftPlanCache {
+ public:
+  // Returnes Fft plan cached for the given device ordinal or creates a new one.
+  FftPlan* GetOrCreate(int device_ordinal) {
+    absl::MutexLock lock(&mu_);
+    std::unique_ptr<FftPlan>& plan = fft_plans_[device_ordinal];
+    if (!plan) plan = std::make_unique<FftPlan>();
+    return plan.get();
+  }
+
+ private:
+  absl::Mutex mu_;
+  absl::flat_hash_map<int, std::unique_ptr<FftPlan>> fft_plans_
+      ABSL_GUARDED_BY(mu_);
+};
+
+// This class stores everything that StreamExecutor needs to launch an FFT.
+// It is generated by IrEmitter.
+//
+// This is thread-compatible.
+class FftThunk : public Thunk {
+ public:
+  // Constructs a thunk for launching an FFT on a stream.
+  // Semantics of null hlo_instruction argument are as in Thunk.
+  FftThunk(ThunkInfo thunk_info, FftType fft_type,
+           absl::Span<const int64_t> fft_length,
+           const BufferAllocation::Slice& input_buffer,
+           const BufferAllocation::Slice& output_buffer,
+           const Shape& input_shape, const Shape& output_shape);
+
+  FftThunk(const FftThunk&) = delete;             // Cannot share fft_plan_
+  FftThunk& operator=(const FftThunk&) = delete;  // Cannot share fft_plan_
+
+  // Does the FFT for the thunk on "stream".
+  Status ExecuteOnStream(const ExecuteParams& params) override;
+
+ private:
+  const se::fft::Type fft_type_;
+  const std::vector<int64_t> fft_length_;
+
+  FftPlanCache fft_plan_cache_;
+
+  const BufferAllocation::Slice input_buffer_;
+  const BufferAllocation::Slice output_buffer_;
+
+  const Shape input_shape_;
+  const Shape output_shape_;
+};
+
+Status RunFft(se::DeviceMemoryBase input, const Shape& input_shape,
+              se::DeviceMemoryBase output, const Shape& output_shape,
+              se::fft::Type fft_type, absl::Span<const int64_t> fft_length,
+              int device_ordinal, FftPlanCache* fft_plan_cache,
+              se::Stream* stream, se::DeviceMemoryAllocator* memory_allocator);
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_FFT_THUNK_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/for_thunk.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/for_thunk.h
new file mode 100644
index 0000000000000000000000000000000000000000..13e44ede16fa128e958ffacc5801d0ba6e1528c6
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/for_thunk.h
@@ -0,0 +1,52 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_FOR_THUNK_H_
+#define XLA_SERVICE_GPU_FOR_THUNK_H_
+
+#include <vector>
+
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/service/gpu/buffer_allocations.h"
+#include "xla/service/gpu/sequential_thunk.h"
+#include "xla/service/gpu/thunk.h"
+#include "xla/stream_executor/stream_executor.h"
+
+namespace xla {
+namespace gpu {
+
+// ForThunk executes 'loop_limit' invocations of 'body_thunk_sequence'.
+class ForThunk : public Thunk {
+ public:
+  ForThunk(ThunkInfo thunk_info, int64_t loop_limit,
+           std::unique_ptr<ThunkSequence> body_thunk_sequence);
+  ForThunk(const ForThunk&) = delete;
+  ForThunk& operator=(const ForThunk&) = delete;
+
+  Status Initialize(const GpuExecutable& executable,
+                    se::StreamExecutor* executor) override;
+  Status ExecuteOnStream(const ExecuteParams& params) override;
+
+  SequentialThunk* body_thunk_sequence() { return body_thunk_sequence_.get(); }
+
+ private:
+  const int64_t loop_limit_;
+  std::unique_ptr<SequentialThunk> body_thunk_sequence_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_FOR_THUNK_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/fused_mha_thunk.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/fused_mha_thunk.h
new file mode 100644
index 0000000000000000000000000000000000000000..a1db1d23e16c9e2c6d01508d6f4f864e785b2aee
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/fused_mha_thunk.h
@@ -0,0 +1,129 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_FUSED_MHA_THUNK_H_
+#define XLA_SERVICE_GPU_FUSED_MHA_THUNK_H_
+
+#include <memory>
+#include <optional>
+
+#include "absl/container/flat_hash_map.h"
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/hlo/ir/hlo_instructions.h"
+#include "xla/service/buffer_assignment.h"
+#include "xla/service/gpu/buffer_allocations.h"
+#include "xla/service/gpu/gpu_executable.h"
+#include "xla/service/gpu/gpu_fused_mha_runner.h"
+#include "xla/service/gpu/thunk.h"
+#include "xla/stream_executor/stream_executor.h"
+#include "xla/types.h"
+#include "xla/xla_data.pb.h"
+#include "tsl/platform/status.h"
+
+namespace xla {
+namespace gpu {
+
+// This class stores everything that StreamExecutor needs to launch a DNN
+// fMHA. It is generated by IrEmitter.
+//
+// This is thread-compatible.
+class FusedMHAThunk : public Thunk {
+ public:
+  // Constructs a thunk for launching a DNN FMHA.
+  FusedMHAThunk(ThunkInfo thunk_info, GpufMHAConfig config,
+                BufferAllocation::Slice lhs_bmm1_slice,
+                BufferAllocation::Slice rhs_bmm1_slice,
+                BufferAllocation::Slice rhs_bmm2_slice,
+                BufferAllocation::Slice output_slice,
+                BufferAllocation::Slice scratch_slice,
+                BufferAllocation::Slice mask_slice, /* may be null */
+                BufferAllocation::Slice bias_slice /* may be null */,
+                BufferAllocation::Slice activation_slice /* may be null */);
+
+  FusedMHAThunk(const FusedMHAThunk&) = delete;
+  FusedMHAThunk& operator=(const FusedMHAThunk&) = delete;
+
+  Status ExecuteOnStream(const ExecuteParams& params) override;
+
+ private:
+  BufferAllocation::Slice lhs_bmm1_buffer_;
+  BufferAllocation::Slice rhs_bmm1_buffer_;
+  BufferAllocation::Slice rhs_bmm2_buffer_;
+  BufferAllocation::Slice output_buffer_;
+  BufferAllocation::Slice scratch_buffer_;
+  BufferAllocation::Slice mask_buffer_;
+  BufferAllocation::Slice bias_buffer_;
+  BufferAllocation::Slice activation_buffer_;
+
+  FusedMultiHeadedAttentionRunner& GetOrCreateRunner(
+      const stream_executor::Stream* stream);
+
+  // FusedMHA config
+  const GpufMHAConfig config_;
+  absl::Mutex mu_;
+  absl::flat_hash_map<const stream_executor::Stream*,
+                      std::unique_ptr<FusedMultiHeadedAttentionRunner>>
+      runner_cache_ ABSL_GUARDED_BY(mu_);
+};
+
+class FusedMHABackwardThunk : public Thunk {
+ public:
+  // Constructs a thunk for launching a DNN FMHA backward.
+  FusedMHABackwardThunk(ThunkInfo thunk_info, GpufMHABackwardConfig config,
+                        BufferAllocation::Slice bmm1_grad_gemm1_rhs_slice,
+                        BufferAllocation::Slice bmm1_grad_gemm2_rhs_slice,
+                        BufferAllocation::Slice bmm2_grad_gemm1_lhs_slice,
+                        BufferAllocation::Slice bmm2_grad_gemm2_rhs_slice,
+                        BufferAllocation::Slice d_output_slice,
+                        BufferAllocation::Slice scratch_slice,
+                        BufferAllocation::Slice d_bmm1_lhs_slice,
+                        BufferAllocation::Slice d_bmm1_rhs_slice,
+                        BufferAllocation::Slice d_bmm2_rhs_slice,
+                        BufferAllocation::Slice d_S_slice,
+                        BufferAllocation::Slice mask_slice,
+                        BufferAllocation::Slice d_bias_slice);
+
+  FusedMHABackwardThunk(const FusedMHABackwardThunk&) = delete;
+  FusedMHABackwardThunk& operator=(const FusedMHABackwardThunk&) = delete;
+
+  Status ExecuteOnStream(const ExecuteParams& params) override;
+
+ private:
+  BufferAllocation::Slice bmm1_grad_gemm1_rhs_buffer_;
+  BufferAllocation::Slice bmm1_grad_gemm2_rhs_buffer_;
+  BufferAllocation::Slice bmm2_grad_gemm1_lhs_buffer_;
+  BufferAllocation::Slice bmm2_grad_gemm2_rhs_buffer_;
+  BufferAllocation::Slice d_output_buffer_;
+  BufferAllocation::Slice scratch_buffer_;
+  BufferAllocation::Slice d_bmm1_lhs_buffer_;
+  BufferAllocation::Slice d_bmm1_rhs_buffer_;
+  BufferAllocation::Slice d_bmm2_rhs_buffer_;
+  BufferAllocation::Slice d_s_buffer_;
+  BufferAllocation::Slice mask_buffer_;
+  BufferAllocation::Slice d_bias_buffer_;
+
+  FusedMultiHeadedAttentionBackwardRunner& GetOrCreateRunner(
+      const stream_executor::Stream* stream);
+
+  // FusedMHA backward config
+  const GpufMHABackwardConfig config_;
+  absl::Mutex mu_;
+  absl::flat_hash_map<const stream_executor::Stream*,
+                      std::unique_ptr<FusedMultiHeadedAttentionBackwardRunner>>
+      runner_cache_ ABSL_GUARDED_BY(mu_);
+};
+}  // namespace gpu
+}  // namespace xla
+#endif  // XLA_SERVICE_GPU_FUSED_MHA_THUNK_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/fusion_merger.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/fusion_merger.h
new file mode 100644
index 0000000000000000000000000000000000000000..cefb945ba8a8f9b60613d4e2b6bd49c6505123c5
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/fusion_merger.h
@@ -0,0 +1,82 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_FUSION_MERGER_H_
+#define XLA_SERVICE_GPU_FUSION_MERGER_H_
+
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/service/gpu/gpu_hlo_cost_analysis.h"
+#include "xla/service/hlo_pass_interface.h"
+#include "xla/stream_executor/device_description.h"
+
+namespace xla {
+namespace gpu {
+
+// An HLO pass that attempts to merge fusion instructions to reduce memory
+// bandwidth requirements and kernel launch overhead.
+//
+// Consider the example below. On the left-hand side, op A is the producer and
+// ops B and C are its consumers. FusionMerger duplicates producer ops and fuses
+// them into all consumers. The result is depicted on the right-hand side below.
+//
+//        p                    p
+//        |                  /   \
+//        v                 /     \
+//        A            +fusion+  +fusion+
+//      /   \          |  A'  |  |  A"  |
+//     |     |         |  |   |  |  |   |
+//     v     v         |  v   |  |  v   |
+//     B     C         |  B   |  |  C   |
+//                     +------+  +------+
+//
+// Op A has been cloned twice and fused with B and C. The kernel launch overhead
+// is reduced from 3 to 2. The memory bandwidth requirements may be reduced.
+// We trade 1 read of input(A) + 1 write and 2 reads of output(A) for 2 reads of
+// input(A). In general the achieveable savings in memory bandwidth depend on
+// the differences in memory read and written and the number of consumers. The
+// FusionMeger pass takes this into account when making fusion decisions.
+//
+// The pass traverses the HLO module in reverse post-order (defs before uses).
+// Fusion instructions are merged into their users if some conditions are met:
+// * The result of merging the fusion instruction into its users would not
+//   increase bytes transferred.
+// * Producer ops are fusible with _all_ consumers. If they are not fusible with
+//   at least one consumers, they won't be fused at all.
+// * Producers are kLoop fusion ops.
+//
+// None of these restrictions are necessary for correctness. In fact, lifting
+// the latter two could be beneficial.
+
+class FusionMerger : public HloModulePass {
+ public:
+  explicit FusionMerger(const se::DeviceDescription& d,
+                        HloCostAnalysis::ShapeSizeFunction f)
+      : gpu_device_info_(d), shape_size_function_(f) {}
+  absl::string_view name() const override { return "fusion_merger"; }
+
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+
+ private:
+  se::DeviceDescription gpu_device_info_;
+  HloCostAnalysis::ShapeSizeFunction shape_size_function_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_FUSION_MERGER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/fusion_pipeline.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/fusion_pipeline.h
new file mode 100644
index 0000000000000000000000000000000000000000..cecb1a9809127067365aab14189ddd85c7c16e0f
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/fusion_pipeline.h
@@ -0,0 +1,40 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_FUSION_PIPELINE_H_
+#define XLA_SERVICE_GPU_FUSION_PIPELINE_H_
+
+#include "xla/service/hlo_cost_analysis.h"
+#include "xla/service/hlo_pass_pipeline.h"
+#include "xla/stream_executor/device_description.h"
+#include "xla/xla.pb.h"
+
+namespace xla {
+namespace gpu {
+
+// Function wrapper around the (non-horizontal) XLA GPU fusion pipeline.
+HloPassPipeline FusionPipeline(
+    const DebugOptions& debug_options,
+    HloCostAnalysis::ShapeSizeFunction shape_size_bytes_function,
+    const se::DeviceDescription& gpu_device_info);
+
+// Function wrapper around the horizontal XLA GPU fusion pipeline.
+HloPassPipeline HorizontalFusionPipeline(
+    const se::DeviceDescription& gpu_device_info);
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_FUSION_PIPELINE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/fusion_wrapper.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/fusion_wrapper.h
new file mode 100644
index 0000000000000000000000000000000000000000..3dd05047ce3428b801d902ef5038f5e598788778
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/fusion_wrapper.h
@@ -0,0 +1,42 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef XLA_SERVICE_GPU_FUSION_WRAPPER_H_
+#define XLA_SERVICE_GPU_FUSION_WRAPPER_H_
+
+#include "absl/container/flat_hash_set.h"
+#include "absl/strings/string_view.h"
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/service/hlo_pass_interface.h"
+#include "xla/statusor.h"
+
+namespace xla {
+namespace gpu {
+
+// Wraps leftover unfused instruction that are in the entry computation that
+// have no LHLO equivalent in fusions containing just that instruction.
+class FusionWrapper : public HloModulePass {
+ public:
+  absl::string_view name() const override { return "fusion-wrapper"; }
+
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_FUSION_WRAPPER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/fusions/copy.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/fusions/copy.h
new file mode 100644
index 0000000000000000000000000000000000000000..173517d73384c7eae9e36aab5f29bd7a509f3b9a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/fusions/copy.h
@@ -0,0 +1,45 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef XLA_SERVICE_GPU_FUSIONS_COPY_H_
+#define XLA_SERVICE_GPU_FUSIONS_COPY_H_
+
+#include "xla/service/gpu/fusions/fusion_emitter.h"
+#include "xla/service/gpu/ir_emitter_context.h"
+
+namespace xla {
+namespace gpu {
+
+// Special case of a fusion consisting only of a kCopy instruction that can be
+// implemented using a memcpy.
+class MemcpyFusion : public FusionInterface {
+ public:
+  MemcpyFusion(mlir::Value src, mlir::Value dst) : src_(src), dst_(dst) {}
+
+  StatusOr<FusionEmissionResult> Emit(IrEmitterContext& ir_emitter_context,
+                                      ElementalIrEmitter& elemental_emitter,
+                                      mlir::lmhlo::FusionOp fusion_op,
+                                      const HloFusionInstruction& fusion,
+                                      KernelReuseCache& kernel_cache,
+                                      llvm::IRBuilder<>*) const final;
+
+ private:
+  mlir::Value src_;
+  mlir::Value dst_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_FUSIONS_COPY_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/fusions/fusion_emitter.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/fusions/fusion_emitter.h
new file mode 100644
index 0000000000000000000000000000000000000000..1cd527d0788081449b8d4edde66555a3d7bf2a6e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/fusions/fusion_emitter.h
@@ -0,0 +1,88 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef XLA_SERVICE_GPU_FUSIONS_FUSION_EMITTER_H_
+#define XLA_SERVICE_GPU_FUSIONS_FUSION_EMITTER_H_
+
+#include <memory>
+#include <optional>
+#include <vector>
+
+#include "xla/hlo/ir/hlo_instructions.h"
+#include "xla/mlir_hlo/lhlo/IR/lhlo_ops.h"
+#include "xla/service/elemental_ir_emitter.h"
+#include "xla/service/gpu/ir_emitter_context.h"
+#include "xla/service/gpu/kernel_reuse_cache.h"
+#include "xla/service/gpu/launch_dimensions.h"
+#include "xla/service/gpu/thunk.h"
+#include "xla/service/llvm_ir/ir_array.h"
+
+namespace xla {
+namespace gpu {
+
+struct FusionEmissionResult {
+  std::vector<std::unique_ptr<Thunk>> thunks;
+};
+
+class FusionInterface {
+ public:
+  virtual ~FusionInterface() = default;
+
+  virtual StatusOr<FusionEmissionResult> Emit(
+      IrEmitterContext& ir_emitter_context,
+      ElementalIrEmitter& elemental_emitter, mlir::lmhlo::FusionOp fusion_op,
+      const HloFusionInstruction& fusion, KernelReuseCache& kernel_cache,
+      llvm::IRBuilder<>* builder) const = 0;
+};
+
+class KernelFusionEmitterBase : public FusionInterface {
+ public:
+  // The downstream code that is used by this emitter operates on a mix of MLIR
+  // and HLO classes. Ideally this would not be the case, but it's hard to
+  // change.
+  StatusOr<FusionEmissionResult> Emit(IrEmitterContext& ir_emitter_context,
+                                      ElementalIrEmitter& elemental_emitter,
+                                      mlir::lmhlo::FusionOp fusion_op,
+                                      const HloFusionInstruction& fusion,
+                                      KernelReuseCache& kernel_cache,
+                                      llvm::IRBuilder<>* builder) const final;
+  virtual StatusOr<LaunchDimensions> launch_dimensions(
+      IrEmitterContext& ir_emitter_context, int kernel_index) const = 0;
+
+ protected:
+  virtual Status EmitKernel(IrEmitterContext& ir_emitter_context,
+                            ElementalIrEmitter& elemental_emitter,
+                            mlir::lmhlo::FusionOp fusion_op,
+                            const HloFusionInstruction& fusion,
+                            const LaunchDimensions& launch_dims,
+                            std::vector<llvm_ir::IrArray> inputs,
+                            std::vector<llvm_ir::IrArray> outputs,
+                            llvm::IRBuilder<>* builder,
+                            int kernel_index) const = 0;
+  virtual int num_kernels() const { return 1; }
+};
+
+std::tuple<llvm::Function*, std::vector<llvm_ir::IrArray /*inputs*/>,
+           std::vector<llvm_ir::IrArray> /*outputs*/>
+BuildKernelPrototype(IrEmitterContext& ir_emitter_context,
+                     const std::string& suggested_name,
+                     absl::Span<const KernelArgument> arguments,
+                     size_t num_inputs,
+                     const LaunchDimensions& launch_dimensions,
+                     llvm::IRBuilder<>* builder);
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_FUSIONS_FUSION_EMITTER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/fusions/fusions.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/fusions/fusions.h
new file mode 100644
index 0000000000000000000000000000000000000000..1899fea07caa606790d594bd37e88e7d17d403d6
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/fusions/fusions.h
@@ -0,0 +1,41 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef XLA_SERVICE_GPU_FUSIONS_FUSIONS_H_
+#define XLA_SERVICE_GPU_FUSIONS_FUSIONS_H_
+
+#include <memory>
+#include <optional>
+
+#include "absl/types/span.h"
+#include "xla/mlir_hlo/lhlo/IR/lhlo_ops.h"
+#include "xla/service/buffer_assignment.h"
+#include "xla/service/gpu/fusions/fusion_emitter.h"
+#include "xla/service/gpu/hlo_fusion_analysis.h"
+
+namespace xla {
+namespace gpu {
+
+// Returns the emitter for the given fusion. Returns nullopt if the fusion
+// type is not yet supported.
+// `allocations` may be empty and `fusion_op` may be nullptr if buffer
+// assignment didn't run yet.
+std::optional<std::unique_ptr<FusionInterface>> GetFusionEmitter(
+    HloFusionAnalysis& analysis, absl::Span<const BufferAllocation> allocations,
+    mlir::lmhlo::FusionOp fusion_op);
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_FUSIONS_FUSIONS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/fusions/in_place_dynamic_update_slice.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/fusions/in_place_dynamic_update_slice.h
new file mode 100644
index 0000000000000000000000000000000000000000..c6e15c2811b37aa76807bc972b8b0da8fc755de8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/fusions/in_place_dynamic_update_slice.h
@@ -0,0 +1,77 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef XLA_SERVICE_GPU_FUSIONS_IN_PLACE_DYNAMIC_UPDATE_SLICE_H_
+#define XLA_SERVICE_GPU_FUSIONS_IN_PLACE_DYNAMIC_UPDATE_SLICE_H_
+
+#include <vector>
+
+#include "xla/service/gpu/fusions/fusion_emitter.h"
+#include "xla/service/gpu/hlo_fusion_analysis.h"
+#include "xla/service/gpu/ir_emission_utils.h"
+
+namespace xla {
+namespace gpu {
+
+// Fusion node where the root is either:
+// 1. a dynamic-update-slice op
+// 2. a bitcast of a dynamic-update-slice op
+// 3. a tuple op returning the result of several dynamic-update-slice ops
+// 4. a tuple op returning the result of several bitcast
+//    dynamic-update-slice ops
+//
+// Additionally, all the dynamic-update-slice ops have exactly one user. The
+// fusion parameter that they update can have users (in addition to the
+// dynamic-update-slice op) that read in either
+// a. a dynamic-slice corresponding exactly to the slice of the parameter that
+//    is updated by the dynamic-update-slice op
+// b. a dynamic-slice reading in a single element anywhere in the parameter.
+//    This is only allowed if the dynamic-update-slice op updates a single
+//    element
+//
+// In both cases, the additional users must not flow into any other output
+// than the dynamic-slice-update corresponding to that particular slice of the
+// parameter.
+//
+// The assumption is that each op's input (i.e. array to update) shares the
+// same slice as its output. In this case, we have a special algorithm that
+// modifies the output in place without touching the un-updated elements. The
+// update slice is assumed to be the exact same for all the
+// dynamic-update-slice ops.
+class InPlaceDynamicUpdateSliceEmitter : public KernelFusionEmitterBase {
+ public:
+  explicit InPlaceDynamicUpdateSliceEmitter(const HloFusionAnalysis& analysis)
+      : dus_ops_(
+            GetOutputDefiningDynamicUpdateSlices(analysis.fusion_roots())) {}
+  StatusOr<LaunchDimensions> launch_dimensions(
+      IrEmitterContext& ir_emitter_context, int kernel_index) const override;
+
+ protected:
+  Status EmitKernel(IrEmitterContext& ir_emitter_context,
+                    ElementalIrEmitter& elemental_emitter,
+                    mlir::lmhlo::FusionOp fusion_op,
+                    const HloFusionInstruction& fusion,
+                    const LaunchDimensions& launch_dims,
+                    std::vector<llvm_ir::IrArray> inputs,
+                    std::vector<llvm_ir::IrArray> outputs,
+                    llvm::IRBuilder<>* builder,
+                    int kernel_index) const override;
+
+  std::vector<const HloInstruction*> dus_ops_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_FUSIONS_IN_PLACE_DYNAMIC_UPDATE_SLICE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/fusions/input_slices.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/fusions/input_slices.h
new file mode 100644
index 0000000000000000000000000000000000000000..886e23609732e65ccea2fe873c524ed1505c409a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/fusions/input_slices.h
@@ -0,0 +1,58 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef XLA_SERVICE_GPU_FUSIONS_INPUT_SLICES_H_
+#define XLA_SERVICE_GPU_FUSIONS_INPUT_SLICES_H_
+
+#include <vector>
+
+#include "xla/service/gpu/fusions/fusion_emitter.h"
+#include "xla/service/gpu/hlo_fusion_analysis.h"
+
+namespace xla {
+namespace gpu {
+
+// Generates code for input-fusible slices.
+//
+// Prerequisite: ROOT is either a slice or a tuple of slices. The input shapes
+// of all ROOT slices need to be the same while their output shapes can be
+// different. On the other hand, the input ranges of slices can be
+// overlapping. Further generalization/specialization when the needs are seen
+// in the future.
+class InputSlicesFusion : public KernelFusionEmitterBase {
+ public:
+  explicit InputSlicesFusion(HloFusionAnalysis& analysis)
+      : analysis_(analysis) {}
+  StatusOr<LaunchDimensions> launch_dimensions(
+      IrEmitterContext& ir_emitter_context, int kernel_index) const override;
+
+ protected:
+  Status EmitKernel(IrEmitterContext& ir_emitter_context,
+                    ElementalIrEmitter& elemental_emitter,
+                    mlir::lmhlo::FusionOp fusion_op,
+                    const HloFusionInstruction& fusion,
+                    const LaunchDimensions& launch_dims,
+                    std::vector<llvm_ir::IrArray> inputs,
+                    std::vector<llvm_ir::IrArray> outputs,
+                    llvm::IRBuilder<>* builder,
+                    int kernel_index) const override;
+
+ private:
+  HloFusionAnalysis& analysis_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_FUSIONS_INPUT_SLICES_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/fusions/loop.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/fusions/loop.h
new file mode 100644
index 0000000000000000000000000000000000000000..6d539355c6a5d326bb3604584e5e832710e6e912
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/fusions/loop.h
@@ -0,0 +1,55 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef XLA_SERVICE_GPU_FUSIONS_LOOP_H_
+#define XLA_SERVICE_GPU_FUSIONS_LOOP_H_
+
+#include <vector>
+
+#include "xla/hlo/ir/hlo_instructions.h"
+#include "xla/mlir_hlo/lhlo/IR/lhlo_ops.h"
+#include "xla/service/elemental_ir_emitter.h"
+#include "xla/service/gpu/fusions/fusion_emitter.h"
+#include "xla/service/gpu/hlo_fusion_analysis.h"
+#include "xla/service/gpu/ir_emitter_context.h"
+
+namespace xla {
+namespace gpu {
+
+// Generic loop fusion.
+class LoopFusion : public KernelFusionEmitterBase {
+ public:
+  explicit LoopFusion(HloFusionAnalysis& analysis) : analysis_(analysis) {}
+  StatusOr<LaunchDimensions> launch_dimensions(
+      IrEmitterContext& ir_emitter_context, int kernel_index) const override;
+
+ protected:
+  Status EmitKernel(IrEmitterContext& ir_emitter_context,
+                    ElementalIrEmitter& elemental_emitter,
+                    mlir::lmhlo::FusionOp fusion_op,
+                    const HloFusionInstruction& fusion,
+                    const LaunchDimensions& launch_dims,
+                    std::vector<llvm_ir::IrArray> inputs,
+                    std::vector<llvm_ir::IrArray> outputs,
+                    llvm::IRBuilder<>* builder,
+                    int kernel_index) const override;
+
+ private:
+  HloFusionAnalysis& analysis_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_FUSIONS_LOOP_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/fusions/reduction.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/fusions/reduction.h
new file mode 100644
index 0000000000000000000000000000000000000000..3b3e7897b2cc69f546bd8353afb62a8a8ef30a03
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/fusions/reduction.h
@@ -0,0 +1,107 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef XLA_SERVICE_GPU_FUSIONS_REDUCTION_H_
+#define XLA_SERVICE_GPU_FUSIONS_REDUCTION_H_
+
+#include "xla/service/gpu/fusions/fusion_emitter.h"
+#include "xla/service/gpu/hlo_fusion_analysis.h"
+
+namespace xla {
+namespace gpu {
+
+// Generates code for reduction to contiguous dimensions.
+//
+// Row reduction uses the following algorithm described in CUDA-like
+// pseudocode:
+//
+// ```
+//  __global__ void reduce(int num_rows, float *in, float out) {
+//    __shared__ float[32] cache;
+//    int offset = blockDim.x * blockIdx.x + threadIdx.x;
+//    if (offset >= num_rows) return;
+//    int tile_bound = std::min(offset + kTileSizeX, num_rows);
+//    float accum = 0;
+//    for (int i=offset; i<num_rows; i+= blockDim.x) {
+//      accum += in[i];
+//    }
+//    accum = warp_reduce(accum);
+//    if (threadIdx.x % WarpSize == 0) {
+//      cache[threadIdx.x / WarpSize] = accum;
+//    }
+//    __syncthreads();
+//    if (threadIdx.x / WarpSize == 0) {
+//      bool warp_exists = threadIdx.x < (blockDim.x / WarpSize);
+//      float block_accum = warp_exists ? cache[threadIdx.x % WarpSize] : 0;
+//      block_accum = warp_reduce(accum);
+//      if (threadIdx.x == 0) {
+//        out += block_accum;
+//      }
+//    }
+//  }
+// ```
+//
+// Column reduction uses the following algorithm:
+//
+// ```
+// void reduce(float** in, float* out) {
+//   __shared__ float[32][33] cache;
+//   int thread_id = GetThreadId();
+//   int block_id = GetBlockId();
+//   int tile_size = 128;
+//
+//   float accum = 0;
+//   for (int i=0; i<tile_size; i++) {
+//     accum += in[thread_id.y * tile_size + i][block_id * 32 + thread_id.x];
+//   }
+//   cache[thread_id.x][thread_id.y] = accum;
+//
+//   __syncthreads();
+//   accum = cache[thread_id.y][thread_id.x];
+//   accum = warp_reduce(accum); // Sum all the values of `accum` in the same
+//                               // warp.
+//
+//   if (thread_id.y % 32 == 0) {
+//     out[block_id * 32 + thread_id.x] = accum;
+//   }
+// }
+// ```
+//
+// Moreover, a heuristic is implemented to divide the reduce instructions
+// into groups for parallelization (see `DivideOutputInstructionsIntoGroups`
+// for details about the heuristic.) Reduce instructions in the same group
+// will run sequentially while different groups will run in parallel.
+//
+// we use raw block_id_y to select the reduce groups for execution without
+// complicating the index calculation in the code generation of the reduce
+// instructions. In other words, a block_id_y is assigned to a group and so
+// different groups can be run in parallel.
+class ReductionFusion : public FusionInterface {
+ public:
+  explicit ReductionFusion(HloFusionAnalysis& analysis) : analysis_(analysis) {}
+
+  StatusOr<FusionEmissionResult> Emit(
+      IrEmitterContext& ir_emitter_context,
+      ElementalIrEmitter& elemental_emitter, mlir::lmhlo::FusionOp fusion_op,
+      const HloFusionInstruction& fusion, KernelReuseCache& kernel_cache,
+      llvm::IRBuilder<>* builder) const override;
+
+ private:
+  HloFusionAnalysis& analysis_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_FUSIONS_REDUCTION_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/fusions/thunk_util.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/fusions/thunk_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..0ac5dad3f9009951e4b0df97fb91dba665590a90
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/fusions/thunk_util.h
@@ -0,0 +1,37 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef XLA_SERVICE_GPU_FUSIONS_THUNK_UTIL_H_
+#define XLA_SERVICE_GPU_FUSIONS_THUNK_UTIL_H_
+
+#include <memory>
+#include <optional>
+
+#include "xla/service/gpu/ir_emitter_context.h"
+#include "xla/service/gpu/thunk.h"
+#include "xla/statusor.h"
+
+namespace xla {
+namespace gpu {
+
+// Attempts to build an initializer constant for the given value. Returns an
+// empty optional if the value is not a constant.
+StatusOr<std::optional<std::unique_ptr<Thunk>>> BuildConstantInitializerThunk(
+    IrEmitterContext& ir_emitter_context, mlir::Operation* op,
+    mlir::Value init_value, mlir::Value dest);
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_FUSIONS_THUNK_UTIL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/fusions/tiling_util.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/fusions/tiling_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..7765d02de9a6f1e22358968b7a29267589a17de0
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/fusions/tiling_util.h
@@ -0,0 +1,149 @@
+/*Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef XLA_SERVICE_GPU_FUSIONS_TILING_UTIL_H_
+#define XLA_SERVICE_GPU_FUSIONS_TILING_UTIL_H_
+
+#include <functional>
+
+#include "xla/service/gpu/kernel_mapping_scheme.h"
+#include "xla/service/llvm_ir/ir_array.h"
+
+namespace xla {
+namespace gpu {
+
+// Contains threading information. Note that for performance we might apply
+// thread id "scaling" where the physical thread id (to achieve good SM
+// occupancy) will differ from logical thread id. This struct contains
+// logical thread ids, along with meta-information about the scaling applied.
+struct TilingThreadIdInfo {
+  TilingThreadIdInfo(llvm::Value* thread_id, llvm::Value* thread_id_x,
+                     llvm::Value* thread_id_y, llvm::Value* lane_id,
+                     llvm::Value* block_id, llvm::Value* scaling)
+      : thread_id(thread_id),
+        thread_id_x(thread_id_x),
+        thread_id_y(thread_id_y),
+        lane_id(lane_id),
+        block_id(block_id),
+        scaling(scaling) {}
+
+  llvm::Value* thread_id;
+
+  // X-coordinate calculated from thread id: `thread_id % num_threads_x`
+  llvm::Value* thread_id_x;
+
+  // Y-coordinate calculated from thread id: `thread_id / num_threads_x`
+  llvm::Value* thread_id_y;
+
+  // Lane id: `thread_id % WarpSize`
+  llvm::Value* lane_id;
+
+  // Block id.
+  llvm::Value* block_id;
+
+  // Emits GEP into a shared memory, taking virtual thread scaling into
+  // account. Automatically inserts the first zero required by LLVM GEP.
+  // Defined on ThreadIdInfo to keep `scaling` private.
+  //
+  // Same semantics as CreateInBoundsGEP.
+  llvm::Value* GEPIntoSharedMemory(
+      llvm::IRBuilder<>* b, llvm::GlobalVariable* shared,
+      absl::Span<llvm::Value* const> idx_major_to_minor,
+      const llvm::Twine& name = "") const;
+
+  // Calculate the pointee type of the llvm::Value returned by
+  // GEPIntoSharedMemory
+  llvm::Type* GEPIntoSharedMemoryType(
+      llvm::GlobalVariable* shared,
+      absl::Span<llvm::Value* const> idx_major_to_minor) const;
+
+ private:
+  llvm::Value* scaling;
+};
+
+struct TilingKernelInfo {
+  // Tiling bounds.
+  std::array<llvm::Value*, 2> output_tile_bounds;
+
+  // Starting tile, as calculated from block id only.
+  llvm_ir::IrArray::Index tile_origin;
+
+  // Thread meta-info.
+  TilingThreadIdInfo thread_id_info;
+};
+
+// A function to generate the code to emit the entire tile.
+//
+// index: Absolute coordinate of the start of the tile in input.
+// tile_dimensions: Size of the tile
+using TileElementGenerator =
+    std::function<void(const TilingThreadIdInfo& thread_id_info,
+                       const llvm_ir::IrArray::Index& index,
+                       std::array<llvm::Value*, 2> tile_dimensions)>;
+
+// A function object to generate code to process one element in a tile.
+//
+// index: the index for the first output element of the current thread.
+// y_loc: The y coordinate within a tile.
+// x_loc: The x coordinate within a tile.
+using EmitTileElementFunction =
+    std::function<void(const TilingThreadIdInfo& thread_id_info,
+                       const llvm_ir::IrArray::Index& index, llvm::Value* y_loc,
+                       llvm::Value* x_loc)>;
+
+// Emits code to iterate through a 2-dimensional tile with a given tile
+// dimensions and given strides, and call the callback at each iteration.,
+//
+// thread_id_y` and `thread_id_x` are the intra-tile coordinates for
+// the first element to process, and `index` is the index for the origin of
+// the tile. Emits bounds check to ensure that each processed element
+// is within the boundary defined by `tile_dimensions`.
+//
+// Rough pseudocode:
+//
+// Given: tile_dimensions, x_offset, y_offset
+//
+// for (y = 0; y < tile_dimensions[0]; y += num_threads_y) {
+//   for (x = 0; x < tile_dimensions[1]; x++) {
+//
+//     y_pos = y_offset + y
+//     x_pos = x_offset + x * stride
+//
+//     if (x_loc < tile_width) {
+//       emit_elem_function(y_offset + y, x_loc);
+//     }
+//   }
+// }
+//
+void EmitTile(llvm::IRBuilder<>* builder, const TilingScheme& tiling_scheme,
+              const llvm_ir::IrArray::Index& tile_origin_index,
+              const TilingThreadIdInfo& thread_id_info,
+              std::array<llvm::Value*, 2> tile_dimensions,
+              const EmitTileElementFunction& emit_elem_function);
+
+// Emits a kernel for the hlo instruction using the given kernel mapping
+// scheme.
+StatusOr<TilingKernelInfo> EmitTilingKernel(
+    llvm::IRBuilder<>* builder, const TilingScheme& tiling_scheme,
+    llvm::Type* index_ty, const TileElementGenerator& tile_element_generator);
+
+llvm_ir::IrArray::Index GetUnnormalizedIndex(
+    const llvm_ir::IrArray::Index& normalized_shape_index,
+    const Shape& unnormalized_shape, llvm::IRBuilder<>* builder,
+    absl::Span<const int64_t> dims_in_elems);
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_FUSIONS_TILING_UTIL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/fusions/transpose.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/fusions/transpose.h
new file mode 100644
index 0000000000000000000000000000000000000000..85f7292d524077d6688dc5970346e3169e4da898
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/fusions/transpose.h
@@ -0,0 +1,79 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef XLA_SERVICE_GPU_FUSIONS_TRANSPOSE_H_
+#define XLA_SERVICE_GPU_FUSIONS_TRANSPOSE_H_
+
+#include <vector>
+
+#include "xla/hlo/ir/hlo_instructions.h"
+#include "xla/mlir_hlo/lhlo/IR/lhlo_ops.h"
+#include "xla/service/elemental_ir_emitter.h"
+#include "xla/service/gpu/fusions/fusion_emitter.h"
+#include "xla/service/gpu/hlo_fusion_analysis.h"
+#include "xla/service/gpu/ir_emitter_context.h"
+
+namespace xla {
+namespace gpu {
+
+// Emits a kernel for the given hlo instruction using a tiled 0-2-1 transpose
+// algorithm to improve the memory access patterns for the input parameters
+// with a shape that is a 0-2-1 transpose of the output tensor shape. The
+// caller is responsible for making sure that it is safe to apply the shared
+// memory transpose on the input parameters.
+//
+// For the purpose of tiling, the output tensors have a logical shape of three
+// components 0-2-1 while the relevant input parameters have a logical shape
+// of three components 0-1-2 in the order major to minor. The x- and y-
+// dimensions of the tensors are tiled in square tiles with an edge length
+// `kTileSize`. Each thread block of `kTileSize` x `kNumRows` threads
+// transposes one tile: each thread copies kTileSize/kNumRows elements from
+// the input to a shared memory tile, then the otherwise "regular HLO kernel"
+// reads from the shared memory instead of the original input.
+//
+// This is similar to the following CUDA algorithm in TensorFlow:
+// https://goo.gl/MStRV6.
+//
+// `kTileSize` should usually be same as warp size. We currently choose 32 for
+// `kTileSize` and 4 for `kNumRows`. The CUDA algorithm uses 8 for `kNumRows`.
+//
+// TODO(b/33320379): Here each block transposes 1 tile. It may be more
+// efficient to launch fewer blocks so each transposes many tiles.
+class TransposeFusion : public KernelFusionEmitterBase {
+ public:
+  explicit TransposeFusion(HloFusionAnalysis& analysis) : analysis_(analysis) {}
+  StatusOr<LaunchDimensions> launch_dimensions(
+      IrEmitterContext& ir_emitter_context, int kernel_index) const override {
+    return analysis_.GetLaunchDimensions();
+  }
+
+ protected:
+  Status EmitKernel(IrEmitterContext& ir_emitter_context,
+                    ElementalIrEmitter& elemental_emitter,
+                    mlir::lmhlo::FusionOp fusion_op,
+                    const HloFusionInstruction& fusion,
+                    const LaunchDimensions& launch_dims,
+                    std::vector<llvm_ir::IrArray> inputs,
+                    std::vector<llvm_ir::IrArray> outputs,
+                    llvm::IRBuilder<>* builder,
+                    int kernel_index) const override;
+
+ private:
+  HloFusionAnalysis& analysis_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_FUSIONS_TRANSPOSE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gemm_algorithm_picker.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gemm_algorithm_picker.h
new file mode 100644
index 0000000000000000000000000000000000000000..9675d8968bfebf26762361a2d5880eef8e52929b
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gemm_algorithm_picker.h
@@ -0,0 +1,78 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef XLA_SERVICE_GPU_GEMM_ALGORITHM_PICKER_H_
+#define XLA_SERVICE_GPU_GEMM_ALGORITHM_PICKER_H_
+
+#include <functional>
+#include <optional>
+#include <string>
+#include <string_view>
+#include <variant>
+
+#include "absl/strings/string_view.h"
+#include "xla/autotune_results.pb.h"
+#include "xla/autotuning.pb.h"
+#include "xla/hlo/ir/hlo_instructions.h"
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/service/gpu/autotuner_util.h"
+#include "xla/service/hlo_pass_interface.h"
+#include "xla/stream_executor/device_description.h"
+#include "xla/stream_executor/device_memory_allocator.h"
+#include "xla/stream_executor/stream_executor.h"
+
+#if (defined(GOOGLE_CUDA) && GOOGLE_CUDA)
+#include "xla/service/gpu/gpu_conv_runner.h"
+#include "xla/stream_executor/cuda/cuda_blas_lt.h"
+#include "xla/stream_executor/gpu/redzone_allocator.h"
+#endif
+
+namespace xla {
+namespace gpu {
+
+StatusOr<AutotuneResult> GetBestBlasAlgorithm(
+    se::Stream* stream, se::RedzoneAllocator& allocator,
+    std::optional<std::string_view> gemm_str,
+    const AutotuneConfig& autotune_config, se::DeviceMemoryBase lhs_buffer,
+    se::DeviceMemoryBase rhs_buffer, se::DeviceMemoryBase output_buffer,
+    absl::Span<const se::blas::AlgorithmType> algorithms,
+    const Shape& output_shape, const HloModuleConfig& hlo_module_config,
+    double beta,
+    const std::function<StatusOr<se::blas::ProfileResult>(
+        const se::blas::AlgorithmType&)>& run_benchmark);
+
+// GemmAlgorithmPicker supports two modes: device and deviceless.
+// In device mode, we run autotuning on the device and store autotune results.
+// In deviceless mode, we pass in some information related to the device and
+// use stored autotune results to rewrite Gemm instructions. If the required
+// autotune result is not stored, then algorithm is set to kRuntimeAutotuning.
+class GemmAlgorithmPicker : public HloModulePass {
+ public:
+  explicit GemmAlgorithmPicker(AutotuneConfig config) : config_(config) {}
+
+  absl::string_view name() const override { return "gemm-algorithm-picker"; }
+
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+
+ private:
+  AutotuneConfig config_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_GEMM_ALGORITHM_PICKER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gemm_broadcast_folding_rewriter.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gemm_broadcast_folding_rewriter.h
new file mode 100644
index 0000000000000000000000000000000000000000..46fdc839738768befc3fd25fab706f4c30b37e32
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gemm_broadcast_folding_rewriter.h
@@ -0,0 +1,51 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef XLA_SERVICE_GPU_GEMM_BROADCAST_FOLDING_REWRITER_H_
+#define XLA_SERVICE_GPU_GEMM_BROADCAST_FOLDING_REWRITER_H_
+
+#include <optional>
+
+#include "xla/hlo/ir/hlo_instructions.h"
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/service/hlo_pass_interface.h"
+
+namespace xla {
+namespace gpu {
+
+// cuBLAS GEMM has support for strided batched calls, where the stride is used
+// to determine the offset between the batches.
+//
+// This allows (kCustomCall:gemm A kBroadcast(B)) or
+//             (kCustomCall:gemm kBroadcast(A) B)
+// to be rewritten as (kCustomCall:gemm A B) with a zero stride for the
+// broadcasted operand if the broadcast operates on all the batch dimensions.
+//
+// This pattern matches the above case and removes the unnecessary broadcast.
+class GemmBroadcastFoldingRewriter : public HloModulePass {
+ public:
+  absl::string_view name() const override {
+    return "cublas-gemm-broadcast-folding-rewriter";
+  }
+
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_GEMM_BROADCAST_FOLDING_REWRITER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gemm_rewriter.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gemm_rewriter.h
new file mode 100644
index 0000000000000000000000000000000000000000..65efd940450e468ed4424f727351da8ff5b0b2e7
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gemm_rewriter.h
@@ -0,0 +1,62 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef XLA_SERVICE_GPU_GEMM_REWRITER_H_
+#define XLA_SERVICE_GPU_GEMM_REWRITER_H_
+
+#include <optional>
+
+#include "xla/hlo/ir/hlo_instructions.h"
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/service/hlo_pass_interface.h"
+#include "xla/stream_executor/device_description.h"
+
+namespace xla {
+namespace gpu {
+
+// cuBLAS GEMM in the most general form can run the following operation:
+//
+// (kAdd
+//    (kMultiply (kDot A B) alpha)
+//    (kMultiply C beta))
+//
+// where A, B, C are matrixes and `alpha` and `beta` are host constants.
+// The additional requirement is that C has no other users (otherwise,
+// it does not make sense to fuse it inside the custom call).
+//
+// Both multiplication and addition can be avoided (equivalent to setting
+// `alpha` to one and `beta` to zero).
+//
+// This pass pattern-matches the most general form of this instruction
+// (we assume transposes are already folded), and rewrites it into a custom call
+// where (A, B, C) are three operands respectively, and `alpha` and `beta` are
+// stored in the backend config.
+class GemmRewriter : public HloModulePass {
+ public:
+  explicit GemmRewriter(se::GpuComputeCapability gpu_version);
+  absl::string_view name() const override { return "cublas-gemm-rewriter"; }
+
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+
+ private:
+  se::GpuComputeCapability gpu_version_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_GEMM_REWRITER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gemm_rewriter_triton.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gemm_rewriter_triton.h
new file mode 100644
index 0000000000000000000000000000000000000000..db52fa54aadb31456780a82e24b3a9273d10caec
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gemm_rewriter_triton.h
@@ -0,0 +1,173 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef XLA_SERVICE_GPU_GEMM_REWRITER_TRITON_H_
+#define XLA_SERVICE_GPU_GEMM_REWRITER_TRITON_H_
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+#include "absl/container/flat_hash_map.h"
+#include "absl/container/flat_hash_set.h"
+#include "absl/strings/string_view.h"
+#include "xla/autotuning.pb.h"
+#include "xla/hlo/ir/hlo_computation.h"
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/hlo/ir/hlo_opcode.h"
+#include "xla/service/hlo_pass_interface.h"
+#include "xla/service/instruction_fusion.h"
+#include "xla/status.h"
+#include "xla/statusor.h"
+#include "xla/stream_executor/device_description.h"
+#include "xla/xla_data.pb.h"
+
+namespace xla {
+namespace gpu {
+
+// Tells if f(a+b) == f(a) + f(b).
+bool IsDistributiveOverAddition(const HloInstruction& hlo);
+
+// Allowlist of unary elementwise operations supported by Triton GEMM codegen.
+std::vector<HloOpcode> TritonSupportedUnaryElementwise(PrimitiveType);
+
+// Allowlist of binary elementwise operations supported by Triton GEMM codegen.
+std::vector<HloOpcode> TritonSupportedBinaryElementwise(PrimitiveType);
+
+// Allowlist of ternary elementwise operations supported by Triton GEMM codegen.
+std::vector<HloOpcode> TritonSupportedTernaryElementwise(PrimitiveType);
+
+// Data types that are supported by the Triton emitters.
+bool IsTritonSupportedDataType(PrimitiveType, se::GpuComputeCapability);
+
+// Checks elementwise operation against all supported by Triton GEMM codegen.
+bool IsTritonSupportedElementwise(HloOpcode, PrimitiveType);
+
+// Filters GEMMs which can be handled using Triton.
+FusionDecision CanTritonHandleGEMM(const HloInstruction&,
+                                   se::GpuComputeCapability gpu_version);
+
+// Filters GEMMs which are better to handle using Triton.
+bool ShouldTritonHandleGEMM(HloInstruction&,
+                            se::GpuComputeCapability gpu_version);
+
+class TensorIterationSpec {
+ public:
+  // Description of basic iteration: `count` elements separated by `stride`.
+  struct IterationSpecFragment {
+    int64_t stride;
+    int64_t count;
+    int64_t slice_start;
+    int64_t slice_limit;
+    // Logical subfragments when this iteration is composed
+    // of several HLO dimensions.
+    std::vector<int64_t> subfragments;
+
+    bool is_sliced() const { return count != slice_limit - slice_start; }
+    bool operator!=(const IterationSpecFragment& other) const;
+    std::string ToString() const;
+  };
+  // Description of complex iteration over a sequence of several strides.
+  // Describes a logically contiguous dimension of a tensor physically
+  // separated into multiple fragments by other dimensions.
+  using DimIterationSpec = std::vector<IterationSpecFragment>;
+
+  using StorageType = absl::flat_hash_map<int, DimIterationSpec>;
+  const DimIterationSpec& operator[](const int dimension) const {
+    return dim_iteration_specs_.at(dimension);
+  }
+  DimIterationSpec& operator[](const int dimension) {
+    return dim_iteration_specs_[dimension];
+  }
+  const StorageType& Storage() const { return dim_iteration_specs_; }
+  void RemoveEmptyDimensions() {
+    absl::erase_if(dim_iteration_specs_,
+                   [](const auto& it) { return it.second.empty(); });
+  }
+
+  // Compares physical layouts of tensors ignoring subfragments of dimensions.
+  bool operator==(const TensorIterationSpec& other) const;
+
+  std::string ToString() const;
+
+ private:
+  StorageType dim_iteration_specs_;
+};
+
+// Analysis of tensor iteration orders within tiled fusions.
+class TritonFusionAnalysis {
+  Status ExecuteForDotFusion(const HloInstruction& dot, int split_k);
+  Status ExecuteForSoftmaxFusion(const HloInstruction& root);
+
+ public:
+  // Execute the analysis of a fusion computation.
+  // `split_k` indicates whether this operation was converted to the split-K
+  // form and tells the analysis how to interpret the batch dimensions.
+  static StatusOr<TritonFusionAnalysis> Execute(
+      const HloComputation& computation, int split_k = 1);
+
+  // A scope is an HLO graph that can be tiled efficiently using same or
+  // compatible tile shapes on all operations. GEMM fusion has 3 scopes
+  // defined by left operand, right operand and output.
+  enum class Scope { LHS = 0, RHS = 1, OUTPUT = 2 };
+
+  using IterationSpecByInstructionMap =
+      ConstHloInstructionMap<TensorIterationSpec>;
+  using IterationSpecByInstructionByScopeMap =
+      std::map<Scope, IterationSpecByInstructionMap>;
+
+  // Every parameter requires a separate piece of shared memory for asynchronous
+  // loads. Multiple parameters are approximately equivalent to multiple
+  // pipeline stages.
+  static constexpr int kMaxParameterPerScope = 4;
+
+  // Scope -> HLO -> dot dimension number -> iteration spec at the HLO's output.
+  const TensorIterationSpec::DimIterationSpec* IterSpec(Scope scope,
+                                                        const HloInstruction*,
+                                                        int dimension) const;
+  // Parameter HLO instructions used in a scope of `dot`.
+  const ConstHloInstructionSet& ScopeParameters(const Scope scope) const {
+    return parameters_.at(scope);
+  }
+
+  std::string ToString() const;
+
+ private:
+  IterationSpecByInstructionByScopeMap iter_specs_;
+  // HLO computation parameters per scope.
+  std::map<Scope, ConstHloInstructionSet> parameters_;
+};
+
+// Rewrite compatible dot() calls into custom calls with fused computations
+// that target Triton-based matmul emitter.
+class GemmRewriterTriton : public HloModulePass {
+ public:
+  explicit GemmRewriterTriton(se::GpuComputeCapability gpu_version)
+      : gpu_version_(gpu_version) {}
+  absl::string_view name() const override { return "triton-gemm-rewriter"; }
+
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+
+ private:
+  se::GpuComputeCapability gpu_version_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_GEMM_REWRITER_TRITON_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gemm_thunk.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gemm_thunk.h
new file mode 100644
index 0000000000000000000000000000000000000000..548ff737425557d154f208ae82ea76cdfd8b2cfb
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gemm_thunk.h
@@ -0,0 +1,57 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_GEMM_THUNK_H_
+#define XLA_SERVICE_GPU_GEMM_THUNK_H_
+
+#include "xla/service/buffer_assignment.h"
+#include "xla/service/gpu/matmul_utils.h"
+#include "xla/service/gpu/thunk.h"
+#include "xla/status.h"
+#include "xla/stream_executor/stream_executor.h"
+
+namespace xla {
+namespace gpu {
+
+// This is thread-compatible.
+class GemmThunk : public Thunk {
+ public:
+  // Constructs a thunk that computes "output = (lhs <dot> rhs) * alpha" using
+  // BLAS gemm (alpha is stored in the instruction GemmBackendConfig).
+  GemmThunk(ThunkInfo thunk_info, GemmConfig config,
+            const BufferAllocation::Slice& lhs_buffer,
+            const BufferAllocation::Slice& rhs_buffer,
+            const BufferAllocation::Slice& output_buffer, bool deterministic);
+
+  GemmThunk(const GemmThunk&) = delete;
+  GemmThunk& operator=(const GemmThunk&) = delete;
+
+  Status ExecuteOnStream(const ExecuteParams& params) override;
+  Status Initialize(const GpuExecutable& executable,
+                    se::StreamExecutor* executor) override;
+
+ private:
+  const GemmConfig config_;
+  const BufferAllocation::Slice lhs_buffer_;
+  const BufferAllocation::Slice rhs_buffer_;
+  const BufferAllocation::Slice output_buffer_;
+  // Whether to run deterministically.
+  const bool deterministic_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_GEMM_THUNK_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_all_gather_optimizer.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_all_gather_optimizer.h
new file mode 100644
index 0000000000000000000000000000000000000000..717c6088f06e4b5f87bcab369a34033fc09fee77
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_all_gather_optimizer.h
@@ -0,0 +1,42 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_GPU_ALL_GATHER_OPTIMIZER_H_
+#define XLA_SERVICE_GPU_GPU_ALL_GATHER_OPTIMIZER_H_
+
+#include "xla/service/hlo_pass_interface.h"
+
+namespace xla {
+namespace gpu {
+
+// Transforms binary_op(all-gather(reduce_scatter(a)),
+// all-gather(reduce_scatter(b))) to allgather(binary_op(reduce_scatter(a),
+// reduce_scatter(b)))
+
+class AllGatherOptimizer : public HloModulePass {
+ public:
+  AllGatherOptimizer() = default;
+  absl::string_view name() const override { return "all-gather-optimizer"; }
+
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_GPU_ALL_GATHER_OPTIMIZER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_asm_opts_util.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_asm_opts_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..22a08f8657a99b7006134011a871d9aee3b6581b
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_asm_opts_util.h
@@ -0,0 +1,32 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_GPU_ASM_OPTS_UTIL_H_
+#define XLA_SERVICE_GPU_GPU_ASM_OPTS_UTIL_H_
+
+#include "xla/stream_executor/gpu/gpu_asm_opts.h"
+#include "xla/xla.pb.h"
+
+namespace xla {
+namespace gpu {
+
+// Create GpuAsmOpts out of DebugOptions.
+stream_executor::GpuAsmOpts PtxOptsFromDebugOptions(
+    const DebugOptions& debug_options);
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_GPU_ASM_OPTS_UTIL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_async_collective_annotator.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_async_collective_annotator.h
new file mode 100644
index 0000000000000000000000000000000000000000..94955ff6395b616826edfa3bff63b36487ac11a4
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_async_collective_annotator.h
@@ -0,0 +1,47 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_GPU_ASYNC_COLLECTIVE_ANNOTATOR_H_
+#define XLA_SERVICE_GPU_GPU_ASYNC_COLLECTIVE_ANNOTATOR_H_
+
+#include <utility>
+
+#include "xla/service/hlo_pass_interface.h"
+
+namespace xla {
+namespace gpu {
+
+// Annotate async collectives with CollectiveBackendConfig.
+class GpuAsyncCollectiveAnnotator : public HloModulePass {
+ public:
+  explicit GpuAsyncCollectiveAnnotator(HloPredicate is_collective_async)
+      : is_collective_async_(std::move(is_collective_async)) {}
+  absl::string_view name() const override {
+    return "gpu-async-collective-annotator";
+  }
+
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+
+ private:
+  HloPredicate is_collective_async_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_GPU_ASYNC_COLLECTIVE_ANNOTATOR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_autotuning.pb.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_autotuning.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..620b191fd4a9cfac804eb7133247471a7ccb6e71
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_autotuning.pb.h
@@ -0,0 +1,1494 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: xla/service/gpu/gpu_autotuning.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_xla_2fservice_2fgpu_2fgpu_5fautotuning_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_xla_2fservice_2fgpu_2fgpu_5fautotuning_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3021000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3021009 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+#include "xla/autotuning.pb.h"
+#include "xla/service/hlo.pb.h"
+#include "xla/xla_data.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_xla_2fservice_2fgpu_2fgpu_5fautotuning_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_xla_2fservice_2fgpu_2fgpu_5fautotuning_2eproto {
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_xla_2fservice_2fgpu_2fgpu_5fautotuning_2eproto;
+namespace xla {
+namespace gpu {
+class AlgorithmDenylist;
+struct AlgorithmDenylistDefaultTypeInternal;
+extern AlgorithmDenylistDefaultTypeInternal _AlgorithmDenylist_default_instance_;
+class AlgorithmDenylistEntry;
+struct AlgorithmDenylistEntryDefaultTypeInternal;
+extern AlgorithmDenylistEntryDefaultTypeInternal _AlgorithmDenylistEntry_default_instance_;
+class ConvInstructionLog;
+struct ConvInstructionLogDefaultTypeInternal;
+extern ConvInstructionLogDefaultTypeInternal _ConvInstructionLog_default_instance_;
+class DenylistedAlgorithm;
+struct DenylistedAlgorithmDefaultTypeInternal;
+extern DenylistedAlgorithmDefaultTypeInternal _DenylistedAlgorithm_default_instance_;
+}  // namespace gpu
+}  // namespace xla
+PROTOBUF_NAMESPACE_OPEN
+template<> ::xla::gpu::AlgorithmDenylist* Arena::CreateMaybeMessage<::xla::gpu::AlgorithmDenylist>(Arena*);
+template<> ::xla::gpu::AlgorithmDenylistEntry* Arena::CreateMaybeMessage<::xla::gpu::AlgorithmDenylistEntry>(Arena*);
+template<> ::xla::gpu::ConvInstructionLog* Arena::CreateMaybeMessage<::xla::gpu::ConvInstructionLog>(Arena*);
+template<> ::xla::gpu::DenylistedAlgorithm* Arena::CreateMaybeMessage<::xla::gpu::DenylistedAlgorithm>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace xla {
+namespace gpu {
+
+// ===================================================================
+
+class ConvInstructionLog final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.gpu.ConvInstructionLog) */ {
+ public:
+  inline ConvInstructionLog() : ConvInstructionLog(nullptr) {}
+  ~ConvInstructionLog() override;
+  explicit PROTOBUF_CONSTEXPR ConvInstructionLog(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ConvInstructionLog(const ConvInstructionLog& from);
+  ConvInstructionLog(ConvInstructionLog&& from) noexcept
+    : ConvInstructionLog() {
+    *this = ::std::move(from);
+  }
+
+  inline ConvInstructionLog& operator=(const ConvInstructionLog& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ConvInstructionLog& operator=(ConvInstructionLog&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ConvInstructionLog& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ConvInstructionLog* internal_default_instance() {
+    return reinterpret_cast<const ConvInstructionLog*>(
+               &_ConvInstructionLog_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(ConvInstructionLog& a, ConvInstructionLog& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ConvInstructionLog* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ConvInstructionLog* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ConvInstructionLog* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ConvInstructionLog>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ConvInstructionLog& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const ConvInstructionLog& from) {
+    ConvInstructionLog::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ConvInstructionLog* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "xla.gpu.ConvInstructionLog";
+  }
+  protected:
+  explicit ConvInstructionLog(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kOperandShapesFieldNumber = 2,
+    kResultAddressesFieldNumber = 3,
+    kOperandAddressesFieldNumber = 4,
+    kInstructionFieldNumber = 1,
+  };
+  // repeated .xla.ShapeProto operand_shapes = 2;
+  int operand_shapes_size() const;
+  private:
+  int _internal_operand_shapes_size() const;
+  public:
+  void clear_operand_shapes();
+  ::xla::ShapeProto* mutable_operand_shapes(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::ShapeProto >*
+      mutable_operand_shapes();
+  private:
+  const ::xla::ShapeProto& _internal_operand_shapes(int index) const;
+  ::xla::ShapeProto* _internal_add_operand_shapes();
+  public:
+  const ::xla::ShapeProto& operand_shapes(int index) const;
+  ::xla::ShapeProto* add_operand_shapes();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::ShapeProto >&
+      operand_shapes() const;
+
+  // repeated uint64 result_addresses = 3;
+  int result_addresses_size() const;
+  private:
+  int _internal_result_addresses_size() const;
+  public:
+  void clear_result_addresses();
+  private:
+  uint64_t _internal_result_addresses(int index) const;
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
+      _internal_result_addresses() const;
+  void _internal_add_result_addresses(uint64_t value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
+      _internal_mutable_result_addresses();
+  public:
+  uint64_t result_addresses(int index) const;
+  void set_result_addresses(int index, uint64_t value);
+  void add_result_addresses(uint64_t value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
+      result_addresses() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
+      mutable_result_addresses();
+
+  // repeated uint64 operand_addresses = 4;
+  int operand_addresses_size() const;
+  private:
+  int _internal_operand_addresses_size() const;
+  public:
+  void clear_operand_addresses();
+  private:
+  uint64_t _internal_operand_addresses(int index) const;
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
+      _internal_operand_addresses() const;
+  void _internal_add_operand_addresses(uint64_t value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
+      _internal_mutable_operand_addresses();
+  public:
+  uint64_t operand_addresses(int index) const;
+  void set_operand_addresses(int index, uint64_t value);
+  void add_operand_addresses(uint64_t value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
+      operand_addresses() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
+      mutable_operand_addresses();
+
+  // .xla.HloInstructionProto instruction = 1;
+  bool has_instruction() const;
+  private:
+  bool _internal_has_instruction() const;
+  public:
+  void clear_instruction();
+  const ::xla::HloInstructionProto& instruction() const;
+  PROTOBUF_NODISCARD ::xla::HloInstructionProto* release_instruction();
+  ::xla::HloInstructionProto* mutable_instruction();
+  void set_allocated_instruction(::xla::HloInstructionProto* instruction);
+  private:
+  const ::xla::HloInstructionProto& _internal_instruction() const;
+  ::xla::HloInstructionProto* _internal_mutable_instruction();
+  public:
+  void unsafe_arena_set_allocated_instruction(
+      ::xla::HloInstructionProto* instruction);
+  ::xla::HloInstructionProto* unsafe_arena_release_instruction();
+
+  // @@protoc_insertion_point(class_scope:xla.gpu.ConvInstructionLog)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::ShapeProto > operand_shapes_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t > result_addresses_;
+    mutable std::atomic<int> _result_addresses_cached_byte_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t > operand_addresses_;
+    mutable std::atomic<int> _operand_addresses_cached_byte_size_;
+    ::xla::HloInstructionProto* instruction_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_xla_2fservice_2fgpu_2fgpu_5fautotuning_2eproto;
+};
+// -------------------------------------------------------------------
+
+class DenylistedAlgorithm final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.gpu.DenylistedAlgorithm) */ {
+ public:
+  inline DenylistedAlgorithm() : DenylistedAlgorithm(nullptr) {}
+  ~DenylistedAlgorithm() override;
+  explicit PROTOBUF_CONSTEXPR DenylistedAlgorithm(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DenylistedAlgorithm(const DenylistedAlgorithm& from);
+  DenylistedAlgorithm(DenylistedAlgorithm&& from) noexcept
+    : DenylistedAlgorithm() {
+    *this = ::std::move(from);
+  }
+
+  inline DenylistedAlgorithm& operator=(const DenylistedAlgorithm& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DenylistedAlgorithm& operator=(DenylistedAlgorithm&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const DenylistedAlgorithm& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const DenylistedAlgorithm* internal_default_instance() {
+    return reinterpret_cast<const DenylistedAlgorithm*>(
+               &_DenylistedAlgorithm_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(DenylistedAlgorithm& a, DenylistedAlgorithm& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DenylistedAlgorithm* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(DenylistedAlgorithm* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  DenylistedAlgorithm* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<DenylistedAlgorithm>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const DenylistedAlgorithm& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const DenylistedAlgorithm& from) {
+    DenylistedAlgorithm::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(DenylistedAlgorithm* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "xla.gpu.DenylistedAlgorithm";
+  }
+  protected:
+  explicit DenylistedAlgorithm(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kIdFieldNumber = 1,
+    kTensorOpsFieldNumber = 2,
+  };
+  // int64 id = 1;
+  void clear_id();
+  int64_t id() const;
+  void set_id(int64_t value);
+  private:
+  int64_t _internal_id() const;
+  void _internal_set_id(int64_t value);
+  public:
+
+  // bool tensor_ops = 2;
+  void clear_tensor_ops();
+  bool tensor_ops() const;
+  void set_tensor_ops(bool value);
+  private:
+  bool _internal_tensor_ops() const;
+  void _internal_set_tensor_ops(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:xla.gpu.DenylistedAlgorithm)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    int64_t id_;
+    bool tensor_ops_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_xla_2fservice_2fgpu_2fgpu_5fautotuning_2eproto;
+};
+// -------------------------------------------------------------------
+
+class AlgorithmDenylistEntry final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.gpu.AlgorithmDenylistEntry) */ {
+ public:
+  inline AlgorithmDenylistEntry() : AlgorithmDenylistEntry(nullptr) {}
+  ~AlgorithmDenylistEntry() override;
+  explicit PROTOBUF_CONSTEXPR AlgorithmDenylistEntry(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  AlgorithmDenylistEntry(const AlgorithmDenylistEntry& from);
+  AlgorithmDenylistEntry(AlgorithmDenylistEntry&& from) noexcept
+    : AlgorithmDenylistEntry() {
+    *this = ::std::move(from);
+  }
+
+  inline AlgorithmDenylistEntry& operator=(const AlgorithmDenylistEntry& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline AlgorithmDenylistEntry& operator=(AlgorithmDenylistEntry&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const AlgorithmDenylistEntry& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const AlgorithmDenylistEntry* internal_default_instance() {
+    return reinterpret_cast<const AlgorithmDenylistEntry*>(
+               &_AlgorithmDenylistEntry_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(AlgorithmDenylistEntry& a, AlgorithmDenylistEntry& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(AlgorithmDenylistEntry* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(AlgorithmDenylistEntry* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  AlgorithmDenylistEntry* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<AlgorithmDenylistEntry>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const AlgorithmDenylistEntry& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const AlgorithmDenylistEntry& from) {
+    AlgorithmDenylistEntry::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(AlgorithmDenylistEntry* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "xla.gpu.AlgorithmDenylistEntry";
+  }
+  protected:
+  explicit AlgorithmDenylistEntry(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kAlgosFieldNumber = 4,
+    kHloFieldNumber = 1,
+    kBlasVersionFieldNumber = 5,
+    kCcFieldNumber = 2,
+    kCudnnVersionFieldNumber = 3,
+  };
+  // repeated .xla.gpu.DenylistedAlgorithm algos = 4;
+  int algos_size() const;
+  private:
+  int _internal_algos_size() const;
+  public:
+  void clear_algos();
+  ::xla::gpu::DenylistedAlgorithm* mutable_algos(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::gpu::DenylistedAlgorithm >*
+      mutable_algos();
+  private:
+  const ::xla::gpu::DenylistedAlgorithm& _internal_algos(int index) const;
+  ::xla::gpu::DenylistedAlgorithm* _internal_add_algos();
+  public:
+  const ::xla::gpu::DenylistedAlgorithm& algos(int index) const;
+  ::xla::gpu::DenylistedAlgorithm* add_algos();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::gpu::DenylistedAlgorithm >&
+      algos() const;
+
+  // string hlo = 1;
+  void clear_hlo();
+  const std::string& hlo() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_hlo(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_hlo();
+  PROTOBUF_NODISCARD std::string* release_hlo();
+  void set_allocated_hlo(std::string* hlo);
+  private:
+  const std::string& _internal_hlo() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_hlo(const std::string& value);
+  std::string* _internal_mutable_hlo();
+  public:
+
+  // string blas_version = 5;
+  void clear_blas_version();
+  const std::string& blas_version() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_blas_version(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_blas_version();
+  PROTOBUF_NODISCARD std::string* release_blas_version();
+  void set_allocated_blas_version(std::string* blas_version);
+  private:
+  const std::string& _internal_blas_version() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_blas_version(const std::string& value);
+  std::string* _internal_mutable_blas_version();
+  public:
+
+  // .xla.ComputeCapability cc = 2;
+  bool has_cc() const;
+  private:
+  bool _internal_has_cc() const;
+  public:
+  void clear_cc();
+  const ::xla::ComputeCapability& cc() const;
+  PROTOBUF_NODISCARD ::xla::ComputeCapability* release_cc();
+  ::xla::ComputeCapability* mutable_cc();
+  void set_allocated_cc(::xla::ComputeCapability* cc);
+  private:
+  const ::xla::ComputeCapability& _internal_cc() const;
+  ::xla::ComputeCapability* _internal_mutable_cc();
+  public:
+  void unsafe_arena_set_allocated_cc(
+      ::xla::ComputeCapability* cc);
+  ::xla::ComputeCapability* unsafe_arena_release_cc();
+
+  // .xla.CudnnVersion cudnn_version = 3;
+  bool has_cudnn_version() const;
+  private:
+  bool _internal_has_cudnn_version() const;
+  public:
+  void clear_cudnn_version();
+  const ::xla::CudnnVersion& cudnn_version() const;
+  PROTOBUF_NODISCARD ::xla::CudnnVersion* release_cudnn_version();
+  ::xla::CudnnVersion* mutable_cudnn_version();
+  void set_allocated_cudnn_version(::xla::CudnnVersion* cudnn_version);
+  private:
+  const ::xla::CudnnVersion& _internal_cudnn_version() const;
+  ::xla::CudnnVersion* _internal_mutable_cudnn_version();
+  public:
+  void unsafe_arena_set_allocated_cudnn_version(
+      ::xla::CudnnVersion* cudnn_version);
+  ::xla::CudnnVersion* unsafe_arena_release_cudnn_version();
+
+  // @@protoc_insertion_point(class_scope:xla.gpu.AlgorithmDenylistEntry)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::gpu::DenylistedAlgorithm > algos_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr hlo_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr blas_version_;
+    ::xla::ComputeCapability* cc_;
+    ::xla::CudnnVersion* cudnn_version_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_xla_2fservice_2fgpu_2fgpu_5fautotuning_2eproto;
+};
+// -------------------------------------------------------------------
+
+class AlgorithmDenylist final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.gpu.AlgorithmDenylist) */ {
+ public:
+  inline AlgorithmDenylist() : AlgorithmDenylist(nullptr) {}
+  ~AlgorithmDenylist() override;
+  explicit PROTOBUF_CONSTEXPR AlgorithmDenylist(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  AlgorithmDenylist(const AlgorithmDenylist& from);
+  AlgorithmDenylist(AlgorithmDenylist&& from) noexcept
+    : AlgorithmDenylist() {
+    *this = ::std::move(from);
+  }
+
+  inline AlgorithmDenylist& operator=(const AlgorithmDenylist& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline AlgorithmDenylist& operator=(AlgorithmDenylist&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const AlgorithmDenylist& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const AlgorithmDenylist* internal_default_instance() {
+    return reinterpret_cast<const AlgorithmDenylist*>(
+               &_AlgorithmDenylist_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  friend void swap(AlgorithmDenylist& a, AlgorithmDenylist& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(AlgorithmDenylist* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(AlgorithmDenylist* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  AlgorithmDenylist* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<AlgorithmDenylist>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const AlgorithmDenylist& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const AlgorithmDenylist& from) {
+    AlgorithmDenylist::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(AlgorithmDenylist* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "xla.gpu.AlgorithmDenylist";
+  }
+  protected:
+  explicit AlgorithmDenylist(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kEntriesFieldNumber = 1,
+  };
+  // repeated .xla.gpu.AlgorithmDenylistEntry entries = 1;
+  int entries_size() const;
+  private:
+  int _internal_entries_size() const;
+  public:
+  void clear_entries();
+  ::xla::gpu::AlgorithmDenylistEntry* mutable_entries(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::gpu::AlgorithmDenylistEntry >*
+      mutable_entries();
+  private:
+  const ::xla::gpu::AlgorithmDenylistEntry& _internal_entries(int index) const;
+  ::xla::gpu::AlgorithmDenylistEntry* _internal_add_entries();
+  public:
+  const ::xla::gpu::AlgorithmDenylistEntry& entries(int index) const;
+  ::xla::gpu::AlgorithmDenylistEntry* add_entries();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::gpu::AlgorithmDenylistEntry >&
+      entries() const;
+
+  // @@protoc_insertion_point(class_scope:xla.gpu.AlgorithmDenylist)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::gpu::AlgorithmDenylistEntry > entries_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_xla_2fservice_2fgpu_2fgpu_5fautotuning_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// ConvInstructionLog
+
+// .xla.HloInstructionProto instruction = 1;
+inline bool ConvInstructionLog::_internal_has_instruction() const {
+  return this != internal_default_instance() && _impl_.instruction_ != nullptr;
+}
+inline bool ConvInstructionLog::has_instruction() const {
+  return _internal_has_instruction();
+}
+inline const ::xla::HloInstructionProto& ConvInstructionLog::_internal_instruction() const {
+  const ::xla::HloInstructionProto* p = _impl_.instruction_;
+  return p != nullptr ? *p : reinterpret_cast<const ::xla::HloInstructionProto&>(
+      ::xla::_HloInstructionProto_default_instance_);
+}
+inline const ::xla::HloInstructionProto& ConvInstructionLog::instruction() const {
+  // @@protoc_insertion_point(field_get:xla.gpu.ConvInstructionLog.instruction)
+  return _internal_instruction();
+}
+inline void ConvInstructionLog::unsafe_arena_set_allocated_instruction(
+    ::xla::HloInstructionProto* instruction) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.instruction_);
+  }
+  _impl_.instruction_ = instruction;
+  if (instruction) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.gpu.ConvInstructionLog.instruction)
+}
+inline ::xla::HloInstructionProto* ConvInstructionLog::release_instruction() {
+  
+  ::xla::HloInstructionProto* temp = _impl_.instruction_;
+  _impl_.instruction_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::xla::HloInstructionProto* ConvInstructionLog::unsafe_arena_release_instruction() {
+  // @@protoc_insertion_point(field_release:xla.gpu.ConvInstructionLog.instruction)
+  
+  ::xla::HloInstructionProto* temp = _impl_.instruction_;
+  _impl_.instruction_ = nullptr;
+  return temp;
+}
+inline ::xla::HloInstructionProto* ConvInstructionLog::_internal_mutable_instruction() {
+  
+  if (_impl_.instruction_ == nullptr) {
+    auto* p = CreateMaybeMessage<::xla::HloInstructionProto>(GetArenaForAllocation());
+    _impl_.instruction_ = p;
+  }
+  return _impl_.instruction_;
+}
+inline ::xla::HloInstructionProto* ConvInstructionLog::mutable_instruction() {
+  ::xla::HloInstructionProto* _msg = _internal_mutable_instruction();
+  // @@protoc_insertion_point(field_mutable:xla.gpu.ConvInstructionLog.instruction)
+  return _msg;
+}
+inline void ConvInstructionLog::set_allocated_instruction(::xla::HloInstructionProto* instruction) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.instruction_);
+  }
+  if (instruction) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(instruction));
+    if (message_arena != submessage_arena) {
+      instruction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, instruction, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.instruction_ = instruction;
+  // @@protoc_insertion_point(field_set_allocated:xla.gpu.ConvInstructionLog.instruction)
+}
+
+// repeated .xla.ShapeProto operand_shapes = 2;
+inline int ConvInstructionLog::_internal_operand_shapes_size() const {
+  return _impl_.operand_shapes_.size();
+}
+inline int ConvInstructionLog::operand_shapes_size() const {
+  return _internal_operand_shapes_size();
+}
+inline ::xla::ShapeProto* ConvInstructionLog::mutable_operand_shapes(int index) {
+  // @@protoc_insertion_point(field_mutable:xla.gpu.ConvInstructionLog.operand_shapes)
+  return _impl_.operand_shapes_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::ShapeProto >*
+ConvInstructionLog::mutable_operand_shapes() {
+  // @@protoc_insertion_point(field_mutable_list:xla.gpu.ConvInstructionLog.operand_shapes)
+  return &_impl_.operand_shapes_;
+}
+inline const ::xla::ShapeProto& ConvInstructionLog::_internal_operand_shapes(int index) const {
+  return _impl_.operand_shapes_.Get(index);
+}
+inline const ::xla::ShapeProto& ConvInstructionLog::operand_shapes(int index) const {
+  // @@protoc_insertion_point(field_get:xla.gpu.ConvInstructionLog.operand_shapes)
+  return _internal_operand_shapes(index);
+}
+inline ::xla::ShapeProto* ConvInstructionLog::_internal_add_operand_shapes() {
+  return _impl_.operand_shapes_.Add();
+}
+inline ::xla::ShapeProto* ConvInstructionLog::add_operand_shapes() {
+  ::xla::ShapeProto* _add = _internal_add_operand_shapes();
+  // @@protoc_insertion_point(field_add:xla.gpu.ConvInstructionLog.operand_shapes)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::ShapeProto >&
+ConvInstructionLog::operand_shapes() const {
+  // @@protoc_insertion_point(field_list:xla.gpu.ConvInstructionLog.operand_shapes)
+  return _impl_.operand_shapes_;
+}
+
+// repeated uint64 result_addresses = 3;
+inline int ConvInstructionLog::_internal_result_addresses_size() const {
+  return _impl_.result_addresses_.size();
+}
+inline int ConvInstructionLog::result_addresses_size() const {
+  return _internal_result_addresses_size();
+}
+inline void ConvInstructionLog::clear_result_addresses() {
+  _impl_.result_addresses_.Clear();
+}
+inline uint64_t ConvInstructionLog::_internal_result_addresses(int index) const {
+  return _impl_.result_addresses_.Get(index);
+}
+inline uint64_t ConvInstructionLog::result_addresses(int index) const {
+  // @@protoc_insertion_point(field_get:xla.gpu.ConvInstructionLog.result_addresses)
+  return _internal_result_addresses(index);
+}
+inline void ConvInstructionLog::set_result_addresses(int index, uint64_t value) {
+  _impl_.result_addresses_.Set(index, value);
+  // @@protoc_insertion_point(field_set:xla.gpu.ConvInstructionLog.result_addresses)
+}
+inline void ConvInstructionLog::_internal_add_result_addresses(uint64_t value) {
+  _impl_.result_addresses_.Add(value);
+}
+inline void ConvInstructionLog::add_result_addresses(uint64_t value) {
+  _internal_add_result_addresses(value);
+  // @@protoc_insertion_point(field_add:xla.gpu.ConvInstructionLog.result_addresses)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
+ConvInstructionLog::_internal_result_addresses() const {
+  return _impl_.result_addresses_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
+ConvInstructionLog::result_addresses() const {
+  // @@protoc_insertion_point(field_list:xla.gpu.ConvInstructionLog.result_addresses)
+  return _internal_result_addresses();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
+ConvInstructionLog::_internal_mutable_result_addresses() {
+  return &_impl_.result_addresses_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
+ConvInstructionLog::mutable_result_addresses() {
+  // @@protoc_insertion_point(field_mutable_list:xla.gpu.ConvInstructionLog.result_addresses)
+  return _internal_mutable_result_addresses();
+}
+
+// repeated uint64 operand_addresses = 4;
+inline int ConvInstructionLog::_internal_operand_addresses_size() const {
+  return _impl_.operand_addresses_.size();
+}
+inline int ConvInstructionLog::operand_addresses_size() const {
+  return _internal_operand_addresses_size();
+}
+inline void ConvInstructionLog::clear_operand_addresses() {
+  _impl_.operand_addresses_.Clear();
+}
+inline uint64_t ConvInstructionLog::_internal_operand_addresses(int index) const {
+  return _impl_.operand_addresses_.Get(index);
+}
+inline uint64_t ConvInstructionLog::operand_addresses(int index) const {
+  // @@protoc_insertion_point(field_get:xla.gpu.ConvInstructionLog.operand_addresses)
+  return _internal_operand_addresses(index);
+}
+inline void ConvInstructionLog::set_operand_addresses(int index, uint64_t value) {
+  _impl_.operand_addresses_.Set(index, value);
+  // @@protoc_insertion_point(field_set:xla.gpu.ConvInstructionLog.operand_addresses)
+}
+inline void ConvInstructionLog::_internal_add_operand_addresses(uint64_t value) {
+  _impl_.operand_addresses_.Add(value);
+}
+inline void ConvInstructionLog::add_operand_addresses(uint64_t value) {
+  _internal_add_operand_addresses(value);
+  // @@protoc_insertion_point(field_add:xla.gpu.ConvInstructionLog.operand_addresses)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
+ConvInstructionLog::_internal_operand_addresses() const {
+  return _impl_.operand_addresses_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
+ConvInstructionLog::operand_addresses() const {
+  // @@protoc_insertion_point(field_list:xla.gpu.ConvInstructionLog.operand_addresses)
+  return _internal_operand_addresses();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
+ConvInstructionLog::_internal_mutable_operand_addresses() {
+  return &_impl_.operand_addresses_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
+ConvInstructionLog::mutable_operand_addresses() {
+  // @@protoc_insertion_point(field_mutable_list:xla.gpu.ConvInstructionLog.operand_addresses)
+  return _internal_mutable_operand_addresses();
+}
+
+// -------------------------------------------------------------------
+
+// DenylistedAlgorithm
+
+// int64 id = 1;
+inline void DenylistedAlgorithm::clear_id() {
+  _impl_.id_ = int64_t{0};
+}
+inline int64_t DenylistedAlgorithm::_internal_id() const {
+  return _impl_.id_;
+}
+inline int64_t DenylistedAlgorithm::id() const {
+  // @@protoc_insertion_point(field_get:xla.gpu.DenylistedAlgorithm.id)
+  return _internal_id();
+}
+inline void DenylistedAlgorithm::_internal_set_id(int64_t value) {
+  
+  _impl_.id_ = value;
+}
+inline void DenylistedAlgorithm::set_id(int64_t value) {
+  _internal_set_id(value);
+  // @@protoc_insertion_point(field_set:xla.gpu.DenylistedAlgorithm.id)
+}
+
+// bool tensor_ops = 2;
+inline void DenylistedAlgorithm::clear_tensor_ops() {
+  _impl_.tensor_ops_ = false;
+}
+inline bool DenylistedAlgorithm::_internal_tensor_ops() const {
+  return _impl_.tensor_ops_;
+}
+inline bool DenylistedAlgorithm::tensor_ops() const {
+  // @@protoc_insertion_point(field_get:xla.gpu.DenylistedAlgorithm.tensor_ops)
+  return _internal_tensor_ops();
+}
+inline void DenylistedAlgorithm::_internal_set_tensor_ops(bool value) {
+  
+  _impl_.tensor_ops_ = value;
+}
+inline void DenylistedAlgorithm::set_tensor_ops(bool value) {
+  _internal_set_tensor_ops(value);
+  // @@protoc_insertion_point(field_set:xla.gpu.DenylistedAlgorithm.tensor_ops)
+}
+
+// -------------------------------------------------------------------
+
+// AlgorithmDenylistEntry
+
+// string hlo = 1;
+inline void AlgorithmDenylistEntry::clear_hlo() {
+  _impl_.hlo_.ClearToEmpty();
+}
+inline const std::string& AlgorithmDenylistEntry::hlo() const {
+  // @@protoc_insertion_point(field_get:xla.gpu.AlgorithmDenylistEntry.hlo)
+  return _internal_hlo();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void AlgorithmDenylistEntry::set_hlo(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.hlo_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:xla.gpu.AlgorithmDenylistEntry.hlo)
+}
+inline std::string* AlgorithmDenylistEntry::mutable_hlo() {
+  std::string* _s = _internal_mutable_hlo();
+  // @@protoc_insertion_point(field_mutable:xla.gpu.AlgorithmDenylistEntry.hlo)
+  return _s;
+}
+inline const std::string& AlgorithmDenylistEntry::_internal_hlo() const {
+  return _impl_.hlo_.Get();
+}
+inline void AlgorithmDenylistEntry::_internal_set_hlo(const std::string& value) {
+  
+  _impl_.hlo_.Set(value, GetArenaForAllocation());
+}
+inline std::string* AlgorithmDenylistEntry::_internal_mutable_hlo() {
+  
+  return _impl_.hlo_.Mutable(GetArenaForAllocation());
+}
+inline std::string* AlgorithmDenylistEntry::release_hlo() {
+  // @@protoc_insertion_point(field_release:xla.gpu.AlgorithmDenylistEntry.hlo)
+  return _impl_.hlo_.Release();
+}
+inline void AlgorithmDenylistEntry::set_allocated_hlo(std::string* hlo) {
+  if (hlo != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.hlo_.SetAllocated(hlo, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.hlo_.IsDefault()) {
+    _impl_.hlo_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:xla.gpu.AlgorithmDenylistEntry.hlo)
+}
+
+// .xla.ComputeCapability cc = 2;
+inline bool AlgorithmDenylistEntry::_internal_has_cc() const {
+  return this != internal_default_instance() && _impl_.cc_ != nullptr;
+}
+inline bool AlgorithmDenylistEntry::has_cc() const {
+  return _internal_has_cc();
+}
+inline const ::xla::ComputeCapability& AlgorithmDenylistEntry::_internal_cc() const {
+  const ::xla::ComputeCapability* p = _impl_.cc_;
+  return p != nullptr ? *p : reinterpret_cast<const ::xla::ComputeCapability&>(
+      ::xla::_ComputeCapability_default_instance_);
+}
+inline const ::xla::ComputeCapability& AlgorithmDenylistEntry::cc() const {
+  // @@protoc_insertion_point(field_get:xla.gpu.AlgorithmDenylistEntry.cc)
+  return _internal_cc();
+}
+inline void AlgorithmDenylistEntry::unsafe_arena_set_allocated_cc(
+    ::xla::ComputeCapability* cc) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.cc_);
+  }
+  _impl_.cc_ = cc;
+  if (cc) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.gpu.AlgorithmDenylistEntry.cc)
+}
+inline ::xla::ComputeCapability* AlgorithmDenylistEntry::release_cc() {
+  
+  ::xla::ComputeCapability* temp = _impl_.cc_;
+  _impl_.cc_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::xla::ComputeCapability* AlgorithmDenylistEntry::unsafe_arena_release_cc() {
+  // @@protoc_insertion_point(field_release:xla.gpu.AlgorithmDenylistEntry.cc)
+  
+  ::xla::ComputeCapability* temp = _impl_.cc_;
+  _impl_.cc_ = nullptr;
+  return temp;
+}
+inline ::xla::ComputeCapability* AlgorithmDenylistEntry::_internal_mutable_cc() {
+  
+  if (_impl_.cc_ == nullptr) {
+    auto* p = CreateMaybeMessage<::xla::ComputeCapability>(GetArenaForAllocation());
+    _impl_.cc_ = p;
+  }
+  return _impl_.cc_;
+}
+inline ::xla::ComputeCapability* AlgorithmDenylistEntry::mutable_cc() {
+  ::xla::ComputeCapability* _msg = _internal_mutable_cc();
+  // @@protoc_insertion_point(field_mutable:xla.gpu.AlgorithmDenylistEntry.cc)
+  return _msg;
+}
+inline void AlgorithmDenylistEntry::set_allocated_cc(::xla::ComputeCapability* cc) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.cc_);
+  }
+  if (cc) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(cc));
+    if (message_arena != submessage_arena) {
+      cc = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, cc, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.cc_ = cc;
+  // @@protoc_insertion_point(field_set_allocated:xla.gpu.AlgorithmDenylistEntry.cc)
+}
+
+// .xla.CudnnVersion cudnn_version = 3;
+inline bool AlgorithmDenylistEntry::_internal_has_cudnn_version() const {
+  return this != internal_default_instance() && _impl_.cudnn_version_ != nullptr;
+}
+inline bool AlgorithmDenylistEntry::has_cudnn_version() const {
+  return _internal_has_cudnn_version();
+}
+inline const ::xla::CudnnVersion& AlgorithmDenylistEntry::_internal_cudnn_version() const {
+  const ::xla::CudnnVersion* p = _impl_.cudnn_version_;
+  return p != nullptr ? *p : reinterpret_cast<const ::xla::CudnnVersion&>(
+      ::xla::_CudnnVersion_default_instance_);
+}
+inline const ::xla::CudnnVersion& AlgorithmDenylistEntry::cudnn_version() const {
+  // @@protoc_insertion_point(field_get:xla.gpu.AlgorithmDenylistEntry.cudnn_version)
+  return _internal_cudnn_version();
+}
+inline void AlgorithmDenylistEntry::unsafe_arena_set_allocated_cudnn_version(
+    ::xla::CudnnVersion* cudnn_version) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.cudnn_version_);
+  }
+  _impl_.cudnn_version_ = cudnn_version;
+  if (cudnn_version) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.gpu.AlgorithmDenylistEntry.cudnn_version)
+}
+inline ::xla::CudnnVersion* AlgorithmDenylistEntry::release_cudnn_version() {
+  
+  ::xla::CudnnVersion* temp = _impl_.cudnn_version_;
+  _impl_.cudnn_version_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::xla::CudnnVersion* AlgorithmDenylistEntry::unsafe_arena_release_cudnn_version() {
+  // @@protoc_insertion_point(field_release:xla.gpu.AlgorithmDenylistEntry.cudnn_version)
+  
+  ::xla::CudnnVersion* temp = _impl_.cudnn_version_;
+  _impl_.cudnn_version_ = nullptr;
+  return temp;
+}
+inline ::xla::CudnnVersion* AlgorithmDenylistEntry::_internal_mutable_cudnn_version() {
+  
+  if (_impl_.cudnn_version_ == nullptr) {
+    auto* p = CreateMaybeMessage<::xla::CudnnVersion>(GetArenaForAllocation());
+    _impl_.cudnn_version_ = p;
+  }
+  return _impl_.cudnn_version_;
+}
+inline ::xla::CudnnVersion* AlgorithmDenylistEntry::mutable_cudnn_version() {
+  ::xla::CudnnVersion* _msg = _internal_mutable_cudnn_version();
+  // @@protoc_insertion_point(field_mutable:xla.gpu.AlgorithmDenylistEntry.cudnn_version)
+  return _msg;
+}
+inline void AlgorithmDenylistEntry::set_allocated_cudnn_version(::xla::CudnnVersion* cudnn_version) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.cudnn_version_);
+  }
+  if (cudnn_version) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(cudnn_version));
+    if (message_arena != submessage_arena) {
+      cudnn_version = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, cudnn_version, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.cudnn_version_ = cudnn_version;
+  // @@protoc_insertion_point(field_set_allocated:xla.gpu.AlgorithmDenylistEntry.cudnn_version)
+}
+
+// string blas_version = 5;
+inline void AlgorithmDenylistEntry::clear_blas_version() {
+  _impl_.blas_version_.ClearToEmpty();
+}
+inline const std::string& AlgorithmDenylistEntry::blas_version() const {
+  // @@protoc_insertion_point(field_get:xla.gpu.AlgorithmDenylistEntry.blas_version)
+  return _internal_blas_version();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void AlgorithmDenylistEntry::set_blas_version(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.blas_version_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:xla.gpu.AlgorithmDenylistEntry.blas_version)
+}
+inline std::string* AlgorithmDenylistEntry::mutable_blas_version() {
+  std::string* _s = _internal_mutable_blas_version();
+  // @@protoc_insertion_point(field_mutable:xla.gpu.AlgorithmDenylistEntry.blas_version)
+  return _s;
+}
+inline const std::string& AlgorithmDenylistEntry::_internal_blas_version() const {
+  return _impl_.blas_version_.Get();
+}
+inline void AlgorithmDenylistEntry::_internal_set_blas_version(const std::string& value) {
+  
+  _impl_.blas_version_.Set(value, GetArenaForAllocation());
+}
+inline std::string* AlgorithmDenylistEntry::_internal_mutable_blas_version() {
+  
+  return _impl_.blas_version_.Mutable(GetArenaForAllocation());
+}
+inline std::string* AlgorithmDenylistEntry::release_blas_version() {
+  // @@protoc_insertion_point(field_release:xla.gpu.AlgorithmDenylistEntry.blas_version)
+  return _impl_.blas_version_.Release();
+}
+inline void AlgorithmDenylistEntry::set_allocated_blas_version(std::string* blas_version) {
+  if (blas_version != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.blas_version_.SetAllocated(blas_version, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.blas_version_.IsDefault()) {
+    _impl_.blas_version_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:xla.gpu.AlgorithmDenylistEntry.blas_version)
+}
+
+// repeated .xla.gpu.DenylistedAlgorithm algos = 4;
+inline int AlgorithmDenylistEntry::_internal_algos_size() const {
+  return _impl_.algos_.size();
+}
+inline int AlgorithmDenylistEntry::algos_size() const {
+  return _internal_algos_size();
+}
+inline void AlgorithmDenylistEntry::clear_algos() {
+  _impl_.algos_.Clear();
+}
+inline ::xla::gpu::DenylistedAlgorithm* AlgorithmDenylistEntry::mutable_algos(int index) {
+  // @@protoc_insertion_point(field_mutable:xla.gpu.AlgorithmDenylistEntry.algos)
+  return _impl_.algos_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::gpu::DenylistedAlgorithm >*
+AlgorithmDenylistEntry::mutable_algos() {
+  // @@protoc_insertion_point(field_mutable_list:xla.gpu.AlgorithmDenylistEntry.algos)
+  return &_impl_.algos_;
+}
+inline const ::xla::gpu::DenylistedAlgorithm& AlgorithmDenylistEntry::_internal_algos(int index) const {
+  return _impl_.algos_.Get(index);
+}
+inline const ::xla::gpu::DenylistedAlgorithm& AlgorithmDenylistEntry::algos(int index) const {
+  // @@protoc_insertion_point(field_get:xla.gpu.AlgorithmDenylistEntry.algos)
+  return _internal_algos(index);
+}
+inline ::xla::gpu::DenylistedAlgorithm* AlgorithmDenylistEntry::_internal_add_algos() {
+  return _impl_.algos_.Add();
+}
+inline ::xla::gpu::DenylistedAlgorithm* AlgorithmDenylistEntry::add_algos() {
+  ::xla::gpu::DenylistedAlgorithm* _add = _internal_add_algos();
+  // @@protoc_insertion_point(field_add:xla.gpu.AlgorithmDenylistEntry.algos)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::gpu::DenylistedAlgorithm >&
+AlgorithmDenylistEntry::algos() const {
+  // @@protoc_insertion_point(field_list:xla.gpu.AlgorithmDenylistEntry.algos)
+  return _impl_.algos_;
+}
+
+// -------------------------------------------------------------------
+
+// AlgorithmDenylist
+
+// repeated .xla.gpu.AlgorithmDenylistEntry entries = 1;
+inline int AlgorithmDenylist::_internal_entries_size() const {
+  return _impl_.entries_.size();
+}
+inline int AlgorithmDenylist::entries_size() const {
+  return _internal_entries_size();
+}
+inline void AlgorithmDenylist::clear_entries() {
+  _impl_.entries_.Clear();
+}
+inline ::xla::gpu::AlgorithmDenylistEntry* AlgorithmDenylist::mutable_entries(int index) {
+  // @@protoc_insertion_point(field_mutable:xla.gpu.AlgorithmDenylist.entries)
+  return _impl_.entries_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::gpu::AlgorithmDenylistEntry >*
+AlgorithmDenylist::mutable_entries() {
+  // @@protoc_insertion_point(field_mutable_list:xla.gpu.AlgorithmDenylist.entries)
+  return &_impl_.entries_;
+}
+inline const ::xla::gpu::AlgorithmDenylistEntry& AlgorithmDenylist::_internal_entries(int index) const {
+  return _impl_.entries_.Get(index);
+}
+inline const ::xla::gpu::AlgorithmDenylistEntry& AlgorithmDenylist::entries(int index) const {
+  // @@protoc_insertion_point(field_get:xla.gpu.AlgorithmDenylist.entries)
+  return _internal_entries(index);
+}
+inline ::xla::gpu::AlgorithmDenylistEntry* AlgorithmDenylist::_internal_add_entries() {
+  return _impl_.entries_.Add();
+}
+inline ::xla::gpu::AlgorithmDenylistEntry* AlgorithmDenylist::add_entries() {
+  ::xla::gpu::AlgorithmDenylistEntry* _add = _internal_add_entries();
+  // @@protoc_insertion_point(field_add:xla.gpu.AlgorithmDenylist.entries)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::gpu::AlgorithmDenylistEntry >&
+AlgorithmDenylist::entries() const {
+  // @@protoc_insertion_point(field_list:xla.gpu.AlgorithmDenylist.entries)
+  return _impl_.entries_;
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace gpu
+}  // namespace xla
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_xla_2fservice_2fgpu_2fgpu_5fautotuning_2eproto
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_compiler.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_compiler.h
new file mode 100644
index 0000000000000000000000000000000000000000..d4d500d352c6033b4d6d7e7099fcd87a79516dc8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_compiler.h
@@ -0,0 +1,260 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_GPU_COMPILER_H_
+#define XLA_SERVICE_GPU_GPU_COMPILER_H_
+
+#include <memory>
+#include <optional>
+#include <string>
+#include <string_view>
+#include <utility>
+#include <vector>
+
+#include "xla/autotune_results.pb.h"
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/service/executable.h"
+#include "xla/service/gpu/autotuner_util.h"
+#include "xla/service/gpu/buffer_sharing.h"
+#include "xla/service/gpu/executable.pb.h"
+#include "xla/service/gpu/gpu_executable.h"
+#include "xla/service/gpu/gpu_target_config.h"
+#include "xla/service/hlo.pb.h"
+#include "xla/service/hlo_dataflow_analysis.h"
+#include "xla/service/hlo_pass_pipeline.h"
+#include "xla/service/llvm_compiler.h"
+#include "xla/statusor.h"
+#include "xla/stream_executor/device_description.h"
+#include "xla/stream_executor/device_description.pb.h"
+#include "xla/stream_executor/stream_executor.h"
+#include "xla/util.h"
+
+namespace xla {
+namespace gpu {
+
+// TODO(b/232263665): It should be shared between GPU and CPU.
+class GpuXlaRuntimeAotCompilationResult : public AotCompilationResult {
+ public:
+  GpuXlaRuntimeAotCompilationResult(
+      HloModuleProto hlo, std::string_view obj_file,
+      std::string_view mlir_module, EntryFunctionAttributes entry_func_attrs,
+      std::string_view gpu_asm_text, absl::Span<const uint8_t> gpu_binary,
+      absl::Span<const GpuExecutable::ConstantInfo> constants = {}) {
+    XlaRuntimeExecutableProto xla_runtime_executable;
+    *xla_runtime_executable.mutable_hlo_module_proto() = hlo;
+    xla_runtime_executable.set_obj_file(std::string(obj_file));
+    xla_runtime_executable.set_mlir_module(std::string(mlir_module));
+    *xla_runtime_gpu_executable_.mutable_xla_runtime_executable() =
+        xla_runtime_executable;
+
+    *xla_runtime_gpu_executable_.mutable_entry_func_attrs() = entry_func_attrs;
+    xla_runtime_gpu_executable_.set_gpu_asm_text(std::string(gpu_asm_text));
+    xla_runtime_gpu_executable_.set_gpu_binary(gpu_binary.data(),
+                                               gpu_binary.size());
+
+    for (const GpuExecutable::ConstantInfo& cst : constants) {
+      auto* cst_proto = xla_runtime_gpu_executable_.add_constants();
+      cst_proto->set_symbol_name(cst.symbol_name);
+      cst_proto->set_allocation_index(cst.allocation_index);
+      cst_proto->set_content(cst.content.data(), cst.content.size());
+    }
+  }
+
+  explicit GpuXlaRuntimeAotCompilationResult(
+      XlaRuntimeGpuExecutableProto executable)
+      : xla_runtime_gpu_executable_(executable) {}
+
+  StatusOr<std::string> SerializeAsString() const override {
+    return xla_runtime_gpu_executable_.SerializeAsString();
+  }
+
+  static StatusOr<std::unique_ptr<GpuXlaRuntimeAotCompilationResult>>
+  FromString(const std::string& serialized) {
+    XlaRuntimeGpuExecutableProto xla_runtime_gpu_executable;
+    if (!xla_runtime_gpu_executable.ParseFromString(serialized)) {
+      return InternalError("Failed to parse serialized JitRtExecutableProto.");
+    }
+    return std::make_unique<GpuXlaRuntimeAotCompilationResult>(
+        xla_runtime_gpu_executable);
+  }
+
+  StatusOr<std::unique_ptr<Executable>> LoadExecutable(
+      Compiler* compiler, se::StreamExecutor* executor) const override;
+
+ private:
+  XlaRuntimeGpuExecutableProto xla_runtime_gpu_executable_;
+};
+
+// The GPU compiler generates efficient GPU executables.
+class GpuCompiler : public LLVMCompiler {
+ public:
+  GpuCompiler(se::Platform::Id platform_id, const char* target_triple,
+              const char* data_layout);
+
+  using LLVMCompiler::Compile;
+
+  // An attached device is passed in via stream_exec. We get GPU configuration
+  // from the attached device. GemmAlgorithmPicker and GpuConvAlgorithmPicker
+  // can run on the attached device.
+  StatusOr<std::unique_ptr<HloModule>> RunHloPasses(
+      std::unique_ptr<HloModule> module, se::StreamExecutor* stream_exec,
+      const CompileOptions& options) override;
+
+  // Run HloPasses without an attached deivce. So GemmAlgorithmPicker and
+  // GpuConvAlgorithmPicker can not run.
+  StatusOr<std::unique_ptr<HloModule>> RunHloPassesWithoutDevice(
+      std::unique_ptr<HloModule> module, const CompileOptions& options,
+      const GpuTargetConfig& gpu_target_config,
+      const AutotuneResults& autotune_results);
+
+  StatusOr<std::unique_ptr<BufferAssignment>> AssignBuffers(
+      HloModule* hlo_module, se::StreamExecutor* stream_exec) override;
+
+  se::GpuComputeCapability GetGpuVersion(se::StreamExecutor* stream_exec);
+
+  GpuTargetConfig GetGpuTargetConfig(se::StreamExecutor* stream_exec) {
+    return GpuTargetConfig(stream_exec);
+  }
+
+  StatusOr<std::unique_ptr<Executable>> RunBackend(
+      std::unique_ptr<HloModule> module, se::StreamExecutor* stream_exec,
+      const CompileOptions& options) override;
+
+  StatusOr<std::vector<std::unique_ptr<AotCompilationResult>>>
+  CompileAheadOfTime(std::unique_ptr<HloModuleGroup> module_group,
+                     AotCompilationOptions const& options) override;
+
+  StatusOr<std::pair<std::string, std::vector<uint8_t>>> CompileToTargetBinary(
+      const HloModuleConfig& module_config,
+      std::unique_ptr<llvm::Module> llvm_module,
+      se::GpuComputeCapability gpu_version, se::StreamExecutor* stream_exec,
+      const CompileOptions& options, const HloModule* debug_module);
+
+  se::Platform::Id PlatformId() const override { return platform_id_; }
+
+  HloCostAnalysis::ShapeSizeFunction ShapeSizeBytesFunction() const override;
+
+  // Returns a (deserialized) AotCompilationResult from a serialized
+  // AotCompilationResult.
+  StatusOr<std::unique_ptr<AotCompilationResult>> LoadAotCompilationResult(
+      const std::string& serialized_aot_result) override {
+    return GpuXlaRuntimeAotCompilationResult::FromString(serialized_aot_result);
+  }
+
+  StatusOr<std::unique_ptr<AotCompilationResult>> Export(
+      Executable* executable) const override;
+
+  Status RunPostSchedulingPipelines(HloModule* module,
+                                    int64_t scheduler_mem_limit) const;
+
+ protected:
+  // During compilation with device, stream_exec != null and autotune_results
+  // == null. During deviceless AOT compilation, stream_exec == null and
+  // autotune_results != null.
+  // thread_pool is used to speed up compilation during autotuning.
+  virtual Status OptimizeHloPostLayoutAssignment(
+      HloModule* hlo_module, se::StreamExecutor* stream_exec,
+      const CompileOptions& options, const GpuTargetConfig& gpu_target_config,
+      const AutotuneResults* autotune_results,
+      tsl::thread::ThreadPool* thread_pool);
+
+  // CollectivesScheduleLinearizer enforces a total ordering between collectives
+  // to work around divergence in executables introduced due to auto tuning,
+  // specifically the use of extra scratch space for convolutions. This
+  // function decided whether to apply this pass. If convolutions are present in
+  // the code and we are using "online" autotuning (i.e., not AOT) we need to
+  // use the pass, else we do not need to enable the pass.
+  virtual bool RequiresCollectiveScheduleLinearizer(
+      const HloModule* module, se::StreamExecutor* stream_exec) {
+    return false;
+  }
+
+  // Add autotuning passes for convolution and gemm (except triton).
+  virtual Status AddConvAndGemmAutotuningPasses(
+      HloPassPipeline* pipeline, HloModule* hlo_module,
+      AutotuneConfig& autotune_config, tsl::thread::ThreadPool* thread_pool) {
+    return OkStatus();
+  }
+
+  // Add autotuning passes for triton gemm.
+  virtual Status AddTritonGemmAutotuningPasses(
+      HloPassPipeline* pipeline, HloModule* hlo_module,
+      AutotuneConfig& autotune_config, tsl::thread::ThreadPool* thread_pool) {
+    return OkStatus();
+  }
+
+ private:
+  Status LoadAutotuneResultsFromFile(const DebugOptions& debug_options);
+  Status SerializeAutotuneResultsToFile(const DebugOptions& debug_options);
+
+  // During compilation with device, stream_exec != null and autotune_results
+  // == null. During deviceless AOT compilation, stream_exec == null and
+  // autotune_results != null.
+  Status OptimizeHloModule(HloModule* hlo_module,
+                           se::StreamExecutor* stream_exec,
+                           const CompileOptions& options,
+                           const GpuTargetConfig& gpu_target_config,
+                           const AutotuneResults* autotune_results);
+
+  virtual Status OptimizeHloConvolutionCanonicalization(
+      HloModule* hlo_module, se::GpuComputeCapability gpu_version,
+      se::dnn::VersionInfo dnn_version,
+      se::DeviceMemoryAllocator* device_allocator) = 0;
+
+  virtual HloDataflowAnalysis::CanShareBuffer GetCanShareBuffer() const {
+    return &FusionCanShareBufferHint;
+  }
+
+  // TODO(timshen): Replace `debug_module` with some portable debug information
+  // that accommodates both HLO and MLIR.
+  virtual StatusOr<std::pair<std::string, std::vector<uint8_t>>>
+  CompileTargetBinary(const HloModuleConfig& module_config,
+                      llvm::Module* llvm_module,
+                      se::GpuComputeCapability gpu_version, bool relocatable,
+                      const HloModule* debug_module,
+                      const CompileOptions& options) = 0;
+
+  Status PrepareHloModuleForIrEmitting(HloModule* hlo_module);
+
+  virtual StatusOr<bool> CanUseLinkModules(const HloModuleConfig& config) {
+    return false;
+  }
+
+  virtual StatusOr<std::vector<uint8_t>> LinkModules(
+      se::StreamExecutor* stream_exec,
+      std::vector<std::vector<uint8_t>> modules,
+      const DebugOptions& debug_options) {
+    return Unimplemented("LinkModules is not implemented.");
+  }
+
+  se::Platform::Id platform_id_;
+
+  // The triple that represents our target.
+  const char* target_triple_;
+
+  // The data layout of the emitted module.
+  const char* data_layout_;
+
+  // The size in bytes of a pointer. Used by ShapeSizeBytesFunction.
+  const int64_t pointer_size_;
+
+  GpuCompiler(const GpuCompiler&) = delete;
+  GpuCompiler& operator=(const GpuCompiler&) = delete;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_GPU_COMPILER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_constants.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_constants.h
new file mode 100644
index 0000000000000000000000000000000000000000..68eda89b715fa9e39d00cb914d81e1372f959cf3
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_constants.h
@@ -0,0 +1,50 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_GPU_CONSTANTS_H_
+#define XLA_SERVICE_GPU_GPU_CONSTANTS_H_
+
+#include <cstdint>
+
+namespace xla {
+namespace gpu {
+
+// Minimum alignment for buffers passed as incoming arguments by TensorFlow.
+//
+// kEntryParameterAlignBytes is equal to EIGEN_MAX_ALIGN_BYTES, though including
+// Eigen headers here to get that symbol may not be a good idea.
+// EIGEN_MAX_ALIGN_BYTES may differ between CUDA-enabled builds vs CUDA-disabled
+// builds and we don't want the IR generated by XLA:GPU to depend on that.
+//
+// TODO(b/111767313): Consider raising EIGEN_MAX_ALIGN_BYTES if it helps.
+inline constexpr int64_t kEntryParameterAlignBytes = 16;
+
+// Minimum alignment for buffers allocated by XLA: the temp buffers and the live
+// out (result) buffers.
+//
+// cudnn requires 128-bit (16-byte) alignment for TensorCore operations, but
+// says that 1024-bit (128-byte) alignment "may deliver better performance".
+// https://docs.nvidia.com/deeplearning/cudnn/developer-guide/index.html#tensor-ops-guidelines-for-dl-compiler
+//
+inline constexpr int64_t kXlaAllocatedBufferAlignBytes = 128;
+
+// Minimum alignment for constant buffers.
+inline constexpr int64_t kConstantBufferAlignBytes =
+    kXlaAllocatedBufferAlignBytes;
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_GPU_CONSTANTS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_conv_padding_legalization.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_conv_padding_legalization.h
new file mode 100644
index 0000000000000000000000000000000000000000..15e5de46e5a9376312882e5e4df877000732e005
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_conv_padding_legalization.h
@@ -0,0 +1,49 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_GPU_CONV_PADDING_LEGALIZATION_H_
+#define XLA_SERVICE_GPU_GPU_CONV_PADDING_LEGALIZATION_H_
+
+#include "xla/service/hlo_pass_interface.h"
+
+namespace xla {
+namespace gpu {
+
+// An HLO pass that canonicalizes convolution instructions for GPU codegen. It
+// inserts Pad instructions before Convolution instructions with uncanonicalized
+// padding, so that they can be lowered to Cudnn/Miopen convolution.
+class GpuConvPaddingLegalization : public HloModulePass {
+ public:
+  absl::string_view name() const override {
+    return "gpu-conv-padding-legalization";
+  }
+
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+
+ private:
+  StatusOr<bool> RunOnComputation(HloComputation* computation);
+  // Returns if any changes are made to the parent computation.
+  bool CanonicalizeForwardConvolution(HloInstruction* conv);
+  bool CanonicalizeBackwardFilterConvolution(HloInstruction* backward_conv);
+  bool CanonicalizeBackwardInputConvolution(HloInstruction* backward_conv);
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_GPU_CONV_PADDING_LEGALIZATION_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_conv_rewriter.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_conv_rewriter.h
new file mode 100644
index 0000000000000000000000000000000000000000..4e36a69ceaa11cd03b3e74837cb705416350ba54
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_conv_rewriter.h
@@ -0,0 +1,54 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_GPU_CONV_REWRITER_H_
+#define XLA_SERVICE_GPU_GPU_CONV_REWRITER_H_
+
+#include <optional>
+#include <tuple>
+
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/service/hlo_pass_interface.h"
+
+namespace xla {
+namespace gpu {
+
+// Rewrites plain convolutions, backwards-filter convolutions, and
+// backwards-input convolutions into CustomCall HLOs that call into
+// Cudnn/Miopen.
+// For integer convolution, it requires the following pattern:
+// conv<InputT=int32_t, ResultT=int32_t>(
+//   convert<int32_t>(int8_x), convert<int32_t>(int8_y))
+// We transform it to:
+// custom_call<int32_t>(int8_x, int8_y, target=cudnnForwardConvolution)
+// Note that this pattern is necessary but not sufficient to map convolutions
+// to CuDNN. More patterns will be matched in cudnn_fused_conv_rewriter.
+
+class GpuConvRewriter : public HloModulePass {
+ public:
+  absl::string_view name() const override { return "gpu-conv-rewriter"; }
+
+  static bool ConvIsLowerable(HloInstruction* conv);
+
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_GPU_CONV_REWRITER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_conv_runner.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_conv_runner.h
new file mode 100644
index 0000000000000000000000000000000000000000..ff85fceb74cf6ea8600dc91a4b8d29f7fc896286
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_conv_runner.h
@@ -0,0 +1,266 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_GPU_CONV_RUNNER_H_
+#define XLA_SERVICE_GPU_GPU_CONV_RUNNER_H_
+
+#include <optional>
+#include <string>
+#include <vector>
+
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/hlo/ir/hlo_instructions.h"
+#include "xla/service/gpu/backend_configs.pb.h"
+#include "xla/service/gpu/cublas_cudnn.h"
+#include "xla/status.h"
+#include "xla/statusor.h"
+#include "xla/stream_executor/dnn.h"
+#include "xla/stream_executor/lazy_op_runner.h"
+#include "xla/stream_executor/stream_executor.h"
+#include "xla/types.h"
+#include "xla/xla_data.pb.h"
+
+namespace xla {
+namespace gpu {
+
+// Structure to describe static properties of a GPU convolution.
+struct GpuConvConfig {
+  // Field related to cuDNN's fused convolution are in FusionConfig &
+  // FusionParams structures. The result thus is defined as:
+  //   activation(conv_result_scale * conv(x, w) +
+  //       side_input_scale * side_input + broadcast(bias))
+  //
+  // The most common fused conv is conv forward + relu/identity, for example.
+  //
+  // bias_buf is a single-dimensional array, with the length equal to the number
+  // of output features. It'll be broadcasted to the output shape in order to be
+  // added to the final results.
+  //
+  // side_input_buf, if valid, must have the same shape as the output buffer.
+  struct FusionConfig {
+    se::dnn::ActivationMode mode;
+    double side_input_scale;
+    double leakyrelu_alpha = 0.0;
+  };
+
+  PrimitiveType input_type;
+  PrimitiveType output_type;
+  CudnnConvKind kind;
+  se::dnn::AlgorithmDesc algorithm;
+  double conv_result_scale;
+
+  se::dnn::BatchDescriptor input_descriptor;
+  se::dnn::FilterDescriptor filter_descriptor;
+  se::dnn::BatchDescriptor output_descriptor;
+  se::dnn::ConvolutionDescriptor conv_desc;
+  se::dnn::BatchDescriptor bias_descriptor;
+
+  Shape input_shape;
+  Shape filter_shape;
+  Shape output_shape;
+  std::optional<FusionConfig> fusion;
+
+  // String serialization of the subgraph of adjacent ops to be fused into the
+  // cuDNN convolution Custom Call. Currently used for FP8 convolutions only.
+  // Additional information is provided in gpu_fused_conv_rewriter.cc.
+  std::string serialized_graph;
+};
+
+// Implementation struct exposed for debugging and log analysis.
+struct GpuConvParams {
+  const GpuConvConfig* config;  // Not owned
+  struct FusionParams {
+    se::DeviceMemoryBase bias_buf;
+    se::DeviceMemoryBase side_input_buf;  // nullable
+  };
+
+  se::DeviceMemoryBase input_buf;
+  se::DeviceMemoryBase filter_buf;
+  se::DeviceMemoryBase output_buf;
+
+  // Buffers for operands of ops to be fused into the cuDNN
+  // convolution Custom Call.
+  std::vector<se::DeviceMemoryBase> operand_bufs;
+
+  // Buffers for additional outputs of ops to be fused into the cuDNN
+  // convolution Custom Call.
+  std::vector<se::DeviceMemoryBase> aux_bufs;
+
+  std::optional<FusionParams> fusion;
+};
+
+// The XLA convolution plumbing is all dynamically-typed w.r.t. whether a
+// convolution is fused (and has extra arguments) or unfused, which doesn't
+// naturally play well with the typed APIs provided by StreamExecutor; rather
+// than rewriting everything here, just propagate the dynamic typing to one more
+// place by having a ConvRunner, FusedConvRunner or GraphConvRunner.
+class GenericConvRunner {
+ public:
+  GenericConvRunner() = default;
+
+  explicit GenericConvRunner(
+      std::unique_ptr<se::dnn::LazyOpRunner<se::dnn::FusedConvOp>> runner)
+      : repr_(std::move(runner)) {}
+
+  explicit GenericConvRunner(
+      std::unique_ptr<se::dnn::LazyOpRunner<se::dnn::GraphConvOp>> runner)
+      : repr_(std::move(runner)) {}
+
+  explicit GenericConvRunner(
+      std::unique_ptr<se::dnn::LazyOpRunner<se::dnn::ConvOp>> runner)
+      : repr_(std::move(runner)) {}
+
+  explicit GenericConvRunner(const GpuConvConfig& config)
+      : GenericConvRunner(FromGpuConvConfig(config)) {}
+
+  static GenericConvRunner FromGpuConvConfig(const GpuConvConfig& config) {
+    if (config.kind == CudnnConvKind::kForwardGraph) {
+      return GenericConvRunner(
+          std::make_unique<se::dnn::LazyOpRunner<se::dnn::GraphConvOp>>(
+              config.algorithm));
+    } else if (config.kind == CudnnConvKind::kForwardActivation) {
+      return GenericConvRunner(
+          std::make_unique<se::dnn::LazyOpRunner<se::dnn::FusedConvOp>>(
+              config.algorithm));
+    } else {
+      return GenericConvRunner(
+          std::make_unique<se::dnn::LazyOpRunner<se::dnn::ConvOp>>(
+              config.algorithm));
+    }
+  }
+
+  se::dnn::AlgorithmDesc ToAlgorithmDesc() const {
+    return std::visit(ToAlgorithmDescVisitor{}, repr_);
+  }
+
+  se::dnn::LazyOpRunner<se::dnn::ConvOp>* AsConvRunner() {
+    CHECK(std::holds_alternative<
+          std::unique_ptr<se::dnn::LazyOpRunner<se::dnn::ConvOp>>>(repr_));
+    return std::get<std::unique_ptr<se::dnn::LazyOpRunner<se::dnn::ConvOp>>>(
+               repr_)
+        .get();
+  }
+
+  se::dnn::LazyOpRunner<se::dnn::GraphConvOp>* AsGraphConvRunner() {
+    CHECK(std::holds_alternative<
+          std::unique_ptr<se::dnn::LazyOpRunner<se::dnn::GraphConvOp>>>(repr_));
+    return std::get<
+               std::unique_ptr<se::dnn::LazyOpRunner<se::dnn::GraphConvOp>>>(
+               repr_)
+        .get();
+  }
+
+  se::dnn::LazyOpRunner<se::dnn::FusedConvOp>* AsFusedConvRunner() {
+    CHECK(std::holds_alternative<
+          std::unique_ptr<se::dnn::LazyOpRunner<se::dnn::FusedConvOp>>>(repr_));
+    return std::get<
+               std::unique_ptr<se::dnn::LazyOpRunner<se::dnn::FusedConvOp>>>(
+               repr_)
+        .get();
+  }
+
+ private:
+  struct ToAlgorithmDescVisitor {
+    template <typename RunnerPtr>
+    se::dnn::AlgorithmDesc operator()(const RunnerPtr& runner) {
+      return runner->ToAlgorithmDesc();
+    }
+
+    se::dnn::AlgorithmDesc operator()(const std::monostate&) {
+      CHECK(false) << "Internal error: uninitialized runner in ToAlgorithmDesc";
+    }
+  };
+
+  using Repr =
+      std::variant<std::monostate,  // To allow GpuConvConfig default ctor
+                   std::unique_ptr<se::dnn::LazyOpRunner<se::dnn::FusedConvOp>>,
+                   std::unique_ptr<se::dnn::LazyOpRunner<se::dnn::GraphConvOp>>,
+                   std::unique_ptr<se::dnn::LazyOpRunner<se::dnn::ConvOp>>>;
+  Repr repr_;
+};
+
+struct RunConvOptions {
+  // Nullable output-parameter pointer for profiling results.
+  se::dnn::ProfileResult* profile_result = nullptr;
+
+  // Use this runner cache (and its configured algorithm), instead of the one
+  // from the instruction.
+  GenericConvRunner* runner_cache;
+};
+
+// This file contains low-level routines for running cudnn convolutions.
+
+// Calls into cudnn to run the specified convolution.
+//
+// We provide one overload which takes a scratch buffer, and another which takes
+// an allocator which is responsible for allocating the scratch space.  In
+// theory the second one shouldn't be necessary -- users of this function could
+// just ask cudnn how much scratch space it needs for a particular convolution.
+// But in practice, StreamExecutor does not expose such an API, and in the name
+// of parsimony, perhaps it's better not to add it.  Instead, the first time you
+// call a convolution, you should call the version that takes a scratch
+// allocator and take note of how much memory is used.  The next time you call
+// the same conv, you can provide an explicitly preallocated scratch buffer of
+// that size, if you like.
+Status RunGpuConv(const GpuConvConfig& conv_config,
+                  absl::Span<const se::DeviceMemoryBase> operand_buffers,
+                  absl::Span<const se::DeviceMemoryBase> result_buffers,
+                  se::DeviceMemoryBase scratch_memory, se::Stream* stream,
+                  RunConvOptions = {});
+
+// Struct to describe properties of a convolution without being tied to specific
+// IR. Will be used to help build Convolution thunks from either XLA HLO or
+// LHLO GPU dialect in MLIR.
+struct GpuConvDescriptor {
+  CudnnConvKind kind;
+  CudnnConvBackendConfig backend_config;
+  Shape operand0_shape;
+  Shape operand1_shape;
+  Shape result_shape;
+  size_t scratch_size;
+  Window window;
+  ConvolutionDimensionNumbers dnums;
+  int64_t feature_group_count;
+};
+
+// Returns the convolution configuration given a XLA HLO instruction.
+StatusOr<GpuConvConfig> GetGpuConvConfig(
+    const HloCustomCallInstruction* cudnn_call);
+
+// Returns the convolution configuration given a convolution descriptor `desc`
+// and a string representation of the convolution instruction `inst_as_string`
+// (for error reporting).
+StatusOr<GpuConvConfig> GetGpuConvConfig(const GpuConvDescriptor& desc,
+                                         absl::string_view inst_as_string);
+
+// Implementation details exposed for debugging and log analysis.
+StatusOr<GpuConvParams> GetGpuConvParams(
+    const GpuConvConfig& conv_config,
+    absl::Span<const se::DeviceMemoryBase> operand_buffers,
+    absl::Span<const se::DeviceMemoryBase> result_buffers);
+
+inline se::dnn::DataType BiasTypeForInputType(se::dnn::DataType input_type) {
+  switch (input_type) {
+    default:
+      return input_type;
+    case se::dnn::DataType::kInt8:
+      return se::dnn::DataType::kFloat;
+  }
+}
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_GPU_CONV_RUNNER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_convert_async_collectives_to_sync.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_convert_async_collectives_to_sync.h
new file mode 100644
index 0000000000000000000000000000000000000000..01713f8dd3cef4158ef17d20466d8686e1a6473e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_convert_async_collectives_to_sync.h
@@ -0,0 +1,42 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_GPU_CONVERT_ASYNC_COLLECTIVES_TO_SYNC_H_
+#define XLA_SERVICE_GPU_GPU_CONVERT_ASYNC_COLLECTIVES_TO_SYNC_H_
+
+#include <utility>
+
+#include "xla/service/convert_async_collectives_to_sync.h"
+
+namespace xla {
+namespace gpu {
+
+class GpuConvertAsyncCollectivesToSync : public ConvertAsyncCollectivesToSync {
+ public:
+  using ConvertAsyncCollectivesToSync::ConvertAsyncCollectivesToSync;
+  absl::string_view name() const override {
+    return "gpu-convert-async-collectives-to-sync";
+  }
+
+  Status ConvertAsyncInstructionsToSync(
+      HloComputation* computation,
+      absl::Span<const std::pair<HloInstruction*, HloInstruction*>> async_pairs)
+      const override;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_GPU_CONVERT_ASYNC_COLLECTIVES_TO_SYNC_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_cost_model_stats_collection.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_cost_model_stats_collection.h
new file mode 100644
index 0000000000000000000000000000000000000000..678327c899cae144a4fb9f79a3f093c195af5dc8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_cost_model_stats_collection.h
@@ -0,0 +1,59 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_GPU_COST_MODEL_STATS_COLLECTION_H_
+#define XLA_SERVICE_GPU_GPU_COST_MODEL_STATS_COLLECTION_H_
+
+#include "absl/container/flat_hash_set.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/service/gpu/gpu_hlo_cost_analysis.h"
+#include "xla/service/hlo_cost_analysis.h"
+#include "xla/service/hlo_pass_interface.h"
+#include "xla/statusor.h"
+#include "xla/stream_executor/device_description.h"
+
+namespace xla {
+namespace gpu {
+
+// Calculates costs for each fusion op and stores the result in backend
+// config.
+class GpuCostModelStatsCollection : public HloModulePass {
+ public:
+  explicit GpuCostModelStatsCollection(
+      const se::DeviceDescription& d,
+      const GpuHloCostAnalysis::Options& cost_analysis_options)
+      : device_info_(d), cost_analysis_(cost_analysis_options, &device_info_) {}
+
+  absl::string_view name() const override {
+    return "gpu_cost_model_stats_collection";
+  }
+
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+
+ private:
+  se::DeviceDescription device_info_;
+  GpuHloCostAnalysis cost_analysis_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_GPU_COST_MODEL_STATS_COLLECTION_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_executable.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_executable.h
new file mode 100644
index 0000000000000000000000000000000000000000..7984ae2c8fab27e960cff2989fda2844cfdb71a4
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_executable.h
@@ -0,0 +1,353 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_GPU_EXECUTABLE_H_
+#define XLA_SERVICE_GPU_GPU_EXECUTABLE_H_
+
+#include <cstdint>
+#include <functional>
+#include <map>
+#include <memory>
+#include <optional>
+#include <string>
+#include <string_view>
+#include <utility>
+#include <variant>
+#include <vector>
+
+#include "absl/container/flat_hash_map.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/span.h"
+#include "absl/types/variant.h"
+#include "mlir/Dialect/Func/IR/FuncOps.h"  // from @llvm-project
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/service/buffer_assignment.h"
+#include "xla/service/executable.h"
+#include "xla/service/gpu/buffer_allocations.h"
+#include "xla/service/gpu/non_atomically_upgradeable_rw_lock.h"
+#include "xla/service/gpu/runtime/executable.h"
+#include "xla/service/gpu/runtime2/executable.h"
+#include "xla/service/gpu/thunk.h"
+#include "xla/service/hlo_execution_profile.h"
+#include "xla/service/shaped_buffer.h"
+#include "xla/statusor.h"
+#include "xla/stream_executor/device_description.h"
+#include "xla/stream_executor/device_memory_allocator.h"
+#include "xla/stream_executor/stream_executor.h"
+
+namespace xla {
+namespace gpu {
+
+// Returns whether GpuExecutable runs with Xla Runtime.
+bool IsXlaRuntimeExecutableEnabled(const HloModuleConfig& config);
+
+// Returns whether GpuExecutable runs with experimental XLA:GPU Runtime.
+bool IsXlaGpu2RuntimeEnabled(const HloModuleConfig& config);
+
+// GPU-targeting implementation of the XLA Executable interface.
+//
+// Launches the given GPU kernel via the StreamExecutor.
+//
+// This is an immutable data type after initialization, and thus thread safe.
+class GpuExecutable : public Executable {
+ public:
+  using OwnedThunkSequence = std::unique_ptr<const ThunkSequence>;
+  using OwnedGpuRuntimeProgram = std::unique_ptr<GpuRuntimeProgram>;
+  using OwnedGpu2RuntimeProgram = std::unique_ptr<Gpu2RuntimeProgram>;
+
+  struct ConstantInfo {
+    std::string symbol_name;
+    std::vector<uint8_t> content;
+    int allocation_index = -1;
+  };
+
+  struct OutputInfo {
+    // Corresponding allocation index.
+    int allocation_index;
+
+    // Output is passed-through from a parameter.
+    bool passthrough = false;
+
+    // Whether this output is hinted to alias a parameter (BufferAllocation*
+    // would indicate the aliased parameter), and what kind of alias it is.
+    std::optional<HloInputOutputAliasConfig::Alias> alias_config;
+  };
+
+  struct Params {
+    std::string asm_text;
+    std::vector<uint8_t> binary;
+    se::GpuComputeCapability gpu_version;
+    // The GpuExecutable will either execute Thunks, XLA runtime executable
+    // (native function) or experimental XLA runtime executable (IREE VM
+    // function) depending on which is supplied.
+    std::variant<OwnedThunkSequence, OwnedGpuRuntimeProgram,
+                 OwnedGpu2RuntimeProgram>
+        executable;
+    xla::EntryFunctionAttributes entry_func_attrs;
+    std::vector<ConstantInfo> constants;
+    absl::flat_hash_map<ShapeIndex, OutputInfo> output_info;
+    std::string module_name;
+    xla::Shape output_shape;
+    std::vector<BufferAllocation> allocations;
+    bool enable_persistent_temp_buffers;
+    std::unique_ptr<BufferAssignmentProto> debug_buffer_assignment = nullptr;
+
+    // A callable that dumps out a debug string upon device OOM. It's not the
+    // string itself, as the string can be huge and increase peak host memory
+    // usage for the common (non-OOM) case.
+    std::function<std::string()> verbose_buffer_assignment_string_dumper = [] {
+      return std::string();
+    };
+
+    std::unique_ptr<HloModule> debug_module = nullptr;
+    bool enable_debug_info_manager = true;
+  };
+
+  // Analyze the entry function to construct buffer allocation and other output
+  // information.
+  //
+  // TODO(ezhulenev): Once Xla runtime enabled by default, hide this method as
+  // an implementation detail of GpuExecutable.
+  static Status SetUpMlirAllocation(
+      mlir::func::FuncOp func, llvm::ArrayRef<int64_t> buffer_sizes,
+      std::vector<BufferAllocation>* allocations,
+      absl::flat_hash_map<ShapeIndex, OutputInfo>* output_info,
+      Shape* output_shape);
+
+  // Returns an Executable that is loaded from an object file (XLA program
+  // compiled to a native function using the XLA Runtime stack).
+  static StatusOr<std::unique_ptr<Executable>> LoadFromObjFile(
+      std::shared_ptr<HloModule> hlo_module, absl::string_view obj_file,
+      absl::string_view mlir_module,
+      xla::EntryFunctionAttributes entry_func_attrs, DebugOptions debug_options,
+      absl::string_view asm_text, absl::string_view binary,
+      std::vector<ConstantInfo> constants, se::GpuComputeCapability gpu_version,
+      stream_executor::StreamExecutor* executor);
+
+  // Constructor to use when loading a GpuExecutable from an object file (native
+  // function compiled for XLA Runtime). Omits setting class members that aren't
+  // used in XLA Runtime execution mode.
+  GpuExecutable(std::shared_ptr<HloModule> hlo_module, std::string asm_text,
+                std::vector<uint8_t> binary,
+                std::vector<ConstantInfo> constants,
+                se::GpuComputeCapability gpu_version,
+                xla::EntryFunctionAttributes entry_func_attrs,
+                absl::string_view module_name, Shape xla_output_shape,
+                std::vector<BufferAllocation> allocations,
+                absl::flat_hash_map<ShapeIndex, OutputInfo> output_info,
+                std::unique_ptr<GpuRuntimeExecutable> runtime_executable);
+
+  static StatusOr<std::unique_ptr<GpuExecutable>> Create(Params params);
+  ~GpuExecutable() override;
+
+  int64_t SizeOfGeneratedCodeInBytes() const override;
+
+  // This should be called after set_ir_module_string.
+  const std::string& ir_module_string() const { return ir_module_string_; }
+
+  // This should be called before ExecuteOnStream.
+  void set_ir_module_string(const std::string& ir_module_string) {
+    ir_module_string_ = ir_module_string;
+  }
+
+  // Returns the compiled code for the computation.
+  //
+  // The compiled code is PTX in Cuda and unused empty string in ROCm.
+  // This may be left empty for saving memory if we have a non-empty binary.
+  // If both text() and binary() are empty, that means the HLO required no
+  // custom kernels to be compiled.
+  const std::string& text() const { return text_; }
+
+  // Returns the binary stored in this GpuExecutable.
+  //
+  // The binary is cubin in Cuda, and HSA code object in ROCm. It may be empty,
+  // in which case compilation is left up to the GPU driver. If both text() and
+  // binary() are empty, that means the HLO required no custom kernels to be
+  // compiled.
+  const std::vector<uint8_t>& binary() const { return binary_; }
+
+  // ExecuteAsyncOnStream will fail if the compute capability of the stream
+  // doesn't match the compute capability passed to this object's constructor.
+  StatusOr<ExecutionOutput> ExecuteAsyncOnStream(
+      const ServiceExecutableRunOptions* run_options,
+      std::vector<ExecutionInput> arguments,
+      HloExecutionProfile* hlo_execution_profile) override;
+
+  StatusOr<ScopedShapedBuffer> ExecuteAsyncOnStream(
+      const ServiceExecutableRunOptions* run_options,
+      absl::Span<const ShapedBuffer* const> arguments,
+      HloExecutionProfile* hlo_execution_profile) override;
+
+  using VariantArguments = std::variant<absl::Span<const ShapedBuffer* const>,
+                                        absl::Span<ExecutionInput>>;
+  StatusOr<ExecutionOutput> ExecuteAsyncOnStreamImpl(
+      const ServiceExecutableRunOptions* run_options,
+      VariantArguments arguments);
+
+  absl::Span<const BufferAllocation> GetAllocations() const {
+    return allocations_;
+  }
+
+  const std::vector<ConstantInfo>& constants() const { return constants_; }
+
+  xla::EntryFunctionAttributes entry_func_attrs() const {
+    return entry_func_attrs_;
+  }
+
+  StatusOr<std::string_view> GetObjFile() const;
+  StatusOr<std::string_view> GetMlirModule() const;
+
+ private:
+  // Use GpuExecutable::Create() to create an instance.
+  explicit GpuExecutable(Params params);
+
+  // If `block_host_until_done` is false, execution will not block the host
+  // until the kernels have completed. This is used as an optimization for
+  // clients, such as Tensorflow, that use a single stream of execution for
+  // computations, and allow host-side deallocation from the allocator before
+  // GPU execution completes.
+  Status ExecuteThunksOrXlaRuntime(
+      const ServiceExecutableRunOptions* run_options,
+      const BufferAllocations& buffer_allocations, bool block_host_until_done,
+      NonAtomicallyUpgradeableRWLock& gpu_lock);
+
+  using BufferAllocToDeviceMemoryMap =
+      absl::flat_hash_map<BufferAllocation::Index, se::DeviceMemoryBase>;
+
+  // Loads the PTX or CUBIN for this executable and initializes all
+  // constants that haven't already been initialized by the CUDA driver. Loaded
+  // modules are owned by this executable.
+  //
+  // Returns a map from buffer allocation indices to device memory pointers
+  // (only for allocations that contain constants).
+  //
+  // The returned map is cached. If the above process has already been run for
+  // the given stream, it is skipped and the cached map is immediately returned
+  // instead.
+  StatusOr<const BufferAllocToDeviceMemoryMap*> ResolveConstantGlobals(
+      stream_executor::Stream* stream);
+
+  // Allocate the temp buffers and store them with the GpuExecutable. This
+  // function only allocates buffers on the first run for each executor.
+  Status PopulatePersistentTempBuffers(se::StreamExecutor* executor)
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(persistent_temp_buffers_mu_);
+
+  // GpuExecutable check with either AMD's ISA version, or Nvidia's major minor
+  // version for compute capability, depending on the hardware.
+  Status CheckCompatibilityWithServiceExecutableRunOptions(
+      const ServiceExecutableRunOptions* run_options);
+
+  StatusOr<BufferAllocations> GenerateBufferAllocations(
+      VariantArguments arguments,
+      const GpuExecutable::BufferAllocToDeviceMemoryMap* globals,
+      se::DeviceMemoryAllocator* memory_allocator, int device_ordinal,
+      const BufferAllocToDeviceMemoryMap&
+          buffer_alloc_to_persistent_memory_map);
+
+  StatusOr<se::DeviceMemoryBase> BufferForAllocation(
+      VariantArguments arguments,
+      const GpuExecutable::BufferAllocToDeviceMemoryMap* globals,
+      const BufferAllocation& allocation,
+      se::DeviceMemoryAllocator* memory_allocator, int device_ordinal,
+      int64_t arg_idx);
+
+  // The LLVM IR, in string format, of the unoptimized module generated for
+  // this GpuExecutable. We save a string instead of an llvm::Module* because
+  // leaving llvm::Module* in a singleton can cause the heap checker to emit
+  // false positives.
+  //
+  // This string should be modified only before ExecuteOnStream.
+  std::string ir_module_string_;
+
+  // The compiled code for the computation.
+  const std::string text_;
+
+  // The GPU machine code for the computation, targeting GPUs at
+  // compute_capability_.
+  //
+  // May be empty, in which case we leave compilation up to the GPU driver.
+#ifdef TENSORFLOW_USE_ROCM
+  std::vector<uint8_t> binary_;
+#else
+  const std::vector<uint8_t> binary_;
+#endif
+  // The GPU version for compute compatibility check.
+  se::GpuComputeCapability gpu_version_;
+
+  // The thunks to be invoked by this GpuExecutable. They are generated by the
+  // IrEmitter (null if XLA:GPU runtime is enabled).
+  OwnedThunkSequence thunks_;
+
+  // Gpu runtime executable that encapsulates all the state for running Gpu
+  // runtime custom calls implementing gpu abstraction layer (available only if
+  // Xla runtime is enabled).
+  std::unique_ptr<GpuRuntimeExecutable> gpu_runtime_executable_;
+
+  // XLA:GPU runtime executable that encapsulates all the state for running
+  // XLA:GPU executables compiled to IREE VM modules, including VM module
+  // itself. Available only if experimental XLA:GPU runtime is enabled.
+  std::unique_ptr<Gpu2RuntimeExecutable> gpu2_runtime_executable_;
+
+  xla::EntryFunctionAttributes entry_func_attrs_;
+
+  std::string module_name_;
+
+  xla::Shape output_shape_;
+
+  // Owns the buffer data at runtime. It provides information to allocate
+  // memory for every output/temp buffers.
+  const std::vector<BufferAllocation> allocations_;
+
+  bool enable_persistent_temp_buffers_ = false;
+
+  absl::Mutex persistent_temp_buffers_mu_;
+  // Temp buffers can be allocated once and be reused whenever the GpuExecutable
+  // is executed. The persistent temp buffer is stored in a map that maps from
+  // a BufferAllocation to the temp buffer.
+  absl::flat_hash_map<stream_executor::StreamExecutor*,
+                      BufferAllocToDeviceMemoryMap>
+      persistent_temp_buffers_ ABSL_GUARDED_BY(persistent_temp_buffers_mu_);
+
+  std::shared_ptr<BufferAssignmentProto> debug_buffer_assignment_;
+  std::function<std::string()> verbose_buffer_assignment_string_dumper_;
+
+  absl::Mutex module_handle_mutex_;
+  // Cache of module handles. Required to keep loaded modules alive until this
+  // executable is destroyed.
+  absl::flat_hash_map<stream_executor::StreamExecutor*, se::ScopedModuleHandle>
+      module_handles_ ABSL_GUARDED_BY(module_handle_mutex_);
+  // Cache of constant buffer allocation maps used by `ResolveConstantGlobals`.
+  absl::flat_hash_map<stream_executor::StreamExecutor*,
+                      std::unique_ptr<BufferAllocToDeviceMemoryMap>>
+      module_globals_ ABSL_GUARDED_BY(module_handle_mutex_);
+
+  std::vector<ConstantInfo> constants_;
+  const absl::flat_hash_map<ShapeIndex, OutputInfo> output_info_;
+  // Retains shared ownership of on-device constants that are managed by XLA and
+  // potentially shared with other executables.
+  std::vector<std::shared_ptr<se::DeviceMemoryBase>> shared_constants_;
+  bool enable_debug_info_manager_;
+
+  GpuExecutable(const GpuExecutable&) = delete;
+  GpuExecutable& operator=(const GpuExecutable&) = delete;
+};
+
+StatusOr<absl::flat_hash_map<ShapeIndex, GpuExecutable::OutputInfo>>
+GetOutputInfo(const HloModule& hlo_module, const BufferAssignment& assignment);
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_GPU_EXECUTABLE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_executable_run_options.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_executable_run_options.h
new file mode 100644
index 0000000000000000000000000000000000000000..ffb8785bf7cce924623addb7746554640257883d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_executable_run_options.h
@@ -0,0 +1,133 @@
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_GPU_EXECUTABLE_RUN_OPTIONS_H_
+#define XLA_SERVICE_GPU_GPU_EXECUTABLE_RUN_OPTIONS_H_
+
+#include <functional>
+#include <map>
+#include <optional>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "xla/service/global_device_id.h"
+#include "xla/service/service_executable_run_options.h"
+#include "xla/statusor.h"
+#include "xla/stream_executor/stream_executor.h"
+
+namespace xla {
+namespace gpu {
+
+// Key for naming up a particular NCCL clique.  This is just a set of unique
+// device IDs (i.e. GPU IDs) and a stream_id. The device IDs must be global
+// within a cluster. The stream_id is used to create different NCCL clique and
+// communicators for collectives executed on different streams within an
+// executable.
+class NcclCliqueKey {
+ public:
+  explicit NcclCliqueKey(std::vector<GlobalDeviceId> devices,
+                         int64_t stream_id = 0)
+      : devices_(std::move(devices)), stream_id_(stream_id) {}
+
+  template <typename H>
+  friend H AbslHashValue(H h, const NcclCliqueKey& k) {
+    return H::combine(std::move(h), k.devices_, k.stream_id_);
+  }
+  friend bool operator==(const NcclCliqueKey& a, const NcclCliqueKey& b) {
+    return a.devices_ == b.devices_ && a.stream_id_ == b.stream_id_;
+  }
+
+  const std::vector<GlobalDeviceId>& devices() const { return devices_; }
+
+  std::string ToString() const {
+    return absl::StrCat("stream[", stream_id_, "]",
+                        GlobalDeviceIdsToString(devices_));
+  }
+
+ private:
+  const std::vector<GlobalDeviceId> devices_;
+  const int64_t stream_id_;
+};
+
+using NcclUniqueIdCallback =
+    std::function<StatusOr<std::string>(const NcclCliqueKey&)>;
+
+// GPU-specific executable options.
+// We keep these separate from ExecutableRunOptions to avoid adding
+// dependencies to ExecutableRunOptions.
+class GpuExecutableRunOptions {
+ public:
+  // Sets a mapping from local device ordinals to global device IDs.
+  // Used only on NVidia GPUs for cross-host NCCL collectives. If set, the
+  // elements of `device_assignment` are interpreted as global device IDs, not
+  // local device ordinals.
+  GpuExecutableRunOptions& set_gpu_global_device_ids(
+      std::optional<std::map<int, GlobalDeviceId>> gpu_global_device_ids);
+  const std::optional<std::map<int, GlobalDeviceId>>& gpu_global_device_ids()
+      const;
+
+  // Callback that returns a ncclUniqueId encoded as a string for a group of
+  // communicating GPU devices. Used only on NVidia GPUs.
+  GpuExecutableRunOptions& set_nccl_unique_id_callback(
+      NcclUniqueIdCallback nccl_unique_id_callback);
+  const NcclUniqueIdCallback& nccl_unique_id_callback() const;
+
+  // Whether the run requires an exclusive lock on the GPU.
+  bool requires_exclusive_lock_on_gpu() const {
+    return requires_exclusive_lock_on_gpu_;
+  }
+
+  // Require writers lock on the GPU.
+  GpuExecutableRunOptions& set_requires_exclusive_lock_on_gpu() {
+    requires_exclusive_lock_on_gpu_ = true;
+    return *this;
+  }
+
+  bool enable_mock_nccl_collectives() const {
+    return enable_mock_nccl_collectives_;
+  }
+
+  // Enable mocking nccl collective operations on the GPU
+  GpuExecutableRunOptions& set_enable_mock_nccl_collectives() {
+    enable_mock_nccl_collectives_ = true;
+    return *this;
+  }
+
+ private:
+  bool requires_exclusive_lock_on_gpu_ = false;
+  bool enable_mock_nccl_collectives_ = false;
+  std::optional<std::map<int, GlobalDeviceId>> gpu_global_device_ids_;
+  NcclUniqueIdCallback nccl_unique_id_callback_;
+};
+
+// NCCL-related execution parameters.
+struct NcclExecuteParams {
+  NcclExecuteParams(const ServiceExecutableRunOptions& run_options,
+                    se::StreamExecutor* stream_executor);
+
+  se::StreamExecutor* stream_executor;
+  RunId run_id;
+  const DeviceAssignment* device_assn;                         // never null
+  const std::map<int, GlobalDeviceId>* gpu_global_device_ids;  // may be null
+  const NcclUniqueIdCallback* nccl_unique_id_callback;         // may be null
+
+  StatusOr<GlobalDeviceId> GetGlobalDeviceId() const;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_GPU_EXECUTABLE_RUN_OPTIONS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_float_support.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_float_support.h
new file mode 100644
index 0000000000000000000000000000000000000000..c9e0e2ac0c48e71925e67b96ae9598a1100bc572
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_float_support.h
@@ -0,0 +1,52 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_GPU_FLOAT_SUPPORT_H_
+#define XLA_SERVICE_GPU_GPU_FLOAT_SUPPORT_H_
+
+#include <cstdint>
+
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/service/float_support.h"
+#include "xla/xla_data.pb.h"
+
+namespace xla {
+namespace gpu {
+
+class GpuFloatSupport : public FloatSupport {
+ public:
+  explicit GpuFloatSupport(PrimitiveType low_precision_type)
+      : FloatSupport(low_precision_type) {}
+
+  bool SupportsLowPrecisionOperand(const HloInstruction& hlo,
+                                   int64_t operand_index) const override {
+    return FloatSupport::SupportsLowPrecisionOperand(hlo, operand_index) ||
+           IsSupported(hlo);
+  }
+
+  bool SupportsLowPrecisionOutput(const HloInstruction& hlo) const override {
+    return FloatSupport::SupportsLowPrecisionOutput(hlo) || IsSupported(hlo);
+  }
+
+  bool SupportsMixedPrecisions(const HloInstruction& hlo) const override;
+
+ private:
+  bool IsSupported(const HloInstruction& hlo) const;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_GPU_FLOAT_SUPPORT_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_fused_mha_runner.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_fused_mha_runner.h
new file mode 100644
index 0000000000000000000000000000000000000000..637a3c474c4f7e6d9aeba0874596a4a55ebe996c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_fused_mha_runner.h
@@ -0,0 +1,393 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_GPU_FUSED_MHA_RUNNER_H_
+#define XLA_SERVICE_GPU_GPU_FUSED_MHA_RUNNER_H_
+
+#include <memory>
+#include <optional>
+#include <string>
+#include <utility>
+#include <variant>
+#include <vector>
+
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/hlo/ir/hlo_instructions.h"
+#include "xla/service/gpu/backend_configs.pb.h"
+#include "xla/service/gpu/cublas_cudnn.h"
+#include "xla/status.h"
+#include "xla/statusor.h"
+#include "xla/stream_executor/dnn.h"
+#include "xla/stream_executor/lazy_op_runner.h"
+#include "xla/stream_executor/stream_executor.h"
+#include "xla/types.h"
+#include "xla/xla_data.pb.h"
+
+namespace xla {
+namespace gpu {
+
+// This is an interim structure to hold the parameters to construct a
+// GpufMHAConfig.
+// Struct to describe properties of a FMHA without being tied to specific
+// IR. Will be used to help build FMHA thunks from either XLA HLO or
+// LHLO GPU dialect in MLIR.
+struct GpufMHADescriptor {
+  CudnnfMHAKind kind;
+  CudnnfMHABackendConfig backend_config;
+  Shape lhs_bmm1_shape;
+  Shape rhs_bmm1_shape;
+  Shape rhs_bmm2_shape;
+  Shape intermediate_lhs_bmm2_shape;
+  // This will contain both output shape and activation shape
+  std::vector<Shape> output_shapes;
+  DotDimensionNumbers bmm1_dnums;
+  DotDimensionNumbers bmm2_dnums;
+
+  std::optional<Shape> mask_shape;
+  std::optional<Shape> bias_shape;
+};
+
+struct GpufMHABackwardDescriptor {
+  CudnnfMHAKind kind;
+  CudnnfMHABackendConfig backend_config;
+  Shape bmm1_grad_gemm1_rhs_shape;
+  Shape bmm1_grad_gemm2_rhs_shape;
+  Shape bmm2_grad_gemm1_lhs_shape;
+  Shape bmm2_grad_gemm2_rhs_shape;
+  Shape d_output_shape;
+  Shape d_bmm1_lhs_shape;
+  Shape d_bmm1_rhs_shape;
+  Shape d_bmm2_rhs_shape;
+  DotDimensionNumbers bmm1_grad_gemm1_dnums;
+  DotDimensionNumbers bmm1_grad_gemm2_dnums;
+  DotDimensionNumbers bmm2_grad_gemm1_dnums;
+  DotDimensionNumbers bmm2_grad_gemm2_dnums;
+
+  std::optional<Shape> mask_shape;
+  std::optional<Shape> d_bias_shape;
+};
+// Structure to describe static properties of a GPU fused Multi-Headed
+// Attention.
+struct GpufMHAConfig {
+  static StatusOr<GpufMHAConfig> For(const GpufMHADescriptor& fmha_desc);
+  PrimitiveType
+      input_type;  // Capture the primitive type of one of the inputs of BMM1
+  PrimitiveType output_type;
+  CudnnfMHAKind kind;
+  std::optional<double> fmha_scale;
+  std::optional<double> dropout_rate;
+  std::optional<int64_t> seed;
+
+  se::dnn::AlgorithmDesc algorithm;
+
+  // bias -> [1, num_attn_heads, q_seq_len, kv_seq_len]
+  // mask -> [batch_size, 1, q_seq_len, kv_seq_len]
+  se::dnn::MatmulTensorDescriptor lhs_bmm1;
+  se::dnn::MatmulTensorDescriptor rhs_bmm1;
+  se::dnn::MatmulTensorDescriptor rhs_bmm2;
+  se::dnn::MatmulTensorDescriptor intermediate_lhs_bmm2;
+  se::dnn::TensorDescriptor output;
+
+  std::optional<se::dnn::TensorDescriptor> activation;
+  std::optional<se::dnn::TensorDescriptor> mask;
+  std::optional<se::dnn::TensorDescriptor> bias;
+};
+
+// Structure to describe static properties of a GPU fused Multi-Headed
+// Attention backward.
+struct GpufMHABackwardConfig {
+  static StatusOr<GpufMHABackwardConfig> For(
+      const GpufMHABackwardDescriptor& fmha_desc);
+  PrimitiveType
+      input_type;  // Capture the primitive type of one of the inputs of BMM1
+  PrimitiveType output_type;
+  CudnnfMHAKind kind;
+  std::optional<double> fmha_scale;
+  std::optional<double> dropout_rate;
+  std::optional<int64_t> seed;
+
+  se::dnn::AlgorithmDesc algorithm;
+
+  // mask -> [batch_size, 1, q_seq_len, kv_seq_len]
+  // d_bias -> [1, num_heads, q_seq_len, kv_seq_len]
+  se::dnn::MatmulTensorDescriptor bmm1_grad_gemm1_rhs;
+  se::dnn::MatmulTensorDescriptor bmm1_grad_gemm2_rhs;
+  se::dnn::MatmulTensorDescriptor bmm2_grad_gemm1_lhs;
+  se::dnn::MatmulTensorDescriptor bmm2_grad_gemm2_rhs;
+  se::dnn::MatmulTensorDescriptor d_output;
+  se::dnn::TensorDescriptor d_bmm1_lhs;
+  se::dnn::TensorDescriptor d_bmm1_rhs;
+  se::dnn::TensorDescriptor d_bmm2_rhs;
+  se::dnn::TensorDescriptor d_s;
+  std::optional<se::dnn::TensorDescriptor> d_bias;
+  std::optional<se::dnn::TensorDescriptor> mask;
+};
+
+// Implementation struct exposed for debugging and log analysis.
+struct GpufMHAParams {
+  static StatusOr<GpufMHAParams> For(
+      const GpufMHAConfig& config, se::DeviceMemoryBase lhs_bmm1_buffer,
+      se::DeviceMemoryBase rhs_bmm1_buffer,
+      se::DeviceMemoryBase rhs_bmm2_buffer, se::DeviceMemoryBase output_buffer,
+      std::optional<se::DeviceMemoryBase> mask_buffer,
+      std::optional<se::DeviceMemoryBase> bias_buffer,
+      std::optional<se::DeviceMemoryBase> activation_buffer);
+
+  const GpufMHAConfig* config;  // Not owned
+  se::DeviceMemoryBase lhs_bmm1_buffer;
+  se::DeviceMemoryBase rhs_bmm1_buffer;
+  se::DeviceMemoryBase rhs_bmm2_buffer;
+  se::DeviceMemoryBase output_buffer;
+  std::optional<se::DeviceMemoryBase> activation_buffer;
+  std::optional<se::DeviceMemoryBase> mask_buffer;
+  std::optional<se::DeviceMemoryBase> bias_buffer;
+};
+
+struct GpufMHABackwardParams {
+  static StatusOr<GpufMHABackwardParams> For(
+      const GpufMHABackwardConfig& config,
+      se::DeviceMemoryBase bmm1_grad_gemm1_rhs_buffer,
+      se::DeviceMemoryBase bmm1_grad_gemm2_rhs_buffer,
+      se::DeviceMemoryBase bmm2_grad_gemm1_lhs_buffer,
+      se::DeviceMemoryBase bmm2_grad_gemm2_rhs_buffer,
+      se::DeviceMemoryBase d_output_buffer,
+      se::DeviceMemoryBase d_bmm1_lhs_buffer,
+      se::DeviceMemoryBase d_bmm1_rhs_buffer,
+      se::DeviceMemoryBase d_bmm2_rhs_buffer, se::DeviceMemoryBase d_s_buffer,
+      std::optional<se::DeviceMemoryBase> mask_buffer,
+      std::optional<se::DeviceMemoryBase> d_bias_buffer);
+
+  const GpufMHABackwardConfig* config;  // Not owned
+  se::DeviceMemoryBase bmm1_grad_gemm1_rhs_buffer;
+  se::DeviceMemoryBase bmm1_grad_gemm2_rhs_buffer;
+  se::DeviceMemoryBase bmm2_grad_gemm1_lhs_buffer;
+  se::DeviceMemoryBase bmm2_grad_gemm2_rhs_buffer;
+  se::DeviceMemoryBase d_output_buffer;
+  se::DeviceMemoryBase d_bmm1_lhs_buffer;
+  se::DeviceMemoryBase d_bmm1_rhs_buffer;
+  se::DeviceMemoryBase d_bmm2_rhs_buffer;
+  se::DeviceMemoryBase d_s_buffer;
+  std::optional<se::DeviceMemoryBase> d_bias_buffer;
+  std::optional<se::DeviceMemoryBase> mask_buffer;
+};
+
+class FusedMultiHeadedAttentionRunner {
+ public:
+  using Repr =
+      std::variant<std::monostate,  // To allow XXX default ctor
+                   std::unique_ptr<se::dnn::LazyOpRunner<se::dnn::FusedMHAOp>>>;
+
+  FusedMultiHeadedAttentionRunner() = default;
+
+  explicit FusedMultiHeadedAttentionRunner(
+      std::unique_ptr<se::dnn::LazyOpRunner<se::dnn::FusedMHAOp>> runner)
+      : repr_(std::move(runner)) {}
+
+  explicit FusedMultiHeadedAttentionRunner(Repr runner)
+      : repr_(std::move(runner)) {}
+
+  explicit FusedMultiHeadedAttentionRunner(const GpufMHAConfig& config)
+      : FusedMultiHeadedAttentionRunner(CreateRunner(config)) {
+    if (std::holds_alternative<std::monostate>(repr_)) {
+      CHECK(false) << "Cannot construct FusedMultiHeadedAttentionRunner with "
+                      "std::monostate";
+    }
+  }
+
+  se::dnn::AlgorithmDesc ToAlgorithmDesc() const {
+    return std::visit(ToAlgorithmDescVisitor{}, repr_);
+  }
+
+  se::dnn::LazyOpRunner<se::dnn::FusedMHAOp>* AsFusedMHARunner() {
+    CHECK(std::holds_alternative<
+          std::unique_ptr<se::dnn::LazyOpRunner<se::dnn::FusedMHAOp>>>(repr_));
+    return std::get<
+               std::unique_ptr<se::dnn::LazyOpRunner<se::dnn::FusedMHAOp>>>(
+               repr_)
+        .get();
+  }
+
+ private:
+  //  The CreateRunner function is defined as static because it
+  //  doesn't need access to any non-static member variables of the
+  //  FusedMultiHeadedAttentionRunner class. Defining it static makes it easy to
+  //  use and makes it clear that it is a utility function that doesn't rely on
+  //  the state of any specific instance of the class.
+  static Repr CreateRunner(const GpufMHAConfig& config) {
+    switch (config.kind) {
+      case CudnnfMHAKind::kBmmBmm:
+      case CudnnfMHAKind::kSoftmaxDropout:
+      case CudnnfMHAKind::kSoftmax:
+      case CudnnfMHAKind::kScaleBiasSoftmax:
+      case CudnnfMHAKind::kScaleBiasSoftmaxDropout:
+      case CudnnfMHAKind::kScaleMaskSoftmax:
+      case CudnnfMHAKind::kScaleMaskSoftmaxDropout:
+      case CudnnfMHAKind::kScaleBiasMaskSoftmax:
+      case CudnnfMHAKind::kScaleBiasMaskSoftmaxDropout:
+        return std::make_unique<se::dnn::LazyOpRunner<se::dnn::FusedMHAOp>>(
+            config.algorithm);
+      default:
+        LOG(FATAL) << "Internal error: unsupported CUDNN MHA kind in "
+                      "FusedMultiHeadedAttentionRunner";
+    }
+  }
+
+  struct ToAlgorithmDescVisitor {
+    template <typename RunnerPtr>
+    se::dnn::AlgorithmDesc operator()(const RunnerPtr& runner) {
+      return runner->ToAlgorithmDesc();
+    }
+
+    se::dnn::AlgorithmDesc operator()(const std::monostate&) {
+      CHECK(false) << "Internal error: uninitialized runner in ToAlgorithmDesc";
+    }
+  };
+
+  Repr repr_;
+};
+
+class FusedMultiHeadedAttentionBackwardRunner {
+ public:
+  using Repr = std::variant<
+      std::monostate,  // To allow XXX default ctor
+      std::unique_ptr<se::dnn::LazyOpRunner<se::dnn::FusedMHABackwardOp>>>;
+
+  FusedMultiHeadedAttentionBackwardRunner() = default;
+
+  explicit FusedMultiHeadedAttentionBackwardRunner(
+      std::unique_ptr<se::dnn::LazyOpRunner<se::dnn::FusedMHABackwardOp>>
+          runner)
+      : repr_(std::move(runner)) {}
+
+  explicit FusedMultiHeadedAttentionBackwardRunner(Repr runner)
+      : repr_(std::move(runner)) {}
+
+  explicit FusedMultiHeadedAttentionBackwardRunner(
+      const GpufMHABackwardConfig& config)
+      : FusedMultiHeadedAttentionBackwardRunner(CreateRunner(config)) {
+    if (std::holds_alternative<std::monostate>(repr_)) {
+      CHECK(false)
+          << "Cannot construct FusedMultiHeadedAttentionBackwardRunner with "
+             "std::monostate";
+    }
+  }
+
+  se::dnn::AlgorithmDesc ToAlgorithmDesc() const {
+    return std::visit(ToAlgorithmDescVisitor{}, repr_);
+  }
+
+  se::dnn::LazyOpRunner<se::dnn::FusedMHABackwardOp>*
+  AsFusedMHABackwardRunner() {
+    CHECK(std::holds_alternative<
+          std::unique_ptr<se::dnn::LazyOpRunner<se::dnn::FusedMHABackwardOp>>>(
+        repr_));
+    return std::get<std::unique_ptr<
+        se::dnn::LazyOpRunner<se::dnn::FusedMHABackwardOp>>>(repr_)
+        .get();
+  }
+
+ private:
+  //  The CreateRunner function is defined as static because it
+  //  doesn't need access to any non-static member variables of the
+  //  FusedMultiHeadedAttentionBackwardRunner class. Defining it static makes it
+  //  easy to use and makes it clear that it is a utility function that doesn't
+  //  rely on the state of any specific instance of the class.
+  static Repr CreateRunner(const GpufMHABackwardConfig& config) {
+    switch (config.kind) {
+      case CudnnfMHAKind::kBackwardBmmBmm:
+      case CudnnfMHAKind::kBackwardSoftmaxDropout:
+      case CudnnfMHAKind::kBackwardSoftmax:
+      case CudnnfMHAKind::kBackwardScaleBiasSoftmax:
+      case CudnnfMHAKind::kBackwardScaleBiasSoftmaxDropout:
+      case CudnnfMHAKind::kBackwardScaleBiasMaskSoftmax:
+      case CudnnfMHAKind::kBackwardScaleBiasMaskSoftmaxDropout:
+      case CudnnfMHAKind::kBackwardScaleMaskSoftmax:
+      case CudnnfMHAKind::kBackwardScaleMaskSoftmaxDropout:
+        return std::make_unique<
+            se::dnn::LazyOpRunner<se::dnn::FusedMHABackwardOp>>(
+            config.algorithm);
+      default:
+        LOG(FATAL) << "Internal error: unsupported CUDNN MHA kind in "
+                      "FusedMultiHeadedAttentionBackwardRunner";
+    }
+  }
+
+  struct ToAlgorithmDescVisitor {
+    template <typename RunnerPtr>
+    se::dnn::AlgorithmDesc operator()(const RunnerPtr& runner) {
+      return runner->ToAlgorithmDesc();
+    }
+
+    se::dnn::AlgorithmDesc operator()(const std::monostate&) {
+      CHECK(false) << "Internal error: uninitialized runner in ToAlgorithmDesc";
+    }
+  };
+
+  Repr repr_;
+};
+
+struct RunFusedMHAOptions {
+  // Nullable output-parameter pointer for profiling results.
+  // Profile results remain unused for now since cuDNN FMHA has only one
+  // algorithm for now.
+  se::dnn::ProfileResult* profile_result = nullptr;
+
+  // Use this runner cache (and its configured algorithm), instead of the one
+  // from the instruction.
+  FusedMultiHeadedAttentionRunner* runner_cache;
+};
+
+struct RunFusedMHABackwardOptions {
+  // Nullable output-parameter pointer for profiling results.
+  // Profile results remain unused for now since cuDNN FMHA has only one
+  // algorithm for now.
+  se::dnn::ProfileResult* profile_result = nullptr;
+
+  // Use this runner cache (and its configured algorithm), instead of the one
+  // from the instruction.
+  FusedMultiHeadedAttentionBackwardRunner* runner_cache;
+};
+
+Status RunGpuFMHA(const GpufMHAConfig& fmha_config,
+                  se::DeviceMemoryBase lhs_bmm1_buffer,
+                  se::DeviceMemoryBase rhs_bmm1_buffer,
+                  se::DeviceMemoryBase rhs_bmm2_buffer,
+                  se::DeviceMemoryBase output_buffer,
+                  se::DeviceMemoryBase scratch_buffer,
+                  std::optional<se::DeviceMemoryBase> mask_buffer,
+                  std::optional<se::DeviceMemoryBase> bias_buffer,
+                  std::optional<se::DeviceMemoryBase> activation_buffer,
+                  se::Stream* stream, RunFusedMHAOptions = {});
+
+Status RunGpuFMHABackward(const GpufMHABackwardConfig& fmha_config,
+                          se::DeviceMemoryBase bmm1_grad_gemm1_rhs_buffer,
+                          se::DeviceMemoryBase bmm1_grad_gemm2_rhs_buffer,
+                          se::DeviceMemoryBase bmm2_grad_gemm1_lhs_buffer,
+                          se::DeviceMemoryBase bmm2_grad_gemm2_rhs_buffer,
+                          se::DeviceMemoryBase d_output_buffer,
+                          se::DeviceMemoryBase scratch_buffer,
+                          se::DeviceMemoryBase d_bmm1_lhs_buffer,
+                          se::DeviceMemoryBase d_bmm1_rhs_buffer,
+                          se::DeviceMemoryBase d_bmm2_rhs_buffer,
+                          se::DeviceMemoryBase d_s_buffer,
+                          std::optional<se::DeviceMemoryBase> mask_buffer,
+                          std::optional<se::DeviceMemoryBase> d_bias_buffer,
+                          se::Stream* stream, RunFusedMHABackwardOptions = {});
+
+std::string ToString(const GpufMHAConfig& config);
+
+}  // namespace gpu
+}  // namespace xla
+#endif  // XLA_SERVICE_GPU_GPU_FUSED_MHA_RUNNER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_fusible.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_fusible.h
new file mode 100644
index 0000000000000000000000000000000000000000..ec02a6c2d04ad4e833b086cfdf160029b2e3c026
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_fusible.h
@@ -0,0 +1,197 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_GPU_FUSIBLE_H_
+#define XLA_SERVICE_GPU_GPU_FUSIBLE_H_
+
+#include <vector>
+
+#include "xla/hlo/ir/hlo_computation.h"
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/service/gpu/reduction_utils.h"
+#include "xla/service/instruction_fusion.h"
+#include "xla/stream_executor/device_description.h"
+
+// TODO(b/112957171): Extract logic to determine fusibility of HLO ops from
+// GpuInstructionFusion, FusionMerger, and GpuMultiOutputFusion.
+
+namespace xla {
+namespace gpu {
+
+// Check if the operation accesses the same inputs multiple times
+// while generating its outputs.
+bool IfFusedReadsElementsMultipleTimes(const HloInstruction& instr);
+
+// Check if the operation is memory or computationally expensive
+// to repeat.
+bool IsExpensiveToRepeat(const HloInstruction& instr);
+
+// Fusion passes frequently do checks across all pairs of "interesting" nodes.
+// Computing e.g. FusionFitsInBudget(a, b) requires computing expensive
+// properties of `a` and `b` individually.  This cache lets us avoid recomputing
+// those properties n^2 times.
+//
+// Invariant: After modifying or removing a fusion node, call Invalidate(node).
+struct FusionInfoCache {
+ public:
+  // Must be called after modifying or removing a fusion node (or other node
+  // that's part of this cache).
+  void Invalidate(const HloInstruction* instr) {
+    shared_memory_usage.erase(instr);
+    num_unnested_reductions.erase(instr);
+  }
+
+  // The rest of the members of this class are for internal use within
+  // gpu_fusible. You shouldn't need to use them yourself.
+  absl::flat_hash_map<const HloInstruction*, int64_t> shared_memory_usage;
+  absl::flat_hash_map<const HloInstruction*, int64_t> num_unnested_reductions;
+};
+
+// Returns projected shared memory usage of a given instruction in bytes.
+int64_t SharedMemoryUsage(const HloInstruction& instr,
+                          FusionInfoCache* cache = nullptr);
+
+// Returns projected shared memory usage of a reduction fusion.
+int64_t ReductionProjectedShmemUsageBytes(
+    const ReductionDimensions& reduction_dimensions,
+    const std::vector<std::vector<const HloInstruction*>>& instr_index_groups);
+
+inline constexpr int64_t MaxOperandsAndOutputsPerFusion() { return 64; }
+
+// Whether the op tranposes the physical data layout. Fusing such ops may lead
+// to uncoalesced data access and may thus not be beneficial.
+bool IsPhysicallyTransposing(const HloInstruction& instr);
+
+// Note that reduction ops are lowered in different ways. Reduce input fusions
+// are lowered by IrEmitterUnnested::EmitReductionToVector and must be rooted at
+// reduction-to-vector ops. Other reduction ops are lowered by
+// GpuElementalIrEmitter and fused like elementwise ops.
+
+// Whether `instr` is an input fusion rooted at a reduction-to-vector op or a
+// multi-output input fusion with at least one reduction-to-vector op root.
+bool IsReduceInputFusion(const HloInstruction& instr);
+
+// Whether `instr` is fusible as root of a reduce input fusions, i.e. `instr`
+// is either an unfused reduction-to-vector op or a reduce input fusion.
+bool IsInputFusibleReduction(const HloInstruction& instr);
+
+// Whether `instr` is a nestable variadic reduction
+// or a loop fusion rooted with such.
+bool IsNestableVariadicReduction(const HloInstruction& instr);
+
+// Whether `instr` is fusible as root of a scatter input fusions, i.e. `instr`
+// is either an unfused scatter op or a scatter input fusion.
+bool IsInputFusibleScatter(const HloInstruction& instr);
+
+// Determines whether the combination of `instr1` and `instr2` into a (possibly
+// multi-output) fusion fits within a "budget" -- i.e., does have more operands
+// and outputs than is allowed or occupy too much shared memory. If the fusion
+// is a producer/consumer fusion and `instr1` is the consumer and `instr2` is
+// the producer, set consumer_producer_fusion to true to enable more fusion.
+FusionDecision FusionFitsInBudget(const HloInstruction& instr1,
+                                  const HloInstruction& instr2,
+                                  const se::DeviceDescription& device_info,
+                                  bool is_consumer_producer_fusion = false,
+                                  FusionInfoCache* cache = nullptr);
+
+// Check if fusing producer and consumer will generate a heavy computation, e.g.
+// producer has a complex computation per output and consumer calls this
+// computations multiple times.
+bool CreatesHeavyComputation(const HloInstruction& producer,
+                             const HloInstruction& consumer);
+
+// Returns the instruction that determines the emitter used for lowering,
+// sometimes referred to as "the real hero".
+const HloInstruction* GetRealHeroForMultiOutputFusion(
+    const HloInstruction& instr);
+
+// Whether 'hero1' and 'hero2' are compatible if the two fusions containing
+// 'hero1' and 'hero2' are merged together. For example merging two fusions with
+// a reduction hero and a transpose here, respectively, does not work.
+FusionDecision FusionHeroesAreCompatible(const HloInstruction* hero1,
+                                         const HloInstruction* hero2);
+
+// Whether instruction shapes are compatible for multi-output fusion, i.e.
+// whether the emitters support lowering the resulting fusion.
+// This function works for both, sibling and producer-consumer multi-output
+// fusion.
+// So far, multi-output fusion is supported for loop fusions and reduce
+// input fusions only. It is up to the caller to ensure the instructions
+// themselves are fusible!
+FusionDecision ShapesCompatibleForMultiOutputFusion(
+    const HloInstruction& instr1, const HloInstruction& instr2);
+
+// Whether the instructions are compatible for producer-consumer fusion
+// i.e. whether the producer and consumer are loop/input fusible and
+// they are not library calls.
+// Used both by instruction fusion and fusion-fusion merging.
+FusionDecision IsProducerConsumerFusible(const HloInstruction& producer,
+                                         const HloInstruction& consumer);
+
+// Whether the producer is a valid candidate for a multi-output fusion.
+// That is, the root tuple of the multi-output fusion will contain the results
+// of both, the producer and consumer.
+FusionDecision IsProducerMultiOutputFusible(const HloInstruction& producer);
+// Whether `instr` is a candidate for sibling fusion or as a consumer in
+// a producer-consumer multi-output fusion.
+bool IsFusibleAsMultiOutputFusionRoot(const HloInstruction& instr);
+
+// Determines the fusion kind to be used when fusing `producer` and `consumer`.
+HloInstruction::FusionKind ChooseFusionKind(const HloInstruction& producer,
+                                            const HloInstruction& consumer);
+
+// Returns whether `consumer` is the only non-root user of `instr`.
+bool IsConsumerTheOnlyNonRootUser(const HloInstruction& instr,
+                                  const HloInstruction& consumer);
+
+// Returns number of instructions in the fusible `instr`. If `instr` is not a
+// fusion instruction, 1 is returned.
+size_t GetInstrCountOfFusible(const HloInstruction& instr);
+
+// Returns the outputs of the fusible `instr`.
+absl::InlinedVector<const HloInstruction*, 2> GetOutputsOfFusible(
+    const HloInstruction& instr);
+
+// Returns the output size of the fusible `instr`.
+size_t GetOutputSizeOfFusible(const HloInstruction& instr);
+
+// Returns instructions which are roots of the fusion, following the operands of
+// GTE instructions in the root tuple. Groups multiple subsequent instructions
+// with the same root. CHECKs that the fusion never outputs the same instruction
+// twice, as well as that there are no explicitly created tuples or nested gtes
+// in fusion output.
+//
+// For input: (tuple (gte R1) (gte R1) O2)
+// Expected output: [R1, O2]
+//
+// For input: (tuple R1 R2 O2)
+// Expected output: [R1, R2, O2]
+//
+// For input: (tuple (gte R1) (gte R1) R2 O3)
+// Expected output: [R1, R2, O3]
+//
+// For input: R1
+// Expected output: [R1]
+std::vector<const HloInstruction*> GetFusionRoots(
+    const HloComputation& computation);
+
+// Whether the instruction is a reduction hero for the given root.
+bool IsRealReductionHero(const HloInstruction& root,
+                         const HloInstruction& hero);
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_GPU_FUSIBLE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_hlo_cost_analysis.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_hlo_cost_analysis.h
new file mode 100644
index 0000000000000000000000000000000000000000..10b44ba5c3bca92f16a1886d62ffbdaf5e4fce1d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_hlo_cost_analysis.h
@@ -0,0 +1,109 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_GPU_HLO_COST_ANALYSIS_H_
+#define XLA_SERVICE_GPU_GPU_HLO_COST_ANALYSIS_H_
+
+#include <memory>
+
+#include "absl/strings/string_view.h"
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/service/hlo_cost_analysis.h"
+#include "xla/stream_executor/device_description.h"
+
+namespace xla {
+namespace gpu {
+
+// Cost analysis for GPUs.
+class GpuHloCostAnalysis : public HloCostAnalysis {
+  // Each instruction creating a new basic block roughly doubles the total
+  // number of basic blocks and the IR code size accordingly.
+  static constexpr int64_t kMaxBasicBlockSplitsPerFusion = 10;
+  static constexpr int64_t kMaxIRSize = 10000;
+
+ public:
+  explicit GpuHloCostAnalysis(
+      const Options& options,
+      const se::DeviceDescription* device_info = nullptr)
+      : HloCostAnalysis(options), device_info_(device_info) {}
+
+  Status Preprocess(const HloInstruction* hlo) override;
+
+  float ScalingRatio(const HloInstruction& hlo) const;
+  int64_t NumOfDevices(const HloInstruction& hlo) const;
+
+  Status HandleCustomCall(const HloInstruction* call) override;
+
+  int64_t GetConvolutionFlops(const HloInstruction* convolution) override;
+
+  Status HandleElementwiseOp(const HloInstruction* hlo);
+  Status HandleElementwiseUnary(const HloInstruction* hlo) override;
+  Status HandleElementwiseBinary(const HloInstruction* hlo) override;
+
+  Status HandleAllReduce(const HloInstruction* allreduce) override;
+
+  // Estimate the total size of IR accounting for both duplication
+  // of producer code by consumer and the total number of basic blocks.
+  // Tell if merged IR size would be too slow to compile.
+  bool ProducerConsumerMergedTooLarge(const HloInstruction& producer,
+                                      const HloInstruction& consumer);
+
+  // IR size scale of an instruction: 1 for most instructions,
+  // but for fusions is the number of instructions emitted including the
+  // duplication due to non-element-wise accesses.
+  float IrSize(const HloInstruction& hlo) const;
+
+  // Total common elementwise utilization of two instructions within a fusion.
+  // If two parameters have several common elementwise use roots returned is
+  // the sum of these utilizations. Can also be used to query if a parameter
+  // is used elementwise from the fusion's root.
+  float CommonElementwiseUtilization(const HloInstruction* a,
+                                     const HloInstruction* b) const;
+
+  const se::DeviceDescription* device_info_;
+
+ protected:
+  std::unique_ptr<HloCostAnalysis> CreateNestedCostAnalysis() override;
+  int64_t FusionParameterReadBytes(const HloInstruction* hlo) const override;
+  Status FusionCalculateUtilizations(const HloInstruction* fusion) override;
+
+  size_t immediate_constant_max_elements() const override { return 8; }
+
+  bool KeyToCopyFromSubcomputation(absl::string_view key) const override;
+
+  // Some instructions create new LLVM basic blocks; with our current code
+  // generation this means in the worst case doubling the IR size of a fusion
+  // containing such an instruction.
+  // Count these to avoid unmanageable IR code size.
+  float IrBasicBlockSplitCount(const HloInstruction& hlo) const;
+
+  // To estimate where within the computation an instruction output can be
+  // reused and where it has to be recomputed again we group accesses to the
+  // instruction by their origin from "element-wise use roots". All access
+  // paths from such a root to the instruction are element-wise.
+  absl::flat_hash_map<const HloInstruction*,
+                      absl::flat_hash_set<const HloInstruction*>>
+      elementwise_use_roots_;
+
+  // Elementwise utilization of instruction's input subtree if it is a root.
+  // This is different from hlo_properties_[instr][kUtilizationKey] which
+  // is the utilization of the instruction by other roots.
+  absl::flat_hash_map<const HloInstruction*, float> root_utilizations_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_GPU_HLO_COST_ANALYSIS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_hlo_schedule.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_hlo_schedule.h
new file mode 100644
index 0000000000000000000000000000000000000000..792dfbd2633c11154506882633becd33e8f930be
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_hlo_schedule.h
@@ -0,0 +1,42 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_GPU_HLO_SCHEDULE_H_
+#define XLA_SERVICE_GPU_GPU_HLO_SCHEDULE_H_
+
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/stream_executor/device_description.h"
+
+namespace xla {
+namespace gpu {
+
+int64_t GetSizeOfShape(const Shape& shape, int pointer_size);
+
+// Determines the schedule of HLO instructions for a module run on the GPU.
+Status ScheduleGpuModule(HloModule* module, int64_t pointer_size,
+                         int64_t memory_limit,
+                         const se::DeviceDescription& gpu_device_info);
+HloInstructionSequence PostProcessSchedule(const HloInstructionSequence& input);
+
+int64_t GetSchedulerMemoryLimit(const HloModule* module,
+                                const se::DeviceDescription& gpu_device_info,
+                                int pointer_size);
+
+constexpr absl::string_view kFingerprintBeforeLHS = "fingerprint_before_lhs";
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_GPU_HLO_SCHEDULE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_layout_assignment.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_layout_assignment.h
new file mode 100644
index 0000000000000000000000000000000000000000..27ca9bcfb72be850489bb74622c9d71a36e19fb5
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_layout_assignment.h
@@ -0,0 +1,68 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_GPU_LAYOUT_ASSIGNMENT_H_
+#define XLA_SERVICE_GPU_GPU_LAYOUT_ASSIGNMENT_H_
+
+#include "xla/hlo/ir/hlo_instructions.h"
+#include "xla/service/computation_layout.h"
+#include "xla/service/layout_assignment.h"
+#include "xla/stream_executor/stream_executor.h"
+#include "tsl/platform/status.h"
+
+namespace xla {
+namespace gpu {
+
+// GPU-specific layout assignment pass which preassigns layouts to satisfy
+// layout constraints for operands and results of library calls.
+class GpuLayoutAssignment : public LayoutAssignment {
+ public:
+  explicit GpuLayoutAssignment(
+      ComputationLayout* entry_computation_layout,
+      se::StreamExecutor* stream_executor,
+      ChannelLayoutConstraints* channel_constraints = nullptr)
+      : LayoutAssignment(entry_computation_layout, channel_constraints),
+        stream_executor_(stream_executor) {}
+  ~GpuLayoutAssignment() override = default;
+
+ protected:
+  Status AddBackendConstraints(LayoutConstraints* constraints) override;
+
+ private:
+  Status AddBackendConstraintsToDnnConvCustomCall(
+      HloCustomCallInstruction* instr, LayoutConstraints* constraints);
+
+  // dim_groups are ordered from major to minor dimensions.
+  Status SetOperandMajorToMinorLayout(
+      const HloInstruction* instruction, int64_t operand,
+      std::initializer_list<absl::Span<const int64_t>> dim_groups);
+
+  Status SetDotOperandLayout(const HloInstruction* instruction, int64_t operand,
+                             absl::Span<const int64_t> batch_dims,
+                             absl::Span<const int64_t> row_dims,
+                             absl::Span<const int64_t> col_dims);
+
+  Status SetDotLayout(const HloInstruction* instruction,
+                      LayoutConstraints* constraints);
+
+  bool PropagateReductionLayoutToOperand(const HloInstruction* user) override;
+
+  se::StreamExecutor* stream_executor_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_GPU_LAYOUT_ASSIGNMENT_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_performance_model.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_performance_model.h
new file mode 100644
index 0000000000000000000000000000000000000000..419255686f352fa47642c9e71283f3b33b8bb11e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_performance_model.h
@@ -0,0 +1,160 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_GPU_PERFORMANCE_MODEL_H_
+#define XLA_SERVICE_GPU_GPU_PERFORMANCE_MODEL_H_
+
+#include <array>
+#include <vector>
+
+#include "absl/time/time.h"
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/service/gpu/gpu_hlo_cost_analysis.h"
+#include "xla/stream_executor/device_description.h"
+
+#if GOOGLE_CUDA
+#include <dlfcn.h>
+
+#include "third_party/gpus/cuda/nvml/include/nvml.h"
+// Below is a list of function pointers to be used
+// for querying device properties through nvml library.
+#define NVML_FUNCTOR(name, rettype, args) rettype(*xla_##name) args = nullptr;
+
+NVML_FUNCTOR(nvmlInit, nvmlReturn_t, ())
+NVML_FUNCTOR(nvmlShutdown, nvmlReturn_t, ())
+NVML_FUNCTOR(nvmlDeviceGetHandleByIndex, nvmlReturn_t,
+             (unsigned int index, nvmlDevice_t* device))
+NVML_FUNCTOR(nvmlDeviceGetNvLinkCapability, nvmlReturn_t,
+             (nvmlDevice_t device, unsigned int link,
+              nvmlNvLinkCapability_t capability, unsigned int* capResult))
+
+#endif
+
+namespace xla {
+namespace gpu {
+
+struct EstimateRunTimeData {
+  int64_t flops;
+  int64_t bytes_written;
+  int64_t num_threads;
+  absl::Duration write_time;
+  absl::Duration exec_time;
+};
+
+class GpuPerformanceModel {
+ public:
+  struct RunTimes {
+    absl::Duration time_unfused;
+    absl::Duration time_fused;
+  };
+
+  static EstimateRunTimeData EstimateRunTimeForInstruction(
+      const HloInstruction* instr, const GpuHloCostAnalysis* cost_analysis);
+
+  static RunTimes EstimateRunTimes(
+      const HloInstruction* producer, const GpuHloCostAnalysis* cost_analysis,
+      std::vector<HloInstruction*> fused_consumers = {},
+      bool multi_output = false);
+
+  // Writes estimated execution time to FusionBackendConfig.reification_cost.
+  static void RecordEstimatedRunTime(HloInstruction* instruction,
+                                     const GpuHloCostAnalysis* cost_analysis);
+  static absl::Duration ComputeTime(
+      const se::DeviceDescription& gpu_device_info, int64_t n_flops,
+      int64_t n_threads);
+
+  static absl::Duration ProducerInputAccessTime(
+      const GpuHloCostAnalysis* cost_analysis,
+      const se::DeviceDescription& gpu_device_info,
+      const HloInstruction* producer,
+      const HloInstruction* fused_consumer = nullptr);
+};
+
+class GpuPerformanceWithCollectiveModel : public GpuPerformanceModel {
+ public:
+  // Different algorithms that can be used to perform the collective.
+  enum CollectiveAlgo {
+    RING = 0,
+    TREE,
+  };
+
+  // Table for max system bandwidths GB/s for using NCCL's low latency
+  // algorithm. This is used for intra-node estimate.
+  static constexpr std::array<double, 3> kLowLatencyMaxBandwidths = {
+      39.0 /* Volta*/, 87.7 /* Ampere*/, 87.7 /* Hopper*/
+  };
+
+  // Max bandwidth in GB/s for ring low latency 128 algorithm per channel on a
+  // single-node
+  static constexpr std::array<double, 3> kPerChannelMaxRingLL128Bandwidths = {
+      20.0 /* Volta */,
+      20.0 /* Ampere */,
+      36.7 /* Hopper */,
+  };
+
+  // Nvlink unidirectional bandwidth for different compute cap. Note this is per
+  // lane bandwidth.
+  static constexpr double kSm60NvlinkBandwidth = 18.0;
+  static constexpr double kSm70NvlinkBandwidth = 20.0;
+  static constexpr double kSm80NvlinkBandwidth = 20.0;
+  static constexpr double kSm90NvlinkBandwidth = 20.0;
+
+  // PCIE bandwidth for PCI Gen3 x16
+  static constexpr double kPciBandwidth = 12.0;
+
+  // Discount factor for ring algorithm
+  static constexpr double kRingAlgorithmDiscountFactor = 0.92;
+
+  // Different tiers for intra-node bandwidth.
+  static constexpr std::array<double, 13> kIntraNodeSpeeds = {
+      40.0, 30.0, 20.0, 18.0, 15.0, 12.0, 10.0, 9.0, 7.0, 6.0, 5.0, 4.0, 3.0};
+  // SM90 has different bandwidths.
+  static constexpr std::array<double, 9> kIntraNodeSpeedsSm90 = {
+      60.0, 40.0, 30.0, 24.0, 20.0, 15.0, 12.0, 6.0, 3.0};
+
+  // Maximum number of channels allowed by NCCL
+  static constexpr int64_t kMaxNumChannelsRing = 16;
+
+  // ll128 is by default enabled for Volta, Ampere and Hopper, ll128 by default
+  // launches 640 threads.
+  static constexpr int64_t kLL128NumThreads = 640;
+
+  static absl::Duration ComputeCollectiveTime(
+      const HloInstruction& instr, const GpuHloCostAnalysis* cost_analysis,
+      const se::DeviceDescription& gpu_device_info);
+
+  // Returns NVLink bw in GB/s
+  static float GetNvlinkBw(se::CudaComputeCapability compute_capability);
+
+  // Initialize nvml library.
+  static bool InitNvml();
+
+  // Shut down nvml library.
+  static bool ShutdownNvml();
+
+  // This checks if the nvlink supports direct P2P communication,
+  // If not, we will use PCIE bandwidth to estimate latency.
+  static uint32_t CheckIfNvlinkSupportsP2P();
+
+ private:
+  static absl::Duration ComputeAllreduceTime(
+      const HloInstruction& instr, const GpuHloCostAnalysis* cost_analysis,
+      const se::DeviceDescription& gpu_device_info);
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_GPU_PERFORMANCE_MODEL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_reduce_scatter_creator.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_reduce_scatter_creator.h
new file mode 100644
index 0000000000000000000000000000000000000000..4bc1da7d003fccdb3775caaea3e0d0cadee91176
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_reduce_scatter_creator.h
@@ -0,0 +1,39 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_GPU_REDUCE_SCATTER_CREATOR_H_
+#define XLA_SERVICE_GPU_GPU_REDUCE_SCATTER_CREATOR_H_
+
+#include "xla/service/hlo_pass_interface.h"
+
+namespace xla {
+namespace gpu {
+
+// Transforms dynamic-slice(all-reduce) to a reduce-scatter.
+class ReduceScatterCreator : public HloModulePass {
+ public:
+  ReduceScatterCreator() = default;
+  absl::string_view name() const override { return "reduce-scatter-creator"; }
+
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_GPU_REDUCE_SCATTER_CREATOR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_sanitize_constant_names.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_sanitize_constant_names.h
new file mode 100644
index 0000000000000000000000000000000000000000..70bbebd426ca5f9c133f7a9469f877c03814ab08
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_sanitize_constant_names.h
@@ -0,0 +1,41 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_GPU_SANITIZE_CONSTANT_NAMES_H_
+#define XLA_SERVICE_GPU_GPU_SANITIZE_CONSTANT_NAMES_H_
+
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/service/hlo_pass_interface.h"
+
+namespace xla {
+namespace gpu {
+
+// Sanitizes HLO instruction names for the GPU backend. Currently, it only
+// replaces . and - in the HLO constant instruction names with _ to please the
+// LLVM PTX backend.
+class GpuSanitizeConstantNames : public HloModulePass {
+ public:
+  absl::string_view name() const override { return "sanitize-constant-names"; }
+
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_GPU_SANITIZE_CONSTANT_NAMES_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_scatter_expander.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_scatter_expander.h
new file mode 100644
index 0000000000000000000000000000000000000000..7a91c309b1728b2218d2ab5d10411f5044f45e4c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_scatter_expander.h
@@ -0,0 +1,38 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_GPU_SCATTER_EXPANDER_H_
+#define XLA_SERVICE_GPU_GPU_SCATTER_EXPANDER_H_
+
+#include "xla/service/scatter_expander.h"
+
+namespace xla {
+
+// Legalizes scatters on the GPU.
+class GpuScatterExpander : public ScatterExpander {
+ public:
+  // Although we pass kEliminateAllScatters, we override this behavior in
+  // InstruuctionMatchesPattern and select only some scatters to expand.
+  GpuScatterExpander() : ScatterExpander(kEliminateAllScatters) {}
+
+  absl::string_view name() const override { return "gpu_scatter_expander"; }
+
+ protected:
+  bool InstructionMatchesPattern(HloInstruction* inst) override;
+};
+
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_GPU_SCATTER_EXPANDER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_target_config.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_target_config.h
new file mode 100644
index 0000000000000000000000000000000000000000..1845bc755116cfb9cfe81a87e447cc0b851d1dae
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_target_config.h
@@ -0,0 +1,42 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_GPU_TARGET_CONFIG_H_
+#define XLA_SERVICE_GPU_GPU_TARGET_CONFIG_H_
+
+#include "xla/stream_executor/device_description.h"
+#include "xla/stream_executor/device_description.pb.h"
+#include "xla/stream_executor/dnn.h"
+
+namespace xla {
+namespace gpu {
+
+struct GpuTargetConfig {
+  GpuTargetConfig() = default;
+  explicit GpuTargetConfig(const stream_executor::GpuTargetConfigProto& proto);
+  explicit GpuTargetConfig(stream_executor::StreamExecutor* s);
+
+  stream_executor::GpuTargetConfigProto ToProto() const;
+
+  stream_executor::DeviceDescription gpu_device_info;
+  std::string platform_name;
+  stream_executor::dnn::VersionInfo dnn_version_info;
+  std::string device_description_str;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_GPU_TARGET_CONFIG_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_transfer_manager.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_transfer_manager.h
new file mode 100644
index 0000000000000000000000000000000000000000..5dcc291a9ff4036996088e8d91ecfb8533e2e133
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_transfer_manager.h
@@ -0,0 +1,107 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_GPU_TRANSFER_MANAGER_H_
+#define XLA_SERVICE_GPU_GPU_TRANSFER_MANAGER_H_
+
+#include <vector>
+
+#include "xla/service/generic_transfer_manager.h"
+#include "xla/service/gpu/infeed_manager.h"
+#include "xla/service/transfer_manager.h"
+#include "xla/shape_tree.h"
+#include "xla/statusor.h"
+#include "xla/stream_executor/stream_executor.h"
+#include "xla/xla_data.pb.h"
+
+namespace xla {
+namespace gpu {
+
+// An implementation of the XLA GenericTransferManager that
+// handles GPU-specific infeed.
+class GpuTransferManager : public GenericTransferManager {
+ public:
+  GpuTransferManager(se::Platform::Id id, unsigned pointer_size);
+  ~GpuTransferManager() override;
+
+  Status TransferLiteralToInfeed(se::StreamExecutor* executor,
+                                 const LiteralSlice& literal) override;
+  Status TransferLiteralFromOutfeed(se::StreamExecutor* executor,
+                                    MutableBorrowingLiteral literal) override;
+  Status ReadDynamicShapes(se::Stream* stream,
+                           const ShapedBuffer* device_buffer,
+                           Shape* device_shape) override;
+
+ private:
+  GpuTransferManager(const GpuTransferManager&) = delete;
+  GpuTransferManager& operator=(const GpuTransferManager&) = delete;
+
+  // This class keeps a pool of pinned memory
+  // (StreamExecutor::HostMemoryAllocate()) that serves ReadDynamicShapes().
+  // This is a bit of a hack: Callers like TensorFlow already have a full pinned
+  // memory allocator, and we could in theory use it here and elsewhere in XLA.
+  // But because GpuTransferManager is a singleton, we can't really access that.
+  //
+  // To keep things relatively simple, our allocator does the following.
+  //
+  //  - Allocate one chunk of 128 KiB pinned memory.
+  //  - Divide each chunk into 128-byte buffers.
+  //  - During ReadDynamicShapes(), "check out" one buffer for each dynamic
+  //    subshape.  Copy one subshape into one buffer.  If it doesn't fit or
+  //    there are no free buffers, fall back to an unpinned memcpy.
+  //
+  // A 128-byte buffer is large enough to hold a shape of rank 128/sizeof(int32)
+  // = 32, which is much larger than we normally see in XLA programs.  A 128 KiB
+  // chunk is large enough to hold 128 KiB/128B = 1024 dynamically-shaped
+  // buffers, which is also way larger than we should need, even if we're
+  // running multiple programs in parallel.
+  //
+  // This pool is lazily initialized on first use.  It would be better to
+  // initialize it in the constructor, but doing so poses a challenge in the
+  // presence of multiple GPUs.  We need a StreamExecutor in order to allocate
+  // pinned memory.  We don't care which GPU's SE we use, because SE allocates
+  // pinned memory with the PORTABLE flag, making it available to all CUDA
+  // contexts.  But we do need to avoid calling platform->ExecutorForDevice for
+  // a device that we're not "supposed" to use, because this will create a CUDA
+  // context for that device, consuming significant resources on the GPU,
+  // b/228207839.
+  //
+  // Lazy initialization works around this, because at that point we have a
+  // stream, and therefore we have an already-initialized StreamExecutor.
+  void EnsurePinnedBuffersAllocated(se::StreamExecutor* executor)
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+
+  static constexpr int64_t kPinnedChunkBytes = 128 * 1024;
+  static constexpr int64_t kPinnedBufferBytes = 128;
+
+  absl::Mutex mu_;
+
+  // The StreamExecutor on which our pinned memory was allocated.  We use this
+  // when freeing the pinned memory.  Lazily initialized.
+  se::StreamExecutor* pinned_chunk_se_ ABSL_GUARDED_BY(mu_) = nullptr;
+
+  // Chunk of pinned memory of size kPinnedChunkBytes.  The pointers in
+  // pinned_buffers_ point into this chunk.  Lazily initialized.
+  char* pinned_chunk_ ABSL_GUARDED_BY(mu_) = nullptr;
+
+  // Host buffers for reading dynamic shapes.  Each buffer has size
+  // kPinnedBufferBytes.  Lazily initialized.
+  std::vector<void*> pinned_buffers_ ABSL_GUARDED_BY(mu_);
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_GPU_TRANSFER_MANAGER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/hlo_algorithm_denylist.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/hlo_algorithm_denylist.h
new file mode 100644
index 0000000000000000000000000000000000000000..5dfcb189a954e7fab04ce975abc4d04924cb3032
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/hlo_algorithm_denylist.h
@@ -0,0 +1,34 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_HLO_ALGORITHM_DENYLIST_H_
+#define XLA_SERVICE_GPU_HLO_ALGORITHM_DENYLIST_H_
+
+#include <vector>
+
+#include "xla/autotuning.pb.h"
+#include "xla/stream_executor/stream_executor.h"
+
+namespace xla {
+namespace gpu {
+
+absl::Span<const stream_executor::dnn::AlgorithmDesc> GetDisabledConvAlgorithms(
+    ComputeCapability cc, CudnnVersion cudnn_version,
+    const std::string& blas_version, const std::string& hlo);
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_HLO_ALGORITHM_DENYLIST_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/hlo_fusion_analysis.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/hlo_fusion_analysis.h
new file mode 100644
index 0000000000000000000000000000000000000000..131d9c090424702728170e84bd776d78c3234edb
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/hlo_fusion_analysis.h
@@ -0,0 +1,139 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_HLO_FUSION_ANALYSIS_H_
+#define XLA_SERVICE_GPU_HLO_FUSION_ANALYSIS_H_
+
+#include <optional>
+#include <utility>
+#include <vector>
+
+#include "xla/hlo/ir/hlo_computation.h"
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/hlo/ir/hlo_instructions.h"
+#include "xla/service/gpu/backend_configs.pb.h"
+#include "xla/service/gpu/hlo_traversal.h"
+#include "xla/service/gpu/ir_emission_utils.h"
+#include "xla/service/gpu/kernel_mapping_scheme.h"
+#include "xla/service/gpu/launch_dimensions.h"
+#include "xla/service/gpu/reduction_utils.h"
+#include "xla/statusor.h"
+#include "xla/stream_executor/device_description.h"
+
+namespace xla {
+namespace gpu {
+
+class HloFusionAnalysis {
+ public:
+  // The type of emitted fusion.
+  enum class EmitterFusionKind {
+    kLoop,
+    kTriton,
+    kReduction,
+    kTranspose,
+    kInputSlices,
+    kScatter,
+  };
+
+  static StatusOr<HloFusionAnalysis> Create(
+      FusionBackendConfig backend_config,
+      std::vector<const HloInstruction*> hlo_roots,
+      FusionBoundaryFn boundary_fn, const se::DeviceDescription* device_info);
+  static StatusOr<HloFusionAnalysis> Create(
+      const HloFusionInstruction* fusion,
+      const se::DeviceDescription* device_info);
+
+  const std::vector<const HloInstruction*>& fusion_roots() const {
+    return fusion_roots_;
+  }
+  const FusionBoundaryFn& fusion_boundary() const {
+    return fusion_boundary_fn_;
+  }
+
+  // Determines the fusion type for the emitter.
+  EmitterFusionKind GetEmitterFusionKind() const;
+
+  // Determines the launch dimensions for the fusion. The fusion kind must not
+  // be `kTriton`.
+  StatusOr<LaunchDimensions> GetLaunchDimensions();
+
+  // Calculates the reduction information. Returns `nullptr` if the fusion is
+  // not a reduction.
+  const ReductionCodegenInfo* GetReductionCodegenInfo();
+
+  // Calculates the transpose tiling information. Returns `nullptr` if the
+  // fusion is not a transpose.
+  const TilingScheme* GetTransposeTilingScheme();
+
+  // Calculates the loop fusion config. Returns `nullptr` if the fusion is not a
+  // loop.
+  const LaunchDimensionsConfig* GetLoopFusionConfig();
+
+  // Returns the hero reduction of the computation.
+  const HloInstruction* FindHeroReduction() const;
+
+ private:
+  HloFusionAnalysis(FusionBackendConfig fusion_backend_config,
+                    std::vector<const HloInstruction*> fusion_roots,
+                    FusionBoundaryFn fusion_boundary_fn,
+                    std::vector<const HloInstruction*> fusion_arguments,
+                    std::vector<const HloInstruction*> fusion_heroes,
+                    const se::DeviceDescription* device_info,
+                    std::optional<TransposeDescription> tiled_transpose)
+      : fusion_backend_config_(std::move(fusion_backend_config)),
+        fusion_roots_(std::move(fusion_roots)),
+        fusion_boundary_fn_(std::move(fusion_boundary_fn)),
+        fusion_arguments_(std::move(fusion_arguments)),
+        fusion_heroes_(std::move(fusion_heroes)),
+        device_info_(device_info),
+        tiled_transpose_(tiled_transpose) {}
+
+  const Shape& GetElementShape() const;
+  int SmallestInputDtypeBits() const;
+  int64_t MaxBeneficialColumnReductionUnrollBasedOnBlockSize() const;
+  std::vector<std::vector<const HloInstruction*>> GroupDisjointReductions()
+      const;
+  bool IsUnrollingColumnReductionBeneficial(const Shape& input_shape,
+                                            int64_t num_kept_minor,
+                                            bool reduction_is_race_free) const;
+  bool CanVectorizeReduction(const ReductionDimensions& reduction_dimensions,
+                             int num_threads_x, Vector3 reduction_tiling,
+                             const Shape& input_shape,
+                             bool reduction_is_race_free) const;
+  int CalculateVirtualThreadScalingFactorForReduction(
+      const ReductionDimensions& reduction_dimensions) const;
+  ReductionCodegenInfo ComputeReductionCodegenInfo(
+      const HloInstruction* hero_reduction) const;
+  bool HasConsistentTransposeHeros() const;
+
+  FusionBackendConfig fusion_backend_config_;
+  std::vector<const HloInstruction*> fusion_roots_;
+  FusionBoundaryFn fusion_boundary_fn_;
+  // The HLO instructions that are inputs into the fusion. These instructions
+  // are /outside/ the fusion.
+  std::vector<const HloInstruction*> fusion_arguments_;
+  std::vector<const HloInstruction*> fusion_heroes_;
+  const se::DeviceDescription* device_info_;
+  std::optional<TransposeDescription> tiled_transpose_;
+
+  std::optional<ReductionCodegenInfo> reduction_codegen_info_;
+  std::optional<TilingScheme> transpose_tiling_scheme_;
+  std::optional<LaunchDimensionsConfig> loop_fusion_config_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_HLO_FUSION_ANALYSIS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/hlo_fusion_stats.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/hlo_fusion_stats.h
new file mode 100644
index 0000000000000000000000000000000000000000..22e9348200d5b4185e5b5245402fc664da047151
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/hlo_fusion_stats.h
@@ -0,0 +1,60 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_HLO_FUSION_STATS_H_
+#define XLA_SERVICE_GPU_HLO_FUSION_STATS_H_
+
+#include <cstdint>
+#include <string>
+
+#include "absl/strings/string_view.h"
+#include "xla/hlo/ir/dfs_hlo_visitor_with_default.h"
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/service/hlo_pass_interface.h"
+#include "xla/statusor.h"
+
+// Read-only pass logging statistics about HLO fusion ops in the module. Enabled
+// at VLOG level 1 only.
+namespace xla {
+namespace gpu {
+
+class HloOpcodeHistogram : public std::map<std::set<std::string>, int64_t> {
+ public:
+  std::string ToString();
+};
+
+class HloFusionStatsVisitor : public ConstDfsHloVisitorWithDefault {
+ public:
+  Status RunOnModule(HloModule* module);
+
+  std::string ToString();
+
+ protected:
+  Status DefaultAction(const xla::HloInstruction* instr) final;
+
+  Status HandleFusion(const HloInstruction* fusion) override;
+
+ private:
+  int64_t num_fusions_ = 0;
+  int64_t num_loop_fusions_ = 0;
+  int64_t num_input_fusions_ = 0;
+  HloOpcodeHistogram loop_fusion_opcode_histogram_;
+  HloOpcodeHistogram input_fusion_opcode_histogram_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_HLO_FUSION_STATS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/hlo_op_profile.pb.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/hlo_op_profile.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..a72a24080ed645f4ec9b58abec38249616c088aa
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/hlo_op_profile.pb.h
@@ -0,0 +1,803 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: xla/service/gpu/hlo_op_profile.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_xla_2fservice_2fgpu_2fhlo_5fop_5fprofile_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_xla_2fservice_2fgpu_2fhlo_5fop_5fprofile_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3021000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3021009 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/map.h>  // IWYU pragma: export
+#include <google/protobuf/map_entry.h>
+#include <google/protobuf/map_field_inl.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "xla/service/hlo.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_xla_2fservice_2fgpu_2fhlo_5fop_5fprofile_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_xla_2fservice_2fgpu_2fhlo_5fop_5fprofile_2eproto {
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_xla_2fservice_2fgpu_2fhlo_5fop_5fprofile_2eproto;
+namespace xla {
+namespace gpu {
+class DeviceHloInstructionProfiles;
+struct DeviceHloInstructionProfilesDefaultTypeInternal;
+extern DeviceHloInstructionProfilesDefaultTypeInternal _DeviceHloInstructionProfiles_default_instance_;
+class DeviceHloInstructionProfiles_EntriesEntry_DoNotUse;
+struct DeviceHloInstructionProfiles_EntriesEntry_DoNotUseDefaultTypeInternal;
+extern DeviceHloInstructionProfiles_EntriesEntry_DoNotUseDefaultTypeInternal _DeviceHloInstructionProfiles_EntriesEntry_DoNotUse_default_instance_;
+class HloInstructionProfile;
+struct HloInstructionProfileDefaultTypeInternal;
+extern HloInstructionProfileDefaultTypeInternal _HloInstructionProfile_default_instance_;
+class HloInstructionProfileList;
+struct HloInstructionProfileListDefaultTypeInternal;
+extern HloInstructionProfileListDefaultTypeInternal _HloInstructionProfileList_default_instance_;
+}  // namespace gpu
+}  // namespace xla
+PROTOBUF_NAMESPACE_OPEN
+template<> ::xla::gpu::DeviceHloInstructionProfiles* Arena::CreateMaybeMessage<::xla::gpu::DeviceHloInstructionProfiles>(Arena*);
+template<> ::xla::gpu::DeviceHloInstructionProfiles_EntriesEntry_DoNotUse* Arena::CreateMaybeMessage<::xla::gpu::DeviceHloInstructionProfiles_EntriesEntry_DoNotUse>(Arena*);
+template<> ::xla::gpu::HloInstructionProfile* Arena::CreateMaybeMessage<::xla::gpu::HloInstructionProfile>(Arena*);
+template<> ::xla::gpu::HloInstructionProfileList* Arena::CreateMaybeMessage<::xla::gpu::HloInstructionProfileList>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace xla {
+namespace gpu {
+
+// ===================================================================
+
+class HloInstructionProfile final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.gpu.HloInstructionProfile) */ {
+ public:
+  inline HloInstructionProfile() : HloInstructionProfile(nullptr) {}
+  ~HloInstructionProfile() override;
+  explicit PROTOBUF_CONSTEXPR HloInstructionProfile(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  HloInstructionProfile(const HloInstructionProfile& from);
+  HloInstructionProfile(HloInstructionProfile&& from) noexcept
+    : HloInstructionProfile() {
+    *this = ::std::move(from);
+  }
+
+  inline HloInstructionProfile& operator=(const HloInstructionProfile& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline HloInstructionProfile& operator=(HloInstructionProfile&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const HloInstructionProfile& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const HloInstructionProfile* internal_default_instance() {
+    return reinterpret_cast<const HloInstructionProfile*>(
+               &_HloInstructionProfile_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(HloInstructionProfile& a, HloInstructionProfile& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(HloInstructionProfile* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(HloInstructionProfile* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  HloInstructionProfile* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<HloInstructionProfile>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const HloInstructionProfile& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const HloInstructionProfile& from) {
+    HloInstructionProfile::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(HloInstructionProfile* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "xla.gpu.HloInstructionProfile";
+  }
+  protected:
+  explicit HloInstructionProfile(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kInstructionFieldNumber = 1,
+    kClockCyclesFieldNumber = 2,
+  };
+  // .xla.HloInstructionProto instruction = 1;
+  bool has_instruction() const;
+  private:
+  bool _internal_has_instruction() const;
+  public:
+  void clear_instruction();
+  const ::xla::HloInstructionProto& instruction() const;
+  PROTOBUF_NODISCARD ::xla::HloInstructionProto* release_instruction();
+  ::xla::HloInstructionProto* mutable_instruction();
+  void set_allocated_instruction(::xla::HloInstructionProto* instruction);
+  private:
+  const ::xla::HloInstructionProto& _internal_instruction() const;
+  ::xla::HloInstructionProto* _internal_mutable_instruction();
+  public:
+  void unsafe_arena_set_allocated_instruction(
+      ::xla::HloInstructionProto* instruction);
+  ::xla::HloInstructionProto* unsafe_arena_release_instruction();
+
+  // int64 clock_cycles = 2;
+  void clear_clock_cycles();
+  int64_t clock_cycles() const;
+  void set_clock_cycles(int64_t value);
+  private:
+  int64_t _internal_clock_cycles() const;
+  void _internal_set_clock_cycles(int64_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:xla.gpu.HloInstructionProfile)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::xla::HloInstructionProto* instruction_;
+    int64_t clock_cycles_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_xla_2fservice_2fgpu_2fhlo_5fop_5fprofile_2eproto;
+};
+// -------------------------------------------------------------------
+
+class HloInstructionProfileList final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.gpu.HloInstructionProfileList) */ {
+ public:
+  inline HloInstructionProfileList() : HloInstructionProfileList(nullptr) {}
+  ~HloInstructionProfileList() override;
+  explicit PROTOBUF_CONSTEXPR HloInstructionProfileList(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  HloInstructionProfileList(const HloInstructionProfileList& from);
+  HloInstructionProfileList(HloInstructionProfileList&& from) noexcept
+    : HloInstructionProfileList() {
+    *this = ::std::move(from);
+  }
+
+  inline HloInstructionProfileList& operator=(const HloInstructionProfileList& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline HloInstructionProfileList& operator=(HloInstructionProfileList&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const HloInstructionProfileList& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const HloInstructionProfileList* internal_default_instance() {
+    return reinterpret_cast<const HloInstructionProfileList*>(
+               &_HloInstructionProfileList_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(HloInstructionProfileList& a, HloInstructionProfileList& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(HloInstructionProfileList* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(HloInstructionProfileList* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  HloInstructionProfileList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<HloInstructionProfileList>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const HloInstructionProfileList& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const HloInstructionProfileList& from) {
+    HloInstructionProfileList::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(HloInstructionProfileList* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "xla.gpu.HloInstructionProfileList";
+  }
+  protected:
+  explicit HloInstructionProfileList(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kEntriesFieldNumber = 1,
+  };
+  // repeated .xla.gpu.HloInstructionProfile entries = 1;
+  int entries_size() const;
+  private:
+  int _internal_entries_size() const;
+  public:
+  void clear_entries();
+  ::xla::gpu::HloInstructionProfile* mutable_entries(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::gpu::HloInstructionProfile >*
+      mutable_entries();
+  private:
+  const ::xla::gpu::HloInstructionProfile& _internal_entries(int index) const;
+  ::xla::gpu::HloInstructionProfile* _internal_add_entries();
+  public:
+  const ::xla::gpu::HloInstructionProfile& entries(int index) const;
+  ::xla::gpu::HloInstructionProfile* add_entries();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::gpu::HloInstructionProfile >&
+      entries() const;
+
+  // @@protoc_insertion_point(class_scope:xla.gpu.HloInstructionProfileList)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::gpu::HloInstructionProfile > entries_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_xla_2fservice_2fgpu_2fhlo_5fop_5fprofile_2eproto;
+};
+// -------------------------------------------------------------------
+
+class DeviceHloInstructionProfiles_EntriesEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<DeviceHloInstructionProfiles_EntriesEntry_DoNotUse, 
+    std::string, ::xla::gpu::HloInstructionProfileList,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> {
+public:
+  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<DeviceHloInstructionProfiles_EntriesEntry_DoNotUse, 
+    std::string, ::xla::gpu::HloInstructionProfileList,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
+  DeviceHloInstructionProfiles_EntriesEntry_DoNotUse();
+  explicit PROTOBUF_CONSTEXPR DeviceHloInstructionProfiles_EntriesEntry_DoNotUse(
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+  explicit DeviceHloInstructionProfiles_EntriesEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  void MergeFrom(const DeviceHloInstructionProfiles_EntriesEntry_DoNotUse& other);
+  static const DeviceHloInstructionProfiles_EntriesEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const DeviceHloInstructionProfiles_EntriesEntry_DoNotUse*>(&_DeviceHloInstructionProfiles_EntriesEntry_DoNotUse_default_instance_); }
+  static bool ValidateKey(std::string* s) {
+    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "xla.gpu.DeviceHloInstructionProfiles.EntriesEntry.key");
+ }
+  static bool ValidateValue(void*) { return true; }
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+  friend struct ::TableStruct_xla_2fservice_2fgpu_2fhlo_5fop_5fprofile_2eproto;
+};
+
+// -------------------------------------------------------------------
+
+class DeviceHloInstructionProfiles final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.gpu.DeviceHloInstructionProfiles) */ {
+ public:
+  inline DeviceHloInstructionProfiles() : DeviceHloInstructionProfiles(nullptr) {}
+  ~DeviceHloInstructionProfiles() override;
+  explicit PROTOBUF_CONSTEXPR DeviceHloInstructionProfiles(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DeviceHloInstructionProfiles(const DeviceHloInstructionProfiles& from);
+  DeviceHloInstructionProfiles(DeviceHloInstructionProfiles&& from) noexcept
+    : DeviceHloInstructionProfiles() {
+    *this = ::std::move(from);
+  }
+
+  inline DeviceHloInstructionProfiles& operator=(const DeviceHloInstructionProfiles& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DeviceHloInstructionProfiles& operator=(DeviceHloInstructionProfiles&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const DeviceHloInstructionProfiles& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const DeviceHloInstructionProfiles* internal_default_instance() {
+    return reinterpret_cast<const DeviceHloInstructionProfiles*>(
+               &_DeviceHloInstructionProfiles_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  friend void swap(DeviceHloInstructionProfiles& a, DeviceHloInstructionProfiles& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DeviceHloInstructionProfiles* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(DeviceHloInstructionProfiles* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  DeviceHloInstructionProfiles* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<DeviceHloInstructionProfiles>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const DeviceHloInstructionProfiles& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const DeviceHloInstructionProfiles& from) {
+    DeviceHloInstructionProfiles::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(DeviceHloInstructionProfiles* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "xla.gpu.DeviceHloInstructionProfiles";
+  }
+  protected:
+  explicit DeviceHloInstructionProfiles(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kEntriesFieldNumber = 2,
+  };
+  // map<string, .xla.gpu.HloInstructionProfileList> entries = 2;
+  int entries_size() const;
+  private:
+  int _internal_entries_size() const;
+  public:
+  void clear_entries();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::xla::gpu::HloInstructionProfileList >&
+      _internal_entries() const;
+  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::xla::gpu::HloInstructionProfileList >*
+      _internal_mutable_entries();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::xla::gpu::HloInstructionProfileList >&
+      entries() const;
+  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::xla::gpu::HloInstructionProfileList >*
+      mutable_entries();
+
+  // @@protoc_insertion_point(class_scope:xla.gpu.DeviceHloInstructionProfiles)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::MapField<
+        DeviceHloInstructionProfiles_EntriesEntry_DoNotUse,
+        std::string, ::xla::gpu::HloInstructionProfileList,
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> entries_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_xla_2fservice_2fgpu_2fhlo_5fop_5fprofile_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// HloInstructionProfile
+
+// .xla.HloInstructionProto instruction = 1;
+inline bool HloInstructionProfile::_internal_has_instruction() const {
+  return this != internal_default_instance() && _impl_.instruction_ != nullptr;
+}
+inline bool HloInstructionProfile::has_instruction() const {
+  return _internal_has_instruction();
+}
+inline const ::xla::HloInstructionProto& HloInstructionProfile::_internal_instruction() const {
+  const ::xla::HloInstructionProto* p = _impl_.instruction_;
+  return p != nullptr ? *p : reinterpret_cast<const ::xla::HloInstructionProto&>(
+      ::xla::_HloInstructionProto_default_instance_);
+}
+inline const ::xla::HloInstructionProto& HloInstructionProfile::instruction() const {
+  // @@protoc_insertion_point(field_get:xla.gpu.HloInstructionProfile.instruction)
+  return _internal_instruction();
+}
+inline void HloInstructionProfile::unsafe_arena_set_allocated_instruction(
+    ::xla::HloInstructionProto* instruction) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.instruction_);
+  }
+  _impl_.instruction_ = instruction;
+  if (instruction) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.gpu.HloInstructionProfile.instruction)
+}
+inline ::xla::HloInstructionProto* HloInstructionProfile::release_instruction() {
+  
+  ::xla::HloInstructionProto* temp = _impl_.instruction_;
+  _impl_.instruction_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::xla::HloInstructionProto* HloInstructionProfile::unsafe_arena_release_instruction() {
+  // @@protoc_insertion_point(field_release:xla.gpu.HloInstructionProfile.instruction)
+  
+  ::xla::HloInstructionProto* temp = _impl_.instruction_;
+  _impl_.instruction_ = nullptr;
+  return temp;
+}
+inline ::xla::HloInstructionProto* HloInstructionProfile::_internal_mutable_instruction() {
+  
+  if (_impl_.instruction_ == nullptr) {
+    auto* p = CreateMaybeMessage<::xla::HloInstructionProto>(GetArenaForAllocation());
+    _impl_.instruction_ = p;
+  }
+  return _impl_.instruction_;
+}
+inline ::xla::HloInstructionProto* HloInstructionProfile::mutable_instruction() {
+  ::xla::HloInstructionProto* _msg = _internal_mutable_instruction();
+  // @@protoc_insertion_point(field_mutable:xla.gpu.HloInstructionProfile.instruction)
+  return _msg;
+}
+inline void HloInstructionProfile::set_allocated_instruction(::xla::HloInstructionProto* instruction) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.instruction_);
+  }
+  if (instruction) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(instruction));
+    if (message_arena != submessage_arena) {
+      instruction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, instruction, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.instruction_ = instruction;
+  // @@protoc_insertion_point(field_set_allocated:xla.gpu.HloInstructionProfile.instruction)
+}
+
+// int64 clock_cycles = 2;
+inline void HloInstructionProfile::clear_clock_cycles() {
+  _impl_.clock_cycles_ = int64_t{0};
+}
+inline int64_t HloInstructionProfile::_internal_clock_cycles() const {
+  return _impl_.clock_cycles_;
+}
+inline int64_t HloInstructionProfile::clock_cycles() const {
+  // @@protoc_insertion_point(field_get:xla.gpu.HloInstructionProfile.clock_cycles)
+  return _internal_clock_cycles();
+}
+inline void HloInstructionProfile::_internal_set_clock_cycles(int64_t value) {
+  
+  _impl_.clock_cycles_ = value;
+}
+inline void HloInstructionProfile::set_clock_cycles(int64_t value) {
+  _internal_set_clock_cycles(value);
+  // @@protoc_insertion_point(field_set:xla.gpu.HloInstructionProfile.clock_cycles)
+}
+
+// -------------------------------------------------------------------
+
+// HloInstructionProfileList
+
+// repeated .xla.gpu.HloInstructionProfile entries = 1;
+inline int HloInstructionProfileList::_internal_entries_size() const {
+  return _impl_.entries_.size();
+}
+inline int HloInstructionProfileList::entries_size() const {
+  return _internal_entries_size();
+}
+inline void HloInstructionProfileList::clear_entries() {
+  _impl_.entries_.Clear();
+}
+inline ::xla::gpu::HloInstructionProfile* HloInstructionProfileList::mutable_entries(int index) {
+  // @@protoc_insertion_point(field_mutable:xla.gpu.HloInstructionProfileList.entries)
+  return _impl_.entries_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::gpu::HloInstructionProfile >*
+HloInstructionProfileList::mutable_entries() {
+  // @@protoc_insertion_point(field_mutable_list:xla.gpu.HloInstructionProfileList.entries)
+  return &_impl_.entries_;
+}
+inline const ::xla::gpu::HloInstructionProfile& HloInstructionProfileList::_internal_entries(int index) const {
+  return _impl_.entries_.Get(index);
+}
+inline const ::xla::gpu::HloInstructionProfile& HloInstructionProfileList::entries(int index) const {
+  // @@protoc_insertion_point(field_get:xla.gpu.HloInstructionProfileList.entries)
+  return _internal_entries(index);
+}
+inline ::xla::gpu::HloInstructionProfile* HloInstructionProfileList::_internal_add_entries() {
+  return _impl_.entries_.Add();
+}
+inline ::xla::gpu::HloInstructionProfile* HloInstructionProfileList::add_entries() {
+  ::xla::gpu::HloInstructionProfile* _add = _internal_add_entries();
+  // @@protoc_insertion_point(field_add:xla.gpu.HloInstructionProfileList.entries)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::gpu::HloInstructionProfile >&
+HloInstructionProfileList::entries() const {
+  // @@protoc_insertion_point(field_list:xla.gpu.HloInstructionProfileList.entries)
+  return _impl_.entries_;
+}
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// DeviceHloInstructionProfiles
+
+// map<string, .xla.gpu.HloInstructionProfileList> entries = 2;
+inline int DeviceHloInstructionProfiles::_internal_entries_size() const {
+  return _impl_.entries_.size();
+}
+inline int DeviceHloInstructionProfiles::entries_size() const {
+  return _internal_entries_size();
+}
+inline void DeviceHloInstructionProfiles::clear_entries() {
+  _impl_.entries_.Clear();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::xla::gpu::HloInstructionProfileList >&
+DeviceHloInstructionProfiles::_internal_entries() const {
+  return _impl_.entries_.GetMap();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::xla::gpu::HloInstructionProfileList >&
+DeviceHloInstructionProfiles::entries() const {
+  // @@protoc_insertion_point(field_map:xla.gpu.DeviceHloInstructionProfiles.entries)
+  return _internal_entries();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::xla::gpu::HloInstructionProfileList >*
+DeviceHloInstructionProfiles::_internal_mutable_entries() {
+  return _impl_.entries_.MutableMap();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::xla::gpu::HloInstructionProfileList >*
+DeviceHloInstructionProfiles::mutable_entries() {
+  // @@protoc_insertion_point(field_mutable_map:xla.gpu.DeviceHloInstructionProfiles.entries)
+  return _internal_mutable_entries();
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace gpu
+}  // namespace xla
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_xla_2fservice_2fgpu_2fhlo_5fop_5fprofile_2eproto
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/hlo_op_profiles.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/hlo_op_profiles.h
new file mode 100644
index 0000000000000000000000000000000000000000..e8b73f73fd22a12e7e69ea945e5e5d9ef817838e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/hlo_op_profiles.h
@@ -0,0 +1,3092 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_HLO_OP_PROFILES_H_
+#define XLA_SERVICE_GPU_HLO_OP_PROFILES_H_
+
+namespace xla {
+namespace gpu {
+
+// The data below is obtained with
+// xla/service/gpu:hlo_op_profiler_run
+
+constexpr char kDeviceHloOpProfiles[] = R"pb(
+  entries {
+    key: "sm_90"
+    value {
+      entries {
+        instruction {
+          opcode: "divide"
+          shape { element_type: S8 }
+        }
+        clock_cycles: 351
+      }
+      entries {
+        instruction {
+          opcode: "multiply"
+          shape { element_type: S8 }
+        }
+        clock_cycles: 7
+      }
+      entries {
+        instruction {
+          opcode: "power"
+          shape { element_type: S8 }
+        }
+        clock_cycles: 115
+      }
+      entries {
+        instruction {
+          opcode: "divide"
+          shape { element_type: S16 }
+        }
+        clock_cycles: 375
+      }
+      entries {
+        instruction {
+          opcode: "multiply"
+          shape { element_type: S16 }
+        }
+        clock_cycles: 7
+      }
+      entries {
+        instruction {
+          opcode: "power"
+          shape { element_type: S16 }
+        }
+        clock_cycles: 115
+      }
+      entries {
+        instruction {
+          opcode: "divide"
+          shape { element_type: S32 }
+        }
+        clock_cycles: 298
+      }
+      entries {
+        instruction {
+          opcode: "multiply"
+          shape { element_type: S32 }
+        }
+        clock_cycles: 3
+      }
+      entries {
+        instruction {
+          opcode: "power"
+          shape { element_type: S32 }
+        }
+        clock_cycles: 66
+      }
+      entries {
+        instruction {
+          opcode: "divide"
+          shape { element_type: S64 }
+        }
+        clock_cycles: 698
+      }
+      entries {
+        instruction {
+          opcode: "multiply"
+          shape { element_type: S64 }
+        }
+        clock_cycles: 10
+      }
+      entries {
+        instruction {
+          opcode: "power"
+          shape { element_type: S64 }
+        }
+        clock_cycles: 238
+      }
+      entries {
+        instruction {
+          opcode: "divide"
+          shape { element_type: U8 }
+        }
+        clock_cycles: 308
+      }
+      entries {
+        instruction {
+          opcode: "multiply"
+          shape { element_type: U8 }
+        }
+        clock_cycles: 7
+      }
+      entries {
+        instruction {
+          opcode: "power"
+          shape { element_type: U8 }
+        }
+        clock_cycles: 115
+      }
+      entries {
+        instruction {
+          opcode: "divide"
+          shape { element_type: U16 }
+        }
+        clock_cycles: 301
+      }
+      entries {
+        instruction {
+          opcode: "multiply"
+          shape { element_type: U16 }
+        }
+        clock_cycles: 7
+      }
+      entries {
+        instruction {
+          opcode: "power"
+          shape { element_type: U16 }
+        }
+        clock_cycles: 115
+      }
+      entries {
+        instruction {
+          opcode: "divide"
+          shape { element_type: U32 }
+        }
+        clock_cycles: 119
+      }
+      entries {
+        instruction {
+          opcode: "multiply"
+          shape { element_type: U32 }
+        }
+        clock_cycles: 3
+      }
+      entries {
+        instruction {
+          opcode: "power"
+          shape { element_type: U32 }
+        }
+        clock_cycles: 66
+      }
+      entries {
+        instruction {
+          opcode: "divide"
+          shape { element_type: U64 }
+        }
+        clock_cycles: 621
+      }
+      entries {
+        instruction {
+          opcode: "multiply"
+          shape { element_type: U64 }
+        }
+        clock_cycles: 10
+      }
+      entries {
+        instruction {
+          opcode: "power"
+          shape { element_type: U64 }
+        }
+        clock_cycles: 238
+      }
+      entries {
+        instruction {
+          opcode: "cbrt"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 466
+      }
+      entries {
+        instruction {
+          opcode: "cosine"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 329
+      }
+      entries {
+        instruction {
+          opcode: "exponential"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 105
+      }
+      entries {
+        instruction {
+          opcode: "exponential-minus-one"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 217
+      }
+      entries {
+        instruction {
+          opcode: "log"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 182
+      }
+      entries {
+        instruction {
+          opcode: "log-plus-one"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 245
+      }
+      entries {
+        instruction {
+          opcode: "rsqrt"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 94
+      }
+      entries {
+        instruction {
+          opcode: "sine"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 333
+      }
+      entries {
+        instruction {
+          opcode: "sqrt"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 98
+      }
+      entries {
+        instruction {
+          opcode: "tanh"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 200
+      }
+      entries {
+        instruction {
+          opcode: "add"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 7
+      }
+      entries {
+        instruction {
+          opcode: "atan2"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 449
+      }
+      entries {
+        instruction {
+          opcode: "divide"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 45
+      }
+      entries {
+        instruction {
+          opcode: "multiply"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 7
+      }
+      entries {
+        instruction {
+          opcode: "power"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 491
+      }
+      entries {
+        instruction {
+          opcode: "subtract"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 7
+      }
+      entries {
+        instruction {
+          opcode: "cbrt"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 400
+      }
+      entries {
+        instruction {
+          opcode: "cosine"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 326
+      }
+      entries {
+        instruction {
+          opcode: "exponential"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 80
+      }
+      entries {
+        instruction {
+          opcode: "exponential-minus-one"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 196
+      }
+      entries {
+        instruction {
+          opcode: "log"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 157
+      }
+      entries {
+        instruction {
+          opcode: "log-plus-one"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 221
+      }
+      entries {
+        instruction {
+          opcode: "rsqrt"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 77
+      }
+      entries {
+        instruction {
+          opcode: "sine"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 933
+      }
+      entries {
+        instruction {
+          opcode: "sqrt"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 77
+      }
+      entries {
+        instruction {
+          opcode: "tanh"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 179
+      }
+      entries {
+        instruction {
+          opcode: "add"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 7
+      }
+      entries {
+        instruction {
+          opcode: "atan2"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 428
+      }
+      entries {
+        instruction {
+          opcode: "divide"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 24
+      }
+      entries {
+        instruction {
+          opcode: "multiply"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 7
+      }
+      entries {
+        instruction {
+          opcode: "power"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 487
+      }
+      entries {
+        instruction {
+          opcode: "subtract"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 7
+      }
+      entries {
+        instruction {
+          opcode: "cbrt"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 1656
+      }
+      entries {
+        instruction {
+          opcode: "cosine"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 568
+      }
+      entries {
+        instruction {
+          opcode: "exponential"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 382
+      }
+      entries {
+        instruction {
+          opcode: "exponential-minus-one"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 403
+      }
+      entries {
+        instruction {
+          opcode: "log"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 800
+      }
+      entries {
+        instruction {
+          opcode: "log-plus-one"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 1210
+      }
+      entries {
+        instruction {
+          opcode: "rsqrt"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 277
+      }
+      entries {
+        instruction {
+          opcode: "sine"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 561
+      }
+      entries {
+        instruction {
+          opcode: "sqrt"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 333
+      }
+      entries {
+        instruction {
+          opcode: "tanh"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 393
+      }
+      entries {
+        instruction {
+          opcode: "add"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 14
+      }
+      entries {
+        instruction {
+          opcode: "atan2"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 866
+      }
+      entries {
+        instruction {
+          opcode: "divide"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 530
+      }
+      entries {
+        instruction {
+          opcode: "multiply"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 14
+      }
+      entries {
+        instruction {
+          opcode: "power"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 2179
+      }
+      entries {
+        instruction {
+          opcode: "subtract"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 14
+      }
+      entries {
+        instruction {
+          opcode: "cosine"
+          shape { element_type: C64 }
+        }
+        clock_cycles: 579
+      }
+      entries {
+        instruction {
+          opcode: "exponential"
+          shape { element_type: C64 }
+        }
+        clock_cycles: 635
+      }
+      entries {
+        instruction {
+          opcode: "exponential-minus-one"
+          shape { element_type: C64 }
+        }
+        clock_cycles: 631
+      }
+      entries {
+        instruction {
+          opcode: "log"
+          shape { element_type: C64 }
+        }
+        clock_cycles: 807
+      }
+      entries {
+        instruction {
+          opcode: "log-plus-one"
+          shape { element_type: C64 }
+        }
+        clock_cycles: 614
+      }
+      entries {
+        instruction {
+          opcode: "rsqrt"
+          shape { element_type: C64 }
+        }
+        clock_cycles: 2815
+      }
+      entries {
+        instruction {
+          opcode: "sine"
+          shape { element_type: C64 }
+        }
+        clock_cycles: 723
+      }
+      entries {
+        instruction {
+          opcode: "sqrt"
+          shape { element_type: C64 }
+        }
+        clock_cycles: 4113
+      }
+      entries {
+        instruction {
+          opcode: "tanh"
+          shape { element_type: C64 }
+        }
+        clock_cycles: 2348
+      }
+      entries {
+        instruction {
+          opcode: "add"
+          shape { element_type: C64 }
+        }
+        clock_cycles: 7
+      }
+      entries {
+        instruction {
+          opcode: "atan2"
+          shape { element_type: C64 }
+        }
+        clock_cycles: 6047
+      }
+      entries {
+        instruction {
+          opcode: "divide"
+          shape { element_type: C64 }
+        }
+        clock_cycles: 452
+      }
+      entries {
+        instruction {
+          opcode: "multiply"
+          shape { element_type: C64 }
+        }
+        clock_cycles: 77
+      }
+      entries {
+        instruction {
+          opcode: "power"
+          shape { element_type: C64 }
+        }
+        clock_cycles: 4706
+      }
+      entries {
+        instruction {
+          opcode: "subtract"
+          shape { element_type: C64 }
+        }
+        clock_cycles: 7
+      }
+      entries {
+        instruction {
+          opcode: "cosine"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 1779
+      }
+      entries {
+        instruction {
+          opcode: "exponential"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 1333
+      }
+      entries {
+        instruction {
+          opcode: "exponential-minus-one"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 1288
+      }
+      entries {
+        instruction {
+          opcode: "log"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 2337
+      }
+      entries {
+        instruction {
+          opcode: "log-plus-one"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 2299
+      }
+      entries {
+        instruction {
+          opcode: "rsqrt"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 5036
+      }
+      entries {
+        instruction {
+          opcode: "sine"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 1997
+      }
+      entries {
+        instruction {
+          opcode: "sqrt"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 6181
+      }
+      entries {
+        instruction {
+          opcode: "tanh"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 4419
+      }
+      entries {
+        instruction {
+          opcode: "add"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 14
+      }
+      entries {
+        instruction {
+          opcode: "atan2"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 12453
+      }
+      entries {
+        instruction {
+          opcode: "divide"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 2270
+      }
+      entries {
+        instruction {
+          opcode: "multiply"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 38
+      }
+      entries {
+        instruction {
+          opcode: "power"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 7339
+      }
+      entries {
+        instruction {
+          opcode: "subtract"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 14
+      }
+    }
+  }
+  entries {
+    key: "sm_86"
+    value {
+      entries {
+        instruction {
+          opcode: "divide"
+          shape { element_type: S8 }
+        }
+        clock_cycles: 370
+      }
+      entries {
+        instruction {
+          opcode: "power"
+          shape { element_type: S8 }
+        }
+        clock_cycles: 392
+      }
+      entries {
+        instruction {
+          opcode: "divide"
+          shape { element_type: S16 }
+        }
+        clock_cycles: 367
+      }
+      entries {
+        instruction {
+          opcode: "power"
+          shape { element_type: S16 }
+        }
+        clock_cycles: 396
+      }
+      entries {
+        instruction {
+          opcode: "divide"
+          shape { element_type: S32 }
+        }
+        clock_cycles: 306
+      }
+      entries {
+        instruction {
+          opcode: "divide"
+          shape { element_type: S64 }
+        }
+        clock_cycles: 918
+      }
+      entries {
+        instruction {
+          opcode: "power"
+          shape { element_type: S64 }
+        }
+        clock_cycles: 601
+      }
+      entries {
+        instruction {
+          opcode: "divide"
+          shape { element_type: U8 }
+        }
+        clock_cycles: 306
+      }
+      entries {
+        instruction {
+          opcode: "power"
+          shape { element_type: U8 }
+        }
+        clock_cycles: 388
+      }
+      entries {
+        instruction {
+          opcode: "divide"
+          shape { element_type: U16 }
+        }
+        clock_cycles: 302
+      }
+      entries {
+        instruction {
+          opcode: "power"
+          shape { element_type: U16 }
+        }
+        clock_cycles: 399
+      }
+      entries {
+        instruction {
+          opcode: "divide"
+          shape { element_type: U32 }
+        }
+        clock_cycles: 115
+      }
+      entries {
+        instruction {
+          opcode: "divide"
+          shape { element_type: U64 }
+        }
+        clock_cycles: 838
+      }
+      entries {
+        instruction {
+          opcode: "power"
+          shape { element_type: U64 }
+        }
+        clock_cycles: 604
+      }
+      entries {
+        instruction {
+          opcode: "cbrt"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 925
+      }
+      entries {
+        instruction {
+          opcode: "cosine"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 691
+      }
+      entries {
+        instruction {
+          opcode: "exponential"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 108
+      }
+      entries {
+        instruction {
+          opcode: "exponential-minus-one"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 396
+      }
+      entries {
+        instruction {
+          opcode: "log"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 266
+      }
+      entries {
+        instruction {
+          opcode: "log-plus-one"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 284
+      }
+      entries {
+        instruction {
+          opcode: "logistic"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 226
+      }
+      entries {
+        instruction {
+          opcode: "rsqrt"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 97
+      }
+      entries {
+        instruction {
+          opcode: "sqrt"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 97
+      }
+      entries {
+        instruction {
+          opcode: "tanh"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 212
+      }
+      entries {
+        instruction {
+          opcode: "atan2"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 482
+      }
+      entries {
+        instruction {
+          opcode: "power"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 975
+      }
+      entries {
+        instruction {
+          opcode: "cbrt"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 867
+      }
+      entries {
+        instruction {
+          opcode: "cosine"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 662
+      }
+      entries {
+        instruction {
+          opcode: "exponential"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 86
+      }
+      entries {
+        instruction {
+          opcode: "exponential-minus-one"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 381
+      }
+      entries {
+        instruction {
+          opcode: "log"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 244
+      }
+      entries {
+        instruction {
+          opcode: "log-plus-one"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 262
+      }
+      entries {
+        instruction {
+          opcode: "logistic"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 176
+      }
+      entries {
+        instruction {
+          opcode: "rsqrt"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 75
+      }
+      entries {
+        instruction {
+          opcode: "sine"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 662
+      }
+      entries {
+        instruction {
+          opcode: "sqrt"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 75
+      }
+      entries {
+        instruction {
+          opcode: "tanh"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 190
+      }
+      entries {
+        instruction {
+          opcode: "atan2"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 486
+      }
+      entries {
+        instruction {
+          opcode: "power"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 925
+      }
+      entries {
+        instruction {
+          opcode: "cbrt"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 6339
+      }
+      entries {
+        instruction {
+          opcode: "cosine"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 1717
+      }
+      entries {
+        instruction {
+          opcode: "exponential"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 1652
+      }
+      entries {
+        instruction {
+          opcode: "exponential-minus-one"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 1900
+      }
+      entries {
+        instruction {
+          opcode: "log"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 608
+      }
+      entries {
+        instruction {
+          opcode: "log-plus-one"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 2073
+      }
+      entries {
+        instruction {
+          opcode: "logistic"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 2412
+      }
+      entries {
+        instruction {
+          opcode: "rsqrt"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 698
+      }
+      entries {
+        instruction {
+          opcode: "sine"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 1789
+      }
+      entries {
+        instruction {
+          opcode: "sqrt"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 986
+      }
+      entries {
+        instruction {
+          opcode: "tanh"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 1609
+      }
+      entries {
+        instruction {
+          opcode: "add"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 97
+      }
+      entries {
+        instruction {
+          opcode: "atan2"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 3747
+      }
+      entries {
+        instruction {
+          opcode: "divide"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 2016
+      }
+      entries {
+        instruction {
+          opcode: "multiply"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 97
+      }
+      entries {
+        instruction {
+          opcode: "power"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 5511
+      }
+      entries {
+        instruction {
+          opcode: "subtract"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 97
+      }
+      entries {
+        instruction {
+          opcode: "exponential"
+          shape { element_type: C64 }
+        }
+        clock_cycles: 1360
+      }
+      entries {
+        instruction {
+          opcode: "exponential-minus-one"
+          shape { element_type: C64 }
+        }
+        clock_cycles: 1400
+      }
+      entries {
+        instruction {
+          opcode: "log"
+          shape { element_type: C64 }
+        }
+        clock_cycles: 950
+      }
+      entries {
+        instruction {
+          opcode: "log-plus-one"
+          shape { element_type: C64 }
+        }
+        clock_cycles: 842
+      }
+      entries {
+        instruction {
+          opcode: "rsqrt"
+          shape { element_type: C64 }
+        }
+        clock_cycles: 2383
+      }
+      entries {
+        instruction {
+          opcode: "sqrt"
+          shape { element_type: C64 }
+        }
+        clock_cycles: 3193
+      }
+      entries {
+        instruction {
+          opcode: "atan2"
+          shape { element_type: C64 }
+        }
+        clock_cycles: 5353
+      }
+      entries {
+        instruction {
+          opcode: "divide"
+          shape { element_type: C64 }
+        }
+        clock_cycles: 687
+      }
+      entries {
+        instruction {
+          opcode: "power"
+          shape { element_type: C64 }
+        }
+        clock_cycles: 3351
+      }
+      entries {
+        instruction {
+          opcode: "cosine"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 6613
+      }
+      entries {
+        instruction {
+          opcode: "exponential"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 4028
+      }
+      entries {
+        instruction {
+          opcode: "exponential-minus-one"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 4161
+      }
+      entries {
+        instruction {
+          opcode: "log"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 7599
+      }
+      entries {
+        instruction {
+          opcode: "log-plus-one"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 6962
+      }
+      entries {
+        instruction {
+          opcode: "rsqrt"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 11318
+      }
+      entries {
+        instruction {
+          opcode: "sine"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 5878
+      }
+      entries {
+        instruction {
+          opcode: "sqrt"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 15606
+      }
+      entries {
+        instruction {
+          opcode: "tanh"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 9939
+      }
+      entries {
+        instruction {
+          opcode: "add"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 97
+      }
+      entries {
+        instruction {
+          opcode: "atan2"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 39027
+      }
+      entries {
+        instruction {
+          opcode: "divide"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 7941
+      }
+      entries {
+        instruction {
+          opcode: "multiply"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 270
+      }
+      entries {
+        instruction {
+          opcode: "power"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 18205
+      }
+      entries {
+        instruction {
+          opcode: "subtract"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 97
+      }
+    }
+  }
+
+  entries { key: "sm_80"
+            value { entries {
+              instruction {
+                opcode: "divide"
+                shape { element_type: S8 }
+              }
+              clock_cycles: 417
+            }
+                    entries {
+                      instruction {
+                        opcode: "divide"
+                        shape { element_type: S16 }
+                      }
+                      clock_cycles: 468
+                    }
+                    entries {
+                      instruction {
+                        opcode: "divide"
+                        shape { element_type: S64 }
+                      }
+                      clock_cycles: 1094
+                    }
+                    entries {
+                      instruction {
+                        opcode: "divide"
+                        shape { element_type: U8 }
+                      }
+                      clock_cycles: 420
+                    }
+                    entries {
+                      instruction {
+                        opcode: "power"
+                        shape { element_type: U8 }
+                      }
+                      clock_cycles: 417
+                    }
+                    entries {
+                      instruction {
+                        opcode: "divide"
+                        shape { element_type: U16 }
+                      }
+                      clock_cycles: 391
+                    }
+                    entries {
+                      instruction {
+                        opcode: "power"
+                        shape { element_type: U16 }
+                      }
+                      clock_cycles: 454
+                    }
+                    entries {
+                      instruction {
+                        opcode: "divide"
+                        shape { element_type: U64 }
+                      }
+                      clock_cycles: 908
+                    }
+                    entries {
+                      instruction {
+                        opcode: "power"
+                        shape { element_type: U64 }
+                      }
+                      clock_cycles: 744
+                    }
+                    entries {
+                      instruction {
+                        opcode: "cbrt"
+                        shape { element_type: F16 }
+                      }
+                      clock_cycles: 1195
+                    }
+                    entries {
+                      instruction {
+                        opcode: "log"
+                        shape { element_type: F16 }
+                      }
+                      clock_cycles: 321
+                    }
+                    entries {
+                      instruction {
+                        opcode: "log-plus-one"
+                        shape { element_type: F16 }
+                      }
+                      clock_cycles: 346
+                    }
+                    entries {
+                      instruction {
+                        opcode: "sqrt"
+                        shape { element_type: F16 }
+                      }
+                      clock_cycles: 124
+                    }
+                    entries {
+                      instruction {
+                        opcode: "tanh"
+                        shape { element_type: F16 }
+                      }
+                      clock_cycles: 499
+                    }
+                    entries {
+                      instruction {
+                        opcode: "log"
+                        shape { element_type: F32 }
+                      }
+                      clock_cycles: 259
+                    }
+                    entries {
+                      instruction {
+                        opcode: "tanh"
+                        shape { element_type: F32 }
+                      }
+                      clock_cycles: 504
+                    }
+                    entries {
+                      instruction {
+                        opcode: "power"
+                        shape { element_type: F32 }
+                      }
+                      clock_cycles: 1221
+                    }
+                    entries {
+                      instruction {
+                        opcode: "cbrt"
+                        shape { element_type: F64 }
+                      }
+                      clock_cycles: 1638
+                    }
+                    entries {
+                      instruction {
+                        opcode: "exponential-minus-one"
+                        shape { element_type: F64 }
+                      }
+                      clock_cycles: 572
+                    })pb"
+                                        R"pb(
+      entries {
+        instruction {
+          opcode: "log"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 699
+      }
+      entries {
+        instruction {
+          opcode: "log-plus-one"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 1223
+      }
+      entries {
+        instruction {
+          opcode: "rsqrt"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 329
+      }
+      entries {
+        instruction {
+          opcode: "sine"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 597
+      }
+      entries {
+        instruction {
+          opcode: "sqrt"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 397
+      }
+      entries {
+        instruction {
+          opcode: "tanh"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 733
+      }
+      entries {
+        instruction {
+          opcode: "atan2"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 1080
+      }
+      entries {
+        instruction {
+          opcode: "divide"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 831
+      }
+      entries {
+        instruction {
+          opcode: "power"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 1861
+      }
+      entries {
+        instruction {
+          opcode: "log"
+          shape { element_type: C64 }
+        }
+        clock_cycles: 1037
+      }
+      entries {
+        instruction {
+          opcode: "log-plus-one"
+          shape { element_type: C64 }
+        }
+        clock_cycles: 1029
+      }
+      entries {
+        instruction {
+          opcode: "atan2"
+          shape { element_type: C64 }
+        }
+        clock_cycles: 6618
+      }
+      entries {
+        instruction {
+          opcode: "power"
+          shape { element_type: C64 }
+        }
+        clock_cycles: 4131
+      }
+      entries {
+        instruction {
+          opcode: "cosine"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 2309
+      }
+      entries {
+        instruction {
+          opcode: "log"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 2371
+      }
+      entries {
+        instruction {
+          opcode: "log-plus-one"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 2405
+      }
+      entries {
+        instruction {
+          opcode: "rsqrt"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 3945
+      }
+      entries {
+        instruction {
+          opcode: "sine"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 2284
+      }
+      entries {
+        instruction {
+          opcode: "sqrt"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 5304
+      }
+      entries {
+        instruction {
+          opcode: "tanh"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 3618
+      }
+      entries {
+        instruction {
+          opcode: "atan2"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 13564
+      }
+      entries {
+        instruction {
+          opcode: "divide"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 3037
+      }
+      entries {
+        instruction {
+          opcode: "power"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 6054
+      }
+    }
+        }
+
+  entries {
+    key: "sm_70"
+    value {
+      entries {
+        instruction {
+          opcode: "divide"
+          shape { element_type: S8 }
+        }
+        clock_cycles: 345
+      }
+      entries {
+        instruction {
+          opcode: "divide"
+          shape { element_type: S16 }
+        }
+        clock_cycles: 345
+      }
+      entries {
+        instruction {
+          opcode: "divide"
+          shape { element_type: S64 }
+        }
+        clock_cycles: 954
+      }
+      entries {
+        instruction {
+          opcode: "divide"
+          shape { element_type: U8 }
+        }
+        clock_cycles: 302
+      }
+      entries {
+        instruction {
+          opcode: "power"
+          shape { element_type: U8 }
+        }
+        clock_cycles: 526
+      }
+      entries {
+        instruction {
+          opcode: "divide"
+          shape { element_type: U16 }
+        }
+        clock_cycles: 309
+      }
+      entries {
+        instruction {
+          opcode: "power"
+          shape { element_type: U16 }
+        }
+        clock_cycles: 544
+      }
+      entries {
+        instruction {
+          opcode: "divide"
+          shape { element_type: U64 }
+        }
+        clock_cycles: 749
+      }
+      entries {
+        instruction {
+          opcode: "power"
+          shape { element_type: U64 }
+        }
+        clock_cycles: 820
+      }
+      entries {
+        instruction {
+          opcode: "cbrt"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 1227
+      }
+      entries {
+        instruction {
+          opcode: "cosine"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 865
+      }
+      entries {
+        instruction {
+          opcode: "exponential"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 137
+      }
+      entries {
+        instruction {
+          opcode: "exponential-minus-one"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 544
+      }
+      entries {
+        instruction {
+          opcode: "log"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 354
+      }
+      entries {
+        instruction {
+          opcode: "log-plus-one"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 388
+      }
+      entries {
+        instruction {
+          opcode: "rsqrt"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 122
+      }
+      entries {
+        instruction {
+          opcode: "sine"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 841
+      }
+      entries {
+        instruction {
+          opcode: "sqrt"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 134
+      }
+      entries {
+        instruction {
+          opcode: "tanh"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 556
+      }
+      entries {
+        instruction {
+          opcode: "power"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 1279
+      }
+      entries {
+        instruction {
+          opcode: "cbrt"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 1168
+      }
+      entries {
+        instruction {
+          opcode: "cosine"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 823
+      }
+      entries {
+        instruction {
+          opcode: "exponential"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 110
+      }
+      entries {
+        instruction {
+          opcode: "exponential-minus-one"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 514
+      }
+      entries {
+        instruction {
+          opcode: "log"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 333
+      }
+      entries {
+        instruction {
+          opcode: "log-plus-one"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 361
+      }
+      entries {
+        instruction {
+          opcode: "tanh"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 529
+      }
+      entries {
+        instruction {
+          opcode: "atan2"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 660
+      }
+      entries {
+        instruction {
+          opcode: "power"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 1214
+      }
+      entries {
+        instruction {
+          opcode: "cbrt"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 1392
+      }
+      entries {
+        instruction {
+          opcode: "cosine"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 673
+      }
+      entries {
+        instruction {
+          opcode: "exponential"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 474
+      }
+      entries {
+        instruction {
+          opcode: "exponential-minus-one"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 676
+      }
+      entries {
+        instruction {
+          opcode: "log"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 618
+      }
+      entries {
+        instruction {
+          opcode: "log-plus-one"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 1061
+      }
+      entries {
+        instruction {
+          opcode: "rsqrt"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 290
+      }
+      entries {
+        instruction {
+          opcode: "sine"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 667
+      }
+      entries {
+        instruction {
+          opcode: "sqrt"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 391
+      }
+      entries {
+        instruction {
+          opcode: "tanh"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 709
+      }
+      entries {
+        instruction {
+          opcode: "atan2"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 1178
+      }
+      entries {
+        instruction {
+          opcode: "divide"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 682
+      }
+      entries {
+        instruction {
+          opcode: "power"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 1679
+      }
+      entries {
+        instruction {
+          opcode: "cosine"
+          shape { element_type: C64 }
+        }
+        clock_cycles: 1762
+      }
+      entries {
+        instruction {
+          opcode: "log"
+          shape { element_type: C64 }
+        }
+        clock_cycles: 1450
+      }
+      entries {
+        instruction {
+          opcode: "log-plus-one"
+          shape { element_type: C64 }
+        }
+        clock_cycles: 1141
+      }
+      entries {
+        instruction {
+          opcode: "sine"
+          shape { element_type: C64 }
+        }
+        clock_cycles: 1787
+      }
+      entries {
+        instruction {
+          opcode: "sqrt"
+          shape { element_type: C64 }
+        }
+        clock_cycles: 3935
+      }
+      entries {
+        instruction {
+          opcode: "atan2"
+          shape { element_type: C64 }
+        }
+        clock_cycles: 7025
+      }
+      entries {
+        instruction {
+          opcode: "divide"
+          shape { element_type: C64 }
+        }
+        clock_cycles: 948
+      }
+      entries {
+        instruction {
+          opcode: "power"
+          shape { element_type: C64 }
+        }
+        clock_cycles: 4277
+      }
+      entries {
+        instruction {
+          opcode: "cosine"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 2386
+      }
+      entries {
+        instruction {
+          opcode: "exponential"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 1881
+      }
+      entries {
+        instruction {
+          opcode: "exponential-minus-one"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 1875
+      }
+      entries {
+        instruction {
+          opcode: "log"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 2622
+      }
+      entries {
+        instruction {
+          opcode: "log-plus-one"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 2328
+      }
+      entries {
+        instruction {
+          opcode: "rsqrt"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 4531
+      }
+      entries {
+        instruction {
+          opcode: "sine"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 2408
+      }
+      entries {
+        instruction {
+          opcode: "sqrt"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 5388
+      }
+      entries {
+        instruction {
+          opcode: "tanh"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 3867
+      }
+      entries {
+        instruction {
+          opcode: "atan2"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 13794
+      }
+      entries {
+        instruction {
+          opcode: "divide"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 3001
+      }
+      entries {
+        instruction {
+          opcode: "power"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 6046
+      }
+    }
+  }
+
+  entries {
+    key: "sm_60"
+    value {
+      entries {
+        instruction {
+          opcode: "divide"
+          shape { element_type: S8 }
+        }
+        clock_cycles: 438
+      }
+      entries {
+        instruction {
+          opcode: "divide"
+          shape { element_type: S16 }
+        }
+        clock_cycles: 479
+      }
+      entries {
+        instruction {
+          opcode: "divide"
+          shape { element_type: S32 }
+        }
+        clock_cycles: 758
+      }
+      entries {
+        instruction {
+          opcode: "divide"
+          shape { element_type: S64 }
+        }
+        clock_cycles: 2037
+      }
+      entries {
+        instruction {
+          opcode: "power"
+          shape { element_type: S64 }
+        }
+        clock_cycles: 2937
+      }
+      entries {
+        instruction {
+          opcode: "divide"
+          shape { element_type: U8 }
+        }
+        clock_cycles: 307
+      }
+      entries {
+        instruction {
+          opcode: "divide"
+          shape { element_type: U16 }
+        }
+        clock_cycles: 293
+      }
+      entries {
+        instruction {
+          opcode: "divide"
+          shape { element_type: U64 }
+        }
+        clock_cycles: 1708
+      }
+      entries {
+        instruction {
+          opcode: "power"
+          shape { element_type: U64 }
+        }
+        clock_cycles: 2993
+      }
+      entries {
+        instruction {
+          opcode: "cbrt"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 1661
+      }
+      entries {
+        instruction {
+          opcode: "exponential"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 213
+      }
+      entries {
+        instruction {
+          opcode: "exponential-minus-one"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 778
+      }
+      entries {
+        instruction {
+          opcode: "log"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 598
+      }
+      entries {
+        instruction {
+          opcode: "log-plus-one"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 538
+      }
+      entries {
+        instruction {
+          opcode: "logistic"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 402
+      }
+      entries {
+        instruction {
+          opcode: "rsqrt"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 130
+      }
+      entries {
+        instruction {
+          opcode: "tanh"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 453
+      }
+      entries {
+        instruction {
+          opcode: "power"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 1717
+      }
+      entries {
+        instruction {
+          opcode: "cbrt"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 1672
+      }
+      entries {
+        instruction {
+          opcode: "exponential"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 168
+      }
+      entries {
+        instruction {
+          opcode: "exponential-minus-one"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 731
+      }
+      entries {
+        instruction {
+          opcode: "log"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 435
+      }
+      )pb"
+                                        R"pb(
+      entries {
+        instruction {
+          opcode: "log-plus-one"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 589
+      }
+      entries {
+        instruction {
+          opcode: "logistic"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 343
+      }
+      entries {
+        instruction {
+          opcode: "sine"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 1024
+      }
+      entries {
+        instruction {
+          opcode: "tanh"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 417
+      }
+      entries {
+        instruction {
+          opcode: "atan2"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 873
+      }
+      entries {
+        instruction {
+          opcode: "power"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 1779
+      }
+      entries {
+        instruction {
+          opcode: "cbrt"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 1649
+      }
+      entries {
+        instruction {
+          opcode: "cosine"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 1175
+      }
+      entries {
+        instruction {
+          opcode: "exponential"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 639
+      }
+      entries {
+        instruction {
+          opcode: "exponential-minus-one"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 911
+      }
+      entries {
+        instruction {
+          opcode: "log"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 935
+      }
+      entries {
+        instruction {
+          opcode: "log-plus-one"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 1421
+      }
+      entries {
+        instruction {
+          opcode: "logistic"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 1098
+      }
+      entries {
+        instruction {
+          opcode: "rsqrt"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 355
+      }
+      entries {
+        instruction {
+          opcode: "sine"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 1187
+      }
+      entries {
+        instruction {
+          opcode: "sqrt"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 645
+      }
+      entries {
+        instruction {
+          opcode: "tanh"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 917
+      }
+      entries {
+        instruction {
+          opcode: "atan2"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 1394
+      }
+      entries {
+        instruction {
+          opcode: "divide"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 959
+      }
+      entries {
+        instruction {
+          opcode: "power"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 2667
+      }
+      entries {
+        instruction {
+          opcode: "log"
+          shape { element_type: C64 }
+        }
+        clock_cycles: 1726
+      }
+      entries {
+        instruction {
+          opcode: "log-plus-one"
+          shape { element_type: C64 }
+        }
+        clock_cycles: 1518
+      }
+      entries {
+        instruction {
+          opcode: "rsqrt"
+          shape { element_type: C64 }
+        }
+        clock_cycles: 4142
+      }
+      entries {
+        instruction {
+          opcode: "sqrt"
+          shape { element_type: C64 }
+        }
+        clock_cycles: 5069
+      }
+      entries {
+        instruction {
+          opcode: "tanh"
+          shape { element_type: C64 }
+        }
+        clock_cycles: 4053
+      }
+      entries {
+        instruction {
+          opcode: "atan2"
+          shape { element_type: C64 }
+        }
+        clock_cycles: 9469
+      }
+      entries {
+        instruction {
+          opcode: "divide"
+          shape { element_type: C64 }
+        }
+        clock_cycles: 1317
+      }
+      entries {
+        instruction {
+          opcode: "power"
+          shape { element_type: C64 }
+        }
+        clock_cycles: 5617
+      }
+      entries {
+        instruction {
+          opcode: "cosine"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 3416
+      }
+      entries {
+        instruction {
+          opcode: "exponential"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 2730
+      }
+      entries {
+        instruction {
+          opcode: "exponential-minus-one"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 2765
+      }
+      entries {
+        instruction {
+          opcode: "log"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 3106
+      }
+      entries {
+        instruction {
+          opcode: "log-plus-one"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 2895
+      }
+      entries {
+        instruction {
+          opcode: "rsqrt"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 5922
+      }
+      entries {
+        instruction {
+          opcode: "sine"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 3496
+      }
+      entries {
+        instruction {
+          opcode: "sqrt"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 7014
+      }
+      entries {
+        instruction {
+          opcode: "tanh"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 5400
+      }
+      entries {
+        instruction {
+          opcode: "atan2"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 21766
+      }
+      entries {
+        instruction {
+          opcode: "divide"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 4133
+      }
+      entries {
+        instruction {
+          opcode: "power"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 10458
+      }
+    }
+        }
+
+  entries {
+    key: "sm_75"
+    value {
+      entries {
+        instruction {
+          opcode: "divide"
+          shape { element_type: S8 }
+        }
+        clock_cycles: 360
+      }
+      entries {
+        instruction {
+          opcode: "power"
+          shape { element_type: S8 }
+        }
+        clock_cycles: 336
+      }
+      entries {
+        instruction {
+          opcode: "divide"
+          shape { element_type: S16 }
+        }
+        clock_cycles: 357
+      }
+      entries {
+        instruction {
+          opcode: "power"
+          shape { element_type: S16 }
+        }
+        clock_cycles: 339
+      }
+      entries {
+        instruction {
+          opcode: "divide"
+          shape { element_type: S32 }
+        }
+        clock_cycles: 296
+      }
+      entries {
+        instruction {
+          opcode: "divide"
+          shape { element_type: S64 }
+        }
+        clock_cycles: 979
+      }
+      entries {
+        instruction {
+          opcode: "power"
+          shape { element_type: S64 }
+        }
+        clock_cycles: 495
+      }
+      entries {
+        instruction {
+          opcode: "divide"
+          shape { element_type: U8 }
+        }
+        clock_cycles: 293
+      }
+      entries {
+        instruction {
+          opcode: "power"
+          shape { element_type: U8 }
+        }
+        clock_cycles: 334
+      }
+      entries {
+        instruction {
+          opcode: "divide"
+          shape { element_type: U16 }
+        }
+        clock_cycles: 290
+      }
+      entries {
+        instruction {
+          opcode: "power"
+          shape { element_type: U16 }
+        }
+        clock_cycles: 336
+      }
+      entries {
+        instruction {
+          opcode: "divide"
+          shape { element_type: U32 }
+        }
+        clock_cycles: 118
+      }
+      entries {
+        instruction {
+          opcode: "divide"
+          shape { element_type: U64 }
+        }
+        clock_cycles: 812
+      }
+      entries {
+        instruction {
+          opcode: "power"
+          shape { element_type: U64 }
+        }
+        clock_cycles: 515
+      }
+      entries {
+        instruction {
+          opcode: "cbrt"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 792
+      }
+      entries {
+        instruction {
+          opcode: "cosine"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 815
+      }
+      entries {
+        instruction {
+          opcode: "exponential"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 132
+      }
+      entries {
+        instruction {
+          opcode: "exponential-minus-one"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 342
+      }
+      entries {
+        instruction {
+          opcode: "log"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 239
+      }
+      entries {
+        instruction {
+          opcode: "log-plus-one"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 239
+      }
+      entries {
+        instruction {
+          opcode: "logistic"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 262
+      }
+      entries {
+        instruction {
+          opcode: "rsqrt"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 126
+      }
+      entries {
+        instruction {
+          opcode: "sine"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 794
+      }
+      entries {
+        instruction {
+          opcode: "sqrt"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 123
+      }
+      entries {
+        instruction {
+          opcode: "tanh"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 175
+      }
+      entries {
+        instruction {
+          opcode: "atan2"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 414
+      }
+      entries {
+        instruction {
+          opcode: "divide"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 74
+      }
+      entries {
+        instruction {
+          opcode: "power"
+          shape { element_type: F16 }
+        }
+        clock_cycles: 1120
+      }
+      entries {
+        instruction {
+          opcode: "cbrt"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 783
+      }
+      entries {
+        instruction {
+          opcode: "cosine"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 737
+      }
+      entries {
+        instruction {
+          opcode: "exponential"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 83
+      }
+      entries {
+        instruction {
+          opcode: "exponential-minus-one"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 319
+      }
+      entries {
+        instruction {
+          opcode: "log"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 201
+      }
+      entries {
+        instruction {
+          opcode: "log-plus-one"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 218
+      }
+      entries {
+        instruction {
+          opcode: "logistic"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 181
+      }
+      entries {
+        instruction {
+          opcode: "rsqrt"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 74
+      }
+      entries {
+        instruction {
+          opcode: "sine"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 717
+      }
+      entries {
+        instruction {
+          opcode: "sqrt"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 74
+      }
+      )pb"
+                                        R"pb(
+      entries {
+        instruction {
+          opcode: "tanh"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 167
+      }
+      entries {
+        instruction {
+          opcode: "atan2"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 414
+      }
+      entries {
+        instruction {
+          opcode: "power"
+          shape { element_type: F32 }
+        }
+        clock_cycles: 1085
+      }
+      entries {
+        instruction {
+          opcode: "cbrt"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 6494
+      }
+      entries {
+        instruction {
+          opcode: "cosine"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 1800
+      }
+      entries {
+        instruction {
+          opcode: "exponential"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 1630
+      }
+      entries {
+        instruction {
+          opcode: "exponential-minus-one"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 1929
+      }
+      entries {
+        instruction {
+          opcode: "log"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 596
+      }
+      entries {
+        instruction {
+          opcode: "log-plus-one"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 1774
+      }
+      entries {
+        instruction {
+          opcode: "logistic"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 2430
+      }
+      entries {
+        instruction {
+          opcode: "rsqrt"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 705
+      }
+      entries {
+        instruction {
+          opcode: "sine"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 1805
+      }
+      entries {
+        instruction {
+          opcode: "sqrt"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 984
+      }
+      entries {
+        instruction {
+          opcode: "tanh"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 1535
+      }
+      entries {
+        instruction {
+          opcode: "add"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 95
+      }
+      entries {
+        instruction {
+          opcode: "atan2"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 3744
+      }
+      entries {
+        instruction {
+          opcode: "divide"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 1915
+      }
+      entries {
+        instruction {
+          opcode: "multiply"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 95
+      }
+      entries {
+        instruction {
+          opcode: "power"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 5538
+      }
+      entries {
+        instruction {
+          opcode: "subtract"
+          shape { element_type: F64 }
+        }
+        clock_cycles: 95
+      }
+      entries {
+        instruction {
+          opcode: "cosine"
+          shape { element_type: C64 }
+        }
+        clock_cycles: 1702
+      }
+      entries {
+        instruction {
+          opcode: "exponential"
+          shape { element_type: C64 }
+        }
+        clock_cycles: 1503
+      }
+      entries {
+        instruction {
+          opcode: "exponential-minus-one"
+          shape { element_type: C64 }
+        }
+        clock_cycles: 1474
+      }
+      entries {
+        instruction {
+          opcode: "log"
+          shape { element_type: C64 }
+        }
+        clock_cycles: 835
+      }
+      entries {
+        instruction {
+          opcode: "log-plus-one"
+          shape { element_type: C64 }
+        }
+        clock_cycles: 737
+      }
+      entries {
+        instruction {
+          opcode: "rsqrt"
+          shape { element_type: C64 }
+        }
+        clock_cycles: 2232
+      }
+      entries {
+        instruction {
+          opcode: "sine"
+          shape { element_type: C64 }
+        }
+        clock_cycles: 1632
+      }
+      entries {
+        instruction {
+          opcode: "sqrt"
+          shape { element_type: C64 }
+        }
+        clock_cycles: 2989
+      }
+      entries {
+        instruction {
+          opcode: "tanh"
+          shape { element_type: C64 }
+        }
+        clock_cycles: 2263
+      }
+      entries {
+        instruction {
+          opcode: "atan2"
+          shape { element_type: C64 }
+        }
+        clock_cycles: 4847
+      }
+      entries {
+        instruction {
+          opcode: "power"
+          shape { element_type: C64 }
+        }
+        clock_cycles: 3219
+      }
+      entries {
+        instruction {
+          opcode: "cosine"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 6474
+      }
+      entries {
+        instruction {
+          opcode: "exponential"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 4962
+      }
+      entries {
+        instruction {
+          opcode: "exponential-minus-one"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 4037
+      }
+      entries {
+        instruction {
+          opcode: "log"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 7286
+      }
+      entries {
+        instruction {
+          opcode: "log-plus-one"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 6848
+      }
+      entries {
+        instruction {
+          opcode: "rsqrt"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 10748
+      }
+      entries {
+        instruction {
+          opcode: "sine"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 5391
+      }
+      entries {
+        instruction {
+          opcode: "sqrt"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 15981
+      }
+      entries {
+        instruction {
+          opcode: "tanh"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 9653
+      }
+      entries {
+        instruction {
+          opcode: "add"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 95
+      }
+      entries {
+        instruction {
+          opcode: "atan2"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 38206
+      }
+      entries {
+        instruction {
+          opcode: "divide"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 8040
+      }
+      entries {
+        instruction {
+          opcode: "multiply"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 273
+      }
+      entries {
+        instruction {
+          opcode: "power"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 18550
+      }
+      entries {
+        instruction {
+          opcode: "subtract"
+          shape { element_type: C128 }
+        }
+        clock_cycles: 97
+      }
+    }
+        }
+)pb";
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_HLO_OP_PROFILES_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/hlo_to_ir_bindings.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/hlo_to_ir_bindings.h
new file mode 100644
index 0000000000000000000000000000000000000000..3696968160ad1fee484ab917403d1fe12752bfaf
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/hlo_to_ir_bindings.h
@@ -0,0 +1,116 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_HLO_TO_IR_BINDINGS_H_
+#define XLA_SERVICE_GPU_HLO_TO_IR_BINDINGS_H_
+
+#include "absl/container/flat_hash_map.h"
+#include "absl/types/span.h"
+#include "llvm/IR/IRBuilder.h"
+#include "llvm/IR/Value.h"
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/map_util.h"
+#include "xla/service/llvm_ir/ir_array.h"
+
+namespace xla {
+namespace gpu {
+
+// This class encapsulates the bindings between HloInstructions and LLVM IR
+// values that represent their addresses.
+class HloToIrBindings {
+ public:
+  HloToIrBindings(llvm::IRBuilder<>* b, llvm::Module* llvm_module,
+                  bool is_nested)
+      : is_nested_(is_nested), b_(b), module_(llvm_module) {}
+
+  void EmitBasePointersForHlos(
+      absl::Span<const HloInstruction* const> io_hlos,
+      absl::Span<const HloInstruction* const> non_io_hlos);
+
+  // Rebinds the given HLO to the LLVM IR value that represent its address.
+  void BindHloToIrValue(const HloInstruction& hlo, llvm::Value* ir_value,
+                        ShapeIndexView shape_index = {});
+
+  // Unbinds all IR values that's defined in an LLVM function, e.g., function
+  // arguments and stack variables. Global variables will be kept in bindings_.
+  //
+  // This method is called after emitting code for each top-level HLO. The local
+  // IR values are out of scope at that point and should not be used.
+  void UnbindAllLocalIrValues();
+
+  // Returns whether `hlo` is bound to an LLVM IR value.
+  bool BoundToIrValue(const HloInstruction& hlo) const {
+    return base_ptrs_.contains(&hlo);
+  }
+
+  llvm::Value* GetTempBufferBase() const { return temp_buffer_base_; }
+  void SetTempBufferBase(llvm::Value* v) { temp_buffer_base_ = v; }
+
+  // A helper method that returns the base pointer of the IrArray containing the
+  // output of "inst".at the given ShapeIndex.
+  llvm::Value* GetBasePointer(const HloInstruction& hlo,
+                              ShapeIndexView shape_index = {}) const {
+    auto it = base_ptrs_.find(&hlo);
+    CHECK(it != base_ptrs_.end()) << hlo.ToString();
+    return it->second.element(shape_index);
+  }
+
+  // Returns the IrArray which contains the output of hlo.
+  //
+  // consumer is the HLO in which this IrArray is used -- we use this to (try
+  // to) add metadata indicating that the array is invariant within consumer.
+  //
+  // To get the buffer into which hlo should write its own output, call
+  // GetIrArray(hlo, hlo).
+  llvm_ir::IrArray GetIrArray(const HloInstruction& hlo,
+                              const HloInstruction& consumer,
+                              const ShapeIndex& shape_index = {});
+
+  std::string ToString() const;
+
+ private:
+  // Emits IR to resolve (possibly) recursive GetTupleElement instructions.
+  llvm::Value* EmitGetTupleElement(const HloInstruction* gte,
+                                   llvm::Value* base_ptr);
+
+  // Returns an llvm typed ir representation of 'ir_value' based on 'hlo' shape.
+  llvm::Value* GetTypedIrValue(const HloInstruction& hlo,
+                               ShapeIndexView shape_index,
+                               llvm::Value* ir_value);
+
+  const bool is_nested_;
+
+  llvm::IRBuilder<>* b_;
+  llvm::Module* module_;
+
+  // Stores the underlying llvm::IrArray for each HloInstruction.
+  // For an instruction that generates multiple outputs, the root will be a
+  // tuple shape. The IrArray for each element output is stored in the subnode
+  // in the ShapeTree.
+  absl::flat_hash_map<const HloInstruction*, ShapeTree<llvm::Value*>>
+      base_ptrs_;
+
+  // The address of the memory block that contains all temporary buffers.
+  llvm::Value* temp_buffer_base_ = nullptr;
+};
+
+// Converts `ir_value` with type i8* to a typed LLVM Value* based on `shape`.
+llvm::Value* CastToTypedValue(const Shape& shape, llvm::Value* ir_value,
+                              llvm::IRBuilder<>* b);
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_HLO_TO_IR_BINDINGS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/hlo_traversal.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/hlo_traversal.h
new file mode 100644
index 0000000000000000000000000000000000000000..799a427de94fcc8a46b8679bf280f828eba77eab
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/hlo_traversal.h
@@ -0,0 +1,81 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef XLA_SERVICE_GPU_HLO_TRAVERSAL_H_
+#define XLA_SERVICE_GPU_HLO_TRAVERSAL_H_
+
+#include <functional>
+
+#include "absl/types/span.h"
+#include "xla/hlo/ir/hlo_instruction.h"
+
+namespace xla {
+namespace gpu {
+
+enum class TraversalResult {
+  // Visit the operands of this node.
+  kVisitOperands,
+  // Do not visit any more nodes.
+  kAbortTraversal,
+  // Do not visit the operands of this node (but continue the traversal
+  // otherwise). If the node visitation function returns this, the `boundary`
+  // condition will not be evaluated.
+  kDoNotVisitOperands,
+};
+
+using FusionBoundaryFn = std::function<bool(const HloInstruction& producer,
+                                            const HloInstruction& consumer)>;
+
+// Boundary function for HloFusionInstructions.
+bool DefaultFusionBoundaryFn(const HloInstruction& producer,
+                             const HloInstruction& consumer);
+
+// Creates a fusion boundary function for fusing the given producer and
+// consumer. `fused_consumer` must be a consumer of `fused_producer`.
+FusionBoundaryFn MakeProducerConsumerFusion(
+    const HloInstruction& fused_producer, const HloInstruction& fused_consumer);
+
+// Visit the HLO nodes starting from `roots` in BFS order (consumers before
+// producers). Each node will be visited exactly once. The graph is not
+// traversed along edges for which `boundary` returns true.
+void HloBfsConsumersFirstTraversal(
+    absl::Span<const HloInstruction* const> roots,
+    const FusionBoundaryFn& boundary,
+    const std::function<TraversalResult(const HloInstruction& node)>& visit);
+
+// Visit the HLO nodes starting from `roots`, returning true if the return value
+// of `visit` for any of nodes is true. Uses the same order as
+// `HloBfsConsumersFirstTraversal`.
+bool HloAnyOf(absl::Span<const HloInstruction* const> roots,
+              const FusionBoundaryFn& boundary,
+              const std::function<bool(const HloInstruction& node)>& visit);
+
+// Visit the HLO nodes stating from `roots`, returning the first
+// node for which `visit` returns true, or `nullptr` if no node matches. Uses
+// the same order as `HloBfsConsumersFirstTraversal`.
+const HloInstruction* HloFindIf(
+    absl::Span<const HloInstruction* const> roots,
+    const FusionBoundaryFn& boundary,
+    const std::function<bool(const HloInstruction& node)>& visit);
+
+// Visit the producers of all parameters that are needed by the fusion.
+void FindFusionArguments(
+    absl::Span<const HloInstruction* const> roots,
+    const FusionBoundaryFn& boundary,
+    const std::function<void(const HloInstruction& producer)>& visit);
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_HLO_TRAVERSAL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/horizontal_input_fusion.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/horizontal_input_fusion.h
new file mode 100644
index 0000000000000000000000000000000000000000..0dc45c90adb5f765cc86b94793100ae5b2bc1c53
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/horizontal_input_fusion.h
@@ -0,0 +1,62 @@
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_HORIZONTAL_INPUT_FUSION_H_
+#define XLA_SERVICE_GPU_HORIZONTAL_INPUT_FUSION_H_
+
+#include "xla/hlo/ir/hlo_computation.h"
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/service/hlo_pass_interface.h"
+#include "xla/stream_executor/device_description.h"
+
+namespace xla {
+namespace gpu {
+
+// This optimization pass horizontally fuses kInput fusions to both reduce the
+// kernel launch overhead and increase parallelism degree. See
+// GpuHorizontalFusion for general description and motivation about horizontal
+// fusion. GpuHorizontalFusion deals with kLoop fusions while this pass deals
+// with kInput fusions.
+//
+// Following GpuHorizontalFusion, a simple yet effective heuristic is used
+// to search the fusion candidates while avoiding creating cycles. That is,
+// we simply search for fusion candidates by looking for instructions whose
+// outputs are all consumed by the same instruction. This catches the typical
+// target cases; often, the candidate instructions are just consumed by the
+// ROOT tuple of the entry computation.
+class GpuHorizontalInputFusion : public HloModulePass {
+ public:
+  explicit GpuHorizontalInputFusion(const se::DeviceDescription& d)
+      : device_info_(d) {}
+
+  absl::string_view name() const override {
+    return "gpu_horizontal_input_fusion";
+  }
+
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+
+ private:
+  StatusOr<bool> RunOnComputation(HloComputation*);
+
+  const se::DeviceDescription& device_info_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_HORIZONTAL_INPUT_FUSION_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/horizontal_loop_fusion.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/horizontal_loop_fusion.h
new file mode 100644
index 0000000000000000000000000000000000000000..4d81ba65412f4d6370f93e8d172dc84be3c5666d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/horizontal_loop_fusion.h
@@ -0,0 +1,142 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_HORIZONTAL_LOOP_FUSION_H_
+#define XLA_SERVICE_GPU_HORIZONTAL_LOOP_FUSION_H_
+
+#include "xla/hlo/ir/hlo_computation.h"
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/service/hlo_pass_interface.h"
+
+namespace xla {
+namespace gpu {
+
+// This optimization pass horizontally fuses computations for reducing kernel
+// launch overhead while increasing kernel launch dims on GPU. The initial
+// motivation of this horizontal fusion is due to the observation that the
+// training optimizer phase (e.g., AdamOptimizer and L2Loss, etc.) typically
+// has many small kernels as a result of applying the same formula on many
+// training parameters (or variables in Tensorflow). Fusing these small
+// kernels, hence, provides performance gain.
+//
+// Theoretically speaking, we may implement a cycle detection algorithm to make
+// sure no cycles are created after fusion. However, cycle detection check is
+// somewhat cumbersome; also, we observe that naive horizontal fusion of
+// arbitrary kernels may not be profitable due to control divergence and
+// possible increase of memory bandwidth pressure due to uncoalesced memory
+// accesses (note that horizontal fusion does not change the amount of memory
+// read+written at all). In practice, a simple yet effective heuristic is used
+// to avoid these issues while addressing the known beneficial cases. That is,
+// we simply search for fusion candidates by looking for instructions whose
+// outputs are all consumed by the same instruction. This catches the cases in
+// the training optimizer phase, as the candidate instructions are typically
+// consumed only by the ROOT tuple of the entry computation.
+//
+// The following illustrates the mechanism of the horizontal fusion. Before
+// fusion, there are two trivial kernels in the illustrating example. One has
+// only a Mul op, while the other consists of only an Add op. Since they are
+// only consumed by the same (ROOT) tuple instruction, horizontal fusion is
+// triggered.
+//
+// i0 i1   i2 i3
+//  | |     | |
+//  v v     v v
+//  Mul     Add
+//   |       |
+//   v       v
+//  (ROOT) tuple
+//
+// We fuse into one of two possible patterns, depending on whether all the
+// fused operations have the same shape or not.
+//
+// case 1: if Mul and Add's output shape and type are the same, then we fuse
+// them into the below pattern: i0 i1   i2 i3
+//  | |     | |
+//  v v     v v
+//  Mul     Add
+//   |       |
+//   v       v
+//  (ROOT) tuple
+// the fused kernel will be kLoop type, i.e, GPU code is emitted through
+// IrEmitterUnnested::EmitLoopFusion
+//
+// case 2: if Mul and Add's output shape are diffent, then we fuse them into
+// the below pattern that adds extra indexing:
+// i0 i1   i2 i3       +++ (Slice) Input Fusion
+//  | |     | |          +
+//  v v     v v          +
+//  Mul     Add          +
+//   |       |           +
+//   v       v           +
+// Reshape0  Reshape1    +
+//   |       |           +
+//   v       v           +
+//  Concatenate          +
+//   |       |           +
+//   v       v           +
+//  Slice0  Slice1     +++
+//   |       |
+//   v       v
+// Reshape2  Reshape3
+//   |       |
+//   v       v
+//  (ROOT) tuple
+//
+// the fused kernel will be kInput type, and, the GPU code is emitted through
+// IrEmitterUnnested::EmitInputFusibleNonStridedSlices
+//
+// In theory, the pattern in case 1 could also be fused into the case2 target
+// graph, but we prefer to fuse into kLoop type, because the codegen for it does
+// not have the slicing range check cost introduced by case 2 pattern.
+//
+// Note that the fusion style by case 2 provides an important advantage that
+// kernels of different shapes can be horizontally fused. The first pair of
+// reshapes (i.e., Reshape0 and Reshape1) reshape the dims to 1 dimension, so
+// that the outputs of the fused kernels can (always) be concatenated. The
+// second pair of reshapes (Reshape2 and Reshape3) restore the original shapes
+// to the output tensors.
+//
+// No extra copies are introduced by the horizontal fusion. Besides Reshape2
+// and Reshape3, the other instructions are fused into an input fusion; the
+// output dims of the concatenate will be used as the kernel launch dims.
+// Instruction bitcasts can be used for Reshape2 and Reshape3 as long as the
+// outputs of Mul and Add are row-major.
+//
+// Note, reshapes are added only if the tensors isn't already a vector.
+class GpuHorizontalLoopFusion : public HloModulePass {
+ public:
+  GpuHorizontalLoopFusion() = default;
+  explicit GpuHorizontalLoopFusion(absl::string_view prefix)
+      : prefix_(prefix) {}
+
+  absl::string_view name() const override {
+    return "gpu_horizontal_loop_fusion";
+  }
+
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+
+ private:
+  StatusOr<bool> RunOnComputation(HloComputation*);
+  std::string prefix_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_HORIZONTAL_LOOP_FUSION_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/infeed_manager.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/infeed_manager.h
new file mode 100644
index 0000000000000000000000000000000000000000..055e3139affa768b1f2afb363a9b77717b975532
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/infeed_manager.h
@@ -0,0 +1,67 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// This header declares classes for the infeed manager and the infeed
+// buffer that are used by the GPU runtime to transfer buffers into an
+// executing GPU computation, e.g., to feed data into a while loop.
+
+#ifndef XLA_SERVICE_GPU_INFEED_MANAGER_H_
+#define XLA_SERVICE_GPU_INFEED_MANAGER_H_
+
+#include "absl/base/thread_annotations.h"
+#include "xla/literal.h"
+#include "xla/service/gpu/xfeed_queue.h"
+#include "xla/shape_tree.h"
+#include "xla/stream_executor/stream_executor.h"
+#include "xla/types.h"
+
+namespace xla {
+namespace gpu {
+
+// TODO(b/30467474) Once GPU infeed implementation settles, consider
+// folding back the cpu and gpu infeed implementations into a generic
+// one if possible.
+//
+// Current limitations:
+// * Does not handle multiple devices/replicas.
+//
+// * Buffer space on GPU is allocated on every infeed enqueue request,
+// and it does not handle the case when it runs out of
+// memory. Potential solution is to pre-allocate a fixed amount of
+// memory and block when that memory is full.
+
+// Client-side class used to enqueue infeed buffers.
+class InfeedManager
+    : public BlockingXfeedQueue<ShapeTree<se::ScopedDeviceMemory<uint8_t>>> {
+ public:
+  explicit InfeedManager(se::StreamExecutor* executor);
+
+  Status TransferLiteralToInfeed(se::StreamExecutor* executor,
+                                 const LiteralSlice& literal);
+
+ private:
+  se::Stream* stream() const { return stream_.get(); }
+
+  // Stream used to enqueue infeed device copies.
+  std::unique_ptr<se::Stream> stream_;
+};
+
+// Returns the GPU infeed manager for the given stream executor,
+InfeedManager* GetOrCreateInfeedManager(se::StreamExecutor* executor);
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_INFEED_MANAGER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/infeed_thunk.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/infeed_thunk.h
new file mode 100644
index 0000000000000000000000000000000000000000..c2d1cd325e2f184ebbeb9c72679da2b01b71aeae
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/infeed_thunk.h
@@ -0,0 +1,49 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_INFEED_THUNK_H_
+#define XLA_SERVICE_GPU_INFEED_THUNK_H_
+
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/service/buffer_assignment.h"
+#include "xla/service/gpu/buffer_allocations.h"
+#include "xla/service/gpu/thunk.h"
+#include "xla/stream_executor/stream_executor.h"
+
+namespace xla {
+namespace gpu {
+
+// A thunk that infeeds data. Data must be already resident on the
+// device. This thunk performs an intra-device copy from that location
+// to the buffer allocated for the infeed op.
+class InfeedThunk : public Thunk {
+ public:
+  // Constructs a InfeedThunk that copies data from the on-device
+  // infeed queue into the buffers in the given shape tree.
+  InfeedThunk(ThunkInfo thunk_info, std::vector<ShapedSlice> dest_slices);
+
+  InfeedThunk(const InfeedThunk&) = delete;
+  InfeedThunk& operator=(const InfeedThunk&) = delete;
+
+  Status ExecuteOnStream(const ExecuteParams& params) override;
+
+ private:
+  const std::vector<ShapedSlice> dest_slices_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_INFEED_THUNK_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/instruction_fusion.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/instruction_fusion.h
new file mode 100644
index 0000000000000000000000000000000000000000..bf036cbdd45017627276ae73cb5161332de04218
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/instruction_fusion.h
@@ -0,0 +1,86 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_INSTRUCTION_FUSION_H_
+#define XLA_SERVICE_GPU_INSTRUCTION_FUSION_H_
+
+#include <stdint.h>
+
+#include <memory>
+#include <vector>
+
+#include "absl/container/flat_hash_map.h"
+#include "absl/container/flat_hash_set.h"
+#include "absl/strings/string_view.h"
+#include "xla/hlo/ir/hlo_computation.h"
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/service/fusion_node_indexing_evaluation.h"
+#include "xla/service/fusion_queue.h"
+#include "xla/service/hlo_pass_interface.h"
+#include "xla/service/instruction_fusion.h"
+#include "xla/statusor.h"
+#include "xla/stream_executor/device_description.h"
+
+namespace xla {
+namespace gpu {
+
+class GpuInstructionFusion : public InstructionFusion {
+ public:
+  explicit GpuInstructionFusion(bool may_duplicate,
+                                const se::DeviceDescription& d)
+      : InstructionFusion(GpuInstructionFusion::IsExpensive, may_duplicate),
+        device_info_(d) {}
+
+  static bool IsExpensive(const HloInstruction& instruction);
+
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(HloModule* module,
+                     const absl::flat_hash_set<absl::string_view>&
+                         execution_threads) override {
+    fusion_node_evaluations_.clear();
+    return InstructionFusion::Run(module, execution_threads);
+  }
+
+ protected:
+  std::unique_ptr<FusionQueue> GetFusionQueue(
+      HloComputation* computation) override;
+  FusionDecision ShouldFuse(HloInstruction* consumer,
+                            int64_t operand_index) override;
+
+  HloInstruction::FusionKind ChooseKind(
+      const HloInstruction* producer, const HloInstruction* consumer) override;
+
+ private:
+  // This method is called by ShouldFuse() to do all the computationally
+  // inexpensive checks whether we should fuse the operand into 'consumer'.
+  FusionDecision ShouldFuseInexpensiveChecks(HloInstruction* consumer,
+                                             int64_t operand_index);
+
+  HloInstruction* FuseInstruction(HloInstruction* fusion_instruction,
+                                  HloInstruction* producer) override;
+
+  // Keep track of the number of times each instruction inside a fusion node is
+  // indexed with different index vectors.
+  absl::flat_hash_map<const HloInstruction*, FusionNodeIndexingEvaluation>
+      fusion_node_evaluations_;
+
+  se::DeviceDescription device_info_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_INSTRUCTION_FUSION_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/ir_emission_utils.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/ir_emission_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..a7daa4ccaadcfddba6fc01c7d9416b63a6142552
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/ir_emission_utils.h
@@ -0,0 +1,219 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_IR_EMISSION_UTILS_H_
+#define XLA_SERVICE_GPU_IR_EMISSION_UTILS_H_
+
+#include <optional>
+#include <string>
+#include <vector>
+
+#include "llvm/IR/IRBuilder.h"
+#include "llvm/IR/Value.h"
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/mlir_hlo/lhlo/IR/lhlo_ops.h"
+#include "xla/service/buffer_assignment.h"
+
+namespace xla {
+namespace gpu {
+
+// If a dimensions is smaller than this, untiled transposition may be more
+// efficient.
+inline constexpr int64_t kMinDimensionToTransposeTiled = 16;
+// But if both swap dimensions are larger than 'kMinDimensionToTransposeTiled2',
+// and the product of the dimensions to be swapped is larger than
+// 'kMinTotalDimensionsToTransposeTiled', tiled transposition may be more
+// efficient.
+inline constexpr int64_t kMinDimensionToTransposeTiled2 = 8;
+inline constexpr int64_t kMinTotalDimensionsToTransposeTiled = 64 * 128;
+
+// Matrix multiplication before the rewrite.
+//
+// This function should never return "true" on instructions after
+// GemmRewriter pass has finished.
+bool IsMatrixMultiplication(const HloInstruction& dot);
+
+inline constexpr int64_t WarpSize() { return 32; }
+
+// Fusions that use Triton have FusionBackendConfig.kind equal to this string.
+inline constexpr absl::string_view kTritonGemmFusionKind = "__triton_gemm";
+
+// SoftmaxRewriterTriton sets backend_config of Triton Softmax custom fusions to
+// this string.
+inline constexpr absl::string_view kTritonSoftmaxFusionKind =
+    "__triton_softmax";
+
+inline constexpr absl::string_view kUncompilableFusion =
+    "__uncompilable_fusion";
+
+// Returns true if `hlo` will be implemented as a call to a cuSolver routine.
+//
+// This returns true if `hlo` is a CustomCall HLO with a call target equal to
+// one of the kCusolver... constants, but returns *false* for HLOs with
+// say, a kCholesky opcode.
+bool IsCustomCallToCusolver(const HloInstruction& hlo);
+
+// Cholesky decomposition. Takes a (batched) matrix as input, and returns a
+// tuple of (result, workspace, info), where result is the result of the
+// Cholesky decomposition, workspace is scratch space for cuSolver, and info
+// is a success/failure code per batch element.
+extern const char* const kCusolverCholeskyCallTarget;
+
+// Returns whether unnested_hlo is an input fusion whose root is either a slice
+// or a tuple of slices. If verify_no_strides is true, returns false unless all
+// ROOT slices have no strides.
+bool IsInputFusibleSlices(mlir::Operation* unnested_hlo,
+                          bool verify_no_strides);
+
+// Emits call to "vprintf" with given format and arguments.
+llvm::Value* EmitPrintf(absl::string_view fmt,
+                        absl::Span<llvm::Value* const> arguments,
+                        llvm::IRBuilder<>* builder);
+
+// Emits code to shuffle data between threads of a warp. This has the same
+// semantics as the PTX "shfl.sync.down" instruction but works for values that
+// aren't 32 bits in size. The last operand of the emitted "shfl" is
+// `WarpSize() - 1`.
+//
+// This function emits a "full-warp" shuffle, which all threads of a warp
+// participate in.  *Do not use this function from a divergent context:* You
+// can't correctly do so on both Volta and earlier GPUs.
+//
+// https://docs.nvidia.com/cuda/parallel-thread-execution/#data-movement-and-conversion-instructions-shfl-sync
+llvm::Value* EmitFullWarpShuffleDown(llvm::Value* value, llvm::Value* offset,
+                                     llvm::IRBuilder<>* builder);
+
+// Emits code that determines whether the current thread is thread 0 within
+// block 0 of the kernel.
+llvm::Value* IsBlock0Thread0(llvm::IRBuilder<>* b);
+
+int PartitionLmhloOperandsAndOutputs(mlir::Operation* op);
+llvm::SmallVector<mlir::Value> GetHloOperands(mlir::Operation* op);
+llvm::SmallVector<mlir::Value> GetHloOutputs(mlir::Operation* op);
+
+bool WritesMlirBuffer(mlir::Operation* op, mlir::Value operand);
+
+template <typename T>
+std::vector<T> ToStdVector(const llvm::SmallVectorImpl<T>& v) {
+  return std::vector<T>(v.begin(), v.end());
+}
+
+StatusOr<BufferAllocation::Slice> GetAllocationSlice(
+    mlir::Value v, absl::Span<const BufferAllocation> allocations,
+    std::string* constant_name = nullptr);
+
+bool CanEmitFusedDynamicUpdateSliceInPlaceForGpu(
+    mlir::lmhlo::FusionOp fusion,
+    absl::Span<const BufferAllocation> allocations);
+
+// Returns the dynamic-update-slice instructions defining the results of a
+// fusion node. A dynamic slice update is said to be "defining" of a result if
+// that result is the output of a dynamic slice update, or if that result is the
+// output of a bitcast of a dynamic slice update---since such bitcast may be
+// handled as a no-op.
+std::vector<const HloInstruction*> GetOutputDefiningDynamicUpdateSlices(
+    const std::vector<const HloInstruction*>& roots);
+
+// Returns the DynamicUpdateSliceOp(s) defining the results of a fusion node.
+// A dynamic slice update is said to be "defining" of a result if that result is
+// the output of a dynamic slice update, or if that result is the output of a
+// bitcast of a dynamic slice update---since such bitcast may be handled as a
+// no-op.
+std::vector<mlir::mhlo::DynamicUpdateSliceOp>
+GetOutputDefiningDynamicUpdateSliceOps(mlir::lmhlo::FusionOp fusion);
+
+Shape GetShape(mlir::Value value);
+
+// `is_boundary` returns `true` for edges that are on the boundary of the
+// fusion, i.e., they go from an instruction inside the fusion to one outside,
+// or vice versa.
+const HloInstruction& FindNonTrivialHero(
+    const HloInstruction& instr,
+    const std::function<bool(const HloInstruction& producer,
+                             const HloInstruction& consumer)>& is_boundary);
+const HloInstruction& FindNonTrivialHero(const HloInstruction& instr);
+
+/// Description of how to emit a given transposition.
+struct TransposeDescription {
+  // Transpose instruction.
+  const HloInstruction* instr;
+
+  // Normalized transpose dimensions.
+  Vector3 dimensions;
+
+  // Permutations of normalized transpose dimensions.
+  Vector3 permutation;
+
+  TransposeDescription(Vector3 dimensions, Vector3 permutation)
+      : TransposeDescription(/*instr=*/nullptr, dimensions, permutation) {}
+
+  TransposeDescription(const HloInstruction* instr, Vector3 dimensions,
+                       Vector3 permutation)
+      : instr(instr), dimensions(dimensions), permutation(permutation) {}
+
+  std::string ToString() const {
+    return absl::StrCat("dimensions=", VectorString(dimensions),
+                        ", permutation=", VectorString(permutation));
+  }
+
+  // Transpose instruction input shape.
+  const Shape& input_shape() const { return instr->operand(0)->shape(); }
+
+  // Returns true, if both descriptions have the same dimensions and
+  // permutation, even if they're produced by different instructions.
+  bool IsEquivalent(const TransposeDescription& other) const {
+    return dimensions == other.dimensions && permutation == other.permutation;
+  }
+};
+
+std::optional<TransposeDescription> FindTiledTranspose(
+    const HloInstruction& instr);
+
+std::optional<TransposeDescription> FindTiledLogicalTranspose(
+    const HloInstruction& instr);
+
+std::optional<TransposeDescription> GetDescriptionForTiledTransposeEmitter(
+    const HloInstruction& root, const HloInstruction& hero);
+
+bool IsIntermediate(const HloInstruction* instr, int allowed_operand_count = 1);
+
+// Log and verify an LLVM module.
+void LogAndVerify(const llvm::Module* m);
+
+// Returns the llvm type for the indices used in the kernel that contains the
+// hlo instruction. Such indices include the index for the parallel loop and
+// the indices for the tensors accessed by the kernel. The return type is i32
+// iff the following conditions are met:
+//  . The launch_size of the kernel is within the range of i32.
+//  . The sizes of all the tensors accessed within the kernel are within the
+//    range of i32.
+// Otherwise, the return type is i64.
+llvm::Type* GetIndexTypeForKernel(const HloInstruction* hlo,
+                                  int64_t launch_size, llvm::IRBuilder<>* b);
+
+// The same as GetIndexTypeForKernel, but works with MLIR ops.
+llvm::Type* GetIndexTypeForKernel(mlir::Operation* op, int64_t launch_size,
+                                  llvm::IRBuilder<>* b);
+
+// Returns a sanitized (doesn't need quoting) identifier name from a location.
+std::string GetIrNameFromLoc(mlir::Location loc);
+
+// Whether the module's target is an AMD GPU.
+bool IsAMDGPU(const llvm::Module* module);
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_IR_EMISSION_UTILS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/ir_emitter.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/ir_emitter.h
new file mode 100644
index 0000000000000000000000000000000000000000..8ac0b2075d3cd7a2c77844257a69d8c6138a78ff
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/ir_emitter.h
@@ -0,0 +1,155 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_IR_EMITTER_H_
+#define XLA_SERVICE_GPU_IR_EMITTER_H_
+
+#include <vector>
+
+#include "llvm/IR/Function.h"
+#include "llvm/IR/IRBuilder.h"
+#include "llvm/IR/Value.h"
+#include "xla/hlo/ir/dfs_hlo_visitor_with_default.h"
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/service/gpu/hlo_to_ir_bindings.h"
+#include "xla/service/gpu/ir_emitter_context.h"
+#include "xla/service/llvm_ir/fused_ir_emitter.h"
+#include "xla/service/llvm_ir/ir_array.h"
+#include "xla/service/llvm_ir/ir_builder_mixin.h"
+#include "xla/service/llvm_ir/loop_emitter.h"
+
+namespace xla {
+namespace gpu {
+
+// Abstract base class for translating HLO graphs to LLVM IR for a GPU.
+//
+// There are two concrete subclasses of IrEmitter: IrEmitterNested and
+// IrEmitterUnnested.  In the unnested variety, each HLO gets its own kernel
+// function, whereas in the nested version the whole computation is emitted as
+// one *non-kernel* function.
+//
+// In XLA, kernel functions never call other kernel functions.  This means that
+// if we have a kernel -- e.g. implementing a kReduce HLO -- that wants to use
+// an HLO computation as a "subroutine" -- e.g. the HLO computation that
+// specifies how to reduce two elements -- then the subroutine computation must
+// be emitted using IrEmitterNested.
+//
+// Fusion nodes are a special case.  A fusion node is emitted using
+// IrEmitterUnnested, but the code is generated using FusedIrEmitter, which is
+// not a subclass of gpu::IrEmitter, and in fact is better understood as an IR
+// generator generator.  See comments on that class.
+class IrEmitter : public DfsHloVisitorWithDefault,
+                  public IrBuilderMixin<IrEmitter> {
+ public:
+  IrEmitter(const IrEmitter&) = delete;
+  IrEmitter& operator=(const IrEmitter&) = delete;
+
+  Status DefaultAction(HloInstruction* hlo) override;
+  Status HandleConstant(HloInstruction* constant) override;
+  Status HandleGetTupleElement(HloInstruction* get_tuple_element) override;
+  Status HandleConvolution(HloInstruction* convolution) override;
+  Status HandleFft(HloInstruction* fft) override;
+  Status HandleAllReduce(HloInstruction* crs) override;
+  Status HandleInfeed(HloInstruction* infeed) override;
+  Status HandleOutfeed(HloInstruction* outfeed) override;
+  Status HandleSend(HloInstruction* send) override;
+  Status HandleSendDone(HloInstruction* send_done) override;
+  Status HandleRecv(HloInstruction* recv) override;
+  Status HandleRecvDone(HloInstruction* recv_done) override;
+  Status HandleParameter(HloInstruction* parameter) override;
+  Status HandleTuple(HloInstruction* tuple) override;
+  Status HandleScatter(HloInstruction* scatter) override;
+  Status HandleFusion(HloInstruction* fusion) override;
+  Status HandleCall(HloInstruction* call) override;
+  Status HandleCustomCall(HloInstruction* custom_call) override;
+  Status HandleBatchNormInference(HloInstruction* batch_norm) override;
+  Status HandleBatchNormTraining(HloInstruction* batch_norm) override;
+  Status HandleBatchNormGrad(HloInstruction* batch_norm) override;
+  Status HandleAddDependency(HloInstruction* add_dependency) override;
+
+  Status FinishVisit(HloInstruction* root) override { return OkStatus(); }
+
+  llvm::IRBuilder<>* builder() { return &b_; }
+
+ protected:
+  // Constructs an IrEmitter with the given IrEmitter context.
+  // ir_emitter_context is owned by the caller and should outlive the IrEmitter
+  // object.
+  explicit IrEmitter(IrEmitterContext* ir_emitter_context, bool is_nested);
+
+  // Helper for calling HloToIrBindings::GetIrArray.
+  //
+  // Gets the IrArray which contains inst.  This array has metadata that makes
+  // it valid only within the IR that implements consumer.  If you are
+  // implementing an HLO and want to get its own output buffer, call
+  // GetIrArray(hlo, hlo).
+  llvm_ir::IrArray GetIrArray(const HloInstruction& inst,
+                              const HloInstruction& consumer,
+                              const ShapeIndex& shape_index = {}) {
+    return bindings_.GetIrArray(inst, consumer, shape_index);
+  }
+  // A convenient helper for calling HloToIrBindings::GetBasePointer.
+  llvm::Value* GetBasePointer(const HloInstruction& inst,
+                              ShapeIndexView shape_index = {}) const {
+    return bindings_.GetBasePointer(inst, shape_index);
+  }
+
+  // Generates the IrArray for each output of an hlo instruction and returns
+  // a vector containing such IrArrays.
+  std::vector<llvm_ir::IrArray> ConstructIrArrayForOutputs(
+      const HloInstruction& hlo);
+
+  // Emit a single-threaded or multi-threaded loop that computes every element
+  // in the result of the given HLO instruction. This produces a series of
+  // nested loops (e.g. one for each dimension of the `hlo`'s shape). The body
+  // of the inner-most loop is provided by the body_emitter function.
+  virtual Status EmitTargetElementLoop(
+      const HloInstruction& hlo,
+      const llvm_ir::ElementGenerator& body_emitter) = 0;
+
+  IrEmitterContext* ir_emitter_context_;
+  llvm::Module* module_;
+
+  // The following fields track the IR emission state. According to LLVM memory
+  // management rules, their memory is owned by the module.
+  llvm::IRBuilder<> b_;
+
+  // Mapping from HLO to its underlying LLVM value.
+  HloToIrBindings bindings_;
+
+  // Bind all argument IrArrays of `fusion` to `fused_emitter`.
+  void BindFusionArguments(const HloInstruction* fusion,
+                           FusedIrEmitter* fused_emitter);
+
+  // Emit a fence for AMDGPU if necessary.
+  void MaybeEmitFenceForAMDGPU(llvm::AtomicOrdering atomic_ordering,
+                               const char* sync_scope_id);
+
+ private:
+  // A helper method for HandleSort(). It adds the inner comparison loop where
+  // we compare elements pointed to by 'keys_index' and 'compare_keys_index'.
+  void EmitCompareLoop(int64_t dimension_to_sort,
+                       const llvm_ir::IrArray::Index& keys_index,
+                       const llvm_ir::IrArray::Index& compare_keys_index,
+                       const llvm_ir::IrArray& keys_array);
+
+  // A convenience method to determine whether or not IR is emitted for AMDGPU.
+  bool IsEmittingForAMDGPU() const;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_IR_EMITTER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/ir_emitter_context.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/ir_emitter_context.h
new file mode 100644
index 0000000000000000000000000000000000000000..a981f0d2a2244bb2827bd2c1c0a014d25a84b15a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/ir_emitter_context.h
@@ -0,0 +1,117 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_IR_EMITTER_CONTEXT_H_
+#define XLA_SERVICE_GPU_IR_EMITTER_CONTEXT_H_
+
+#include <string>
+#include <utility>
+#include <variant>
+#include <vector>
+
+#include "llvm/IR/IRBuilder.h"
+#include "llvm/IR/Module.h"
+#include "mlir/IR/MLIRContext.h"  // from @llvm-project
+#include "xla/service/buffer_assignment.h"
+#include "xla/service/gpu/gpu_executable.h"
+#include "xla/service/name_uniquer.h"
+#include "xla/stream_executor/device_description.h"
+
+namespace xla {
+namespace gpu {
+
+// IrEmitterContext encapsulates common (mutable and immutable) data structures
+// used by both IrEmitterNested and IrEmitterUnnested, such as the buffer
+// assignment and the name uniquer.
+class IrEmitterContext {
+ public:
+  IrEmitterContext(const HloModule* hlo_module,
+                   const BufferAssignment* buffer_assignment,
+                   std::string platform_name,
+                   const se::DeviceDescription& gpu_device_info,
+                   mlir::MLIRContext* mlir_context, llvm::Module* llvm_module)
+      : hlo_module_(hlo_module),
+        buffer_assignment_(buffer_assignment),
+        platform_name_(std::move(platform_name)),
+        gpu_device_info_(gpu_device_info),
+        mlir_context_(mlir_context),
+        llvm_module_(llvm_module) {}
+  // Disallow copy and assign.
+  IrEmitterContext(const IrEmitterContext&) = delete;
+  IrEmitterContext& operator=(const IrEmitterContext&) = delete;
+
+  // Simple accessors.
+  const HloModule& hlo_module() const { return *hlo_module_; }
+  const BufferAssignment& buffer_assignment() const {
+    return *buffer_assignment_;
+  }
+  absl::string_view platform_name() const { return platform_name_; }
+  const se::DeviceDescription& gpu_device_info() const {
+    return gpu_device_info_;
+  }
+  se::CudaComputeCapability cuda_compute_capability() const {
+    auto* cc = std::get_if<se::CudaComputeCapability>(
+        &gpu_device_info_.gpu_compute_capability());
+    return cc != nullptr ? *cc : se::CudaComputeCapability();
+  }
+  se::RocmComputeCapability rocm_compute_capability() const {
+    auto* cc = std::get_if<se::RocmComputeCapability>(
+        &gpu_device_info_.gpu_compute_capability());
+    return cc != nullptr ? *cc : se::RocmComputeCapability();
+  }
+  mlir::MLIRContext* mlir_context() { return mlir_context_; }
+  llvm::Module* llvm_module() { return llvm_module_; }
+  NameUniquer* name_uniquer() { return &name_uniquer_; }
+
+  std::vector<GpuExecutable::ConstantInfo>& constants() { return constants_; }
+
+  absl::Span<const BufferAllocation> allocations() const {
+    if (buffer_assignment_) {
+      return buffer_assignment_->Allocations();
+    }
+    return allocations_;
+  }
+
+  void set_allocations(absl::Span<const BufferAllocation> allocations) {
+    CHECK_EQ(nullptr, buffer_assignment_);
+    allocations_ = allocations;
+  }
+
+  // Emit a constant with a given number of element, given byte size of the
+  // element, given symbol name and content.
+  void emit_constant(int64_t num_elements, int64_t bytes_per_element,
+                     absl::string_view symbol_name, int allocation_idx,
+                     llvm::ArrayRef<uint8_t> content, llvm::IRBuilder<>* b);
+
+  const DebugOptions& debug_options() const {
+    return hlo_module_->config().debug_options();
+  }
+
+ private:
+  const HloModule* hlo_module_;
+  const BufferAssignment* buffer_assignment_;
+  absl::Span<const BufferAllocation> allocations_;
+  std::string platform_name_;
+  const se::DeviceDescription& gpu_device_info_;
+  mlir::MLIRContext* mlir_context_;
+  llvm::Module* llvm_module_;
+  NameUniquer name_uniquer_;
+  std::vector<GpuExecutable::ConstantInfo> constants_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_IR_EMITTER_CONTEXT_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/ir_emitter_nested.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/ir_emitter_nested.h
new file mode 100644
index 0000000000000000000000000000000000000000..9f1b6e1baf9839768b4fc226dcef974ea8da28fe
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/ir_emitter_nested.h
@@ -0,0 +1,78 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_IR_EMITTER_NESTED_H_
+#define XLA_SERVICE_GPU_IR_EMITTER_NESTED_H_
+
+#include "absl/types/span.h"
+#include "llvm/IR/IRBuilder.h"
+#include "llvm/IR/Value.h"
+#include "xla/hlo/ir/hlo_computation.h"
+#include "xla/service/gpu/ir_emitter_context.h"
+#include "xla/service/hlo_module_config.h"
+
+namespace xla {
+namespace gpu {
+
+// Emits LLVM IR for a "nested computation" into a non-kernel device function.
+//
+// This is used to emit code for HloComputations that don't require a separate
+// kernel call.  For example, IrEmitterNested is used to emit code for a kReduce
+// HLO's elementwise reduction computation.  Notably, IrEmitterNested is *not*
+// used to emit code for fusion nodes -- fusion nodes use FusedIrEmitter, which
+// is a different beast altogether.
+//
+// IrEmitterNested generates a non-kernel function with the following
+// parameters:
+//
+//   - N pointers to the buffers of each of the N parameters to the computation,
+//   - a pointer to the output buffer of the computation, and
+//   - a pointer to the top-level temp buffer.
+Status CallNestedComputation(llvm::IRBuilder<>* builder,
+                             IrEmitterContext& ir_emitter_context,
+                             const HloComputation& computation,
+                             absl::Span<llvm::Value* const> operands,
+                             llvm::Value* output);
+
+// Like CallNestedComputation, but parameters and results are scalars.
+StatusOr<std::vector<llvm::Value*>> CallNestedComputationWithScalars(
+    llvm::IRBuilder<>* builder, IrEmitterContext& ir_emitter_context,
+    const HloComputation& computation,
+    absl::Span<llvm::Value* const> parameter_elements);
+
+// Like CallNestedComputationWithScalars, but parameters are scalar addresses.
+StatusOr<std::vector<llvm::Value*>> CallNestedComputationWithScalarAddrs(
+    llvm::IRBuilder<>* builder, IrEmitterContext& ir_emitter_context,
+    const HloComputation& computation,
+    absl::Span<llvm::Value* const> parameter_elements_addrs);
+
+// Emits an atomic operation that implements `nested_computation` in the
+// sequentially consistent memory model. `output_address` and `source_address`
+// are the arguments of the nested computation. For example,
+// atomicAdd(output_address, *source_address).
+//
+// If the computation can be implemented using a single atomic operation, it
+// will, otherwise it will be emitted as a compare-and-swap and a loop.
+//
+// The computation must have exactly two parameters.
+Status EmitAtomicOperationForNestedComputation(
+    llvm::IRBuilder<>* builder, IrEmitterContext& ir_emitter_context,
+    const HloComputation& computation, llvm::Value* output_address,
+    llvm::Value* source_address, llvm::Type* element_type);
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_IR_EMITTER_NESTED_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/ir_emitter_triton.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/ir_emitter_triton.h
new file mode 100644
index 0000000000000000000000000000000000000000..9edf27853e22fd97b597269f2a2a6535d4617427
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/ir_emitter_triton.h
@@ -0,0 +1,97 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_IR_EMITTER_TRITON_H_
+#define XLA_SERVICE_GPU_IR_EMITTER_TRITON_H_
+
+#include <functional>
+
+#include "absl/strings/string_view.h"
+#include "llvm/IR/Module.h"
+#include "mlir/IR/Builders.h"  // from @llvm-project
+#include "mlir/IR/BuiltinOps.h"  // from @llvm-project
+#include "mlir/IR/MLIRContext.h"  // from @llvm-project
+#include "mlir/IR/OwningOpRef.h"  // from @llvm-project
+#include "xla/autotuning.pb.h"
+#include "xla/hlo/ir/hlo_computation.h"
+#include "xla/service/gpu/gemm_rewriter_triton.h"
+#include "xla/service/gpu/hlo_traversal.h"
+#include "xla/service/gpu/launch_dimensions.h"
+#include "xla/statusor.h"
+#include "xla/stream_executor/device_description.h"
+#include "triton/Dialect/Triton/IR/Dialect.h"
+
+namespace xla {
+namespace gpu {
+
+struct TritonWrapperResult {
+  int64_t shmem_bytes;
+};
+
+// Compute the launch dimensions for the given Triton MatMul.
+LaunchDimensions GetMatMulLaunchDimensions(
+    const TritonFusionAnalysis& analysis,
+    absl::Span<const HloInstruction* const> roots,
+    const FusionBoundaryFn& fusion_boundary,
+    const AutotuneResult::TritonGemmKey& config);
+// Use tiling and execution parameters from 'config'.
+Status EmitMatMul(mlir::OpBuilder b, absl::string_view libdevice_path,
+                  const TritonFusionAnalysis& analysis,
+                  const HloComputation* computation, mlir::triton::FuncOp fn,
+                  const AutotuneResult::TritonGemmKey& config,
+                  int shmem_budget);
+
+// Compute the launch dimensions for the given Triton SoftMax.
+LaunchDimensions GetSoftMaxLaunchDimensions(
+    absl::Span<const HloInstruction* const> roots,
+    const FusionBoundaryFn& fusion_boundary,
+    const AutotuneResult::TritonGemmKey& config);
+// Generate Softmax in Triton IR inside 'fn'.
+// Use execution parameters from 'config'.
+Status EmitSoftMax(mlir::OpBuilder b, absl::string_view libdevice_path,
+                   const TritonFusionAnalysis& analysis,
+                   const HloComputation* computation, mlir::triton::FuncOp fn,
+                   const AutotuneResult::TritonGemmKey& config,
+                   int shmem_budget);
+
+using TritonIrEmitter = std::function<Status(
+    mlir::OpBuilder, absl::string_view, const TritonFusionAnalysis& analysis,
+    const HloComputation*, mlir::triton::FuncOp,
+    const AutotuneResult::TritonGemmKey&, int)>;
+
+// Generate Triton IR by running the provided generator and compile it into LLVM
+// IR.
+// MatMul and SoftMax above are some such IR generators.
+StatusOr<TritonWrapperResult> TritonWrapper(
+    const TritonFusionAnalysis& analysis, absl::string_view fn_name,
+    const HloComputation* hlo_computation, absl::string_view fusion_kind,
+    const se::CudaComputeCapability& cc,
+    const se::DeviceDescription& device_info,
+    const AutotuneResult::TritonGemmKey& config, llvm::Module* llvm_module,
+    TritonIrEmitter ir_emitter, mlir::MLIRContext& mlir_context);
+
+// Creates the initial Triton module for the given fusion. Visible for testing,
+// use TritonWrapper instead.
+StatusOr<mlir::OwningOpRef<mlir::ModuleOp>> CreateTritonModule(
+    const TritonFusionAnalysis& analysis, absl::string_view fn_name,
+    const HloComputation* hlo_computation,
+    const se::DeviceDescription& device_info,
+    const AutotuneResult::TritonGemmKey& config, TritonIrEmitter ir_emitter,
+    mlir::MLIRContext& mlir_context);
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_IR_EMITTER_TRITON_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/ir_emitter_unnested.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/ir_emitter_unnested.h
new file mode 100644
index 0000000000000000000000000000000000000000..0a2830aae4c9d551e35a1a05e17f78f4bb4b90c1
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/ir_emitter_unnested.h
@@ -0,0 +1,442 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_IR_EMITTER_UNNESTED_H_
+#define XLA_SERVICE_GPU_IR_EMITTER_UNNESTED_H_
+
+#include <array>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "absl/strings/string_view.h"
+#include "absl/types/span.h"
+#include "mlir/IR/Value.h"  // from @llvm-project
+#include "xla/autotuning.pb.h"
+#include "xla/hlo/ir/hlo_computation.h"
+#include "xla/hlo/ir/hlo_instructions.h"
+#include "xla/service/gpu/elemental_ir_emitter.h"
+#include "xla/service/gpu/fusions/tiling_util.h"
+#include "xla/service/gpu/hlo_fusion_analysis.h"
+#include "xla/service/gpu/ir_emitter.h"
+#include "xla/service/gpu/kernel_mapping_scheme.h"
+#include "xla/service/gpu/kernel_reuse_cache.h"
+#include "xla/service/gpu/nccl_collective_thunk.h"
+#include "xla/service/gpu/thunk.h"
+#include "xla/service/llvm_ir/ir_array.h"
+#include "xla/service/llvm_ir/llvm_util.h"
+
+namespace xla {
+namespace gpu {
+
+struct BufferSlice {
+  // The root buffer to look at.
+  BufferAllocation::Slice buffer_slice;
+
+  // The global constant name of the buffer, if it's a constant.
+  std::string constant_name;
+
+  // The buffer is modified by the kernel.
+  bool written = false;
+
+  Shape shape;
+};
+
+// Emits LLVM IR for an "unnested computation".
+//
+// An unnested computation is an HloComputation which you run by executing one
+// or more kernels for each HloInstruction it contains.  Examples of unnested
+// computations:
+//
+//  - An HloModule's root computation,
+//  - The body of an HLO while loop,
+//  - The true/false computation of an HLO conditional.
+//
+// Note the opportunity for confusion -- the while loop's computation is nested
+// within the root computation, but it's emitted using IrEmitterUnnested!  Don't
+// think about it too hard.
+//
+// Examples of things that are not unnested computations:
+//
+//  - The body of a fusion node.  IrEmitterUnnested emits the relevant code
+//    within a kernel function using FusedIrEmitter.  (FusedIrEmitter is not
+//    really an IrEmitter, but is more an "IR generator generator".)
+//
+class IrEmitterUnnested : public IrEmitter {
+ public:
+  absl::string_view platform_name() const {
+    return ir_emitter_context_->platform_name();
+  }
+
+  using ValueVector3 = std::array<llvm::Value*, 3>;
+  using ValueVector2 = std::array<llvm::Value*, 2>;
+
+  using ConstantGenerator = std::function<llvm::Value*(int64_t)>;
+
+  IrEmitterUnnested(const IrEmitterUnnested&) = delete;
+  IrEmitterUnnested& operator=(const IrEmitterUnnested&) = delete;
+
+  static std::unique_ptr<IrEmitterUnnested> Create(
+      IrEmitterContext* ir_emitter_context);
+
+  // Transfers the ownship of thunk_sequence_ out.
+  std::unique_ptr<ThunkSequence> ConsumeThunkSequence() {
+    return std::make_unique<ThunkSequence>(std::move(thunk_sequence_));
+  }
+
+  // Emits code for the given LMHLO region.
+  //
+  // Also populates related information to 'ir_emitter_context_' for
+  // large-constant initializations. Large constants don't get initializers in
+  // the generated code and so must be initialized by XLA. The value of these
+  // constants will be stored in 'content'. Constants with initializers in the
+  // generated code will have empty 'content'.
+  Status EmitLmhloRegion(
+      mlir::Region* region,
+      const absl::flat_hash_map<const mlir::Operation*, const HloInstruction*>&
+          hlo_for_lmhlo);
+
+  static void GetDependentDialects(mlir::DialectRegistry& registry);
+
+ private:
+  explicit IrEmitterUnnested(IrEmitterContext* ir_emitter_context);
+
+  Status EmitUnreachable(mlir::Operation* op, std::string error_message);
+
+  // IrEmitterUnnested handles the following instructions differently from
+  // IrEmitter. It also mixes in some special handling for custom kernels
+  // via the ThunkEmitter.
+  Status EmitConstant(mlir::Operation* op);
+
+  Status EmitConditional(
+      mlir::Operation* op,
+      const absl::flat_hash_map<const mlir::Operation*, const HloInstruction*>&
+          hlo_for_lmhlo);
+  Status EmitConvolutionThunk(mlir::Operation* op);
+  Status EmitGemmThunk(mlir::Operation* op);
+#if GOOGLE_CUDA || TF_HIPBLASLT
+  Status EmitCublasLtMatmulThunk(mlir::Operation* op);
+#endif  // GOOGLE_CUDA || TF_HIPBLASLT
+#if GOOGLE_CUDA
+  Status EmitCublasLtMatmulThunkF8(mlir::Operation* op);
+  Status EmitConvolutionReorderThunk(mlir::Operation* op);
+  Status EmitTritonFusion(
+      const HloFusionAnalysis& hlo_fusion_analysis, mlir::Operation* op,
+      const AutotuneResult::TritonGemmKey& config,
+      const absl::flat_hash_map<const mlir::Operation*, const HloInstruction*>&
+          hlo_for_lmhlo);
+  Status EmitFusedMHAThunk(mlir::Operation* op);
+  Status EmitFusedMHABackwardThunk(mlir::Operation* op);
+#endif  // GOOGLE_CUDA
+#if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+  Status EmitCholeskyThunk(mlir::Operation* op);
+#endif  // GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+  Status EmitCustomCallThunk(mlir::Operation* op);
+  Status EmitFftThunk(mlir::Operation* op);
+  Status EmitFusion(
+      mlir::Operation* op,
+      const absl::flat_hash_map<const mlir::Operation*, const HloInstruction*>&
+          hlo_for_lmhlo);
+  Status EmitSelectAndScatter(
+      mlir::Operation* op,
+      const absl::flat_hash_map<const mlir::Operation*, const HloInstruction*>&
+          hlo_for_lmhlo);
+  Status EmitWhile(
+      mlir::Operation* op,
+      const absl::flat_hash_map<const mlir::Operation*, const HloInstruction*>&
+          hlo_for_lmhlo);
+  Status EmitInfeed(mlir::Operation* op);
+  Status EmitOutfeed(mlir::Operation* op);
+  Status EmitRngGetAndUpdateState(mlir::Operation* op);
+  Status EmitScatter(
+      mlir::Operation* op,
+      const absl::flat_hash_map<const mlir::Operation*, const HloInstruction*>&
+          hlo_for_lmhlo);
+  Status EmitSort(
+      mlir::Operation* op,
+      const absl::flat_hash_map<const mlir::Operation*, const HloInstruction*>&
+          hlo_for_lmhlo);
+#if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+  Status EmitTriangularSolveCustomCall(mlir::Operation* op);
+#endif  // GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+
+  template <typename NcclThunkType, typename OpT>
+  Status EmitNcclThunk(mlir::Operation* op);
+  template <typename OpT>
+  Status EmitNcclAsyncDone(Thunk::Kind kind, mlir::Operation* op);
+
+  template <typename ThunkType, typename OpT>
+  Status EmitReplicaOrPartitionId(mlir::Operation* op);
+
+  template <typename NcclThunkType, typename OpT>
+  Status EmitCollectivePermute(mlir::Operation* op);
+
+  Status EmitOp(
+      mlir::Operation* op,
+      const absl::flat_hash_map<const mlir::Operation*, const HloInstruction*>&
+          hlo_for_lmhlo);
+
+  static Thunk::ThunkInfo GetThunkInfo(mlir::Operation* op);
+
+  Status EmitTargetElementLoop(
+      const HloInstruction& hlo,
+      const llvm_ir::ElementGenerator& body_emitter) override;
+
+  // Add a owning Thunk object to the thunk sequence.
+  void AddThunkToThunkSequence(std::unique_ptr<Thunk> thunk) {
+    thunk_sequence_.emplace_back(std::move(thunk));
+  }
+
+  // Load data from potentially unaligned address. If address is offset by
+  // `alignment_bytes`, data is read in the unit of `alignment_bytes` to avoid
+  // memory read misalignment in CUDA; otherwise, the entire data are loaded
+  // from the given memory address.
+  //
+  //   address: the memory address to load data from.
+  //   data_type: the type of data to load.
+  //   alignment_bytes: the number of bytes required to align. The number of
+  //     bytes of the data_type must be divisible by alignment_bytes.
+  llvm::Value* CreateLoad(llvm::Value* address, llvm::Type* data_type,
+                          int alignment_bytes);
+
+  // Store data at a potentially unaligned address. If the address is offset by
+  // `alignment_bytes`, data is stored in the unit of `alignment_bytes` to avoid
+  // memory write misalignment in CUDA; otherwise, the entire data is stored at
+  // the given memory address.
+  //
+  //   data: the data to be stored.
+  //   address: the memory address to store data.
+  //   alignment_bytes: the number of bytes required to align. The number of
+  //     bytes of the data_type must be divisible by alignment_bytes.
+  void CreateStore(llvm::Value* data, llvm::Value* address,
+                   int alignment_bytes);
+
+  // Input = {static array, dynamic_dim0, dynamic_dim1}
+  // Output = {dynamic array(with dynamic dimension meta data at the end)}
+  // For a tensor with static dimension [2][<=5] and dynamic dimension [2][3]
+  // (`_` stands for padding)
+  // Input = {{1,2,3,_,_,4,5,6_,_}, 2, 3}
+  // Output = {{1,2,3,4,5,6,_,_,_,_,2,3}}
+
+  // pseudo code for padToStatic on a 2d array
+  //   ```
+  // void padToStatic(int** input, int** output, int threads_per_block,
+  //                  int meta_data_offset, int max_num_element,
+  //                  int static_dim0_size, int static_dim1_size) {
+  //   int* source_array = input[0];
+  //   int* dest_array = output[0];
+
+  //   // extract the dynamic dimension from the source array's metadata
+  //   int* dyn_dim0_size = source_array + meta_data_offset;
+  //   int* dyn_dim1_size = source_array + meta_data_offset + sizeof(int);
+
+  //   // only one thread need to store the dynamic index
+  //   int thread_id = GetThreadId();
+  //   int block_id = GetBlockId();
+  //   if (thread_id == 0 && block_id == 0) {
+  //     *output[1] = *dyn_dim0_size;
+  //     *output[2] = *dyn_dim1_size;
+  //   }
+
+  //   int dyn_element_total = 1;
+  //   dyn_element_total *= *dyn_dim0_size;
+  //   dyn_element_total *= *dyn_dim1_size;
+  //   linear_index = block_id * threads_per_block + thread_id;
+  //   if (linear_index < max_num_element) {
+  //     Index static_index =
+  //         delinerized(linerized_index, static_dim0_size, static_dim1_size);
+  //     if (linerized_index < dyn_element_total) {
+  //       Index dyn_index =
+  //           delinerized(linerized_index, *dyn_dim0_size, *dyn_dim1_size);
+  //       dest_array[dyn_index.dim0][dyn_index.dim1] =
+  //           source_array[static_index.dim0][static_index.dim1];
+  //     }
+  //   }
+  //   return;
+  // }
+  //   ```
+  Status EmitPadToStatic(mlir::Operation* op);
+
+  // Input = {dynamic array(with dynamic dimension meta data at the end)}
+  // Output = {static array, dynamic_dim0, dynamic_dim1}
+  // For a tensor with static dimension [2][<=5] and dynamic dimension [2][3]
+  // (`_` stands for padding)
+  // Input = {{1,2,3,4,5,6,_,_,_,_,2,3}}
+  // Output = {{1,2,3,_,_,4,5,6_,_}, 2, 3}
+
+  // pseudo code for sliceToDynamic on a 2d array
+  //   ```
+  // void sliceToDynamic(int** input, int** output, int threads_per_block,
+  //                  int meta_data_offset, int max_num_element,
+  //                  int static_dim0_size, int static_dim1_size) {
+  //   int* source_array = input[0];
+  //   int* dest_array = output[0];
+
+  //   // calculate the location where metadata needs to be inserted
+  //   int* dyn_dim0_size = dest_array + meta_data_offset;
+  //   int* dyn_dim1_size = dest_array + meta_data_offset + sizeof(int);
+
+  //   // only one thread need to store the dynamic index
+  //   int thread_id = GetThreadId();
+  //   int block_id = GetBlockId();
+  //   if (thread_id == 0 && block_id == 0) {
+  //     *dyn_dim0_size = *output[1];
+  //     *dyn_dim1_size = *output[2];
+  //   }
+
+  //   int dyn_element_total = 1;
+  //   dyn_element_total *= *dyn_dim0_size;
+  //   dyn_element_total *= *dyn_dim1_size;
+  //   linear_index = block_id * threads_per_block + thread_id;
+  //   if (linear_index < max_num_element) {
+  //     Index static_index =
+  //         delinerized(linerized_index, static_dim0_size, static_dim1_size);
+  //     if (linerized_index < dyn_element_total) {
+  //       Index dyn_index =
+  //           delinerized(linerized_index, *dyn_dim0_size, *dyn_dim1_size);
+  //       dest_array[static_index.dim0][static_index.dim1] =
+  //           source_array[dyn_index.dim0][dyn_index.dim1];
+  //     }
+  //   }
+  //   return;
+  // }
+  //   ```
+  Status EmitSliceToDynamic(mlir::Operation* op);
+
+  StatusOr<BufferAllocation::Slice> GetAllocationSlice(mlir::Value v);
+
+  int64_t ByteSizeOf(const Shape& shape) const {
+    return llvm_ir::ByteSizeOf(
+        shape, ir_emitter_context_->llvm_module()->getDataLayout());
+  }
+
+  // Emits code for an in-place scatter, modifying `thunk`s launch dimensions in
+  // the process. Scatter indices are taken from `scatter_indices_gen`, updates
+  // from `updates_gen`. The output buffer is expected to have the operand
+  // values in it already. If unique_indices is false, we will use an atomic
+  // update. Using true for unique_indices behaves properly only when it is
+  // guaranteed that the indices to be updated do not overlap. The caller is
+  // responsible for ensuring this is the case.
+  Status EmitScatter(
+      mlir::lmhlo::ScatterOp scatter, const LaunchDimensions& launch_dimensions,
+      const llvm_ir::IrArray& output,
+      const llvm_ir::ElementGenerator& scatter_indices_gen,
+      const llvm_ir::ElementGenerator& updates_gen,
+      std::function<llvm::Type*(int64_t)> get_index_type,
+      const absl::flat_hash_map<const mlir::Operation*, const HloInstruction*>&
+          hlo_for_lmhlo);
+
+  // Structure describing a scatter operation for IR emission.
+  // TODO(jurahul): Migrate element generators to use MLIR.
+  //                Migrate update_computation to be an MLIR Region.
+  struct ScatterDescriptor {
+    std::string name;
+    Shape operand_shape;
+    Shape scatter_indices_shape;
+    Shape updates_shape;
+    mlir::mhlo::ScatterDimensionNumbersAttr dim_numbers;
+    bool unique_indices;
+    const HloComputation* update_computation;
+    llvm_ir::IrArray output;
+    llvm_ir::ElementGenerator scatter_indices_gen;
+    llvm_ir::ElementGenerator updates_gen;
+    std::function<llvm::Type*(int64_t)> get_index_type;
+  };
+
+  // Emits code for an in-place scatter using the provided scatter operation
+  // description.
+  Status EmitScatter(const ScatterDescriptor& desc,
+                     const LaunchDimensions& launch_dimensions);
+
+  Status EmitScatter(mlir::lmhlo::FusionOp fusion_op,
+                     const HloComputation* fused_computation,
+                     HloFusionAnalysis& fusion_analysis);
+
+  // Builds a kernel thunk for a non-fusion operation, without reuse.
+  //
+  // All input and output tensors of `op` are passed to the kernel.
+  //
+  // TODO(tdanyluk): Consider also reusing non-fusion kernels.
+  StatusOr<std::pair<std::vector<llvm_ir::IrArray> /*inputs*/,
+                     std::vector<llvm_ir::IrArray> /*outputs*/>>
+  BuildKernelThunkForNonFusionOp(mlir::Operation* op,
+                                 const LaunchDimensions& launch_dimensions);
+
+  // Builds a kernel thunk for a non-fusion operation, without reuse.
+  //
+  // Only the tensors specified in `needed_operands` are passed to the kernel.
+  //
+  // TODO(tdanyluk): Consider also reusing non-fusion kernels.
+  StatusOr<std::pair<std::vector<llvm_ir::IrArray> /*inputs*/,
+                     std::vector<llvm_ir::IrArray> /*outputs*/>>
+  BuildKernelThunkForNonFusionOp(mlir::Operation* op,
+                                 mlir::ValueRange needed_operands,
+                                 const LaunchDimensions& launch_dimensions);
+
+  Status BuildInitializerThunk(mlir::Operation* op, mlir::Value init_value,
+                               mlir::Value dest);
+
+  // Returns a WhileThunk that invokes thunk sequences for 'condition' and
+  // 'body' sub-computations of while instruction 'hlo'.
+  StatusOr<std::unique_ptr<Thunk>> BuildWhileThunk(
+      mlir::lmhlo::WhileOp while_op, const Thunk::ThunkInfo& thunk_info,
+      const absl::flat_hash_map<const mlir::Operation*, const HloInstruction*>&
+          hlo_for_lmhlo);
+
+  // Returns a ForThunk which executes 'loop_limit' invocations of a thunk
+  // sequence from the 'body' sub-computation of the while instruction 'hlo'.
+  StatusOr<std::unique_ptr<Thunk>> BuildForThunk(
+      mlir::lmhlo::WhileOp while_op, const Thunk::ThunkInfo& thunk_info,
+      int64_t loop_limit,
+      const absl::flat_hash_map<const mlir::Operation*, const HloInstruction*>&
+          hlo_for_lmhlo);
+
+  // Returns a ConditionalThunk which executes the thunk sequence for the
+  // 'branch_computation' corresponding to the predicate/branch_index of the
+  // given conditional instruction.
+  StatusOr<std::unique_ptr<Thunk>> BuildConditionalThunk(
+      const HloInstruction* conditional);
+
+  Status AssertNonDeterminismIsOkay(const std::string& op_name);
+
+  // The thunk sequence this IrEmitter generates for the input computation.
+  ThunkSequence thunk_sequence_;
+
+  // Maps async start ops to their executors so done can access the thunk.
+  // Executor may be null if the start op is degenerate (so not emitted).
+  absl::flat_hash_map<mlir::Operation*, NcclCollectiveThunk::AsyncExecutor*>
+      async_executors_;
+
+  // Begin optional members for XLA HLO -> LMHLO:
+  absl::flat_hash_map<const mlir::Region*, std::unique_ptr<HloModule>>
+      scratch_nested_computations_;
+  // End optional members for XLA HLO -> LMHLO.
+
+  // Returns the ShapedSlices for the given operands.
+  StatusOr<std::vector<ShapedSlice>> GetShapedSlices(
+      mlir::Operation::operand_range operands);
+
+  GpuElementalIrEmitter elemental_emitter_;
+
+  KernelReuseCache kernel_reuse_cache_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_IR_EMITTER_UNNESTED_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/kernel_arguments.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/kernel_arguments.h
new file mode 100644
index 0000000000000000000000000000000000000000..a7953030b01e7f88fd8958ac2aecbc3740ee617a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/kernel_arguments.h
@@ -0,0 +1,92 @@
+/*Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef XLA_SERVICE_GPU_KERNEL_ARGUMENTS_H_
+#define XLA_SERVICE_GPU_KERNEL_ARGUMENTS_H_
+
+#include <optional>
+#include <utility>
+#include <vector>
+
+#include "mlir/IR/Value.h"  // from @llvm-project
+#include "xla/mlir_hlo/lhlo/IR/lhlo_ops.h"
+#include "xla/service/buffer_assignment.h"
+#include "xla/shape.h"
+#include "xla/statusor.h"
+
+namespace xla {
+namespace gpu {
+
+// An argument descriptor for kernels.
+// Thread-safe.
+class KernelArgument {
+ public:
+  static StatusOr<KernelArgument> Create(
+      absl::Span<const BufferAllocation> allocations, mlir::Value value,
+      bool is_written);
+
+  mlir::Value value() const { return value_; }
+  const Shape& shape() const { return shape_; }
+  const BufferAllocation::Slice& slice() const { return slice_; }
+  bool written() const { return written_; }
+  int64_t alignment() const { return alignment_; }
+  std::optional<int> first_with_same_slice() const {
+    return first_with_same_slice_;
+  }
+  bool aliased() const { return aliased_; }
+
+ private:
+  KernelArgument(mlir::Value value, Shape shape, BufferAllocation::Slice slice,
+                 bool written)
+      : value_(value), shape_(shape), slice_(slice), written_(written) {}
+
+  mlir::Value value_;
+  Shape shape_;
+  BufferAllocation::Slice slice_;
+  bool aliased_ = true;
+  int64_t alignment_ = 1;
+  bool written_ = true;
+  // Holds the index of the first argument which has the same slice as this,
+  // if this is not the first such argument.
+  std::optional<int> first_with_same_slice_;
+
+  friend class KernelArguments;
+};
+
+class KernelArguments {
+ public:
+  static StatusOr<KernelArguments> Create(
+      absl::Span<const BufferAllocation> allocations,
+      mlir::lmhlo::FusionOp fusion);
+
+  static StatusOr<KernelArguments> Create(
+      absl::Span<const BufferAllocation> allocations,
+      mlir::Operation* non_fusion_op, mlir::ValueRange needed_operands);
+
+  const std::vector<KernelArgument>& args() const { return args_; }
+
+ private:
+  explicit KernelArguments(std::vector<KernelArgument> args)
+      : args_(ProcessArguments(std::move(args))) {}
+
+  static std::vector<KernelArgument> ProcessArguments(
+      std::vector<KernelArgument> kernel_arguments);
+
+  std::vector<KernelArgument> args_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_KERNEL_ARGUMENTS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/kernel_mapping_scheme.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/kernel_mapping_scheme.h
new file mode 100644
index 0000000000000000000000000000000000000000..4a6f0f7ae3c6fa1904b8d2a0adb2364213e8070d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/kernel_mapping_scheme.h
@@ -0,0 +1,265 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_KERNEL_MAPPING_SCHEME_H_
+#define XLA_SERVICE_GPU_KERNEL_MAPPING_SCHEME_H_
+
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "absl/container/inlined_vector.h"
+#include "absl/types/span.h"
+#include "llvm/IR/Value.h"
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/service/llvm_ir/loop_emitter.h"
+#include "xla/util.h"
+
+namespace xla {
+namespace gpu {
+
+// Describes tiling used by the kernel.
+//
+// Used by reductions and 021 transpose algorithm. Both algorithms operate over
+// "logical" 3D views over input arrays, hence tiling and number of threads
+// information has only 3 dimensions.
+//
+// In the presence of virtual threadIdx/blockIdx scaling, all accessors are
+// "logical", unless otherwise specified.
+class TilingScheme {
+ public:
+  enum { DimZ = 0, DimY, DimX, DimTot };
+
+  enum IndexingOrder {
+    // Thread reads consecutive elements.
+    LinearIndexingX,
+    // Thread reads strided elements while keeping memory coalescing.
+    StridedIndexingX,
+  };
+
+  TilingScheme(Vector3 dims_in_elems, Vector3 tile_sizes, Vector3 num_threads,
+               IndexingOrder indexing_order, int vector_size,
+               int scaling_factor, Vector2 tiling_dimensions = Vector2{1, 2})
+      : dims_in_elems_(dims_in_elems),
+        tile_sizes_(tile_sizes),
+        tiling_dimensions_(tiling_dimensions),
+        num_threads_(num_threads),
+        indexing_order_(indexing_order),
+        vector_size_(vector_size),
+        thread_id_virtual_scaling_(scaling_factor) {
+    CHECK_EQ(tile_sizes[2] % vector_size_, 0)
+        << "tile sizes = " << absl::StrJoin(tile_sizes, ", ")
+        << "; vector size = " << vector_size_;
+  }
+
+  static std::string IndexingOrderToString(IndexingOrder order) {
+    switch (order) {
+      case LinearIndexingX:
+        return "linear";
+      case StridedIndexingX:
+        return "strided";
+    }
+  }
+
+  std::string ToString() const {
+    return absl::StrJoin(
+        {absl::StrFormat("dims_in_elems = {%s}",
+                         absl::StrJoin(dims_in_elems_, ", ")),
+         absl::StrFormat("tile_sizes = {%s}", absl::StrJoin(tile_sizes_, ", ")),
+         absl::StrFormat("num_threads = {%s}",
+                         absl::StrJoin(num_threads_, ", ")),
+         absl::StrFormat("indexing_order = %s",
+                         IndexingOrderToString(indexing_order_)),
+         absl::StrFormat("vector_size = %d", vector_size_),
+         absl::StrFormat("thread_id_virtual_scaling = %d",
+                         thread_id_virtual_scaling_),
+         absl::StrFormat("tiling_dimensions = {%s}",
+                         absl::StrJoin(tiling_dimensions_, ", "))},
+        ", ");
+  }
+
+  // Number of elements in each dimension (Z/Y/X respectively).
+  absl::Span<const int64_t> GetDimsInElems() const { return dims_in_elems_; }
+
+  Vector3 GetDimsInBlocks() const {
+    return {GetDimInBlock(0), GetDimInBlock(1), GetDimInBlock(2)};
+  }
+
+  // Number of blocks required to "cover" the given dimension.
+  int64_t GetDimInBlock(int d) const {
+    return CeilOfRatio(dims_in_elems_[d], GetBlockTileSizeFor(d));
+  }
+
+  // Tile size for a given dimensions per thread.
+  //
+  // Equals to the number of iterations in the loop each tile will make.
+  int64_t GetTileSizeFor(int d) const { return tile_sizes_.at(d); }
+
+  // The tiling dimension for dimension 'd' of the shared memory tile.
+  int64_t GetTilingDimension(int d) const { return tiling_dimensions_.at(d); }
+
+  // Tile size for a given dimension per entire thread block.
+  int64_t GetBlockTileSizeFor(int d) const {
+    return num_threads_.at(d) * tile_sizes_.at(d);
+  }
+
+  // Number of threads in given dimension.
+  int64_t GetNumThreadsFor(int d) const { return num_threads_.at(d); }
+
+  // Number of logical threads per block.
+  int64_t GetNumThreadsPerBlock() const {
+    return GetNumThreadsFor(0) * GetNumThreadsFor(1) * GetNumThreadsFor(2);
+  }
+
+  // Number of logical blocks.
+  int64_t GetNumberOfBlocks() const {
+    return GetDimInBlock(0) * GetDimInBlock(1) * GetDimInBlock(2);
+  }
+
+  // Number of physical blocks launched (with scaling applied).
+  int64_t GetNumberOfBlocksPhysical() const {
+    return CeilOfRatio(GetNumberOfBlocks(), thread_id_virtual_scaling_);
+  }
+
+  // Number of physical threads per block launched (with scaling applied).
+  int64_t GetNumThreadsPerBlockPhysical() const {
+    return GetNumThreadsPerBlock() * thread_id_virtual_scaling_;
+  }
+
+  IndexingOrder GetIndexingOrder() const { return indexing_order_; }
+  int GetVectorSize() const { return vector_size_; }
+
+  // Scaling factor for transforming physical threadId to logical.
+  int GetThreadIdScalingFactor() const { return thread_id_virtual_scaling_; }
+
+ private:
+  // The number of elements in each dimension.
+  const Vector3 dims_in_elems_;
+
+  // The number of elements for each dimension of a tile.
+  const Vector3 tile_sizes_;
+
+  // The dimensions which are used for the shared memory tile.
+  const Vector2 tiling_dimensions_;
+
+  // Number of threads implicitly assigned to each dimension.
+  const Vector3 num_threads_;
+
+  const IndexingOrder indexing_order_;
+
+  // Vector size for dimension X.
+  const int vector_size_;
+
+  // Scaling apply to transform physical threadIdx into logical.
+  const int64_t thread_id_virtual_scaling_ = 1;
+};
+
+class ReductionCodegenInfo {
+ public:
+  using IndexGroups = std::vector<std::vector<const HloInstruction*>>;
+
+  explicit ReductionCodegenInfo(TilingScheme mapping_scheme,
+                                int num_partial_results, bool is_row_reduction,
+                                bool is_race_free, IndexGroups index_groups,
+                                const HloInstruction* first_reduce)
+      : tiling_scheme_(mapping_scheme),
+        num_partial_results_(num_partial_results),
+        is_row_reduction_(is_row_reduction),
+        is_race_free_(is_race_free),
+        index_groups_(std::move(index_groups)),
+        first_reduce_(first_reduce) {
+    if (!is_row_reduction && num_partial_results > 1) {
+      CHECK_EQ(num_partial_results,
+               mapping_scheme.GetTileSizeFor(TilingScheme::DimX));
+    }
+  }
+
+  const TilingScheme& GetTilingScheme() const { return tiling_scheme_; }
+  const IndexGroups& GetIndexGroups() const { return index_groups_; }
+  Shape GetReduceOperandShape() const {
+    return first_reduce_->operand(0)->shape();
+  }
+
+  int GetNumPartialResults() const { return num_partial_results_; }
+  bool IsRaceFree() const { return is_race_free_; }
+
+ private:
+  friend class ReductionCodegenState;
+
+  const TilingScheme tiling_scheme_;
+  int num_partial_results_;
+  bool is_row_reduction_;
+  bool is_race_free_;
+  IndexGroups index_groups_;
+  const HloInstruction* first_reduce_;
+};
+
+class ReductionCodegenState {
+ public:
+  struct ReductionCalculationState {
+    llvm::GlobalVariable* shared_cache;
+    llvm::Value* initial_value;
+    llvm::AllocaInst* partial_result_address;
+    llvm::AllocaInst* input_address;
+    llvm_ir::ElementGenerator input_gen;
+  };
+
+  explicit ReductionCodegenState(
+      const ReductionCodegenInfo& reduction_codegen_info)
+      : reduction_codegen_info_(reduction_codegen_info) {}
+
+  const TilingScheme& GetTilingScheme() const {
+    return reduction_codegen_info_.tiling_scheme_;
+  }
+
+  int GetNumPartialResults() const {
+    return reduction_codegen_info_.num_partial_results_;
+  }
+
+  bool IsRowReduction() const {
+    return reduction_codegen_info_.is_row_reduction_;
+  }
+
+  bool IsRaceFree() const { return reduction_codegen_info_.IsRaceFree(); }
+
+  const ReductionCalculationState& GetCalculationStateFor(
+      const HloInstruction* instruction, int operand_idx) const {
+    const ReductionOpState& op_state = state_.at(instruction);
+    CHECK_LT(operand_idx, op_state.size());
+    return op_state[operand_idx];
+  }
+
+  void SetCalculationStateFor(
+      const ReductionCalculationState& calculation_state,
+      const HloInstruction* instruction, int operand_idx) {
+    ReductionOpState& op_state = state_[instruction];
+    CHECK_EQ(operand_idx, op_state.size());
+    op_state.push_back(calculation_state);
+  }
+
+ private:
+  ReductionCodegenInfo reduction_codegen_info_;
+
+  // One state per reduction operand.
+  using ReductionOpState = absl::InlinedVector<ReductionCalculationState, 2>;
+
+  // HloInstruction -> operand_idx -> cache
+  absl::flat_hash_map<const HloInstruction*, ReductionOpState> state_;
+};
+
+}  // end namespace gpu
+}  // end namespace xla
+
+#endif  // XLA_SERVICE_GPU_KERNEL_MAPPING_SCHEME_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/kernel_reuse_cache.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/kernel_reuse_cache.h
new file mode 100644
index 0000000000000000000000000000000000000000..33cddb7d5c15cea8d026a49ef531407af5988112
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/kernel_reuse_cache.h
@@ -0,0 +1,74 @@
+/*Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef XLA_SERVICE_GPU_KERNEL_REUSE_CACHE_H_
+#define XLA_SERVICE_GPU_KERNEL_REUSE_CACHE_H_
+
+#include <functional>
+#include <string>
+#include <utility>
+
+#include "absl/strings/string_view.h"
+#include "xla/hlo/ir/hlo_computation.h"
+#include "xla/service/gpu/kernel_arguments.h"
+#include "xla/service/gpu/launch_dimensions.h"
+
+namespace xla {
+namespace gpu {
+
+// Caches identical Kernels for deduplication.
+// Thread-compatible.
+class KernelReuseCache {
+ public:
+  struct Entry {
+    std::string kernel_name;
+    LaunchDimensions launch_dimensions;
+    int64_t shmem_bytes;
+  };
+
+  // Retrieves the cache entry for the given computation, or generates it using
+  // the given generator function and stores it in the cache.
+  std::pair<Entry, bool /*was_cached*/> Get(
+      const HloComputation* fused_computation,
+      absl::Span<const KernelArgument> kernel_arguments,
+      absl::string_view discriminator, const std::function<Entry()>& generator);
+
+  // Like `Get`, but for generator functions that can fail.
+  std::pair<StatusOr<Entry>, bool /*was_cached*/> GetWithStatus(
+      const HloComputation* fused_computation,
+      absl::Span<const KernelArgument> kernel_arguments,
+      absl::string_view discriminator,
+      const std::function<StatusOr<Entry>()>& generator);
+
+ private:
+  absl::flat_hash_map<std::string /*fingerprint*/, Entry> cache_;
+};
+
+// Calculates the fingerprint of a (fused_computation, kernel_arguments,
+// discriminator) tuple.
+//
+// If a given fusion is implemented using multiple kernels, then for each
+// kernel we should provide a discriminator, such as "init" and "impl".
+//
+// If the same fingerprint is returned twice, then we can reuse the kernel
+// generated for the first computation.
+std::string GetComputationFingerprint(
+    const HloComputation* fused_computation,
+    absl::Span<const KernelArgument> kernel_arguments,
+    absl::string_view discriminator = "");
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_KERNEL_REUSE_CACHE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/kernel_thunk.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/kernel_thunk.h
new file mode 100644
index 0000000000000000000000000000000000000000..8b5f6c91cb89c163364d1c6d04591d040944c2ef
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/kernel_thunk.h
@@ -0,0 +1,117 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_KERNEL_THUNK_H_
+#define XLA_SERVICE_GPU_KERNEL_THUNK_H_
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "absl/container/flat_hash_map.h"
+#include "absl/types/span.h"
+#include "mlir/IR/Operation.h"  // from @llvm-project
+#include "mlir/IR/Value.h"  // from @llvm-project
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/service/buffer_assignment.h"
+#include "xla/service/gpu/buffer_allocations.h"
+#include "xla/service/gpu/kernel_arguments.h"
+#include "xla/service/gpu/launch_dimensions.h"
+#include "xla/service/gpu/thunk.h"
+#include "xla/stream_executor/stream_executor.h"
+#include "xla/types.h"
+
+namespace xla {
+namespace gpu {
+
+class GpuExecutable;
+
+// This class stores everything that StreamExecutor needs for launching a
+// kernel. It implements the ExecuteOnStream interface for GpuExecutable to
+// invoke the corresponding kernel.
+//
+// This is thread-compatible.
+class KernelThunk : public Thunk {
+ public:
+  // Constructs a thunk for the given kernel.
+  //
+  // KernelThunk takes args as `BufferAllocation::Slice`s (wrapped in
+  // `KernelArgument`s). Each slice directly corresponds to an argument or
+  // output of the computation. Also, the values must correspond to each arg
+  // directly, not to their base allocation (e.g. they can be the result of an
+  // `mlir::memref::ViewOp`).
+  KernelThunk(mlir::Operation* op, std::string kernel_name,
+              absl::Span<const KernelArgument> kernel_arguments,
+              LaunchDimensions launch_dimensions, int64_t shmem_bytes);
+  KernelThunk(const KernelThunk&) = delete;
+  KernelThunk& operator=(const KernelThunk&) = delete;
+  ~KernelThunk() override = default;
+
+  std::string ToStringExtra(int indent) const override;
+
+  Status Initialize(const GpuExecutable& executable,
+                    se::StreamExecutor* executor) override;
+  Status ExecuteOnStream(const ExecuteParams& params) override;
+
+  void ClearCompileTimeInfo() override {
+    Thunk::ClearCompileTimeInfo();
+    for (auto& value : values_) {
+      value = nullptr;
+    }
+  }
+
+  const std::vector<BufferAllocation::Slice>& arguments() const {
+    return args_;
+  }
+  const std::vector<bool>& written() const { return written_; }
+
+  const std::string& kernel_name() const { return kernel_name_; }
+  const LaunchDimensions& launch_dimensions() const {
+    return launch_dimensions_;
+  }
+  // The shared memory required by the kernel.
+  int64_t shmem_bytes() const { return shmem_bytes_; }
+  absl::Span<const mlir::Value> values() const { return values_; }
+
+ private:
+  // Buffer slices passed to the kernel as arguments.
+  std::vector<BufferAllocation::Slice> args_;
+
+  // args_[i] is written iff (written_[i] == true).
+  std::vector<bool> written_;
+
+  // Entry kernel name for the computation.
+  const std::string kernel_name_;
+
+  // The thread and block dimension used to launch the kernel.
+  const LaunchDimensions launch_dimensions_;
+
+  int64_t shmem_bytes_;
+
+  // mlir::Value(s) corresponding to the buffer slice arguments.
+  std::vector<mlir::Value> values_;
+
+  mutable absl::Mutex mutex_;
+
+  // Loaded kernels for each `StreamExecutor`.  Requires pointer stability of
+  // values.
+  absl::flat_hash_map<se::StreamExecutor*, std::unique_ptr<se::KernelBase>>
+      kernel_cache_ ABSL_GUARDED_BY(mutex_);
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_KERNEL_THUNK_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/launch_dimensions.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/launch_dimensions.h
new file mode 100644
index 0000000000000000000000000000000000000000..5bde8059e3bb5ec1c0acb27892aef1fe5fe6369d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/launch_dimensions.h
@@ -0,0 +1,134 @@
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_LAUNCH_DIMENSIONS_H_
+#define XLA_SERVICE_GPU_LAUNCH_DIMENSIONS_H_
+
+#include <ostream>
+#include <string>
+
+#include "xla/shape.h"
+#include "xla/stream_executor/device_description.h"
+
+namespace xla {
+namespace gpu {
+
+// Encapsulates the launch dimensions of a kernel, e.g., the block count and the
+// number of threads per block.
+class LaunchDimensions {
+ public:
+  struct Dim3D {
+    int64_t x, y, z;
+
+    bool operator==(const Dim3D& other) const {
+      return x == other.x && y == other.y && z == other.z;
+    }
+
+    bool operator!=(const Dim3D& other) const { return !(*this == other); }
+  };
+
+  // The default constructor creates a launch dimension that indicate
+  // single-threaded execution.
+  LaunchDimensions()
+      : block_counts_({1, 1, 1}), thread_counts_per_block_({1, 1, 1}) {}
+
+  LaunchDimensions(int64_t block_x_count, int64_t thread_x_count_per_block)
+      : block_counts_({block_x_count, 1, 1}),
+        thread_counts_per_block_({thread_x_count_per_block, 1, 1}) {}
+
+  LaunchDimensions(const Dim3D& block_counts,
+                   const Dim3D& thread_counts_per_block)
+      : block_counts_(block_counts),
+        thread_counts_per_block_(thread_counts_per_block) {}
+
+  Dim3D block_counts() const { return block_counts_; }
+
+  Dim3D thread_counts_per_block() const { return thread_counts_per_block_; }
+
+  // Returns the total number of threads in a block.
+  int64_t total_nb_threads() const {
+    return thread_counts_per_block_.x * thread_counts_per_block_.y *
+           thread_counts_per_block_.z;
+  }
+
+  int64_t launch_bound() const {
+    return block_counts_.x * thread_counts_per_block_.x * block_counts_.y *
+           thread_counts_per_block_.y * block_counts_.z *
+           thread_counts_per_block_.z;
+  }
+
+  std::string ToString() const {
+    return absl::StrCat("blocks: {", block_counts_.x, ", ", block_counts_.y,
+                        ", ", block_counts_.z, "}, threads/block: {",
+                        thread_counts_per_block_.x, ", ",
+                        thread_counts_per_block_.y, ", ",
+                        thread_counts_per_block_.z, "}");
+  }
+
+  bool operator==(const LaunchDimensions& other) const {
+    return block_counts_ == other.block_counts_ &&
+           thread_counts_per_block_ == other.thread_counts_per_block_;
+  }
+
+  bool operator!=(const LaunchDimensions& other) const {
+    return !(*this == other);
+  }
+
+ private:
+  Dim3D block_counts_;
+  Dim3D thread_counts_per_block_;
+};
+
+std::ostream& operator<<(std::ostream& out,
+                         const LaunchDimensions& launch_dims);
+
+struct LaunchDimensionsConfig {
+  // The kernel implementation will be unrolled if `unroll_factor` is
+  // greater than one.
+  int unroll_factor = 1;
+  // A wave is a group of blocks that execute at the same time on the
+  // GPU. If there are more blocks then the number that can run
+  // concurrently, there are multiple waves of blocks running
+  // sequentially.  If `few_waves` is true, each thread will loop over
+  // a block of unroll_factor elements. Otherwise each thread will
+  // handle only unroll_factor.
+  bool few_waves = false;
+  // If `row_optimized` is true, then the block size will equal to
+  // `hlo.shape().dimensions().back()/unroll_factor`.
+  // Currently few_waves and row_vectorized do not work together.
+  bool row_vectorized = false;
+
+  std::string ToString() {
+    return absl::StrCat("unroll_factor=", unroll_factor,
+                        ", few_waves=", few_waves,
+                        ", row_vectorized=", row_vectorized);
+  }
+};
+
+// Returns -1 if the shape doesn't allow the row vectorization code path.
+// If supported, return the number of threads to use in that case.
+int64_t ThreadsPerBlockRowVectorized(
+    const Shape& shape, const se::DeviceDescription& gpu_device_info,
+    LaunchDimensionsConfig dim_config);
+
+// Calculates the launch dimensions used to invoke `hlo`.
+StatusOr<LaunchDimensions> CalculateLaunchDimensions(
+    const Shape& shape, const se::DeviceDescription& gpu_device_info,
+    LaunchDimensionsConfig dim_config = {});
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_LAUNCH_DIMENSIONS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/llvm_gpu_backend/gpu_backend_lib.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/llvm_gpu_backend/gpu_backend_lib.h
new file mode 100644
index 0000000000000000000000000000000000000000..9ff362c2df33911b099e860409b8019eab3e003a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/llvm_gpu_backend/gpu_backend_lib.h
@@ -0,0 +1,72 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// LLVM-based compiler backend.
+#ifndef XLA_SERVICE_GPU_LLVM_GPU_BACKEND_GPU_BACKEND_LIB_H_
+#define XLA_SERVICE_GPU_LLVM_GPU_BACKEND_GPU_BACKEND_LIB_H_
+
+#include <string>
+#include <utility>
+
+#include "absl/strings/string_view.h"
+#include "llvm/IR/Module.h"
+#include "llvm/Target/TargetMachine.h"
+#include "xla/statusor.h"
+#include "xla/stream_executor/device_description.h"
+#include "xla/types.h"
+#include "xla/xla.pb.h"
+
+namespace xla {
+namespace gpu {
+
+namespace nvptx {
+
+std::string CantFindCudaMessage(absl::string_view msg,
+                                absl::string_view xla_gpu_cuda_data_dir);
+
+// Get path to NVVM libdevice file.
+std::string LibDevicePath(absl::string_view xla_gpu_cuda_data_dir);
+
+// Link libdevice if functions using it are detected in the module.
+Status LinkLibdeviceIfNecessary(llvm::Module* module,
+                                const std::string& libdevice_path);
+
+// Compiles the argument module and returns it. libdevice_dir_path is the parent
+// directory of the libdevice bitcode libraries. The contents of the module may
+// be changed.
+//
+// The Compile.* interfaces each create their own llvm::LLVMContext objects for
+// thread safety, but note that LLVM's multithreaded support is very
+// preliminary; multithreaded use is not recommended at this time.
+StatusOr<std::string> CompileToPtx(
+    llvm::Module* module, se::GpuComputeCapability gpu_version,
+    const DebugOptions& debug_options,
+    std::function<void(llvm::TargetMachine*)> configure_target = nullptr);
+}  // namespace nvptx
+
+namespace amdgpu {
+// Compiles the argument module and returns it with LLVM AMDGPU backend.
+// rocdl_dir_path is the parent directory of ROCm-Device-Libs bitcode libraries.
+// The contents of the module may be changed.
+StatusOr<std::vector<uint8_t>> CompileToHsaco(
+    llvm::Module* module, se::GpuComputeCapability gpu_version,
+    const DebugOptions& debug_options, const std::string& rocdl_dir_path,
+    const std::string& module_config_cache_key);
+}  // namespace amdgpu
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_LLVM_GPU_BACKEND_GPU_BACKEND_LIB_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/llvm_gpu_backend/utils.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/llvm_gpu_backend/utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..5c6a07ae3514e6ac667362c123dd40d160b3df45
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/llvm_gpu_backend/utils.h
@@ -0,0 +1,51 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_LLVM_GPU_BACKEND_UTILS_H_
+#define XLA_SERVICE_GPU_LLVM_GPU_BACKEND_UTILS_H_
+
+#include <memory>
+#include <string>
+
+#include "absl/strings/string_view.h"
+#include "xla/types.h"
+
+namespace llvm {
+class LLVMContext;
+class Module;
+}  // namespace llvm
+
+namespace xla {
+namespace gpu {
+
+// Convenience function for loading a LLVM module from an IR file. The module
+// is created in the given LLVM context.
+//
+// If loading fails for some reason, dies printing a diagnostic error.
+std::unique_ptr<llvm::Module> LoadIRModule(const std::string& filename,
+                                           llvm::LLVMContext* llvm_context);
+
+// Convenience function for replacing the extension of the given filename.
+// If the filename has no extension, the new extension is appended to its name.
+//
+// For example:
+//   ReplaceFilenameExtension("/foo/baz.txt", "cc") --> "/foo/baz.cc"
+std::string ReplaceFilenameExtension(absl::string_view filename,
+                                     absl::string_view new_extension);
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_LLVM_GPU_BACKEND_UTILS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/loop_double_buffer_transformer.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/loop_double_buffer_transformer.h
new file mode 100644
index 0000000000000000000000000000000000000000..b9fb70a1853f41fe69f69af61c0c011bf26ccd86
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/loop_double_buffer_transformer.h
@@ -0,0 +1,54 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef XLA_SERVICE_GPU_LOOP_DOUBLE_BUFFER_TRANSFORMER_H_
+#define XLA_SERVICE_GPU_LOOP_DOUBLE_BUFFER_TRANSFORMER_H_
+
+#include <utility>
+
+#include "absl/strings/string_view.h"
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/service/hlo_pass_interface.h"
+#include "xla/statusor.h"
+
+namespace xla {
+namespace gpu {
+
+// This pass performs the unrolling-by-2 loop transformation
+// to effectively achieve double buffering between inputs and outputs
+// of previously rolled iterations.
+// This pass only runs on loops with known trip counts.
+// For even number of iterations, unrolling-by-2 will be done directly.
+// For odd number of iterations, the first iteration of the loop will be
+// peeled outside of the while loop to make the trip count an even number,
+// then proceed to unroll by 2.
+// It also updates the trip count property of the loop to the correct one (n/2).
+class LoopDoubleBufferTransformer : public HloModulePass {
+ public:
+  LoopDoubleBufferTransformer() = default;
+  ~LoopDoubleBufferTransformer() override = default;
+  absl::string_view name() const override {
+    return "loop-double-buffer-transformer";
+  }
+
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+};
+
+}  // end namespace gpu
+}  // end namespace xla
+
+#endif  // XLA_SERVICE_GPU_LOOP_DOUBLE_BUFFER_TRANSFORMER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/matmul_utils.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/matmul_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..78c11c5bccae85e32557e14ad5389de8be2c1252
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/matmul_utils.h
@@ -0,0 +1,275 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_MATMUL_UTILS_H_
+#define XLA_SERVICE_GPU_MATMUL_UTILS_H_
+
+#include <cstdint>
+#include <optional>
+#include <utility>
+#include <vector>
+
+#include "absl/types/span.h"
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/mlir_hlo/lhlo_gpu/IR/lhlo_gpu_ops.h"
+#include "xla/service/gpu/backend_configs.pb.h"
+#include "xla/service/gpu/ir_emission_utils.h"
+#include "xla/shape.h"
+#include "xla/statusor.h"
+#include "xla/stream_executor/blas.h"
+#include "xla/types.h"
+#include "xla/xla_data.pb.h"
+
+#if GOOGLE_CUDA
+#include "xla/stream_executor/cuda/cuda_blas_lt.h"
+#include "xla/stream_executor/scratch_allocator.h"
+
+#elif TENSORFLOW_USE_ROCM
+#include "rocm/rocm_config.h"
+#if TF_HIPBLASLT
+#include "xla/stream_executor/rocm/hip_blas_lt.h"
+#include "xla/stream_executor/scratch_allocator.h"
+#endif  // TF_HIPBLASLT
+#endif  // GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+
+namespace xla {
+namespace gpu {
+
+StatusOr<std::vector<int64_t>> GetNonContractingDims(
+    const Shape& shape, absl::Span<const int64_t> batch_dims,
+    absl::Span<const int64_t> contracting_dims);
+
+// Batch dimensions of an operand of a dot instruction.
+// Just an unified accessor to lhs_batch_dimensions and rhs_batch_dimensions.
+const tsl::protobuf::RepeatedField<int64_t>& BatchDimensionsForOperand(
+    const HloInstruction& dot, int operand_number);
+
+// Index of the only contracting dimension of dot instruction operand.
+int64_t ContractingDimensionIndex(const HloInstruction& dot,
+                                  int operand_number);
+
+// Index of the only non-contracting dimension of dot instruction operand.
+int64_t NonContractingDimensionIndex(const HloInstruction& dot,
+                                     int operand_number);
+
+// Normalize shape to (batch, rows, columns) logical dimensions.
+StatusOr<Shape> GetBatchRowColumnShape(const Shape& shape,
+                                       absl::Span<const int64_t> batch_dims,
+                                       absl::Span<const int64_t> row_dims,
+                                       absl::Span<const int64_t> col_dims);
+
+struct MatrixLayout {
+  enum class Order {
+    kRowMajor,     // Elements in the same row are contiguous in memory.
+    kColumnMajor,  // Elements in the same column are contiguous in memory.
+  };
+
+  // Returns the matrix layout for a logical shape (batch, rows, columns).
+  static StatusOr<MatrixLayout> For(const Shape& shape);
+  // Returns the matrix layout with the given batch, row, col dimensions.
+  static StatusOr<MatrixLayout> For(const Shape& shape,
+                                    absl::Span<const int64_t> batch_dims,
+                                    absl::Span<const int64_t> row_dims,
+                                    absl::Span<const int64_t> col_dims);
+  // Returns the matrix layout for the output.
+  static StatusOr<MatrixLayout> For(const Shape& shape,
+                                    size_t lhs_num_batch_dims,
+                                    size_t lhs_num_row_dims,
+                                    size_t rhs_num_batch_dims,
+                                    size_t rhs_num_col_dims);
+
+  void Transpose();
+
+  PrimitiveType dtype;
+  // `num_rows` / `num_cols` are for the "logical" matrix shape:
+  // i.e. the contracting dim has size `num_cols` for LHS operands and
+  // `num_rows` for RHS operands.
+  int64_t num_rows;
+  int64_t num_cols;
+  Order order;
+  int64_t leading_dim_stride;
+  int64_t batch_size;
+  int64_t batch_stride;  // `batch_stride` is set to `0` when `batch_size == 1`.
+};
+
+// GPU folding rule for the `TransposeFolding` pass.
+StatusOr<bool> CanFoldTransposeOperandIntoDot(const HloInstruction& dot,
+                                              int64_t operand_idx);
+
+struct GemmConfig {
+  static StatusOr<GemmConfig> For(const HloInstruction* gemm);
+  static StatusOr<GemmConfig> For(mlir::lmhlo_gpu::GEMMOp op);
+
+  static StatusOr<GemmConfig> For(
+      const Shape& lhs_shape, absl::Span<const int64_t> lhs_batch_dims,
+      absl::Span<const int64_t> lhs_contracting_dims, const Shape& rhs_shape,
+      absl::Span<const int64_t> rhs_batch_dims,
+      absl::Span<const int64_t> rhs_contracting_dims, const Shape& output_shape,
+      double alpha_real, double alpha_imag, double beta,
+      std::optional<int64_t> algorithm, int64_t compute_precision);
+
+  // As above with additional `c_shape` and `bias_shape_ptr` parameter, both
+  // which are only necessarily for F8 gemms.
+  static StatusOr<GemmConfig> For(
+      const Shape& lhs_shape, absl::Span<const int64_t> lhs_batch_dims,
+      absl::Span<const int64_t> lhs_contracting_dims, const Shape& rhs_shape,
+      absl::Span<const int64_t> rhs_batch_dims,
+      absl::Span<const int64_t> rhs_contracting_dims, const Shape& c_shape,
+      const Shape* bias_shape_ptr, const Shape& output_shape, double alpha_real,
+      double alpha_imag, double beta, std::optional<int64_t> algorithm,
+      int64_t compute_precision);
+
+  template <typename CublasLtMatmulMaybeF8Op,
+            typename = std::enable_if<
+                std::is_same<CublasLtMatmulMaybeF8Op,
+                             mlir::lmhlo_gpu::CublasLtMatmulOp>::value ||
+                std::is_same<CublasLtMatmulMaybeF8Op,
+                             mlir::lmhlo_gpu::CublasLtMatmulF8Op>::value>>
+  static StatusOr<GemmConfig> For(CublasLtMatmulMaybeF8Op op) {
+    mlir::mhlo::DotDimensionNumbersAttr dot_dims = op.getDotDimensionNumbers();
+
+    int64_t compute_precision = 0;  // Default
+    if (op.getPrecisionConfig().has_value()) {
+      auto precision_config = op.getPrecisionConfig();
+      for (auto attr : precision_config.value()) {
+        int64_t value = static_cast<int64_t>(
+            attr.template cast<mlir::mhlo::PrecisionAttr>().getValue());
+        if (value > compute_precision) {
+          compute_precision = value;
+        }
+      }
+    }
+
+    Shape bias_shape;
+    if (op.getBias() != nullptr) {
+      bias_shape = GetShape(op.getBias());
+    }
+    return GemmConfig::For(
+        GetShape(op.getA()), dot_dims.getLhsBatchingDimensions(),
+        dot_dims.getLhsContractingDimensions(), GetShape(op.getB()),
+        dot_dims.getRhsBatchingDimensions(),
+        dot_dims.getRhsContractingDimensions(), GetShape(op.getC()),
+        op.getBias() == nullptr ? nullptr : &bias_shape, GetShape(op.getD()),
+        op.getAlphaReal().convertToDouble(),
+        op.getAlphaImag().convertToDouble(), op.getBeta().convertToDouble(),
+        op.getAlgorithm(), compute_precision);
+  }
+
+  MatrixLayout lhs_layout;
+  MatrixLayout rhs_layout;
+  MatrixLayout c_layout;
+  MatrixLayout output_layout;
+  complex128 alpha;
+  double beta;
+  std::optional<int64_t> algorithm;
+  int64_t compute_precision;
+};
+
+StatusOr<se::blas::ComputationType> GetBlasComputationType(
+    PrimitiveType lhs_dtype, PrimitiveType output_dtype,
+    int64_t compute_precision);
+
+namespace cublas_lt {
+
+// Returns the type for the alpha and beta scalars.
+se::blas::DataType GetScaleType(se::blas::DataType c_type,
+                                se::blas::ComputationType computation_type);
+
+}  // namespace cublas_lt
+
+// Run the given GEMM instruction `gemm` subject to the configuration
+// in `gemm_config` and the passed buffers.
+//
+// If `algorithm` is provided, it overrides the one specified in `config`.
+Status RunGemm(const GemmConfig& config, se::DeviceMemoryBase lhs_buffer,
+               se::DeviceMemoryBase rhs_buffer,
+               se::DeviceMemoryBase output_buffer, bool deterministic_ops,
+               se::Stream* stream,
+               std::optional<se::blas::AlgorithmType> algorithm = std::nullopt,
+               se::blas::ProfileResult* profile_result = nullptr);
+
+namespace cublas_lt {
+
+StatusOr<bool> EpilogueAddsVectorBias(GemmBackendConfig_Epilogue epilogue);
+StatusOr<bool> EpilogueHasAuxiliaryOutput(GemmBackendConfig_Epilogue epilogue);
+
+}  // namespace cublas_lt
+
+StatusOr<se::blas::DataType> AsBlasDataType(PrimitiveType dtype);
+
+#if GOOGLE_CUDA || TF_HIPBLASLT
+
+namespace cublas_lt {
+
+StatusOr<se::gpu::BlasLt::Epilogue> AsBlasLtEpilogue(
+    mlir::lmhlo_gpu::CublasLtMatmulEpilogue epilogue);
+
+class MatmulPlan {
+ public:
+  static StatusOr<MatmulPlan> From(const GemmConfig& config,
+                                   se::gpu::BlasLt::Epilogue epilogue);
+
+  Status ExecuteOnStream(
+      se::Stream* stream, se::DeviceMemoryBase a_buffer,
+      se::DeviceMemoryBase b_buffer, se::DeviceMemoryBase c_buffer,
+      se::DeviceMemoryBase d_buffer,
+      se::DeviceMemoryBase bias_buffer,  // may be null
+      se::DeviceMemoryBase aux_buffer,   // may be null
+      se::DeviceMemoryBase a_scale_buffer, se::DeviceMemoryBase b_scale_buffer,
+      se::DeviceMemoryBase c_scale_buffer, se::DeviceMemoryBase d_scale_buffer,
+      se::DeviceMemoryBase d_amax_buffer,
+      const se::gpu::BlasLt::MatmulAlgorithm& algorithm,
+      se::ScratchAllocator& scratch_allocator,
+      se::blas::ProfileResult* profile_result = nullptr) const;
+
+  StatusOr<std::vector<se::gpu::BlasLt::MatmulAlgorithm>> GetAlgorithms(
+      se::Stream* stream) const;
+
+ private:
+  MatmulPlan(se::gpu::BlasLt::MatmulPlan plan, complex128 alpha, double beta,
+             bool must_swap_operands)
+      : plan_(std::move(plan)),
+        alpha_(alpha),
+        beta_(beta),
+        must_swap_operands_(must_swap_operands) {}
+
+  template <typename Scale, typename A, typename B = A, typename C = A,
+            typename D = A>
+  Status DoMatmul(se::Stream* stream, se::DeviceMemoryBase a_buffer,
+                  se::DeviceMemoryBase b_buffer, se::DeviceMemoryBase c_buffer,
+                  se::DeviceMemoryBase d_buffer,
+                  se::DeviceMemoryBase bias_buffer,  // may be null
+                  se::DeviceMemoryBase aux_buffer,   // may be null
+                  se::DeviceMemoryBase a_scale, se::DeviceMemoryBase b_scale,
+                  se::DeviceMemoryBase c_scale, se::DeviceMemoryBase d_scale,
+                  se::DeviceMemoryBase d_amax,
+                  const se::gpu::BlasLt::MatmulAlgorithm& algorithm,
+                  se::ScratchAllocator& scratch_allocator,
+                  se::blas::ProfileResult* profile_result) const;
+
+  se::gpu::BlasLt::MatmulPlan plan_;
+  complex128 alpha_;
+  double beta_;
+  bool must_swap_operands_;
+};
+
+}  // namespace cublas_lt
+
+#endif  // GOOGLE_CUDA || TF_HIPBLASLT
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_MATMUL_UTILS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/memset_thunk.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/memset_thunk.h
new file mode 100644
index 0000000000000000000000000000000000000000..4529571b0ebca8b4e0b591a27cea7b52e0ed5a04
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/memset_thunk.h
@@ -0,0 +1,88 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_MEMSET_THUNK_H_
+#define XLA_SERVICE_GPU_MEMSET_THUNK_H_
+
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/service/buffer_assignment.h"
+#include "xla/service/gpu/thunk.h"
+#include "xla/status.h"
+#include "xla/stream_executor/stream_executor.h"
+
+// This file contains thunks that set a buffer's elements to a particular value.
+// This can be faster than emitting a kernel to set the elements.
+
+namespace xla {
+namespace gpu {
+
+// Thunk that zeroes out a given chunk of memory.
+class MemzeroThunk : public Thunk {
+ public:
+  explicit MemzeroThunk(ThunkInfo thunk_info,
+                        const BufferAllocation::Slice& dest,
+                        mlir::Value dest_value)
+      : Thunk(Kind::kMemzero, thunk_info),
+        dest_(dest),
+        dest_value_(dest_value) {}
+
+  Status ExecuteOnStream(const ExecuteParams& params) override;
+
+  void ClearCompileTimeInfo() override {
+    Thunk::ClearCompileTimeInfo();
+    dest_value_ = nullptr;
+  }
+
+  const BufferAllocation::Slice& destination() const { return dest_; }
+  mlir::Value dest_value() const { return dest_value_; }
+
+ private:
+  const BufferAllocation::Slice dest_;
+  mlir::Value dest_value_;
+};
+
+// Thunk that sets a given chunk of memory to a particular 32-bit value.  The
+// destination chunk must have size divisible by 32 bits.
+class Memset32BitValueThunk : public Thunk {
+ public:
+  explicit Memset32BitValueThunk(ThunkInfo thunk_info, uint32_t value,
+                                 const BufferAllocation::Slice& dest,
+                                 mlir::Value dest_value)
+      : Thunk(Kind::kMemset32BitValue, thunk_info),
+        value_(value),
+        dest_(dest),
+        dest_value_(dest_value) {}
+
+  Status ExecuteOnStream(const ExecuteParams& params) override;
+
+  void ClearCompileTimeInfo() override {
+    Thunk::ClearCompileTimeInfo();
+    dest_value_ = nullptr;
+  }
+
+  const BufferAllocation::Slice& destination() const { return dest_; }
+  uint32_t value() const { return value_; }
+  mlir::Value dest_value() const { return dest_value_; }
+
+ private:
+  const uint32_t value_;
+  const BufferAllocation::Slice dest_;
+  mlir::Value dest_value_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_MEMSET_THUNK_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/metrics.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/metrics.h
new file mode 100644
index 0000000000000000000000000000000000000000..d660743838a26fcf4097a56399c0c3df0d538a27
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/metrics.h
@@ -0,0 +1,53 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_METRICS_H_
+#define XLA_SERVICE_GPU_METRICS_H_
+
+#include <cstdint>
+
+namespace xla {
+
+// HLO passes (HLO -> HLO).
+void RecordHloPassesDuration(uint64_t time_usecs);
+
+// Compiling HLO to LLVM.
+void RecordHloToLlvmDuration(uint64_t time_usecs);
+
+// The entire LLVM to PTX pipeline, including both LLVM optimization (LLVM ->
+// LLVM) and compiling LLVM -> PTX.
+void RecordLlvmPassesAndLlvmToPtxDuration(uint64_t time_usecs);
+
+// LLVM passes (linking and optimization) only (LLVM -> LLVM).
+void RecordLlvmPassesDuration(uint64_t time_usecs);
+
+// Compiling LLVM to PTX only.
+void RecordLlvmToPtxDuration(uint64_t time_usecs);
+
+// Compiling PTX to cubin.
+void RecordPtxToCubinDuration(uint64_t time_usecs);
+
+// Counts compiled programs numbers.
+void IncrementCompiledProgramsCount();
+
+// Gets compiled programs numbers.
+int64_t GetCompiledProgramsCount();
+
+// Records the size of the XLA device binary in bytes.
+void RecordXlaDeviceBinarySize(int64_t size);
+
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_METRICS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/move_copy_to_users.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/move_copy_to_users.h
new file mode 100644
index 0000000000000000000000000000000000000000..a01d8e97d186f4ab5b3181d310664fda636e8e31
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/move_copy_to_users.h
@@ -0,0 +1,40 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_MOVE_COPY_TO_USERS_H_
+#define XLA_SERVICE_GPU_MOVE_COPY_TO_USERS_H_
+
+#include <utility>
+
+#include "absl/strings/string_view.h"
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/service/hlo_pass_interface.h"
+#include "xla/statusor.h"
+
+namespace xla {
+
+// Sink kCopy operations as far down the graph as possible.
+class MoveCopyToUsers : public HloModulePass {
+ public:
+  absl::string_view name() const override { return "move_copy_to_users"; }
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+};
+
+}  // end namespace xla
+
+#endif  // XLA_SERVICE_GPU_MOVE_COPY_TO_USERS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/multi_output_fusion.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/multi_output_fusion.h
new file mode 100644
index 0000000000000000000000000000000000000000..103694857407ac4d8464a2cda6c20b61f8e28cf3
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/multi_output_fusion.h
@@ -0,0 +1,133 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_MULTI_OUTPUT_FUSION_H_
+#define XLA_SERVICE_GPU_MULTI_OUTPUT_FUSION_H_
+
+#include <memory>
+#include <queue>
+#include <vector>
+
+#include "absl/container/flat_hash_map.h"
+#include "absl/strings/string_view.h"
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/hlo/ir/hlo_reachability.h"
+#include "xla/service/gpu/gpu_fusible.h"
+#include "xla/service/gpu/gpu_hlo_cost_analysis.h"
+#include "xla/service/hlo_pass_interface.h"
+#include "xla/statusor.h"
+#include "xla/stream_executor/device_description.h"
+
+namespace xla {
+namespace gpu {
+
+// Multi-output fusion of sibling and producer-consumer instructions for the
+// GPU backend to reduce memory bandwidth requirements.
+//
+//   0) Before multi-    1) Sibling multi-    2) Producer-consumer
+//      output fusion       output fusion        multi-output fusion
+//
+//          p                    p                    p
+//          |                    |                    |
+//          v                    v                    v
+//          A                    A               +-fusion--+
+//        /   \                  |               |    A    |
+//       |     |            +-fusion--+          |   / \   |
+//       v     v            |   / \   |          |  B   |  |
+//       B     C            |  B   C  |          |  |   |  |
+//        \   /             |  |   |  |          |  v   v  |
+//         v v              |  v   v  |          |  tuple  |
+//        ROOT              |  tuple  |          +---------+
+//                          +---------+            /    \
+//                            /    \            gte_b  gte_a
+//                         gte_b  gte_c           |      |
+//                           |      |             |      v
+//                            \    /              |      C
+//                             v  v                \    /
+//                             ROOT                 v  v
+//                                                  ROOT
+//
+// Multi-output fusion ops have a tuple op at their root containing multiple
+// elements as outputs. GetTupleElement ops (depicted as gte_* above) are
+// inserted to extract tuple elements for consumers.
+//
+// The two different flavors of multi-output fusion this pass performs are
+// depicted above.
+// 1) Fusion of sibling ops reduces memory bandwidth requirements, because
+//    common input parameters have to be read only once.
+// 2) Fusion of producer-consumer ops reduces memory bandwidth requirements by
+//    saving one read from memory. In the example above, B does not need to read
+//    the output of A from memory, while C still does (using gte_a).
+// Note that sibling (1) and producer-consumer (2) multi-output fusion can be
+// combined.
+//
+// The GpuMultiOutputFusion pass modifies the HLO in reverse post-order (defs
+// before uses). First, it attempts to fuse the consumer ops of the current op,
+// which are siblings (1). Hereafter, it attempts to fuse the current op with
+// one of its consumers (2). This order avoids a phase ordering issue (described
+// in go/fusionfusion). It ensures that all GetTupleElement ops inserted as a
+// by-product of multi-output fusion will occur before the current op in the
+// order of traversal, and hence, not get into the way of subsequent fusion
+// attempts.
+//
+// The GpuMultiOutputFusion pass ensures several conditions are met for fusion.
+// Some of them are relevant for correctness. In particular, no cycles must be
+// introduced into the HLO module. Moreover, the code emitters for multi-output
+// fusion must support the combination of ops and their shapes. Other
+// restrictions are rather arbitrary and lifting them could be beneficial.
+// * Sibling fusion (1) requires at least one op to be a kFusion.
+// * Sibling fusion (1) does not fuse kInput fusions with kLoop fusions, i.e.
+//   the fusion kinds must match.
+
+class GpuMultiOutputFusion : public HloModulePass {
+ public:
+  explicit GpuMultiOutputFusion(
+      const se::DeviceDescription& device_info,
+      HloCostAnalysis::ShapeSizeFunction shape_size_function)
+      : device_info_(device_info), shape_size_function_(shape_size_function) {}
+
+  absl::string_view name() const override { return "multi_output_fusion"; }
+
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+
+ private:
+  bool FuseSiblings(HloInstruction* parent, FusionInfoCache* fusion_info_cache,
+                    GpuHloCostAnalysis* cost_analysis);
+
+  StatusOr<bool> DoMultiOutputFusion();
+
+  // Recompute reachability for the current computation.
+  void RecomputeReachability();
+
+  void DumpFusionState(const HloInstruction& consumer, absl::string_view label,
+                       const HloInstruction* producer = nullptr);
+
+  // Computation for the pass.
+  HloComputation* computation_;
+
+  // The reachability map of current computation.
+  std::unique_ptr<HloReachabilityMap> reachability_;
+
+  se::DeviceDescription device_info_;
+  HloCostAnalysis::ShapeSizeFunction shape_size_function_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_MULTI_OUTPUT_FUSION_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/nccl_all_gather_thunk.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/nccl_all_gather_thunk.h
new file mode 100644
index 0000000000000000000000000000000000000000..dfd4e39b4ebb593372b4105df0d9abe76ac0e2f4
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/nccl_all_gather_thunk.h
@@ -0,0 +1,64 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_NCCL_ALL_GATHER_THUNK_H_
+#define XLA_SERVICE_GPU_NCCL_ALL_GATHER_THUNK_H_
+
+#include <vector>
+
+#include "xla/service/collective_ops_utils.h"
+#include "xla/service/gpu/nccl_collective_thunk.h"
+
+namespace xla {
+namespace gpu {
+
+struct NcclAllGatherConfig {
+  NcclCollectiveConfig config;
+};
+
+// Thunk that performs a NCCL-based All-Gather among CUDA GPU-based replicas.
+class NcclAllGatherStartThunk : public NcclCollectiveThunk {
+ public:
+  NcclAllGatherStartThunk(ThunkInfo thunk_info,
+                          mlir::lmhlo_gpu::AllGatherStartOp op,
+                          std::vector<Buffer> buffers);
+
+  static const char* GetHloOpName() { return "all-gather-start"; }
+
+  static Status CheckImplementable(mlir::lmhlo_gpu::AllGatherStartOp op,
+                                   int64_t replica_count,
+                                   int64_t partition_count);
+  static bool IsDegenerate(mlir::lmhlo_gpu::AllGatherStartOp op,
+                           int64_t replica_count, int64_t partition_count);
+  static CollectiveOpGroupMode GetGroupMode(
+      mlir::lmhlo_gpu::AllGatherStartOp op);
+
+ protected:
+  const NcclCollectiveConfig& config() const override { return config_.config; }
+  Status RunNcclCollective(const ExecuteParams& params, se::Stream& stream,
+                           ncclComm_t comm) override;
+
+ private:
+  const NcclAllGatherConfig config_;
+  const std::vector<Buffer> buffers_;
+};
+
+Status RunAllGather(std::vector<DeviceBufferPair>& buffers, se::Stream& stream,
+                    ncclComm_t comm);
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_NCCL_ALL_GATHER_THUNK_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/nccl_all_reduce_thunk.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/nccl_all_reduce_thunk.h
new file mode 100644
index 0000000000000000000000000000000000000000..b70e7dc317f15625810bb6620be4fb365c5ca158
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/nccl_all_reduce_thunk.h
@@ -0,0 +1,115 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_NCCL_ALL_REDUCE_THUNK_H_
+#define XLA_SERVICE_GPU_NCCL_ALL_REDUCE_THUNK_H_
+
+#include <optional>
+#include <vector>
+
+#include "xla/mlir_hlo/lhlo_gpu/IR/lhlo_gpu_ops.h"
+#include "xla/service/collective_ops_utils.h"
+#include "xla/service/gpu/nccl_collective_thunk.h"
+
+namespace xla {
+namespace gpu {
+
+struct NcclAllReduceConfig {
+  NcclCollectiveConfig config;
+  ReductionKind reduction_kind;
+};
+
+// Thunk that performs a NCCL-based All-Reduce or Reduce-Scatter among CUDA
+// GPU-based replicas.
+class NcclAllReduceReduceScatterThunkBase : public NcclCollectiveThunk {
+ public:
+  static std::optional<ReductionKind> MatchAllReduceComputation(
+      mlir::Region& computation);
+
+  NcclAllReduceReduceScatterThunkBase(Kind kind, ThunkInfo thunk_info,
+                                      NcclAllReduceConfig config,
+                                      std::vector<Buffer> buffers,
+                                      bool is_sync);
+
+ protected:
+  const NcclCollectiveConfig& config() const override { return config_.config; }
+
+  const NcclAllReduceConfig config_;
+  const std::vector<Buffer> buffers_;
+};
+
+// -----------------------------------------------------------------------------
+// AllReduce thunk.
+// -----------------------------------------------------------------------------
+
+class NcclAllReduceStartThunk : public NcclAllReduceReduceScatterThunkBase {
+ public:
+  NcclAllReduceStartThunk(ThunkInfo thunk_info,
+                          mlir::lmhlo_gpu::AllReduceStartOp op,
+                          std::vector<Buffer> buffers);
+
+  static const char* GetHloOpName() { return "all-reduce-start"; }
+
+  static Status CheckImplementable(mlir::lmhlo_gpu::AllReduceStartOp op,
+                                   int64_t replica_count,
+                                   int64_t partition_count);
+  static bool IsDegenerate(mlir::lmhlo_gpu::AllReduceStartOp op,
+                           int64_t replica_count, int64_t partition_count);
+  static CollectiveOpGroupMode GetGroupMode(
+      mlir::lmhlo_gpu::AllReduceStartOp op);
+
+ protected:
+  Status RunNcclCollective(const ExecuteParams& params, se::Stream& stream,
+                           ncclComm_t comm) override;
+};
+
+// -----------------------------------------------------------------------------
+// ReduceScatter thunk
+// -----------------------------------------------------------------------------
+class NcclReduceScatterStartThunk : public NcclAllReduceReduceScatterThunkBase {
+ public:
+  NcclReduceScatterStartThunk(ThunkInfo thunk_info,
+                              mlir::lmhlo_gpu::ReduceScatterStartOp op,
+                              std::vector<Buffer> buffers);
+
+  static const char* GetHloOpName() { return "reduce-scatter-start"; }
+
+  static Status CheckImplementable(mlir::lmhlo_gpu::ReduceScatterStartOp op,
+                                   int64_t replica_count,
+                                   int64_t partition_count);
+  static bool IsDegenerate(mlir::lmhlo_gpu::ReduceScatterStartOp op,
+                           int64_t replica_count, int64_t partition_count);
+  static CollectiveOpGroupMode GetGroupMode(
+      mlir::lmhlo_gpu::ReduceScatterStartOp op);
+
+ protected:
+  Status RunNcclCollective(const ExecuteParams& params, se::Stream& stream,
+                           ncclComm_t comm) override;
+};
+
+// -----------------------------------------------------------------------------
+
+Status RunAllReduce(ReductionKind reduction_kind,
+                    std::vector<DeviceBufferPair>& buffers, se::Stream& stream,
+                    ncclComm_t comm);
+
+Status RunReduceScatter(ReductionKind reduction_kind,
+                        std::vector<DeviceBufferPair>& buffers,
+                        se::Stream& stream, ncclComm_t comm);
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_NCCL_ALL_REDUCE_THUNK_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/nccl_all_to_all_thunk.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/nccl_all_to_all_thunk.h
new file mode 100644
index 0000000000000000000000000000000000000000..e6e60c5d0fb65e37316afce98291a0a8e9e255b2
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/nccl_all_to_all_thunk.h
@@ -0,0 +1,68 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_NCCL_ALL_TO_ALL_THUNK_H_
+#define XLA_SERVICE_GPU_NCCL_ALL_TO_ALL_THUNK_H_
+
+#include <vector>
+
+#include "xla/service/collective_ops_utils.h"
+#include "xla/service/gpu/nccl_collective_thunk.h"
+
+namespace xla {
+namespace gpu {
+
+struct NcclAllToAllConfig {
+  NcclCollectiveConfig config;
+  bool has_split_dimension;
+};
+
+// Thunk that performs a NCCL-based All-to-All among CUDA GPU-based replicas.
+class NcclAllToAllStartThunk : public NcclCollectiveThunk {
+ public:
+  NcclAllToAllStartThunk(ThunkInfo thunk_info,
+                         mlir::lmhlo_gpu::AllToAllStartOp op,
+                         std::vector<Buffer> buffers);
+
+  // Returns whether the given instruction can be lowered to a nccl all-to-all
+  // call.
+  static Status CheckImplementable(mlir::lmhlo_gpu::AllToAllStartOp op,
+                                   int64_t replica_count,
+                                   int64_t partition_count);
+
+  static const char* GetHloOpName() { return "all-to-all-start"; }
+  static bool IsDegenerate(mlir::lmhlo_gpu::AllToAllStartOp op,
+                           int64_t replica_count, int64_t partition_count);
+  static CollectiveOpGroupMode GetGroupMode(
+      mlir::lmhlo_gpu::AllToAllStartOp op);
+
+ protected:
+  const NcclCollectiveConfig& config() const override { return config_.config; }
+  Status RunNcclCollective(const ExecuteParams& params, se::Stream& stream,
+                           ncclComm_t comm) override;
+
+ private:
+  const NcclAllToAllConfig config_;
+  const std::vector<Buffer> buffers_;
+};
+
+Status RunAllToAll(bool has_split_dimension,
+                   std::vector<DeviceBufferPair>& buffers, se::Stream& stream,
+                   ncclComm_t comm);
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_NCCL_ALL_TO_ALL_THUNK_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/nccl_collective_permute_thunk.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/nccl_collective_permute_thunk.h
new file mode 100644
index 0000000000000000000000000000000000000000..8f2a675e782c2b827e02e495bf4c1d150000f26b
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/nccl_collective_permute_thunk.h
@@ -0,0 +1,70 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_NCCL_COLLECTIVE_PERMUTE_THUNK_H_
+#define XLA_SERVICE_GPU_NCCL_COLLECTIVE_PERMUTE_THUNK_H_
+
+#include <cstdint>
+
+#include "xla/service/collective_ops_utils.h"
+#include "xla/service/gpu/nccl_collective_thunk.h"
+#include "xla/service/gpu/nccl_p2p_thunk_common.h"
+
+namespace xla {
+namespace gpu {
+
+// Thunk that performs a NCCL-based collective permute.
+class NcclCollectivePermuteStartThunk : public NcclCollectiveThunk {
+ public:
+  static NcclP2PConfig GetNcclP2PConfig(
+      mlir::lmhlo_gpu::CollectivePermuteStartOp op, int64_t replica_count,
+      int64_t partition_count);
+
+  static Status CheckImplementable(mlir::lmhlo_gpu::CollectivePermuteStartOp op,
+                                   int64_t replica_count,
+                                   int64_t partition_count);
+
+  static bool IsDegenerate(mlir::lmhlo_gpu::CollectivePermuteStartOp op,
+                           int64_t replica_count, int64_t partition_count);
+  static CollectiveOpGroupMode GetGroupMode(
+      mlir::lmhlo_gpu::CollectivePermuteStartOp op);
+
+  static const char* GetHloOpName() { return "collective-permute-start"; }
+
+  NcclCollectivePermuteStartThunk(ThunkInfo thunk_info,
+                                  mlir::lmhlo_gpu::CollectivePermuteStartOp op,
+                                  int64_t replica_count,
+                                  int64_t partition_count,
+                                  const Buffer& buffer);
+
+ protected:
+  const NcclCollectiveConfig& config() const override { return config_.config; }
+  Status RunNcclCollective(const ExecuteParams& params, se::Stream& stream,
+                           ncclComm_t comm) override;
+
+ private:
+  const NcclP2PConfig config_;
+  const Buffer buffer_;
+};
+
+Status RunCollectivePermute(NcclP2PConfig::SourceTargetMapEntry source_target,
+                            DeviceBufferPair& buffer, se::Stream& stream,
+                            ncclComm_t comm, absl::string_view device_string,
+                            int64_t current_id);
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_NCCL_COLLECTIVE_PERMUTE_THUNK_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/nccl_collective_thunk.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/nccl_collective_thunk.h
new file mode 100644
index 0000000000000000000000000000000000000000..a4b5c1ec5041436519a739427f36f3c4089985e6
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/nccl_collective_thunk.h
@@ -0,0 +1,216 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_NCCL_COLLECTIVE_THUNK_H_
+#define XLA_SERVICE_GPU_NCCL_COLLECTIVE_THUNK_H_
+
+#include <memory>
+#include <optional>
+#include <string>
+#include <vector>
+
+#include "absl/functional/function_ref.h"
+#include "mlir/IR/BuiltinOps.h"  // from @llvm-project
+#include "xla/service/collective_ops_utils.h"
+#include "xla/service/gpu/ir_emission_utils.h"
+#include "xla/service/gpu/thunk.h"
+#include "xla/service/llvm_ir/llvm_util.h"
+#include "xla/translate/mhlo_to_hlo/attribute_exporter.h"
+#include "xla/xla_data.pb.h"
+
+#if XLA_ENABLE_XCCL
+#include "xla/service/gpu/nccl_utils.h"
+#endif  // XLA_ENABLE_XCCL
+
+struct ncclComm;
+using ncclComm_t = ncclComm*;
+
+namespace xla {
+namespace gpu {
+
+class NcclClique;
+
+struct NcclCollectiveConfig {
+  NcclCollectiveConfig();
+  NcclCollectiveConfig(NcclCollectiveConfig&&);
+  ~NcclCollectiveConfig();
+
+  NcclCollectiveConfig& operator=(NcclCollectiveConfig&&);
+
+  int64_t operand_count;
+  std::vector<PrimitiveType> operand_element_type;
+  std::vector<ReplicaGroup> replica_groups;
+  RendezvousKey::CollectiveOpKind collective_op_kind;
+  int64_t op_id;
+  CollectiveOpGroupMode group_mode;
+
+  template <typename OpT>
+  void SetCollectiveOpKindAndID(OpT op);
+  bool IsDegenerate(int64_t replica_count, int64_t partition_count) const;
+};
+
+template <typename OpT>
+void NcclCollectiveConfig::SetCollectiveOpKindAndID(OpT op) {
+  if (op.getChannelId()) {
+    collective_op_kind = RendezvousKey::kCrossModule;
+    op_id = static_cast<int64_t>(op.getChannelId()->getHandle());
+  } else {
+    collective_op_kind = RendezvousKey::kCrossReplica;
+    mlir::ModuleOp parent = op->template getParentOfType<mlir::ModuleOp>();
+    mlir::IntegerAttr unique_id =
+        parent->getAttrOfType<mlir::IntegerAttr>("hlo.unique_id");
+    op_id = static_cast<int64_t>(unique_id.getInt());
+  }
+}
+
+template <typename OpT>
+NcclCollectiveConfig GetNcclCollectiveConfigForMlir(
+    OpT op, std::optional<bool> use_global_device_ids) {
+  NcclCollectiveConfig config;
+  config.operand_count = op.getInputs().size();
+  config.operand_element_type.reserve(config.operand_count);
+  for (int i = 0; i < config.operand_count; i++) {
+    const Shape shape = GetShape(op.getInputs()[i]);
+    config.operand_element_type.push_back(shape.element_type());
+  }
+  config.replica_groups = ConvertReplicaGroups(op.getReplicaGroups()).value();
+  config.SetCollectiveOpKindAndID(op);
+  config.group_mode = GetCollectiveOpGroupMode(op.getChannelId().has_value(),
+                                               use_global_device_ids)
+                          .value();
+  return config;
+}
+
+// Thunk base class for NCCL collective operations.
+class NcclCollectiveThunk : public Thunk {
+ public:
+  NcclCollectiveThunk(Kind kind, ThunkInfo thunk_info, bool is_sync);
+
+  struct Buffer {
+    int64_t element_count;
+    BufferAllocation::Slice source_buffer;
+    BufferAllocation::Slice destination_buffer;
+    mlir::Value source_value;
+    mlir::Value destination_value;
+  };
+
+  class AsyncExecutor {
+   public:
+    // Executes the function on the async communications stream and records a
+    // completion event.
+    Status Execute(
+        absl::FunctionRef<Status(const ExecuteParams&, se::Stream&, ncclComm_t)>
+            fn,
+        const ExecuteParams& params, ncclComm_t comm,
+        AsyncStreamKind stream_kind);
+    // Blocks the compute stream until async communication is complete.
+    Status Await(const ExecuteParams& params);
+
+   private:
+    absl::Mutex mu_;
+    // Store done events (by device ordinal) for the done thunk to wait on.
+    absl::flat_hash_map<int, se::Event> done_events_ ABSL_GUARDED_BY(mu_);
+  };
+
+  // Returns whether NCCL operations appear possible to perform; e.g. if we
+  // haven't done a build with the CUDA compiler enabled, we can't compile the
+  // NCCL header, and thus this will be false.
+  //
+  // When this is false, the ExecuteOnStream() call will simply return a status
+  // error.
+  static bool NcclIsEnabled();
+  static Status CheckImplementable();
+
+  // Logging support.
+  static std::string GetDeviceString(const NcclExecuteParams& params);
+
+  AsyncExecutor* async_executor() { return async_.get(); }
+  Status ExecuteOnStream(const ExecuteParams& params) override;
+
+ protected:
+  virtual Status RunNcclCollective(const ExecuteParams& params,
+                                   se::Stream& stream, ncclComm_t comm) = 0;
+  virtual const NcclCollectiveConfig& config() const = 0;
+  virtual AsyncStreamKind GetAsyncStreamKind() const {
+    return kAsyncStreamCollective;
+  }
+
+ private:
+  bool IsAsync() const { return async_ != nullptr; }
+  int64_t GetStreamId() const {
+    return xla::gpu::GetStreamId(IsAsync(), GetAsyncStreamKind());
+  }
+
+#if XLA_ENABLE_XCCL
+  bool first_call_to_execute_ = true;
+#endif  // XLA_ENABLE_XCCL
+  std::unique_ptr<AsyncExecutor> async_;  // null if not async.
+};
+
+class NcclCollectiveDoneThunk : public Thunk {
+ public:
+  NcclCollectiveDoneThunk(Thunk::Kind kind, ThunkInfo thunk_info,
+                          NcclCollectiveThunk::AsyncExecutor& async);
+
+  Status ExecuteOnStream(const ExecuteParams& params) override;
+
+ private:
+  NcclCollectiveThunk::AsyncExecutor& async_;
+};
+
+Status IsValidOperand(mlir::Value operand, Thunk::Kind reduction_op);
+
+template <typename NcclThunkType, typename OpT>
+Status AddOpDescription(Status status, OpT op, int64_t replica_count,
+                        int64_t partition_count) {
+  if (status.ok()) {
+    return status;
+  }
+  CollectiveOpGroupMode group_mode = NcclThunkType::GetGroupMode(op);
+  return Status(
+      status.code(),
+      absl::StrFormat(
+          "%s\n"
+          "%s with replica_count: %d, partition_count: %d, group_mode: %s, "
+          "operand_count: %d\n%s",
+          status.message(), NcclThunkType::GetHloOpName(), replica_count,
+          partition_count, CollectiveOpGroupModeToString(group_mode),
+          op->getNumOperands() / 2, llvm_ir::DumpToString(op.getOperation())));
+}
+
+#if XLA_ENABLE_XCCL
+// TODO(hanbinyoon): Consider moving to nccl_utils.h when deprecating Thunks.
+StatusOr<NcclComm::Lock> LockNcclComm(
+    const NcclExecuteParams& params,
+    const std::vector<ReplicaGroup>& replica_groups,
+    CollectiveOpGroupMode group_mode, int64_t op_id, int64_t stream_id,
+    bool enable_clique_optimization);
+#endif  // XLA_ENABLE_XCCL
+
+struct DeviceBufferPair {
+  PrimitiveType element_type;
+  int64_t element_count;
+  se::DeviceMemoryBase source_buffer;
+  se::DeviceMemoryBase destination_buffer;
+};
+StatusOr<std::vector<DeviceBufferPair>> ConvertToDeviceBuffers(
+    const Thunk::ExecuteParams& params,
+    const std::vector<NcclCollectiveThunk::Buffer>& buffers,
+    const std::vector<PrimitiveType>& element_types);
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_NCCL_COLLECTIVE_THUNK_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/nccl_p2p_thunk_common.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/nccl_p2p_thunk_common.h
new file mode 100644
index 0000000000000000000000000000000000000000..25814402491fc0c29f1eb89f85cf71faac840bda
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/nccl_p2p_thunk_common.h
@@ -0,0 +1,136 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_NCCL_P2P_THUNK_COMMON_H_
+#define XLA_SERVICE_GPU_NCCL_P2P_THUNK_COMMON_H_
+
+#include <cstdint>
+#include <optional>
+#include <utility>
+#include <vector>
+
+#include "absl/container/flat_hash_map.h"
+#include "mlir/IR/BuiltinAttributes.h"  // from @llvm-project
+#include "xla/service/collective_ops_utils.h"
+#include "xla/service/gpu/nccl_collective_thunk.h"
+
+namespace xla {
+namespace gpu {
+
+// Records the information for implementing CollectivePermute, Send and Recv.
+struct NcclP2PConfig {
+  // Record the target ID for sending a data and the source ID from which to
+  // receive a data. Either target or source can be optional.
+  struct SourceTargetMapEntry {
+    std::optional<int64_t> source;
+    std::optional<int64_t> target;
+  };
+
+  using IdToSourceTargetMap =
+      absl::flat_hash_map<int64_t, SourceTargetMapEntry>;
+
+  // Returns the source and target ID corresponding to the given ID (these IDs
+  // are replica_ids for cross replica permute or partition_ids for cross
+  // partition permute). The source ID is the id which will send data to this
+  // ID and the target ID is the id to which this ID will send its data. Either
+  // can be optional.
+  static SourceTargetMapEntry GetSourceTarget(
+      const IdToSourceTargetMap& id_to_source_target, int64_t id) {
+    auto it = id_to_source_target.find(id);
+    if (it != id_to_source_target.end()) return it->second;
+    return SourceTargetMapEntry{};
+  }
+
+  NcclCollectiveConfig config;
+  IdToSourceTargetMap id_to_source_target;
+};
+
+// Extracts source/target pairs for send/recv from frontend attributes.
+StatusOr<std::vector<std::pair<int64_t, int64_t>>> GetSourceTargetPairs(
+    mlir::DictionaryAttr frontend_attributes);
+
+// Returns the GroupMode for Send and Recv.
+template <typename OpT>
+std::enable_if_t<std::is_same_v<OpT, mlir::lmhlo::SendOp> ||
+                     std::is_same_v<OpT, mlir::lmhlo::RecvOp>,
+                 CollectiveOpGroupMode>
+GetGroupModeForSendRecv(OpT op) {
+  return GetCollectiveOpGroupMode(op.getChannelHandle().getHandle() > 1,
+                                  std::nullopt)
+      .value();
+}
+
+// Constructs the NcclP2PConfig for Send and Recv.
+template <typename OpT>
+std::enable_if_t<std::is_same_v<OpT, mlir::lmhlo::SendOp> ||
+                     std::is_same_v<OpT, mlir::lmhlo::RecvOp>,
+                 NcclP2PConfig>
+GetNcclP2PConfigForSendRecv(OpT op, int64_t replica_count,
+                            int64_t partition_count) {
+  NcclP2PConfig p2p_config;
+  auto& config = p2p_config.config;
+
+  config.operand_count = 1;
+  const Shape shape = GetShape(op.getOperand(0));
+  config.operand_element_type.push_back(shape.element_type());
+
+  const int64_t channel_id = op.getChannelHandle().getHandle();
+  config.group_mode = GetGroupModeForSendRecv(op);
+  // Emulate SetCollectiveOpKindAndID.
+  // Send and Recv ops have a non-optional channel id while collective-permute
+  // has an optional channel id. We use 0 to encode the send/recv transformed
+  // from collective-permute without a channel id.
+  if (channel_id >= 1) {
+    config.collective_op_kind = RendezvousKey::kCrossModule;
+    config.op_id = channel_id;
+  } else {
+    config.collective_op_kind = RendezvousKey::kCrossReplica;
+    mlir::ModuleOp parent = op->template getParentOfType<mlir::ModuleOp>();
+    mlir::IntegerAttr unique_id =
+        parent->getAttrOfType<mlir::IntegerAttr>("hlo.unique_id");
+    config.op_id = static_cast<int64_t>(unique_id.getInt());
+  }
+
+  // All execution instances of a send/recv together form a replica group.
+  const int64_t num_participants =
+      config.group_mode == CollectiveOpGroupMode::kCrossReplica
+          ? replica_count
+          : partition_count;
+  config.replica_groups.emplace_back();
+  ReplicaGroup& replica_group = config.replica_groups.front();
+  for (int i = 0; i < num_participants; ++i) {
+    replica_group.add_replica_ids(i);
+  }
+
+  auto source_target_pairs = GetSourceTargetPairs(op.getFrontendAttributes());
+  TF_CHECK_OK(source_target_pairs.status());
+  for (const std::pair<int64_t, int64_t>& source_target :
+       *source_target_pairs) {
+    int64_t source = source_target.first;
+    int64_t target = source_target.second;
+
+    p2p_config.id_to_source_target.insert({target, {}}).first->second.source =
+        source;
+    p2p_config.id_to_source_target.insert({source, {}}).first->second.target =
+        target;
+  }
+
+  return p2p_config;
+}
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_NCCL_P2P_THUNK_COMMON_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/nccl_recv_thunk.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/nccl_recv_thunk.h
new file mode 100644
index 0000000000000000000000000000000000000000..d8dbc22f9822926a6dd3b34ef9ea83f4e8b08d42
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/nccl_recv_thunk.h
@@ -0,0 +1,66 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_NCCL_RECV_THUNK_H_
+#define XLA_SERVICE_GPU_NCCL_RECV_THUNK_H_
+
+#include <cstdint>
+
+#include "xla/service/collective_ops_utils.h"
+#include "xla/service/gpu/nccl_collective_thunk.h"
+#include "xla/service/gpu/nccl_p2p_thunk_common.h"
+
+namespace xla {
+namespace gpu {
+
+// Thunk that performs a NCCL-recv.
+class NcclRecvThunk : public NcclCollectiveThunk {
+ public:
+  static NcclP2PConfig GetNcclP2PConfig(mlir::lmhlo::RecvOp,
+                                        int64_t replica_count,
+                                        int64_t partition_count);
+
+  static Status CheckImplementable(mlir::lmhlo::RecvOp op,
+                                   int64_t replica_count,
+                                   int64_t partition_count);
+
+  static CollectiveOpGroupMode GetGroupMode(mlir::lmhlo::RecvOp op);
+  static const char* GetHloOpName() { return "recv"; }
+
+  NcclRecvThunk(ThunkInfo thunk_info, mlir::lmhlo::RecvOp op,
+                int64_t replica_count, int64_t partition_count,
+                const Buffer& buffer);
+
+ protected:
+  const NcclCollectiveConfig& config() const override { return config_.config; }
+  Status RunNcclCollective(const ExecuteParams& params, se::Stream& stream,
+                           ncclComm_t comm) override;
+  AsyncStreamKind GetAsyncStreamKind() const override {
+    return kAsyncStreamP2P;
+  }
+
+ private:
+  const NcclP2PConfig config_;
+  const Buffer buffer_;
+};
+
+Status RunRecv(NcclP2PConfig::SourceTargetMapEntry source_target,
+               DeviceBufferPair& buffer, se::Stream& stream, ncclComm_t comm,
+               absl::string_view device_string, int64_t current_id);
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_NCCL_RECV_THUNK_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/nccl_send_thunk.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/nccl_send_thunk.h
new file mode 100644
index 0000000000000000000000000000000000000000..b57b1ee3279d70ce78b65c26c0a7f71a237c9c85
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/nccl_send_thunk.h
@@ -0,0 +1,65 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_NCCL_SEND_THUNK_H_
+#define XLA_SERVICE_GPU_NCCL_SEND_THUNK_H_
+
+#include <cstdint>
+
+#include "xla/service/collective_ops_utils.h"
+#include "xla/service/gpu/nccl_collective_thunk.h"
+#include "xla/service/gpu/nccl_p2p_thunk_common.h"
+
+namespace xla {
+namespace gpu {
+
+// Thunk that performs a NCCL-send.
+class NcclSendThunk : public NcclCollectiveThunk {
+ public:
+  static NcclP2PConfig GetNcclP2PConfig(mlir::lmhlo::SendOp,
+                                        int64_t replica_count,
+                                        int64_t partition_count);
+
+  static Status CheckImplementable(mlir::lmhlo::SendOp op,
+                                   int64_t replica_count,
+                                   int64_t partition_count);
+  static CollectiveOpGroupMode GetGroupMode(mlir::lmhlo::SendOp op);
+  static const char* GetHloOpName() { return "send"; }
+
+  NcclSendThunk(ThunkInfo thunk_info, mlir::lmhlo::SendOp op,
+                int64_t replica_count, int64_t partition_count,
+                const Buffer& buffer);
+
+ protected:
+  const NcclCollectiveConfig& config() const override { return config_.config; }
+  Status RunNcclCollective(const ExecuteParams& params, se::Stream& stream,
+                           ncclComm_t comm) override;
+  AsyncStreamKind GetAsyncStreamKind() const override {
+    return kAsyncStreamP2P;
+  }
+
+ private:
+  const NcclP2PConfig config_;
+  const Buffer buffer_;
+};
+
+Status RunSend(NcclP2PConfig::SourceTargetMapEntry source_target,
+               DeviceBufferPair& buffer, se::Stream& stream, ncclComm_t comm,
+               absl::string_view device_string, int64_t current_id);
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_NCCL_SEND_THUNK_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/nccl_utils.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/nccl_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..1d8c9571a81d890a62507aa47d2340293c337e4e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/nccl_utils.h
@@ -0,0 +1,138 @@
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_NCCL_UTILS_H_
+#define XLA_SERVICE_GPU_NCCL_UTILS_H_
+
+#if TENSORFLOW_USE_ROCM
+#define __HIP_DISABLE_CPP_FUNCTIONS__
+#endif
+
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include "absl/synchronization/mutex.h"
+#include "xla/service/collective_ops_utils.h"
+#include "xla/service/gpu/gpu_executable_run_options.h"
+#include "xla/service/gpu/thunk.h"
+#include "xla/status.h"
+#include "xla/statusor.h"
+#include "xla/xla_data.pb.h"
+
+// Common place for all collective thunks to include nccl/rccl headers.
+#if TENSORFLOW_USE_ROCM
+#include "rocm/rocm_config.h"
+#if (TF_ROCM_VERSION >= 50200)
+#include "rocm/include/rccl/rccl.h"
+#else
+#include "rocm/include/rccl.h"
+#endif
+#else
+#include "third_party/nccl/nccl.h"
+#endif
+
+namespace xla {
+namespace gpu {
+
+ncclRedOp_t ToNcclReduction(ReductionKind kind);
+StatusOr<std::pair<ncclDataType_t, int>> ToNcclDataTypeAndCountMultiplier(
+    PrimitiveType element_type, Thunk::Kind reduction_op);
+
+bool IsGlobalNcclConfig();
+
+Status ToStatus(ncclResult_t s, const char* file, int64_t line,
+                const char* expr);
+
+// Macros to return or warn on CUDA/NCCL errors.  (The same macro works for both
+// NCCL and CUDA errors.)
+//
+// It's tempting to say these macros belong in an XLA header somewhere, but in
+// practice we don't do much direct-to-CUDA-API stuff outside of this file.
+#define XLA_CUDA_STATUS(expr) \
+  xla::gpu::ToStatus(expr, __FILE__, __LINE__, #expr)
+
+#define XLA_CUDA_RETURN_IF_ERROR(expr) \
+  do {                                 \
+    Status s = XLA_CUDA_STATUS(expr);  \
+    if (!s.ok()) {                     \
+      return s;                        \
+    }                                  \
+  } while (0)
+
+#define XLA_CUDA_WARN_IF_ERROR(expr)  \
+  do {                                \
+    Status s = XLA_CUDA_STATUS(expr); \
+    if (!s.ok()) {                    \
+      LOG(ERROR) << s.ToString();     \
+    }                                 \
+  } while (0)
+
+size_t GetNumLocalParticipants(
+    const std::vector<GlobalDeviceId>& participants,
+    const std::vector<GlobalDeviceId>* local_devices);  // may be null
+
+StatusOr<const NcclUniqueIdCallback*> GetNcclUniqueIdCallback(
+    const NcclUniqueIdCallback* unique_id_callback,  // may be null
+    bool is_local);
+
+// Represents a type that requires mutually exclusive access.
+template <typename T>
+class Lockable {
+ public:
+  // RAII type that will release the exclusive lock when it is destroyed.
+  using Lock = std::unique_ptr<T, std::function<void(T*)>>;
+
+  Lockable() = default;
+  explicit Lockable(T value) : value_(std::move(value)) {}
+  Lockable(const Lockable&) = delete;
+  Lockable(Lockable&&) = delete;
+  Lockable& operator=(const Lockable&) = delete;
+  Lockable& operator=(Lockable&&) = delete;
+
+  Lock Acquire() {
+    absl::MutexLock lock(&mutex_);
+    mutex_.Await(absl::Condition(&is_unlocked_));
+    is_unlocked_ = false;
+
+    return {&value_, [this](T*) {
+              absl::MutexLock lock(&mutex_);
+              CHECK(!is_unlocked_);
+              is_unlocked_ = true;
+            }};
+  }
+
+ private:
+  T value_;
+  absl::Mutex mutex_;
+  bool is_unlocked_ ABSL_GUARDED_BY(mutex_) = true;
+};
+
+TSL_LIB_GTL_DEFINE_INT_TYPE(OpId, int64_t);
+
+struct NcclComm : public Lockable<ncclComm_t> {
+  explicit NcclComm(ncclComm_t comm) : Lockable(comm) {}
+};
+
+StatusOr<NcclComm::Lock> AcquireNcclComm(
+    RunId run_id, OpId op_id, std::vector<GlobalDeviceId> participants,
+    size_t num_local_participants,
+    const NcclUniqueIdCallback& unique_id_callback, int rank, int64_t stream_id,
+    bool enable_clique_optimization);
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_NCCL_UTILS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/non_atomically_upgradeable_rw_lock.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/non_atomically_upgradeable_rw_lock.h
new file mode 100644
index 0000000000000000000000000000000000000000..ea09016bd6f30b7047e0f90198a10a23177e5321
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/non_atomically_upgradeable_rw_lock.h
@@ -0,0 +1,95 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_NON_ATOMICALLY_UPGRADEABLE_RW_LOCK_H_
+#define XLA_SERVICE_GPU_NON_ATOMICALLY_UPGRADEABLE_RW_LOCK_H_
+
+#include <memory>
+#include <variant>
+
+#include "absl/synchronization/mutex.h"
+
+namespace xla {
+namespace gpu {
+
+// Augments absl::ReaderMutexLock with a poor man's upgrade/downgrade pair using
+// RAII. Instead of a true upgrade (or downgrade), we simply drop the read
+// (write) lock and then reacquire it as a write (read) lock.
+class ABSL_SCOPED_LOCKABLE NonAtomicallyUpgradeableRWLock {
+ public:
+  explicit NonAtomicallyUpgradeableRWLock(absl::Mutex* mu)
+      ABSL_SHARED_LOCK_FUNCTION(mu)
+      : mu_(mu), is_reader_(true) {
+    mu_->ReaderLock();
+  }
+
+  NonAtomicallyUpgradeableRWLock(const NonAtomicallyUpgradeableRWLock&) =
+      delete;
+  NonAtomicallyUpgradeableRWLock(NonAtomicallyUpgradeableRWLock&&) = delete;
+  NonAtomicallyUpgradeableRWLock& operator=(
+      const NonAtomicallyUpgradeableRWLock&) = delete;
+  NonAtomicallyUpgradeableRWLock& operator=(NonAtomicallyUpgradeableRWLock&&) =
+      delete;
+
+  ~NonAtomicallyUpgradeableRWLock() ABSL_UNLOCK_FUNCTION() {
+    if (is_reader_) {
+      mu_->ReaderUnlock();
+    } else {
+      mu_->WriterUnlock();
+    }
+  }
+
+  // Upgrade and downgrade the reader lock via RAII.
+  class ABSL_SCOPED_LOCKABLE WriterLock {
+   public:
+    explicit WriterLock(NonAtomicallyUpgradeableRWLock* parent)
+        ABSL_EXCLUSIVE_LOCK_FUNCTION(parent->mu_)
+        : parent_(parent) {
+      assert(parent_->is_reader_);
+      parent_->mu_->ReaderUnlock();
+      parent_->mu_->WriterLock();
+      parent_->is_reader_ = false;
+    }
+
+    WriterLock(const WriterLock&) = delete;
+    WriterLock(WriterLock&&) = delete;
+    WriterLock& operator=(const WriterLock&) = delete;
+    WriterLock& operator=(WriterLock&&) = delete;
+
+    ~WriterLock() ABSL_UNLOCK_FUNCTION() {
+      parent_->mu_->WriterUnlock();
+      parent_->mu_->ReaderLock();
+      parent_->is_reader_ = true;
+    }
+
+   private:
+    NonAtomicallyUpgradeableRWLock* parent_;
+  };
+
+  // Update the reader lock to a writer lock. The function is invalid if the
+  // lock is already upgraded.
+  WriterLock UpgradeToWriterMutexLock() ABSL_NO_THREAD_SAFETY_ANALYSIS {
+    return WriterLock(this);
+  }
+
+ private:
+  absl::Mutex* const mu_;
+  bool is_reader_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_NON_ATOMICALLY_UPGRADEABLE_RW_LOCK_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/nvptx_compiler.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/nvptx_compiler.h
new file mode 100644
index 0000000000000000000000000000000000000000..ea2162aa95aec5d5f7a2f4872d1e88f96eb4f6a5
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/nvptx_compiler.h
@@ -0,0 +1,156 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_NVPTX_COMPILER_H_
+#define XLA_SERVICE_GPU_NVPTX_COMPILER_H_
+
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "absl/container/flat_hash_map.h"
+#include "absl/container/node_hash_map.h"
+#include "xla/autotune_results.pb.h"
+#include "xla/service/gpu/gpu_compiler.h"
+#include "xla/statusor.h"
+#include "xla/stream_executor/device_description.h"
+#include "xla/xla.pb.h"
+#include "tsl/platform/threadpool.h"
+
+namespace xla {
+namespace gpu {
+
+void WarnIfBadDriverJITVersion();
+
+// NVPTXCompiler generates efficient GPU executables for NVPTX target.
+class NVPTXCompiler : public GpuCompiler {
+ public:
+  NVPTXCompiler();
+
+  Status OptimizeHloConvolutionCanonicalization(
+      HloModule* hlo_module, se::GpuComputeCapability gpu_version,
+      se::dnn::VersionInfo dnn_version,
+      se::DeviceMemoryAllocator* device_allocator) override;
+
+  Status OptimizeHloPostLayoutAssignment(
+      HloModule* hlo_module, se::StreamExecutor* stream_exec,
+      const CompileOptions& options, const GpuTargetConfig& gpu_target_config,
+      const AutotuneResults* autotune_results,
+      tsl::thread::ThreadPool* thread_pool) override;
+
+  bool RequiresCollectiveScheduleLinearizer(
+      const HloModule* module, se::StreamExecutor* stream_exec) override;
+
+  Status AddConvAndGemmAutotuningPasses(
+      HloPassPipeline* pipeline, HloModule* hlo_module,
+      AutotuneConfig& autotune_config,
+      tsl::thread::ThreadPool* thread_pool) override;
+
+  Status AddTritonGemmAutotuningPasses(
+      HloPassPipeline* pipeline, HloModule* hlo_module,
+      AutotuneConfig& autotune_config,
+      tsl::thread::ThreadPool* thread_pool) override;
+
+  HloDataflowAnalysis::CanShareBuffer GetCanShareBuffer() const override;
+
+  StatusOr<std::pair<std::string, std::vector<uint8_t>>> CompileTargetBinary(
+      const HloModuleConfig& module_config, llvm::Module* llvm_module,
+      se::GpuComputeCapability gpu_version, bool relocatable,
+      const HloModule* debug_module, const CompileOptions& options) override;
+
+ private:
+  StatusOr<bool> CanUseLinkModules(
+      const HloModuleConfig& module_config) override;
+
+  StatusOr<std::vector<uint8_t>> LinkModules(
+      se::StreamExecutor* stream_exec,
+      std::vector<std::vector<uint8_t>> modules,
+      const DebugOptions& debug_options) override;
+
+  absl::Mutex mutex_;
+
+  enum class LinkingMethod {
+    kNone,
+    kNvLink,
+    kDriver,
+  };
+  absl::flat_hash_map<std::string, LinkingMethod> linking_methods_
+      ABSL_GUARDED_BY(mutex_);
+
+  StatusOr<LinkingMethod> ChooseLinkingMethod(
+      const std::string& preferred_cuda_dir);
+
+  // Tries to compile the given ptx string to cubin.  Returns a vector with the
+  // compiled cubin if compilation succeeded.
+  StatusOr<std::vector<uint8_t>> CompileGpuAsmOrGetCachedResult(
+      const std::string& ptx, se::CudaComputeCapability cc,
+      const HloModuleConfig& hlo_module_config, absl::string_view module_name,
+      bool relocatable, const CompileOptions& options);
+
+  // The compilation_cache_ map is a cache from {ptx string, cc_major, cc_minor}
+  // -> cubin so we don't recompile the same ptx twice.  This is important for
+  // some interactive workflows.  (We also cache at the HLO level, but sometimes
+  // we can't realize that two modules are the same until we lower to ptx.)
+  //
+  // Compilation of distinct PTX happens in parallel. If more than one thread
+  // attempts to compile the same PTX, the fist thread to obtain
+  // cache_value_->mutex_ performs the compilation. The rest wait() on
+  // cache_value_->compilation_done_cv_ until the compilation is done.
+  //
+  // If compiling the ptx fails, we return an empty cubin, cross our fingers,
+  // and leave compilation up to the driver.
+  struct CompilationCacheKey {
+    CompilationCacheKey(std::string ptx, int cc_major, int cc_minor,
+                        bool relocatable)
+        : ptx(std::move(ptx)),
+          cc_major(cc_major),
+          cc_minor(cc_minor),
+          relocatable(relocatable) {}
+    template <typename H>
+    friend H AbslHashValue(H h, const CompilationCacheKey& key) {
+      return H::combine(std::move(h), key.ptx, key.cc_major, key.cc_minor,
+                        key.relocatable);
+    }
+    friend bool operator==(const CompilationCacheKey& a,
+                           const CompilationCacheKey& b) {
+      return a.cc_major == b.cc_major && a.cc_minor == b.cc_minor &&
+             a.ptx == b.ptx && a.relocatable == b.relocatable;
+    }
+    std::string ptx;
+    int cc_major;
+    int cc_minor;
+    bool relocatable;
+  };
+  struct CompilationCacheValue {
+    bool compilation_done = false;
+    std::vector<uint8_t> cubin_data;
+    // mutex and condition variable to serialize compilation completing.
+    absl::Mutex mutex;
+    absl::CondVar compilation_done_cv;
+  };
+
+  // Don't even think about switching this to flat_hash_map; iterator stability
+  // is critical here.
+  absl::node_hash_map<CompilationCacheKey, CompilationCacheValue>
+      compilation_cache_ ABSL_GUARDED_BY(mutex_);
+
+  NVPTXCompiler(const NVPTXCompiler&) = delete;
+  NVPTXCompiler& operator=(const NVPTXCompiler&) = delete;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_NVPTX_COMPILER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/outfeed_manager.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/outfeed_manager.h
new file mode 100644
index 0000000000000000000000000000000000000000..4da268a26b0b996a489e5eb8c9906d96d00fe637
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/outfeed_manager.h
@@ -0,0 +1,74 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_OUTFEED_MANAGER_H_
+#define XLA_SERVICE_GPU_OUTFEED_MANAGER_H_
+
+#include <memory>
+#include <utility>
+
+#include "xla/literal.h"
+#include "xla/service/gpu/xfeed_queue.h"
+#include "xla/shape_tree.h"
+#include "xla/stream_executor/stream_executor.h"
+#include "tsl/platform/notification.h"
+
+namespace xla {
+namespace gpu {
+
+// TODO(b/30467474) Once GPU outfeed implementation settles, consider
+// folding back the cpu and gpu outfeed implementations into a generic
+// one if possible.
+
+// Defines a buffer holding the destination for an outfeed in host memory and a
+// notification when that triggers when the transfer is done.
+class OutfeedBuffer {
+ public:
+  explicit OutfeedBuffer(int64_t length) : length_(length) {}
+
+  // Waits for the device transfer to be finished.
+  void WaitUntilAvailable() { done_.WaitForNotification(); }
+
+  int64_t length() const { return length_; }
+  void set_destination(std::unique_ptr<MutableBorrowingLiteral> destination) {
+    destination_ = std::move(destination);
+  }
+  MutableBorrowingLiteral* destination() { return destination_.get(); }
+
+  // Callback to signal that this buffer is consumed.
+  void Done() { done_.Notify(); }
+
+ private:
+  std::unique_ptr<MutableBorrowingLiteral> destination_;
+  const int64_t length_;
+  tsl::Notification done_;
+};
+
+// Manages a thread-safe queue of buffers. The buffers are supposed to be
+// produced by the transfer manager and consumed by the device.
+class OutfeedManager
+    : public XfeedQueue<ShapeTree<std::unique_ptr<OutfeedBuffer>>*> {
+ public:
+  Status TransferLiteralFromOutfeed(se::StreamExecutor* executor,
+                                    MutableBorrowingLiteral literal);
+};
+
+// Returns the GPU outfeed manager for the given stream executor.
+OutfeedManager* GetOrCreateOutfeedManager(se::StreamExecutor* executor);
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_OUTFEED_MANAGER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/outfeed_thunk.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/outfeed_thunk.h
new file mode 100644
index 0000000000000000000000000000000000000000..e6abb189a605188c1bf955d9962fa469cd0e5225
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/outfeed_thunk.h
@@ -0,0 +1,48 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_OUTFEED_THUNK_H_
+#define XLA_SERVICE_GPU_OUTFEED_THUNK_H_
+
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/service/gpu/buffer_allocations.h"
+#include "xla/service/gpu/thunk.h"
+#include "xla/stream_executor/stream_executor.h"
+
+namespace xla {
+namespace gpu {
+
+// A thunk that outfeeds data. Data must be already resident on the host. This
+// thunk performs a device to host copy from the buffer allocated for the
+// outfeed op to the host location.
+class OutfeedThunk : public Thunk {
+ public:
+  // Constructs a OutfeedThunk that copies data to the host-side
+  // outfeed queue from the buffers in the given shape tree.
+  OutfeedThunk(ThunkInfo thunk_info, std::vector<ShapedSlice> source_slices);
+
+  OutfeedThunk(const OutfeedThunk&) = delete;
+  OutfeedThunk& operator=(const OutfeedThunk&) = delete;
+
+  Status ExecuteOnStream(const ExecuteParams& params) override;
+
+ private:
+  const std::vector<ShapedSlice> source_slices_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_OUTFEED_THUNK_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/parallel_loop_emitter.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/parallel_loop_emitter.h
new file mode 100644
index 0000000000000000000000000000000000000000..b6ed37ca74220f3ecc502604511f61113a292bde
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/parallel_loop_emitter.h
@@ -0,0 +1,93 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_PARALLEL_LOOP_EMITTER_H_
+#define XLA_SERVICE_GPU_PARALLEL_LOOP_EMITTER_H_
+
+#include "llvm/IR/IRBuilder.h"
+#include "xla/service/gpu/launch_dimensions.h"
+#include "xla/service/llvm_ir/ir_array.h"
+#include "xla/service/llvm_ir/loop_emitter.h"
+
+namespace xla {
+namespace gpu {
+
+// Emits a parallel loop for every element in the given array shape. This loop
+// emitted will be executed by multiple threads in parallel. Therefore, each
+// thread instance of the loop iterates over part of the array, and they
+// collectively iterates over the entire array.
+class ParallelLoopEmitter {
+ public:
+  // `launch_dimensions` specify the number of threads and blocks to
+  // parallelize the loop on.  `launch_config` specify some detail on
+  // how to parallelize.
+  ParallelLoopEmitter(llvm_ir::BodyEmitter body_emitter, const Shape& shape,
+                      const LaunchDimensions& launch_dimensions,
+                      llvm::IRBuilder<>* b,
+                      LaunchDimensionsConfig launch_config = {});
+
+  // Constructs a loop emitter for a loop that generates on element of each of N
+  // arrays on each iteration.
+  //
+  // This is used in multi-output fusion.  target_element_generator should
+  // produce a struct with N elements, one for each of target_arrays.
+  ParallelLoopEmitter(const llvm_ir::ElementGenerator& target_element_generator,
+                      absl::Span<const llvm_ir::IrArray> target_arrays,
+                      const LaunchDimensions& launch_dimensions,
+                      llvm::IRBuilder<>* b,
+                      LaunchDimensionsConfig launch_config = {});
+
+  ParallelLoopEmitter(const ParallelLoopEmitter&) = delete;
+  ParallelLoopEmitter& operator=(const ParallelLoopEmitter&) = delete;
+
+  std::vector<llvm_ir::IrArray::Index> EmitIndexAndSetExitBasicBlock(
+      absl::string_view loop_name, llvm::Type* index_type,
+      llvm::Value* base_index);
+
+  Status EmitLoop(absl::string_view loop_name = "",
+                  llvm::Type* index_type = nullptr);
+
+ private:
+  struct LinearBaseAndThreadIdx {
+    llvm::Value* linear_base;
+    llvm::Value* thread_idx;
+  };
+
+  LinearBaseAndThreadIdx EmitLinearBaseAndThreadIdx(llvm::Type* index_type,
+                                                    llvm::Value* base_index);
+  Status EmitSerialLoop(absl::string_view loop_name, llvm::Type* index_type,
+                        llvm::Value* base_indvar = nullptr);
+
+  // The thread and block dimension to parallelize the loop on.
+  const LaunchDimensions launch_dimensions_;
+  const LaunchDimensionsConfig launch_config_;
+
+  // An IR emitter that generates the loop body.
+  llvm_ir::BodyEmitter body_emitter_;
+
+  // The shape that the emitted loop iterates through.
+  Shape shape_;
+
+  // Points to the exit block of the emitted loop. If the given shape is
+  // scalar, no loops are emitted and exit_bb_ is nullptr in that case.
+  llvm::BasicBlock* exit_bb_;
+
+  llvm::IRBuilder<>* b_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_PARALLEL_LOOP_EMITTER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/precompiled_kernels.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/precompiled_kernels.h
new file mode 100644
index 0000000000000000000000000000000000000000..3d1e96afafbeb269bc4f3bcbeb3dfa8df6e807d4
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/precompiled_kernels.h
@@ -0,0 +1,60 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_PRECOMPILED_KERNELS_H_
+#define XLA_SERVICE_GPU_PRECOMPILED_KERNELS_H_
+
+#include "xla/status.h"
+#include "xla/stream_executor/device_memory.h"
+#include "xla/stream_executor/gpu/gpu_asm_opts.h"
+#include "xla/stream_executor/stream.h"
+#include "xla/types.h"
+
+// Hardcoded GPU kernels for various simple tasks.
+
+namespace xla {
+namespace gpu {
+
+// In GPU memory, does
+//
+//   char* base_ptr = ...;
+//   void* ptrs_out = ...;
+//   for (i = 0; i < n; i++) {
+//     ptrs_out[i] = base_ptr + i * stride;
+//   }
+//
+// This is useful for functions like cublasTrsmBatched that operate on an array
+// of pointers in GPU memory.  In XLA these aren't usually arbitrary pointers
+// but rather are all contiguous values.
+//
+// Instead of using a kernel, a simpler way of doing this would be to create
+// this buffer on the host and then copy it to device.  But using a kernel
+// instead of an H2D copy avoids a few performance pitfalls.
+//
+//  - Only one H2D copy can run on a given GPU at a time.  If there's already
+//    a copy ongoing as part of other work on the GPU, our copy here will
+//    block.  In contrast, multiple kernels can run simultaneously.
+//
+//  - H2D copies from CUDA unpinned memory can acquire a global lock in the
+//    driver and slow down *all* work on the GPU.  So to do this right, we'd
+//    need to allocate the host memory as pinned, one alloc per stream.  Then
+//    we'd need to manage this memory without leaks.  This becomes complex!
+Status MakeBatchPointers(se::Stream* stream, const se::GpuAsmOpts& asm_opts,
+                         se::DeviceMemoryBase base_ptr, int stride_bytes, int n,
+                         se::DeviceMemoryBase ptrs_out);
+
+}  // namespace gpu
+}  // namespace xla
+#endif  // XLA_SERVICE_GPU_PRECOMPILED_KERNELS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/prepare_hlo_for_ir_emitting_pipeline.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/prepare_hlo_for_ir_emitting_pipeline.h
new file mode 100644
index 0000000000000000000000000000000000000000..73881e82614eab3b57372dfd2b8547ba3556c2cf
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/prepare_hlo_for_ir_emitting_pipeline.h
@@ -0,0 +1,36 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_PREPARE_HLO_FOR_IR_EMITTING_PIPELINE_H_
+#define XLA_SERVICE_GPU_PREPARE_HLO_FOR_IR_EMITTING_PIPELINE_H_
+
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/service/hlo_dataflow_analysis.h"
+#include "xla/service/hlo_pass_pipeline.h"
+
+namespace xla {
+namespace gpu {
+
+// Function wrapper around the XLA GPU base pre-IR emission module preparation
+// pipeline. This pipeline must be run right before IR emission to ensure
+// correctness of the input module.
+HloPassPipeline PrepareHloModuleForIrEmittingPipeline(
+    HloModule& hlo_module,
+    HloDataflowAnalysis::CanShareBuffer can_share_buffer);
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_PREPARE_HLO_FOR_IR_EMITTING_PIPELINE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/priority_fusion.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/priority_fusion.h
new file mode 100644
index 0000000000000000000000000000000000000000..b43a7954a5e58e02a3bd5c402b8ae6fd8444c97e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/priority_fusion.h
@@ -0,0 +1,79 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_PRIORITY_FUSION_H_
+#define XLA_SERVICE_GPU_PRIORITY_FUSION_H_
+
+#include <stdint.h>
+
+#include <memory>
+#include <optional>
+
+#include "absl/container/flat_hash_set.h"
+#include "absl/strings/string_view.h"
+#include "xla/hlo/ir/hlo_computation.h"
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/service/fusion_queue.h"
+#include "xla/service/gpu/gpu_hlo_cost_analysis.h"
+#include "xla/service/hlo_cost_analysis.h"
+#include "xla/service/hlo_pass_interface.h"
+#include "xla/service/instruction_fusion.h"
+#include "xla/statusor.h"
+
+namespace xla {
+namespace gpu {
+
+class GpuPriorityFusion : public InstructionFusion {
+ public:
+  explicit GpuPriorityFusion(
+      const se::DeviceDescription& d,
+      const GpuHloCostAnalysis::Options& cost_analysis_options)
+      : InstructionFusion(GpuPriorityFusion::IsExpensive),
+        device_info_(d),
+        cost_analysis_options_(cost_analysis_options) {}
+
+  absl::string_view name() const override { return "priority-fusion"; }
+
+  static bool IsExpensive(const HloInstruction& instruction);
+
+ protected:
+  std::unique_ptr<FusionQueue> GetFusionQueue(
+      HloComputation* computation) override;
+  FusionDecision ShouldFuse(HloInstruction* consumer,
+                            int64_t operand_index) override;
+
+  HloInstruction::FusionKind ChooseKind(
+      const HloInstruction* producer, const HloInstruction* consumer) override;
+
+ private:
+  // This method is called by ShouldFuse() to do all the computationally
+  // inexpensive checks whether we should fuse the operand into 'consumer'.
+  FusionDecision ShouldFuseInexpensiveChecks(HloInstruction* consumer,
+                                             int64_t operand_index);
+
+  HloInstruction* FuseInstruction(HloInstruction* fusion_instruction,
+                                  HloInstruction* producer) override;
+
+  se::DeviceDescription device_info_;
+
+  // Cost model options that defines priorities in the queue.
+  GpuHloCostAnalysis::Options cost_analysis_options_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_PRIORITY_FUSION_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/reduction_degenerate_dim_remover.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/reduction_degenerate_dim_remover.h
new file mode 100644
index 0000000000000000000000000000000000000000..e146a3a01cbd016e98adec16abe25c789fcd9ec6
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/reduction_degenerate_dim_remover.h
@@ -0,0 +1,56 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef XLA_SERVICE_GPU_REDUCTION_DEGENERATE_DIM_REMOVER_H_
+#define XLA_SERVICE_GPU_REDUCTION_DEGENERATE_DIM_REMOVER_H_
+
+#include <optional>
+
+#include "xla/hlo/ir/hlo_instructions.h"
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/service/hlo_pass_interface.h"
+
+namespace xla {
+namespace gpu {
+
+// Enforces the invariant that reduction input and output have no degenerate
+// (size 1) dimension. Since these dimensions are physically meaningless, they
+// are removed using bitcasts.
+//
+// For example,
+//
+//   f[1] out = reduce(f[100, 1, 1] input, dimensions={0, 1})
+//
+// becomes:
+//
+//
+//   f[100] tmp1 = f[100] bitcast(f[100, 1, 1], input)
+//   f[] tmp2 = reduce(f[100] tmp1, dimensions={0})
+//   f[1] out = f[] bitcast(tmp2)
+//
+class ReductionDegenerateDimRemover : public HloModulePass {
+ public:
+  absl::string_view name() const override {
+    return "reduction-degenerate-dim-remover";
+  }
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_REDUCTION_DEGENERATE_DIM_REMOVER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/reduction_dimension_grouper.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/reduction_dimension_grouper.h
new file mode 100644
index 0000000000000000000000000000000000000000..b0d02bde2253e75efd5e6a39b699efabf87c0c7e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/reduction_dimension_grouper.h
@@ -0,0 +1,56 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef XLA_SERVICE_GPU_REDUCTION_DIMENSION_GROUPER_H_
+#define XLA_SERVICE_GPU_REDUCTION_DIMENSION_GROUPER_H_
+
+#include <optional>
+
+#include "xla/hlo/ir/hlo_instructions.h"
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/service/hlo_pass_interface.h"
+
+namespace xla {
+namespace gpu {
+
+// Groups adjacent (logically and physically) reduced dimensions in reduction
+// input.
+//
+// Precondition: ReductionLayoutNormalizer has been run (physical proximity and
+// logical proximity become the same).
+//
+// For example,
+//
+//   f[] out = reduce(f[10,20,30] input, dimensions={0,1,2})
+//
+// becomes:
+//
+//   f[600] tmp = f[600] bitcast(f[10,20,30] input)
+//   f[] out = reduce(f[600] tmp, dimensions={0})
+//
+class ReductionDimensionGrouper : public HloModulePass {
+ public:
+  absl::string_view name() const override {
+    return "reduction-dimension-grouper";
+  }
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_REDUCTION_DIMENSION_GROUPER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/reduction_layout_normalizer.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/reduction_layout_normalizer.h
new file mode 100644
index 0000000000000000000000000000000000000000..b7f0defd619f25d1271b8d808d6317d280c264cd
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/reduction_layout_normalizer.h
@@ -0,0 +1,54 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef XLA_SERVICE_GPU_REDUCTION_LAYOUT_NORMALIZER_H_
+#define XLA_SERVICE_GPU_REDUCTION_LAYOUT_NORMALIZER_H_
+
+#include <optional>
+
+#include "xla/hlo/ir/hlo_instructions.h"
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/service/hlo_pass_interface.h"
+
+namespace xla {
+namespace gpu {
+
+// Enforces default (minor-to-major) layout on all reduction inputs.
+// Note that since reduction output can request a custom layout,
+// this pass only guarantees standard layout for the input.
+//
+// For example,
+//
+//   f[20,30]{0,1} out = reduce(f[10,20,30]{2,0,1} input, dimensions={0})
+//
+// becomes:
+//
+//   f[20,10,30] tmp = f[20,10,30] bitcast(f[10,20,30]{2,0,1} input)
+//   f[20,30]{0,1} out = reduce(f[20,10,30]{2,1,0} tmp, dimensions={1})
+class ReductionLayoutNormalizer : public HloModulePass {
+ public:
+  absl::string_view name() const override {
+    return "reduction-layout-normalizer";
+  }
+
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_REDUCTION_LAYOUT_NORMALIZER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/reduction_splitter.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/reduction_splitter.h
new file mode 100644
index 0000000000000000000000000000000000000000..776055acd4bacd74e56bb4346db682f5c9135bc8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/reduction_splitter.h
@@ -0,0 +1,52 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef XLA_SERVICE_GPU_REDUCTION_SPLITTER_H_
+#define XLA_SERVICE_GPU_REDUCTION_SPLITTER_H_
+
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/service/hlo_pass_interface.h"
+
+namespace xla {
+namespace gpu {
+
+// Splits a reduce op into two consecutive reduce ops if
+// * the reduce dimensions are not contiguous and
+// * at least one reduce dimension is large (i.e. corresponds to a large input
+//   shape dimension).
+//
+// Reductions with non-contiguous dimensions are emitted as simple element-wise
+// loops. This is inefficient when reducing large input shape dimensions.
+// Splitting such reductions allows using more efficient reduction emitters.
+//
+// This pass splits reduce ops into two consecutive reduce ops. Run it to a
+// fixpoint to split reduce ops along multiple large dimensions.
+//
+// Precondition: ReductionDimensionGrouper has been run and adjacent reduce
+// dimentsions have been grouped. Reduction layouts have been normalized.
+
+class ReductionSplitter : public HloModulePass {
+ public:
+  absl::string_view name() const override { return "reduction-splitter"; }
+
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_REDUCTION_SPLITTER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/reduction_utils.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/reduction_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..610200c888464249d46f640b077cfa290f502e68
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/reduction_utils.h
@@ -0,0 +1,69 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_REDUCTION_UTILS_H_
+#define XLA_SERVICE_GPU_REDUCTION_UTILS_H_
+
+#include "absl/types/span.h"
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/service/hlo_module_config.h"
+#include "xla/util.h"
+
+namespace xla {
+namespace gpu {
+
+// Need at least 1024 threads/block for reasonable tree reduction
+// performance (assuming all data fits).
+int64_t MinThreadsXRowReduction(const HloModuleConfig& hlo_module_config);
+
+// When doing batched row reduction, how big the batch dimension could be.
+inline constexpr int64_t BatchedReductionRaceFreeBound() { return 8; }
+
+// Returns true if either the dimensions being reduced or the dimensions being
+// kept are contiguous in the input of the reduce instruction.
+bool IsReductionFromOrToContiguousDimensions(const HloInstruction& reduce);
+
+struct ReductionDimensions {
+  // Indicates whether the reduction is a row reduction or a column reduction.
+  bool is_row_reduction;
+
+  // Contains the size of the three contiguous components for
+  // the reduction [depth, height, width] (major-to-minor ordering).
+  //
+  // For row reduction, we do: [D, H, W] -> [D, H].
+  // For column reduction, we do: [D, H, W] -> [D, W].
+  Vector3 dimensions;
+};
+
+// Given the input shape and dimensions to reduce for a reduction, returns
+// ReductionDimensions.
+//
+// Prerequisite: the reduction instruction passes the check
+// IsReductionFromOrToContiguousDimensions, which guarantees either the
+// dimensions to reduce or the dimensions to keep are consecutive.
+ReductionDimensions GetReductionKindAndContiguousComponents(
+    const HloInstruction& reduce);
+
+// Get tiling per thread for the given reduction in dimensions [D, H, W].
+Vector3 GetReductionTiling(const ReductionDimensions& reduction_dimensions);
+
+// Returns whether the given reduction can be safely generated without atomics :
+// that is, at most one block will write to every output element.
+bool ReductionIsRaceFree(const HloModuleConfig& hlo_module_config,
+                         const ReductionDimensions& reduction_dimensions);
+
+}  // namespace gpu
+}  // namespace xla
+#endif  // XLA_SERVICE_GPU_REDUCTION_UTILS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/replica_id_thunk.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/replica_id_thunk.h
new file mode 100644
index 0000000000000000000000000000000000000000..23f694a0654a8cfd7e0e64961519274a022c7a1d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/replica_id_thunk.h
@@ -0,0 +1,53 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_REPLICA_ID_THUNK_H_
+#define XLA_SERVICE_GPU_REPLICA_ID_THUNK_H_
+
+#include "xla/service/buffer_assignment.h"
+#include "xla/service/gpu/thunk.h"
+
+namespace xla {
+namespace gpu {
+
+// Thunk that implements the ReplicaId(Idx == 0) or PartitionId(Idx == 1).
+class ReplicaOrPartitionIdThunk : public Thunk {
+  Status ExecuteOnStream(const ExecuteParams& params) override;
+
+ protected:
+  ReplicaOrPartitionIdThunk(Kind kind, ThunkInfo thunk_info,
+                            const BufferAllocation::Slice& dest)
+      : Thunk(kind, thunk_info), dest_(dest) {}
+
+ private:
+  const BufferAllocation::Slice dest_;
+};
+
+class ReplicaIdThunk : public ReplicaOrPartitionIdThunk {
+ public:
+  ReplicaIdThunk(ThunkInfo thunk_info, const BufferAllocation::Slice& dest)
+      : ReplicaOrPartitionIdThunk(Kind::kReplicaId, thunk_info, dest) {}
+};
+
+class PartitionIdThunk : public ReplicaOrPartitionIdThunk {
+ public:
+  PartitionIdThunk(ThunkInfo thunk_info, const BufferAllocation::Slice& dest)
+      : ReplicaOrPartitionIdThunk(Kind::kPartitionId, thunk_info, dest) {}
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_REPLICA_ID_THUNK_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/cholesky.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/cholesky.h
new file mode 100644
index 0000000000000000000000000000000000000000..23e8da20198921873c241ff23e64eb79b451ae80
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/cholesky.h
@@ -0,0 +1,30 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_RUNTIME_CHOLESKY_H_
+#define XLA_SERVICE_GPU_RUNTIME_CHOLESKY_H_
+
+#include "xla/runtime/custom_call_registry.h"
+
+namespace xla {
+namespace gpu {
+
+// Registers XLA Gpu runtime cholesky custom calls.
+void RegisterCholeskyCustomCalls(runtime::DirectCustomCallRegistry& registry);
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_RUNTIME_CHOLESKY_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/collectives.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/collectives.h
new file mode 100644
index 0000000000000000000000000000000000000000..23bd700cc151fc07220ef2c6d698cfff1d400e62
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/collectives.h
@@ -0,0 +1,79 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_RUNTIME_COLLECTIVES_H_
+#define XLA_SERVICE_GPU_RUNTIME_COLLECTIVES_H_
+
+#include <cstdint>
+
+#include "absl/container/flat_hash_map.h"
+#include "absl/container/flat_hash_set.h"
+#include "xla/runtime/custom_call_registry.h"
+#include "xla/service/gpu/nccl_collective_thunk.h"
+#include "xla/stream_executor/event.h"
+
+namespace xla {
+namespace gpu {
+
+// Support for running async collective operations communicating via events.
+// Registers XLA Gpu runtime collective custom calls.
+void RegisterCollectiveCustomCalls(runtime::DirectCustomCallRegistry& registry);
+
+class CollectivesSupport {
+ public:
+  // Maybe block host after the first call to the collective operation with the
+  // given uid, to ensure that all devices have allocated the required buffers
+  // for their communicators before allowing any device to continue enqueuing
+  // operations. Otherwise, the allocations can cause deadlock in the CUDA
+  // driver.
+  //
+  // This basically ports workaround from cr/435058849 to Xla runtime (see
+  // details in the b/215649390).
+  absl::Status MaybeBlockAfterFirstRun(int32_t uid, int32_t device_ordinal,
+                                       se::Stream* stream);
+
+ private:
+  absl::Mutex mutex_;
+
+  // Store if a particular collective operation was executed at least once. We
+  // rely on unique `uid` assigned to each collective operation by the lowering
+  // pass.
+  absl::flat_hash_set<int64_t> executed_ ABSL_GUARDED_BY(mutex_);
+};
+
+// Support for running async collective operations communicating via events.
+class AsyncCollectivesSupport {
+ public:
+  explicit AsyncCollectivesSupport(absl::Span<se::Stream* const> async_streams);
+
+  absl::Status RecordEvent(int32_t uid, AsyncStreamKind async_stream_kind);
+  absl::StatusOr<se::Event> PopEvent(int32_t uid);
+
+  se::Stream* async_comm_stream(AsyncStreamKind async_stream_kind) const {
+    return async_comm_streams_[async_stream_kind];
+  }
+
+ private:
+  absl::Mutex mutex_;
+  absl::InlinedVector<se::Stream*, kAsyncStreamTotal> async_comm_streams_;
+
+  // Store done events for the Done ops to wait upon.
+  absl::flat_hash_map<int, se::Event> done_events_ ABSL_GUARDED_BY(mutex_);
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_RUNTIME_COLLECTIVES_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/concurrent_region.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/concurrent_region.h
new file mode 100644
index 0000000000000000000000000000000000000000..c662282ef6efa279c9812429b62b3280b465c63c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/concurrent_region.h
@@ -0,0 +1,75 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_RUNTIME_CONCURRENT_REGION_H_
+#define XLA_SERVICE_GPU_RUNTIME_CONCURRENT_REGION_H_
+
+#include <vector>
+
+#include "xla/runtime/custom_call_registry.h"
+#include "xla/service/service_executable_run_options.h"
+
+namespace xla {
+namespace gpu {
+
+// Registers XLA Gpu runtime kernel launch custom calls.
+void RegisterConcurrentRegionCustomCalls(
+    runtime::DirectCustomCallRegistry& registry);
+
+// The state to keep track of the information regarding concurrent regions
+// between custom calls.
+class ConcurrentRegionStatus {
+ public:
+  explicit ConcurrentRegionStatus(
+      const ServiceExecutableRunOptions* run_options,
+      int num_borrowed_streams = 10);
+
+  ~ConcurrentRegionStatus();
+
+  absl::Status StartConcurrentRegion(se::Stream* capture_stream, int64_t size);
+  void EndConcurrentRegion();
+
+  // Temporarily disable concurrent execution when we run GPU graphs op-by-op.
+  // If disabled_ is set to true, StartConcurrentRegion will become an no-op and
+  // IsInConcurrentRegion always returns false.
+  void DisableConcurrentRegion() { disabled_ = true; }
+  void EnableConcurrentRegion() { disabled_ = false; }
+
+  // Get a stream on which the concurrent-executable kernel runs. It returns a
+  // different stream each time to avoid building dependencies in the CUDA
+  // graph.
+  se::Stream* GetNextStream();
+
+  absl::StatusOr<se::Stream*> GetStream(int index);
+
+  bool IsInConcurrentRegion();
+
+ private:
+  const int num_borrowed_streams_;
+  std::vector<StreamPool::Ptr> borrowed_streams_;
+  const ServiceExecutableRunOptions* run_options_;
+
+  bool disabled_ = false;
+  int32_t stream_index_;
+
+  // It is set to nullptr if not in a concurrent region.
+  se::Stream* capture_stream_;
+  int region_size_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_RUNTIME_CONCURRENT_REGION_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/conv.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/conv.h
new file mode 100644
index 0000000000000000000000000000000000000000..d8622c16136b41572df650bb23f7e175450de79a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/conv.h
@@ -0,0 +1,67 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_RUNTIME_CONV_H_
+#define XLA_SERVICE_GPU_RUNTIME_CONV_H_
+
+#include <memory>
+#include <utility>
+
+#include "absl/container/node_hash_map.h"
+#include "absl/synchronization/mutex.h"
+#include "xla/mlir/runtime/transforms/custom_call_encoding.h"
+#include "xla/runtime/custom_call_registry.h"
+#include "xla/service/gpu/gpu_conv_runner.h"
+
+namespace xla {
+namespace gpu {
+
+// Registers XLA Gpu runtime Conv custom calls.
+void RegisterConvCustomCalls(runtime::DirectCustomCallRegistry& registry);
+
+// Register type names for convoluttion attributes defined by MHLO dialect.
+void RegisterConvTypeIdNames(runtime::TypeIDNameRegistry& registry);
+
+// Add attributes encoding for convoluttion attributes defined by MHLO dialect.
+void PopulateConvAttrEncoding(runtime::CustomCallAttrEncodingSet& encoding);
+
+//===----------------------------------------------------------------------===//
+// Cache conv runners between invocations of convolution custom calls.
+//===----------------------------------------------------------------------===//
+
+struct ConvRunner {
+  explicit ConvRunner(GpuConvConfig config)
+      : config(std::move(config)), runner(this->config) {}
+  GpuConvConfig config;
+  GenericConvRunner runner;
+};
+
+class StreamExecutorConvRunners : public runtime::StateVector<ConvRunner> {};
+
+// Xla executable keeps a mapping from stream executors to convolution runners.
+class ConvRunners {
+ public:
+  StreamExecutorConvRunners* operator()(se::StreamExecutor* executor);
+
+ private:
+  mutable absl::Mutex mutex_;
+  absl::node_hash_map<se::StreamExecutor*, StreamExecutorConvRunners> runners_
+      ABSL_GUARDED_BY(mutex_);
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_RUNTIME_CONV_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/conv_reorder.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/conv_reorder.h
new file mode 100644
index 0000000000000000000000000000000000000000..654e9dd56bcb5bdad0ab4ede49c1dfc7bd909219
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/conv_reorder.h
@@ -0,0 +1,31 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_RUNTIME_CONV_REORDER_H_
+#define XLA_SERVICE_GPU_RUNTIME_CONV_REORDER_H_
+
+#include "xla/runtime/custom_call_registry.h"
+
+namespace xla {
+namespace gpu {
+
+// Registers XLA Gpu runtime convolution reorder custom calls.
+void RegisterConvReorderCustomCalls(
+    runtime::DirectCustomCallRegistry& registry);
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_RUNTIME_CONV_REORDER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/cublas_lt_matmul.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/cublas_lt_matmul.h
new file mode 100644
index 0000000000000000000000000000000000000000..ee7f501caf12c3db7d9344bb720c1b46a9e34073
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/cublas_lt_matmul.h
@@ -0,0 +1,50 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_RUNTIME_CUBLAS_LT_MATMUL_H_
+#define XLA_SERVICE_GPU_RUNTIME_CUBLAS_LT_MATMUL_H_
+
+#include "xla/mlir/runtime/transforms/custom_call_encoding.h"
+#include "xla/runtime/custom_call_registry.h"
+
+#if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+#include "xla/service/gpu/matmul_utils.h"
+#if GOOGLE_CUDA
+#include "xla/stream_executor/cuda/cuda_blas_lt.h"
+#else
+#include "rocm/rocm_config.h"
+#include "xla/stream_executor/rocm/hip_blas_lt.h"
+#endif
+#endif  // GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+
+namespace xla {
+namespace gpu {
+
+// Registers XLA Gpu runtime cuBLASLt custom calls.
+void RegisterMatmulCustomCalls(runtime::DirectCustomCallRegistry& registry);
+
+// Add cuBLASLt attributes encoding
+void PopulateCublasLtMatmulAttrEncoding(
+    runtime::CustomCallAttrEncodingSet& encoding);
+
+#if GOOGLE_CUDA || TF_HIPBLASLT
+// Keep cublas_lt::MatmulPlan's for all matmul instances in the executable.
+class MatmulPlans : public runtime::StateVector<cublas_lt::MatmulPlan> {};
+#endif  // GOOGLE_CUDA || TF_HIPBLASLT
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_RUNTIME_CUBLAS_LT_MATMUL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/custom_call.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/custom_call.h
new file mode 100644
index 0000000000000000000000000000000000000000..df1c9f9fca3ef5e6a68c868cb665a8d05059c8df
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/custom_call.h
@@ -0,0 +1,29 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_RUNTIME_CUSTOM_CALL_H_
+#define XLA_SERVICE_GPU_RUNTIME_CUSTOM_CALL_H_
+
+#include "xla/runtime/custom_call_registry.h"
+
+namespace xla {
+namespace gpu {
+
+void RegisterXlaClassicCustomCalls(runtime::DirectCustomCallRegistry& registry);
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_RUNTIME_CUSTOM_CALL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/executable.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/executable.h
new file mode 100644
index 0000000000000000000000000000000000000000..05967e17afa3c6f87547562ad4ceb1ed6836539e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/executable.h
@@ -0,0 +1,196 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_RUNTIME_EXECUTABLE_H_
+#define XLA_SERVICE_GPU_RUNTIME_EXECUTABLE_H_
+
+#include <memory>
+#include <string>
+#include <string_view>
+#include <utility>
+#include <variant>
+#include <vector>
+
+#include "xla/runtime/executable.h"
+#include "xla/runtime/ffi.h"
+#include "xla/runtime/jit_executable.h"
+#include "xla/runtime/module_registry.h"
+#include "xla/service/gpu/buffer_allocations.h"
+#include "xla/service/gpu/non_atomically_upgradeable_rw_lock.h"
+#include "xla/service/gpu/runtime/collectives.h"
+#include "xla/service/gpu/runtime/conv.h"
+#include "xla/service/gpu/runtime/cublas_lt_matmul.h"
+#include "xla/service/gpu/runtime/fft.h"
+#include "xla/service/gpu/runtime/fused_attention.h"
+#include "xla/service/gpu/runtime/gemm.h"
+#include "xla/service/gpu/runtime/graph_launch.h"
+#include "xla/service/gpu/runtime/kernel_launch.h"
+#include "xla/service/service_executable_run_options.h"
+#include "xla/xla.pb.h"
+
+namespace xla {
+namespace gpu {
+
+// Register custom calls implementing Xla Gpu runtime.
+void RegisterXlaGpuRuntimeCustomCalls(
+    runtime::DirectCustomCallRegistry& registry);
+
+// Register mapping from XLA (SE) enums/structs type ids to symbol names.
+void RegisterXlaGpuTypeIdNames(runtime::TypeIDNameRegistry& registry);
+
+// Register encoding for (L)MHLO attributes required by the runtime functions.
+void RegisterXlaGpuAttrEncoding(runtime::CustomCallAttrEncodingSet& encoding);
+
+// Xla Gpu program lowered to the Xla runtime dialects. Gpu runtime executable
+// jit-compiles this program to an executable artifact (via lowering to LLVM).
+//
+// We have this program as an intermediate step between lowering from HLO to
+// runtime executable to be able to introspect the compilation process. Once we
+// have this program, the Xla gpu compiler job is done, and lowering to LLVM is
+// the responsibility of backend-agnostic Xla runtime passes. This is the last
+// stage when IR is still at a fairly high level of abstraction and has a lot of
+// Gpu specific details in it.
+struct GpuRuntimeProgram {
+  GpuRuntimeProgram(std::string entry_point, std::string module,
+                    std::vector<int64_t> buffer_sizes,
+                    DebugOptions debug_options)
+      : entry_point(std::move(entry_point)),
+        module(std::move(module)),
+        buffer_sizes(std::move(buffer_sizes)),
+        debug_options(std::move(debug_options)) {}
+
+  std::string entry_point;
+  std::string module;
+  std::vector<int64_t> buffer_sizes;
+  DebugOptions debug_options;
+};
+
+// Gpu runtime executable encapsulates the Xla runtime executable compiled from
+// an Xla program and owns all the state required for running it (e.g. it owns
+// various caches required for performance).
+//
+// TODO(ezhulenev): Once thunks are removed from Xla, it might make sense to
+// merge this executable into GpuExecutable. Today we keep it separate to manage
+// the complexity of mixing two execution modes in the same file. GpuExecutable
+// provides an API at XLA level of abstraction (streams and buffers), and this
+// executable provides a lower level API exposing some of the implementation
+// details.
+class GpuRuntimeExecutable {
+  using ModulesState = ::xla::runtime::ModulesState;
+  using FfiModulesState = ::xla::runtime::ffi::FfiModulesState;
+
+ public:
+  // Creates GpuRuntimeExecutable from the Xla Gpu Program.
+  static StatusOr<std::unique_ptr<GpuRuntimeExecutable>> Create(
+      std::string module_name, std::unique_ptr<GpuRuntimeProgram> program);
+
+  // Creates GpuRuntimeExecutable from the AOT compiled binary.
+  static StatusOr<std::unique_ptr<GpuRuntimeExecutable>> Create(
+      std::string module_name, absl::Span<const int64_t> buffer_sizes,
+      runtime::Executable executable, DebugOptions debug_options);
+
+  // Executes entry function with the given buffer arguments.
+  Status Execute(const ServiceExecutableRunOptions* run_options,
+                 const std::string& asm_text,
+                 const std::vector<uint8_t>& binary,
+                 const BufferAllocations& buffer_allocations,
+                 NonAtomicallyUpgradeableRWLock& gpu_lock,
+                 const BufferAllocation* temp_alloc = nullptr);
+
+  // Returns object file behind the runtime executable. This object file can
+  // be exported and loaded later to instantiate another executable.
+  StatusOr<std::string_view> GetObjFile() const;
+
+  // Returns MLIR module behind this executable if it is available.
+  StatusOr<std::string_view> GetMlirModule() const;
+
+  std::string_view module_name() const { return module_name_; }
+
+ private:
+  GpuRuntimeExecutable(std::string module_name,
+                       std::vector<int64_t> buffer_sizes,
+                       std::unique_ptr<runtime::JitExecutable> jit_executable,
+                       DebugOptions debug_options, ModulesState modules_state,
+                       FfiModulesState ffi_modules_state);
+
+  GpuRuntimeExecutable(std::string module_name,
+                       std::vector<int64_t> buffer_sizes,
+                       std::unique_ptr<runtime::Executable> aot_executable,
+                       DebugOptions debug_options, ModulesState modules_state,
+                       FfiModulesState ffi_modules_state);
+
+  std::string module_name_;
+
+  // Depending on the state of `executable_` returns a reference to active
+  // Xla runtime executable.
+  runtime::Executable& executable();
+
+  std::vector<int64_t> buffer_sizes_;
+
+  // In JIT compilation mode `JitExecutable` is used. In AOT compilation mode
+  // `Executable` is used.
+  std::variant<std::unique_ptr<runtime::JitExecutable>,
+               std::unique_ptr<runtime::Executable>>
+      executable_;
+
+  const DebugOptions debug_options_;
+
+  // Keep gpu kernels loaded by this executable.
+  GpuExecutableKernels gpu_kernels_;
+
+  // Keep gemm configs for all gemm operation in the program.
+  GemmConfigs gemm_configs_;
+
+  // Keep a cache for conv configs for all conv operations in the program.
+  ConvRunners conv_runners_;
+
+  // Keep a cache for fused_dot_attention configs for all fused_dot_attention
+  // operations in the program.
+  FusedAttentionRunners fused_attention_runners_;
+
+  // Keep a cache for fused_dot_attention configs for all fused_dot_attention
+  // backward
+  // operations in the program.
+  FusedAttentionBackwardRunners fused_attention_backward_runners_;
+
+  // Support for running collective operations.
+  CollectivesSupport collectives_;
+
+  // Keep a cache of fft plans for all FFT operations in the program.
+  FftPlans fft_plans_;
+
+#if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+  // Keep matmul execution plans (only if cuBLASLt is available).
+  MatmulPlans cublas_lt_matmul_plans_;
+  // Keep captured and instantiated GPU graphs instances.
+  GraphInstances graph_instances_;
+  CapturedFunctionExecutionCounts captured_function_counts_;
+  OrdinalToFallback ordinal_to_fallback_;
+#endif  // GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+
+  // Keep an executable state for all registered runtime modules.
+  ModulesState modules_state_;
+
+  // Keeps an executable state for all registered FFI modules.
+  FfiModulesState ffi_modules_state_;
+
+  // Dynamic custom calls exported from XLA runtime modules (and FFI modules).
+  runtime::DynamicCustomCallRegistry dynamic_custom_calls_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_RUNTIME_EXECUTABLE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/fft.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/fft.h
new file mode 100644
index 0000000000000000000000000000000000000000..bc45e310272dc75857bcbdcc534ada5e952f4f46
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/fft.h
@@ -0,0 +1,40 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_RUNTIME_FFT_H_
+#define XLA_SERVICE_GPU_RUNTIME_FFT_H_
+
+#include <memory>
+
+#include "xla/mlir/runtime/transforms/custom_call_encoding.h"
+#include "xla/runtime/custom_call_registry.h"
+#include "xla/service/gpu/fft_thunk.h"
+
+namespace xla {
+namespace gpu {
+
+// Registers XLA Gpu runtime fft custom calls.
+void RegisterFftCustomCalls(runtime::DirectCustomCallRegistry& registry);
+
+// Adds attributes encoding set for fft custom calls
+void PopulateFftAttrEncoding(runtime::CustomCallAttrEncodingSet& encoding);
+
+// Keep FftPlanCache for all FFT instances in the executable.
+class FftPlans : public runtime::StateVector<std::unique_ptr<FftPlanCache>> {};
+
+}  //  namespace gpu
+}  //  namespace xla
+
+#endif  // XLA_SERVICE_GPU_RUNTIME_FFT_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/fused_attention.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/fused_attention.h
new file mode 100644
index 0000000000000000000000000000000000000000..d6458f31c4a27bf4407ee19a699ee9ac520786cd
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/fused_attention.h
@@ -0,0 +1,108 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_RUNTIME_FUSED_ATTENTION_H_
+#define XLA_SERVICE_GPU_RUNTIME_FUSED_ATTENTION_H_
+
+#include <memory>
+#include <utility>
+
+#include "absl/container/node_hash_map.h"
+#include "absl/synchronization/mutex.h"
+#include "xla/mlir/runtime/transforms/custom_call_encoding.h"
+#include "xla/runtime/custom_call_registry.h"
+#include "xla/service/gpu/gpu_fused_mha_runner.h"
+
+namespace xla {
+namespace gpu {
+
+// Registers XLA Gpu runtime fused attention custom calls.
+void RegisterFusedAttentionCustomCalls(
+    runtime::DirectCustomCallRegistry& registry);
+
+// Register type names for fused attention attributes defined by MHLO dialect.
+void RegisterFusedAttentionTypeIdNames(runtime::TypeIDNameRegistry& registry);
+
+// Add attributes encoding for fused attention attributes defined by LMHLO
+// dialect.
+void PopulateFusedAttentionForwardDAGSignatureAttrEncoding(
+    runtime::CustomCallAttrEncodingSet& encoding);
+
+// Registers XLA Gpu runtime fused attention backward custom calls.
+void RegisterFusedAttentionBackwardCustomCalls(
+    runtime::DirectCustomCallRegistry& registry);
+
+// Add attributes encoding for fused attention backward attributes defined by
+// LMHLO dialect.
+void PopulateFusedAttentionBackwardDAGSignatureAttrEncoding(
+    runtime::CustomCallAttrEncodingSet& encoding);
+
+void PopulateFusedAttentionAlgorithmConfigAttrEncoding(
+    runtime::CustomCallAttrEncodingSet& encoding);
+
+//===----------------------------------------------------------------------===//
+// Cache fused dot attention runners between invocations of fused dot attention
+// custom calls.
+//===----------------------------------------------------------------------===//
+struct FusedAttentionRunner {
+  explicit FusedAttentionRunner(GpufMHAConfig config)
+      : config(std::move(config)), runner(this->config) {}
+  GpufMHAConfig config;
+  FusedMultiHeadedAttentionRunner runner;
+};
+
+struct FusedAttentionBackwardRunner {
+  explicit FusedAttentionBackwardRunner(GpufMHABackwardConfig config)
+      : config(std::move(config)), runner(this->config) {}
+  GpufMHABackwardConfig config;
+  FusedMultiHeadedAttentionBackwardRunner runner;
+};
+
+class StreamExecutorFusedAttentionRunners
+    : public runtime::StateVector<FusedAttentionRunner> {};
+
+class StreamExecutorFusedAttentionBackwardRunners
+    : public runtime::StateVector<FusedAttentionBackwardRunner> {};
+
+// Xla executable keeps a mapping from stream executors to fused attention
+// runners.
+class FusedAttentionRunners {
+ public:
+  StreamExecutorFusedAttentionRunners* operator()(se::StreamExecutor* executor);
+
+ private:
+  mutable absl::Mutex mutex_;
+  absl::node_hash_map<se::StreamExecutor*, StreamExecutorFusedAttentionRunners>
+      runners_ ABSL_GUARDED_BY(mutex_);
+};
+
+// Xla executable keeps a mapping from stream executors to fused attention
+// backward runners.
+class FusedAttentionBackwardRunners {
+ public:
+  StreamExecutorFusedAttentionBackwardRunners* operator()(
+      se::StreamExecutor* executor);
+
+ private:
+  mutable absl::Mutex mutex_;
+  absl::node_hash_map<se::StreamExecutor*,
+                      StreamExecutorFusedAttentionBackwardRunners>
+      runners_ ABSL_GUARDED_BY(mutex_);
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_RUNTIME_FUSED_ATTENTION_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/gemm.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/gemm.h
new file mode 100644
index 0000000000000000000000000000000000000000..828c8a10602f0571c75c0ef1efe1a8737955600a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/gemm.h
@@ -0,0 +1,36 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_RUNTIME_GEMM_H_
+#define XLA_SERVICE_GPU_RUNTIME_GEMM_H_
+
+#include "absl/container/node_hash_map.h"
+#include "xla/runtime/custom_call_registry.h"
+#include "xla/runtime/state.h"
+#include "xla/service/gpu/matmul_utils.h"
+
+namespace xla {
+namespace gpu {
+
+// Registers XLA Gpu runtime Gemm# custom calls.
+void RegisterGemmCustomCalls(runtime::DirectCustomCallRegistry& registry);
+
+// Keep GemmConfigs for all gemm/matmul instances in the executable.
+class GemmConfigs : public runtime::StateVector<GemmConfig> {};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_RUNTIME_GEMM_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/graph_launch.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/graph_launch.h
new file mode 100644
index 0000000000000000000000000000000000000000..e4841541bc781e685a23fa2a1cb617454719b8db
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/graph_launch.h
@@ -0,0 +1,139 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_RUNTIME_GRAPH_LAUNCH_H_
+#define XLA_SERVICE_GPU_RUNTIME_GRAPH_LAUNCH_H_
+
+#include <atomic>
+#include <memory>
+#include <optional>
+#include <string>
+#include <utility>
+#include <variant>
+
+#include "absl/container/node_hash_map.h"
+#include "xla/runtime/custom_call_registry.h"
+#include "xla/runtime/executable.h"
+#include "xla/service/service_executable_run_options.h"
+#include "xla/stream_executor/stream_executor.h"
+
+#if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+#include "xla/stream_executor/gpu/gpu_graph.h"
+#endif  // #if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+
+namespace xla {
+namespace gpu {
+
+// Registers XLA Gpu runtime graph launch custom calls.
+void RegisterGraphLaunchCustomCalls(
+    runtime::DirectCustomCallRegistry& registry);
+
+struct GraphInstance;                // Forward declare
+class StreamExecutorGraphInstances;  // Forward declare
+
+// A state vector that keeps track of the number of times a capture function
+// gets executed. Graph capture function ordinal is the key in this container.
+class CapturedFunctionExecutionCount
+    : public runtime::StateVector<std::unique_ptr<std::atomic<uint64_t>>> {};
+
+// Create the i-th value if the capture function with ordinal i causes graph
+// update failure.
+class OrdinalToFallback : public runtime::StateVector<std::monostate> {};
+
+#if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+
+// A state vector that owns all instantiated GPU graphs. Graph capture function
+// ordinal is the key in this container.
+class StreamExecutorGraphInstances
+    : public runtime::StateVector<GraphInstance> {};
+
+// Instantiated GPU graph instance guarded with a mutex for exclusive access.
+struct GraphInstance {
+  GraphInstance(size_t ptr_hash, se::gpu::OwnedGpuGraphExec exec)
+      : ptr_hash(ptr_hash), exec(std::move(exec)), mutex(new absl::Mutex) {}
+
+  // Graph instance is fully identified by the hash of its pointer arguments
+  // because currently it's guaranteed that all shapes and launch dimensions
+  // will be constant from run to run.
+  size_t ptr_hash ABSL_GUARDED_BY(*mutex);
+  se::gpu::OwnedGpuGraphExec exec ABSL_GUARDED_BY(*mutex);
+
+  // Access to a graph instance must be synchronized, because we potentially can
+  // run concurrent graph instance updates.
+  std::unique_ptr<absl::Mutex> mutex;
+};
+
+#else  // #if !GOOGLE_CUDA && !TENSORFLOW_USE_ROCM
+
+// Define empty struct and empty state when GPU is not enabled.
+struct GraphInstance {};
+class StreamExecutorGraphInstances
+    : public runtime::StateVector<GraphInstance> {};
+
+#endif  // #if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+
+// Xla executable keeps a mapping from stream executors to graph instances.
+//
+// Graph instances allocate on-device memory, so we periodically destroy
+// them to free up some space on device. JAX for example keeps all XLA
+// executables alive, and destroys them when the process shuts down, so we can
+// end up with thousands of unused (or rarely used) graphs in device memory.
+class GraphInstances {
+ public:
+  struct Impl;
+
+  GraphInstances(std::string module_name, int64_t num_graphs);
+  ~GraphInstances();
+
+  std::shared_ptr<StreamExecutorGraphInstances> operator()(
+      se::StreamExecutor* executor);
+
+  // Instantiates all Gpu graphs defined by the given executable using user
+  // provided run options. This guarantees that once we start execution, all Gpu
+  // graphs are ready, and will only require cheap update operation and will not
+  // require allocating new resources (we avoid non deterministic OOM errors).
+  //
+  // If timeout is not nullopt it will evict all previously instantiated graphs
+  // that were used more than `eviction_timeout_seconds` seconds ago.
+  Status InstantiateAllGraphs(
+      const ServiceExecutableRunOptions* run_options,
+      const runtime::Executable& executable,
+      const runtime::CustomCall::UserData& user_data, void* ptr,
+      OrdinalToFallback::Snapshot* ordinal_to_fallback,
+      std::optional<uint64_t> eviction_timeout_seconds = std::nullopt);
+
+  // Returns true if all Gpu graphs were already instantiated.
+  bool InstantiatedAllGraphs(const ServiceExecutableRunOptions* run_options,
+                             const runtime::Executable& executable);
+
+ private:
+  std::shared_ptr<Impl> impl_;
+};
+
+// Xla executable keeps a mapping from stream executors to execution counts.
+class CapturedFunctionExecutionCounts {
+ public:
+  CapturedFunctionExecutionCount* operator()(se::StreamExecutor* executor);
+
+ private:
+  mutable absl::Mutex mutex_;
+  absl::node_hash_map<se::StreamExecutor*, CapturedFunctionExecutionCount>
+      counts_ ABSL_GUARDED_BY(mutex_);
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_RUNTIME_GRAPH_LAUNCH_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/io_feed.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/io_feed.h
new file mode 100644
index 0000000000000000000000000000000000000000..ef4e42d770e49a9cdb875145136849037df9ec63
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/io_feed.h
@@ -0,0 +1,30 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_RUNTIME_IO_FEED_H_
+#define XLA_SERVICE_GPU_RUNTIME_IO_FEED_H_
+
+#include "xla/runtime/custom_call_registry.h"
+
+namespace xla {
+namespace gpu {
+
+// Registers XLA Gpu runtime infeed and outfeed custom calls.
+void RegisterIoFeedCustomCalls(runtime::DirectCustomCallRegistry& registry);
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_RUNTIME_IO_FEED_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/kernel_launch.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/kernel_launch.h
new file mode 100644
index 0000000000000000000000000000000000000000..80040b0f55f411fd898c32848cd9914bf5123592
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/kernel_launch.h
@@ -0,0 +1,56 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_RUNTIME_KERNEL_LAUNCH_H_
+#define XLA_SERVICE_GPU_RUNTIME_KERNEL_LAUNCH_H_
+
+#include <memory>
+#include <string_view>
+#include <tuple>
+
+#include "absl/container/node_hash_map.h"
+#include "absl/synchronization/mutex.h"
+#include "xla/runtime/custom_call_registry.h"
+#include "xla/runtime/state.h"
+#include "xla/stream_executor/stream_executor.h"
+
+namespace xla {
+namespace gpu {
+
+// Registers XLA Gpu runtime kernel launch custom calls.
+void RegisterKernelLaunchCustomCalls(
+    runtime::DirectCustomCallRegistry& registry);
+
+// Kernels loaded by Gpu executable for a single stream executor.
+class StreamExecutorKernels
+    : public runtime::StateVector<std::unique_ptr<se::KernelBase>> {};
+
+// Xla runtime Gpu executable owns the pre-compiled device module (PTX and
+// Cubin for Nvidia Gpus) for all device kernels, and the cache keeps a mapping
+// from stream executor to pre-loaded kernels
+class GpuExecutableKernels {
+ public:
+  StreamExecutorKernels* operator()(se::StreamExecutor* executor);
+
+ private:
+  mutable absl::Mutex mutex_;
+  absl::node_hash_map<se::StreamExecutor*, StreamExecutorKernels> kernels_
+      ABSL_GUARDED_BY(mutex_);
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_RUNTIME_KERNEL_LAUNCH_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/memcpy.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/memcpy.h
new file mode 100644
index 0000000000000000000000000000000000000000..cd4ecb4d5020a8e8fa5cbd5a2f12cb81bc485ffb
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/memcpy.h
@@ -0,0 +1,30 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_RUNTIME_MEMCPY_H_
+#define XLA_SERVICE_GPU_RUNTIME_MEMCPY_H_
+
+#include "xla/runtime/custom_call_registry.h"
+
+namespace xla {
+namespace gpu {
+
+// Registers XLA Gpu runtime memcpy custom calls.
+void RegisterMemcpyCustomCalls(runtime::DirectCustomCallRegistry& registry);
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_RUNTIME_MEMCPY_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/memset.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/memset.h
new file mode 100644
index 0000000000000000000000000000000000000000..e6d717941865ff366b15c4f5a92ad1e95c43532e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/memset.h
@@ -0,0 +1,30 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_RUNTIME_MEMSET_H_
+#define XLA_SERVICE_GPU_RUNTIME_MEMSET_H_
+
+#include "xla/runtime/custom_call_registry.h"
+
+namespace xla {
+namespace gpu {
+
+// Registers XLA Gpu runtime memset custom calls.
+void RegisterMemsetCustomCalls(runtime::DirectCustomCallRegistry& registry);
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_RUNTIME_MEMSET_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/send_recv.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/send_recv.h
new file mode 100644
index 0000000000000000000000000000000000000000..fcbe1ddcc9f9c0398a0d831f0701fdb9a065332b
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/send_recv.h
@@ -0,0 +1,56 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_RUNTIME_SEND_RECV_H_
+#define XLA_SERVICE_GPU_RUNTIME_SEND_RECV_H_
+
+#include <memory>
+#include <utility>
+
+#include "xla/mlir/runtime/transforms/custom_call_encoding.h"
+#include "xla/runtime/custom_call_registry.h"
+#include "xla/stream_executor/event.h"
+
+namespace xla {
+namespace gpu {
+
+// Registers XLA Gpu runtime Send/Recv custom calls.
+void RegisterSendRecvCustomCalls(runtime::DirectCustomCallRegistry& registry);
+
+// Register type names for communication attributes defined by MHLO dialect.
+void RegisterSendRecvTypeIdNames(runtime::TypeIDNameRegistry& registry);
+
+// Adds attributes encoding for Send/Recv custom calls
+void PopulateSendRecvAttrEncoding(runtime::CustomCallAttrEncodingSet& encoding);
+
+//===----------------------------------------------------------------------===//
+// Support for running asynchronous Send/Recv SendDone/RecvDone operations.
+//===----------------------------------------------------------------------===//
+
+class SendRecvEvents {
+ public:
+  absl::Status PushEvent(int32_t handle, tsl::AsyncValueRef<se::Event> event);
+  absl::StatusOr<tsl::AsyncValueRef<se::Event>> PopEvent(int32_t handle);
+
+ private:
+  absl::Mutex mutex_;
+  absl::flat_hash_map<int, tsl::AsyncValueRef<se::Event>> events_
+      ABSL_GUARDED_BY(mutex_);
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_RUNTIME_SEND_RECV_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/sleep_kernel.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/sleep_kernel.h
new file mode 100644
index 0000000000000000000000000000000000000000..0bcaed7c56cfb35a6a15d0c9d0f0b785e5b45d28
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/sleep_kernel.h
@@ -0,0 +1,21 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef XLA_SERVICE_GPU_RUNTIME_SLEEP_KERNEL_H_
+#define XLA_SERVICE_GPU_RUNTIME_SLEEP_KERNEL_H_
+
+namespace xla::gpu {
+
+void* GetSleepKernel();
+
+}  // namespace xla::gpu
+
+#endif  // XLA_SERVICE_GPU_RUNTIME_SLEEP_KERNEL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/stream_synchronization.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/stream_synchronization.h
new file mode 100644
index 0000000000000000000000000000000000000000..11d3175057c8c2457ca63918e63319fdae774125
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/stream_synchronization.h
@@ -0,0 +1,31 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_RUNTIME_STREAM_SYNCHRONIZATION_H_
+#define XLA_SERVICE_GPU_RUNTIME_STREAM_SYNCHRONIZATION_H_
+
+#include "xla/runtime/custom_call_registry.h"
+
+namespace xla {
+namespace gpu {
+
+// Registers XLA Gpu runtime stream synchronization custom calls.
+void RegisterStreamSynchronizationCustomCalls(
+    runtime::DirectCustomCallRegistry& registry);
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_RUNTIME_STREAM_SYNCHRONIZATION_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/support.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/support.h
new file mode 100644
index 0000000000000000000000000000000000000000..57bce214a73e1107fc83d6a25d9426bb72dd3038
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/support.h
@@ -0,0 +1,162 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_RUNTIME_SUPPORT_H_
+#define XLA_SERVICE_GPU_RUNTIME_SUPPORT_H_
+
+#include <string>
+#include <string_view>
+#include <utility>
+
+#include "absl/strings/str_cat.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "xla/mlir/runtime/transforms/custom_call_encoding.h"
+#include "xla/runtime/custom_call.h"
+#include "xla/service/gpu/matmul_utils.h"
+#include "xla/shape_util.h"
+#include "xla/stream_executor/blas.h"
+#include "xla/stream_executor/device_memory.h"
+
+namespace xla {
+namespace gpu {
+
+template <auto T>
+using FunctionWrapper = xla::runtime::CustomCall::FunctionWrapper<T>;
+
+struct DotDimensionNumbers {
+  absl::Span<const int64_t> lhs_batch;
+  absl::Span<const int64_t> lhs_contract;
+  absl::Span<const int64_t> rhs_batch;
+  absl::Span<const int64_t> rhs_contract;
+};
+
+// Disable expensive CustomCall checks in optimized build.
+inline constexpr runtime::CustomCall::RuntimeChecks checks =  // NOLINT
+#if defined(NDEBUG)
+    runtime::CustomCall::RuntimeChecks::kLess;
+#else
+    runtime::CustomCall::RuntimeChecks::kDefault;
+#endif
+
+template <typename T>
+absl::StatusOr<T> ToAbsl(StatusOr<T> status_or) {
+  if (!status_or.ok()) return status_or.status();
+  return std::move(status_or).value();
+}
+
+inline se::DeviceMemoryBase GetDeviceAddress(
+    const runtime::FlatMemrefView& memref) {
+  return se::DeviceMemoryBase(memref.data, memref.size_in_bytes);
+}
+
+inline se::DeviceMemoryBase GetDeviceAddress(
+    const runtime::MemrefView& memref) {
+  uint64_t size = primitive_util::ByteWidth(memref.dtype);
+  for (auto dim : memref.sizes) size *= dim;
+  return se::DeviceMemoryBase(memref.data, size);
+}
+
+inline se::DeviceMemoryBase GetDeviceAddress(
+    const runtime::StridedMemrefView& memref) {
+  uint64_t size = primitive_util::ByteWidth(memref.dtype);
+  for (auto dim : memref.sizes) size *= dim;
+  return se::DeviceMemoryBase(memref.data, size);
+}
+
+inline Shape ToShape(const runtime::StridedMemrefView& memref) {
+  // Recover `minor_to_major` dimensions permutation from strides.
+  auto indexed_strides_range =
+      llvm::map_range(llvm::enumerate(memref.strides), [](auto pair) {
+        return std::pair<int64_t, size_t>{pair.value(), pair.index()};
+      });
+
+  auto indexed_strides = llvm::to_vector(indexed_strides_range);
+  llvm::stable_sort(indexed_strides);
+
+  llvm::SmallVector<int64_t> minor_to_major;
+  minor_to_major.reserve(indexed_strides.size());
+  for (auto& pair : indexed_strides) minor_to_major.push_back(pair.second);
+
+  return ShapeUtil::MakeShapeWithDenseLayout(memref.dtype, memref.sizes,
+                                             minor_to_major);
+}
+
+inline StatusOr<GemmConfig> GetGemmConfig(
+    const runtime::StridedMemrefView& lhs,
+    const runtime::StridedMemrefView& rhs,
+    const runtime::StridedMemrefView& out, int64_t algorithm, double alpha_real,
+    double alpha_imag, double beta, absl::Span<const int64_t> lhs_batch,
+    absl::Span<const int64_t> lhs_contract, absl::Span<const int64_t> rhs_batch,
+    absl::Span<const int64_t> rhs_contract, int64_t compute_precision,
+    const std::optional<runtime::StridedMemrefView> c = std::nullopt,
+    const std::optional<runtime::StridedMemrefView>& bias = std::nullopt) {
+  Shape c_shape = ToShape(c.value_or(out));
+  Shape bias_shape;
+  Shape* bias_shape_ptr = nullptr;
+  if (bias) {
+    bias_shape = ToShape(*bias);
+    bias_shape_ptr = &bias_shape;
+  }
+  return GemmConfig::For(ToShape(lhs), lhs_batch, lhs_contract, ToShape(rhs),
+                         rhs_batch, rhs_contract, c_shape, bias_shape_ptr,
+                         ToShape(out), alpha_real, alpha_imag, beta, algorithm,
+                         compute_precision);
+}
+
+// adds Dot Dimension Attribute encodings for calls to Gemm and cuBLASLt
+inline void PopulateDotDimsAttrEncoding(
+    runtime::CustomCallAttrEncodingSet& encoding) {
+  using DotDimsAttr = mlir::mhlo::DotDimensionNumbersAttr;
+  encoding.Add<
+      xla::runtime::AggregateAttrEncoding<DotDimsAttr, DotDimensionNumbers>>(
+      encoding,
+      xla::runtime::AggregateAttrDef<DotDimsAttr>()
+          .Add("lhs_batch", &DotDimsAttr::getLhsBatchingDimensions)
+          .Add("lhs_contract", &DotDimsAttr::getLhsContractingDimensions)
+          .Add("rhs_batch", &DotDimsAttr::getRhsBatchingDimensions)
+          .Add("rhs_contract", &DotDimsAttr::getRhsContractingDimensions));
+}
+
+// Appends to `diagnostic_engine` a handler that appends all emitted errors to
+// the `diagnostic` string. If `append_annotation_stack` is true, it will append
+// current profiler annotation stack to the diagnostic message (annotation used
+// in Xprof).
+void AppendDiagnosticToString(runtime::DiagnosticEngine& diagnostic_engine,
+                              std::string* diagnostic,
+                              bool append_annotation_stack = false);
+
+// Sets the current tracing scope that will be added to all emitted diagnostics.
+void SetCurrentTracingScope(std::string_view scope);
+void ResetCurrentTracingScope();
+
+}  // namespace gpu
+}  // namespace xla
+
+namespace xla {
+namespace runtime {
+
+// using llvm::ArrayRef;
+
+XLA_RUNTIME_REGISTER_AGGREGATE_ATTR_DECODING(
+    xla::gpu::DotDimensionNumbers,
+    AggregateMember<absl::Span<const int64_t>>("lhs_batch"),
+    AggregateMember<absl::Span<const int64_t>>("lhs_contract"),
+    AggregateMember<absl::Span<const int64_t>>("rhs_batch"),
+    AggregateMember<absl::Span<const int64_t>>("rhs_contract"));
+
+}  // namespace runtime
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_RUNTIME_SUPPORT_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/topk.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/topk.h
new file mode 100644
index 0000000000000000000000000000000000000000..ea669e903dd6f0f5cc4eb56f8588c4f3e23f2808
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/topk.h
@@ -0,0 +1,28 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_RUNTIME_TOPK_H_
+#define XLA_SERVICE_GPU_RUNTIME_TOPK_H_
+
+#include "xla/runtime/custom_call_registry.h"
+
+namespace xla::gpu {
+
+// Registers XLA Gpu runtime TopK custom calls.
+void RegisterTopkCustomCall(runtime::DirectCustomCallRegistry& registry);
+
+}  // namespace xla::gpu
+
+#endif  // XLA_SERVICE_GPU_RUNTIME_TOPK_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/topk_kernel.cu.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/topk_kernel.cu.h
new file mode 100644
index 0000000000000000000000000000000000000000..908401c9979af87e133cae929071366ef9e23c18
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/topk_kernel.cu.h
@@ -0,0 +1,280 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_RUNTIME_TOPK_KERNEL_CU_H_
+#define XLA_SERVICE_GPU_RUNTIME_TOPK_KERNEL_CU_H_
+
+// This file contains bespoke and optimized implementation for TopK shapes. When
+// adding support for new shapes/dtypes, you also need to modify the rewritter
+// on topk_specializer.cc for these changes to be picked up.
+
+#include <cstddef>
+#include <cstdint>
+#include <limits>
+
+#include "xla/service/gpu/runtime/topk_kernel_common.h"
+
+namespace xla::gpu {
+
+// Default implementation for KV holder. Useful for testing while adding support
+// for a new type, but generally bitpacking those values is more efficient. See
+// implementations below.
+template <typename T, typename V>
+struct Descending {
+  class KVT {
+   public:
+    __device__ KVT() = default;
+    __device__ KVT& operator=(const KVT&) = default;
+    __device__ KVT& operator=(KVT&&) = default;
+    __device__ KVT(const KVT&) = default;
+    __device__ KVT(KVT&&) = default;
+
+    __device__ KVT(T k, V v) : k_(k), v_(v) {}
+    __forceinline__ __device__ void Write(T* key, uint32_t* value) const {
+      *key = k_;
+      *value = v_;
+    }
+
+    __device__ __forceinline__ KVT ShuffleDown(int offset) const {
+      unsigned FULL_MASK = 0xffffffff;
+      // The static casts here are necessary because some types will be
+      // broadened (e.g. bfloat16 -> f32), so we need to narrow them back after
+      // the shuffle.
+      return KVT(static_cast<T>(__shfl_down_sync(FULL_MASK, k_, offset)),
+                 static_cast<V>(__shfl_down_sync(FULL_MASK, v_, offset)));
+    }
+
+   private:
+    T k_;
+    V v_;
+    friend class Descending<T, V>;
+  };
+
+  __device__ __forceinline__ static constexpr bool Gt(const KVT& lhs,
+                                                      const KVT& rhs) {
+    return lhs.k_ == rhs.k_ ? lhs.v_ < rhs.v_ : lhs.k_ > rhs.k_;
+  }
+};
+
+// -----------------------------------------------------------------------------
+// More efficient implementation of Descending.
+// -----------------------------------------------------------------------------
+
+// Strided indexing.
+__device__ __forceinline__ int Idx(int i) {
+  return blockDim.x * i + threadIdx.x;
+}
+
+// TopK implements a faster TopK for K < 16.
+//
+// To compute the final largest K elements, we shard the data threads and each
+// of them computes the top k elements for the data in its slice. When all lanes
+// in a warp are done with their TopK, we merge all the lane-local topks into
+// lane 0 using warp-local reductions. The lane-local topk is computed at
+// PerWarpTopK() and the warp reduction is computed in Reduce(). The warp-local
+// results are stored in shared memory.
+//
+// Once all warps are done, we load all previously produced results into a
+// single warp and repeat the reduction described above. This is implemented in
+// MergeTopKs() and we reuse the Reduce() implementation described above. On
+// MergeTopKs we also write the final results to the user-provided buffer.
+//
+// === Detailed Design
+//
+// The high level goals of this implementations are:
+//  - Low latency for small N (i.e. kilobytes).
+//  - High throughput for large N and/or large batch.
+//
+// Non-goals:
+//  - K > 32. Register pressure will be too high.
+//  - Sharding over multiple SMs. As explained later, we can use TopK's
+//    structure to get this "for free".
+//
+// The core observation of this implementation is that reading/writing to main
+// memory is the bottleneck in usual the Sort/TopK implementations and that for
+// K<16 a linear scan with in-register data is faster than using a heap with
+// shared memory, especially when K is a power of two.
+//
+// The heap for K=7 looks like:
+//
+//             a0
+//        a1        a2
+//      a3  a4    a5  a6
+//
+// When performing a push/pop, in the worst case scenario we need to compare it
+// with the root, both of its children, and one of the two subtrees. This means
+// that using a heap for K=7 only save us 2/7 comparions. Additionally, if the
+// tree were unbalanced(e.g. K=8), we would not be able to unroll this
+// computation.
+//
+// If we're using linear insertion, the worst case results in the full K
+// comparisons comparisons, but with care all of those values can be kept in
+// registers, replacing somewhat load/store instructions with movs. This
+// performance are more than enough to surpass the heap.
+//
+// We split the data evenly over T (<=1024) threads, and use the algorithm above
+// to maintain a sorted list of K elements in registers and perform linear
+// insertions on every new element. Once a warp is done with their local slice,
+// we reduce the slice-local data using shfl and the insertion described above,
+// by adding the other lane's TopK results to the local lane. Once the warp is
+// done, lane 0 writes its results to shared memory. This step has complexity:
+//    theta(k * slice_size + k^2 * log2(k))
+//
+// On a second pass, we use a single warp to consume the results of the previous
+// step and merge them into a final topk, using an analogous algorithm to what
+// has been previously described. Complexity of this stage is:
+//    theta(k^2 * log2(k)).
+//
+// This algorithm only uses a single block per batch dimension, but for large N,
+// we can split the input into B batches of size N/B, calculate each of their
+// topks and then compute a final topk, fixing the indices in the process.
+//
+// Future improvements:
+//  - Use optimal sort/merge networks to reduce the complexity the algorithm and
+//    allow better scaling past K=16. This is fairly tricky to implement
+//    efficiently, so it was let out of v1.
+//
+template <size_t K, typename KT, typename VT,
+          template <typename KT1, typename VT2> class Traits = Descending>
+class TopK {
+ public:
+  using Trait = Traits<KT, VT>;
+  using KVT = typename Trait::KVT;
+
+  __device__ TopK(void* buffer, int num_outputs)
+      : buffer_(reinterpret_cast<KVT*>(buffer)), num_outputs_(num_outputs) {}
+
+  __device__ void Run(KT* key, int n, KT* keys, uint32_t* values) {
+    PerWarpTopK(key, n);
+    MergeTopKs(keys, values);
+  }
+
+ private:
+  // Compute a per-warp topk of a slice of data.
+  __device__ void PerWarpTopK(KT* key, int n) {
+    KVT tmp[K];
+    // TODO(doak): Use bitonic sort.
+#pragma unroll
+    for (int i = 0; i < K; i++) tmp[i] = KVT(key[Idx(i)], Idx(i));
+#pragma unroll
+    for (int i = 0; i < K; i++) {
+#pragma unroll
+      for (int j = i + 1; j < K; j++) {
+        KVT ti = tmp[i];
+        KVT tj = tmp[j];
+        bool cmp = Trait::Gt(ti, tj);
+        tmp[i] = cmp ? ti : tj;
+        tmp[j] = cmp ? tj : ti;
+      }
+    }
+
+    for (int idx = K; idx < n; idx++) {
+      KVT kv(key[Idx(idx)], Idx(idx));
+      Push(tmp, kv);
+    }
+
+    Reduce(tmp, 32);
+
+    if (threadIdx.x % 32 != 0) return;
+    int warp_id = threadIdx.x / 32;
+    for (int i = 0; i < K; i++) {
+      buffer_[i * 32 + warp_id] = tmp[i];
+    }
+  }
+
+  // Merge the per-warp topks into a single topk. The final data is written to
+  // `keys` and `values`
+  __device__ void MergeTopKs(KT* keys, uint32_t* values) {
+    KVT tmp[K];
+    // We only use one warp for this step.
+    if (threadIdx.x / 32 != 0) return;
+    __syncthreads();
+#pragma unroll
+    for (int i = 0; i < K; i++) tmp[i] = buffer_[i * 32 + threadIdx.x];
+    Reduce(tmp, blockDim.x / 32);
+    if (threadIdx.x != 0) return;
+    for (int i = 0; i < num_outputs_; ++i) {
+      tmp[i].Write(&keys[i], &values[i]);
+    }
+  }
+
+  // Merge `tmp` (a reverse-sorted array) from (0, `num_lanes`) lanes. The
+  // resulting array is stored in the tmp array of lane 0. For all other lanes,
+  // `tmp` is unspecified after this function is called.
+  __device__ __forceinline__ void Reduce(KVT tmp[K], int num_lanes) {
+    int lane_id = threadIdx.x % 32;
+    for (int offset = num_lanes / 2; offset > 0; offset /= 2) {
+#pragma unroll
+      for (int i = 0; i < K; i++) {
+        KVT kv = tmp[i].ShuffleDown(offset);
+        if (lane_id >= offset) continue;
+        Push(tmp, kv);
+      }
+    }
+  }
+
+  // Given a K-array of previously reverse-sorted KVTs, add kv to to it and
+  // remove the smallest element of the resulting array. Preserves the sorted
+  // order of `tmp`.
+  static __device__ __forceinline__ bool Push(KVT tmp[K], const KVT& kv) {
+    if (Trait::Gt(tmp[K - 1], kv)) return false;
+    tmp[K - 1] = kv;
+    if constexpr (K >= 2) {
+#pragma unroll
+      for (int i = K - 2; i >= 0; --i) {
+        if (Trait::Gt(tmp[i], kv)) break;
+        // Swap
+        KVT t = tmp[i];
+        tmp[i] = tmp[i + 1];
+        tmp[i + 1] = t;
+      }
+    }
+    return true;
+  }
+
+  int source_ = 0;
+  KVT* buffer_;
+  int num_outputs_;
+};
+
+// This shared memory buffer needs to be declared outside of the templated
+// Run(), as otherwise it would generate name conflicts from the multiple
+// instantiations of Run() from the multiple monomorphizations of Run().
+extern __device__ __shared__ int shmem[];
+
+template <size_t K, typename KT, typename VT>
+__launch_bounds__(kTopKMaxThreadsPerBlock, 1) __global__
+    void Run(KT* data, int n, KT* result, uint32_t* result_idxs, int k) {
+  TopK<K, KT, VT> top_k(shmem, k);
+  int slice_size = n / blockDim.x;
+  if (threadIdx.x < n % blockDim.x) {
+    slice_size++;
+  }
+  top_k.Run(&data[n * blockIdx.x], slice_size, &result[k * blockIdx.x],
+            &result_idxs[k * blockIdx.x]);
+}
+
+template <typename T, size_t K>
+void* GetTopKKernelForK(int n) {
+  // TODO(doak): Switch to uint32_t if we don't have an efficient
+  // implemementation for uint16_t.
+  return n < std::numeric_limits<uint16_t>::max()
+             ? reinterpret_cast<void*>(&Run<K, T, uint16_t>)
+             : reinterpret_cast<void*>(&Run<K, T, uint32_t>);
+}
+
+}  // namespace xla::gpu
+
+#endif  // XLA_SERVICE_GPU_RUNTIME_TOPK_KERNEL_CU_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/topk_kernel.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/topk_kernel.h
new file mode 100644
index 0000000000000000000000000000000000000000..6afd56d35fe9d6c4788781d8776879fe69dc0e7c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/topk_kernel.h
@@ -0,0 +1,43 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_RUNTIME_TOPK_KERNEL_H_
+#define XLA_SERVICE_GPU_RUNTIME_TOPK_KERNEL_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include "absl/status/status.h"
+#include "xla/stream_executor/gpu/gpu_stream.h"
+#include "xla/stream_executor/gpu/gpu_types.h"
+#include "xla/stream_executor/platform.h"
+#include "xla/xla_data.pb.h"
+
+namespace xla::gpu {
+
+// Input: [batch_size, num_elements]dtype
+// Output:
+//  - top_elements: [batch_size, k] dtype
+//  - top_indices: [batch_size, k] u32
+// Where `top_elements` contains the largest elements of the input, and
+// `top_indices` their original indices.
+absl::Status RunTopk(::tensorflow::se::gpu::GpuStreamHandle stream,
+                     PrimitiveType dtype, void* data, size_t num_elements,
+                     void* top_elements, uint32_t* top_indices, size_t k,
+                     size_t batch_size);
+
+}  // namespace xla::gpu
+
+#endif  // XLA_SERVICE_GPU_RUNTIME_TOPK_KERNEL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/topk_kernel_common.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/topk_kernel_common.h
new file mode 100644
index 0000000000000000000000000000000000000000..a805b4507aa09c7df2124e22ec9e311f44a3eea9
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/topk_kernel_common.h
@@ -0,0 +1,34 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_RUNTIME_TOPK_KERNEL_COMMON_H_
+#define XLA_SERVICE_GPU_RUNTIME_TOPK_KERNEL_COMMON_H_
+
+// Contains shared declarations between topk_kernel.cc and topk_kernel.cu.cc
+// but avoids including ABSL, etc. which some CUDA compilers cannot
+// handle.
+
+namespace xla::gpu {
+
+// We perform 2 32-way reductions, which means the largest number of threads per
+// block we support is 1024.
+static constexpr size_t kTopKMaxThreadsPerBlock = 1024;
+
+template <typename T, size_t K>
+void* GetTopKKernelForK(int n);
+
+}  // namespace xla::gpu
+
+#endif  // XLA_SERVICE_GPU_RUNTIME_TOPK_KERNEL_COMMON_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/tracing.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/tracing.h
new file mode 100644
index 0000000000000000000000000000000000000000..7f5efe48accac438642b8074e0a55e7e34c5a9d6
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/tracing.h
@@ -0,0 +1,34 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_RUNTIME_TRACING_H_
+#define XLA_SERVICE_GPU_RUNTIME_TRACING_H_
+
+#include <memory>
+
+#include "xla/runtime/custom_call_registry.h"
+#include "xla/runtime/type_id.h"
+
+namespace xla {
+namespace gpu {
+
+void RegisterTracingTypeIdNames(runtime::TypeIDNameRegistry& registry);
+
+void RegisterTracingCustomCalls(runtime::DirectCustomCallRegistry& registry);
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_RUNTIME_TRACING_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/triangular_solve.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/triangular_solve.h
new file mode 100644
index 0000000000000000000000000000000000000000..947633ed2d0793eb153321e6d69e12a3c43a41f8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime/triangular_solve.h
@@ -0,0 +1,52 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_RUNTIME_TRIANGULAR_SOLVE_H_
+#define XLA_SERVICE_GPU_RUNTIME_TRIANGULAR_SOLVE_H_
+
+#include <string_view>
+
+#include "xla/runtime/custom_call.h"
+#include "xla/service/service_executable_run_options.h"
+#include "xla/xla.pb.h"
+
+namespace xla {
+namespace gpu {
+
+using runtime::CustomCall;
+
+struct TriangularSolve {
+  // Adaptor from XlaCustomCall API to properly typed TriangularSolve handler.
+  static absl::Status run(const ServiceExecutableRunOptions* run_options,
+                          const DebugOptions* debug_options,
+                          CustomCall::RemainingArgs args,
+                          std::string_view backend_config);
+
+  absl::Status operator()(const ServiceExecutableRunOptions* run_options,
+                          const DebugOptions* debug_options,
+                          runtime::StridedMemrefView a,
+                          runtime::StridedMemrefView b,
+                          runtime::StridedMemrefView result,
+                          runtime::FlatMemrefView temp, bool left_side,
+                          bool lower, bool unit_diagonal,
+                          TriangularSolveOptions::Transpose transpose_a) const;
+
+  static TriangularSolve Handler() { return TriangularSolve(); }
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_RUNTIME_TRIANGULAR_SOLVE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime2/executable.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime2/executable.h
new file mode 100644
index 0000000000000000000000000000000000000000..ac61847680c07bd7be659b3c5a4bf2b1da0e6147
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime2/executable.h
@@ -0,0 +1,176 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_RUNTIME2_EXECUTABLE_H_
+#define XLA_SERVICE_GPU_RUNTIME2_EXECUTABLE_H_
+
+#include <cstdint>
+#include <memory>
+#include <string_view>
+#include <vector>
+
+#include "mlir/IR/BuiltinOps.h"  // from @llvm-project
+#include "mlir/IR/MLIRContext.h"  // from @llvm-project
+#include "xla/service/gpu/buffer_allocations.h"
+#include "xla/service/service_executable_run_options.h"
+#include "xla/status.h"
+#include "xla/statusor.h"
+
+//===----------------------------------------------------------------------===//
+// TODO(ezhulenev): We currently do not build with experimental XLA:GPU runtime
+// in open source because we do not have bazel dependency from XLA to IREE.
+#if XLA_DISABLE_GPU2_RUNTIME
+//===----------------------------------------------------------------------===//
+
+namespace xla::gpu {
+struct Gpu2RuntimeProgram {
+  Gpu2RuntimeProgram(std::unique_ptr<mlir::MLIRContext>,
+                     mlir::OwningOpRef<mlir::ModuleOp>, std::string,
+                     std::vector<int64_t>, DebugOptions) {}
+};
+
+struct Gpu2RuntimeExecutable {
+  static StatusOr<std::unique_ptr<Gpu2RuntimeExecutable>> Create(
+      std::unique_ptr<Gpu2RuntimeProgram>, std::string_view,
+      const std::vector<uint8_t>&) {
+    return absl::UnimplementedError(
+        "Experimental XLA:GPU runtime is not supported in OSS build");
+  }
+
+  Status Execute(const ServiceExecutableRunOptions* run_options,
+                 const BufferAllocations& buffer_allocations,
+                 const BufferAllocation* temp_alloc) {
+    return absl::UnimplementedError(
+        "Experimental XLA:GPU runtime is not supported in OSS build");
+  }
+};
+
+}  // namespace xla::gpu
+
+//===----------------------------------------------------------------------===//
+#else  // !XLA_DISABLE_GPU2_RUNTIME
+//===----------------------------------------------------------------------===//
+
+#include <string>
+#include <utility>
+
+#include "third_party/iree/runtime/src/iree/vm/api.h"  // IWYU pragma: keep
+#include "mlir/IR/OwningOpRef.h"  // from @llvm-project
+#include "xla/service/buffer_assignment.h"
+#include "xla/service/gpu/runtime2/compiler.h"
+#include "xla/xla.pb.h"
+
+namespace xla {
+namespace gpu {
+
+// Forward declare.
+struct HalDevice;
+
+// XLA:GPU program lowered to the IREE input dialects. XLA:GPU runtime
+// executable jit-compiles this program to an executable artifact (via lowering
+// to IREE VM executable).
+//
+// Top level module has a single HAL executable source that contains all device
+// kernels for an XLA module. After lowering from LMHLO executable source is
+// just a placeholder; it gets updated with a real device kernels source only
+// before we pass IR to IREE compiler (see Gpu2RuntimeExecutable below),
+// because in the XLA compilation pipeline backend compiler runs last.
+//
+// We have this program as an intermediate step between lowering from LMHLO to
+// VM executable to be able to introspect the compilation process. Once we have
+// this program, the Xla gpu compiler job is done, and lowering to IREE VM is
+// the responsibility of IREE compiler.
+struct Gpu2RuntimeProgram {
+  Gpu2RuntimeProgram(std::unique_ptr<mlir::MLIRContext> ctx,
+                     mlir::OwningOpRef<mlir::ModuleOp> module,
+                     std::string entry_point, std::vector<int64_t> buffer_sizes,
+                     DebugOptions debug_options)
+      : ctx(std::move(ctx)),
+        module(std::move(module)),
+        entry_point(std::move(entry_point)),
+        buffer_sizes(std::move(buffer_sizes)),
+        debug_options(std::move(debug_options)) {}
+
+  std::unique_ptr<mlir::MLIRContext> ctx;
+  mlir::OwningOpRef<mlir::ModuleOp> module;
+  std::string entry_point;
+  std::vector<int64_t> buffer_sizes;
+  DebugOptions debug_options;
+};
+
+// Gpu runtime executable encapsulates the Xla runtime executable compiled from
+// an Xla program and owns all the state required for running it (e.g. it owns
+// various caches required for performance).
+class Gpu2RuntimeExecutable {
+ public:
+  using Bytecode = RuntimeCompiler::Bytecode;
+
+  // Creates Gpu2RuntimeExecutable from the XLA:GPU program.
+  static StatusOr<std::unique_ptr<Gpu2RuntimeExecutable>> Create(
+      std::unique_ptr<Gpu2RuntimeProgram> program, std::string_view asm_text,
+      const std::vector<uint8_t>& binary);
+
+  ~Gpu2RuntimeExecutable();
+
+  // Executes entry function with the given buffer arguments.
+  Status Execute(const ServiceExecutableRunOptions* run_options,
+                 const BufferAllocations& buffer_allocations,
+                 const BufferAllocation* temp_alloc);
+
+ private:
+  Gpu2RuntimeExecutable(std::string module_name, int32_t module_id,
+                        std::unique_ptr<HalDevice> device,
+                        std::unique_ptr<Bytecode> bytecode,
+                        std::vector<int64_t> buffer_sizes,
+                        DebugOptions debug_options, std::string_view asm_text,
+                        absl::Span<const uint8_t> binary,
+                        iree::vm::ref<iree_vm_context_t> context,
+                        iree::vm::ref<iree_vm_instance_t> instance,
+                        std::unique_ptr<std::vector<iree_vm_module_t*>> modules,
+                        iree_vm_function_t function);
+
+  // Module name and unique id of the corresponding HLO module.
+  std::string module_name_;
+  int32_t module_id_;
+
+  // TODO(ezhulenev): Devices should be created lazily for each StreamExecutor
+  // and share underlying resources. For now we create a CUDA driver and CUDA
+  // HAL device for each executable. And we assume that we have just once GPU
+  // attached to the host, and always run on device with ordinal 0.
+  std::unique_ptr<HalDevice> device_;
+
+  std::unique_ptr<Bytecode> bytecode_;
+
+  std::vector<int64_t> buffer_sizes_;
+  const DebugOptions debug_options_;
+
+  std::string_view asm_text_;
+  absl::Span<const uint8_t> binary_;
+
+  // TODO(ezhulenev): VM context and instance should be shared between multiple
+  // executables. Also HAL module should be loaded just once. This has to be
+  // fixed together with efficient device sharing, because HAL VM module
+  // requires HAL device for loading.
+  iree::vm::ref<iree_vm_context_t> context_;
+  iree::vm::ref<iree_vm_instance_t> instance_;
+  std::unique_ptr<std::vector<iree_vm_module_t*>> modules_;
+  iree_vm_function_t function_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // !XLA_DISABLE_GPU2_RUNTIME
+#endif  // XLA_SERVICE_GPU_RUNTIME2_EXECUTABLE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime3/cholesky_thunk.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime3/cholesky_thunk.h
new file mode 100644
index 0000000000000000000000000000000000000000..f226a25f7e4885fd32462852c9015f697d09217c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime3/cholesky_thunk.h
@@ -0,0 +1,83 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_RUNTIME3_CHOLESKY_THUNK_H_
+#define XLA_SERVICE_GPU_RUNTIME3_CHOLESKY_THUNK_H_
+
+#include <optional>
+
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/service/buffer_assignment.h"
+#include "xla/service/gpu/buffer_allocations.h"
+#include "xla/service/gpu/cusolver_context.h"
+#include "xla/service/gpu/thunk.h"
+#include "xla/stream_executor/blas.h"
+#include "xla/stream_executor/gpu/gpu_asm_opts.h"
+#include "xla/stream_executor/stream_executor.h"
+#include "xla/types.h"
+#include "xla/xla_data.pb.h"
+#include "tsl/platform/status.h"
+
+namespace xla {
+namespace gpu {
+
+// This class stores everything that StreamExecutor needs to launch a Cholesky
+// decomposition (LAPACK potrf). It is generated by IrEmitter.
+//
+// As an implementation detail, we may run potrf (potentially in a loop, if
+// batch_size >1), or potrfBatched.
+//
+// Thread-compatible.
+class CholeskyThunk : public Thunk {
+ public:
+  CholeskyThunk(ThunkInfo thunk_info, const CholeskyOptions& options,
+                se::GpuAsmOpts asm_opts, BufferAllocation::Slice a_buffer,
+                BufferAllocation::Slice workspace_buffer,
+                BufferAllocation::Slice info_buffer, PrimitiveType type,
+                int64_t batch_size, int64_t n);
+
+  CholeskyThunk(const CholeskyThunk&) = delete;
+  CholeskyThunk& operator=(const CholeskyThunk&) = delete;
+
+  Status ExecuteOnStream(const ExecuteParams& params) override;
+
+ private:
+  se::GpuAsmOpts asm_opts_;
+  se::blas::UpperLower uplo_;
+
+  const BufferAllocation::Slice a_buffer_;
+  const BufferAllocation::Slice workspace_buffer_;
+  const BufferAllocation::Slice info_buffer_;
+
+  const PrimitiveType type_;
+  const int64_t batch_size_;
+  const int64_t n_;
+};
+
+struct CholeskyParams {
+  int64_t n;
+  int64_t batch_size;
+  se::blas::UpperLower uplo;
+  se::DeviceMemoryBase a_buffer;
+  se::DeviceMemoryBase workspace_buffer;
+  se::DeviceMemoryBase info_buffer;
+};
+Status RunCholesky(const se::GpuAsmOpts& asm_opts, PrimitiveType type,
+                   CholeskyParams* params, se::Stream* stream);
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_RUNTIME3_CHOLESKY_THUNK_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime_intrinsics.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime_intrinsics.h
new file mode 100644
index 0000000000000000000000000000000000000000..d73aced0e2a1fc58d7e83e7f82ab73ed2406d2c2
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/runtime_intrinsics.h
@@ -0,0 +1,28 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_RUNTIME_INTRINSICS_H_
+#define XLA_SERVICE_GPU_RUNTIME_INTRINSICS_H_
+
+#include "absl/strings/string_view.h"
+
+namespace xla {
+
+inline constexpr absl::string_view kXlaGpuAssertCustomCallTag =
+    "__xla_gpu_assert";
+
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_RUNTIME_INTRINSICS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/scatter_slice_simplifier.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/scatter_slice_simplifier.h
new file mode 100644
index 0000000000000000000000000000000000000000..374498fc31c5cd3d1067662c4db4f6c9432d03c9
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/scatter_slice_simplifier.h
@@ -0,0 +1,53 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_SCATTER_SLICE_SIMPLIFIER_H_
+#define XLA_SERVICE_GPU_SCATTER_SLICE_SIMPLIFIER_H_
+
+#include "xla/service/hlo_pass_interface.h"
+
+namespace xla {
+
+// Replaces scatters followed by truncation slices with a new scatter using
+// a different output shape, and the slices are eliminated.
+//
+// (a) Single output     (b) Multiple outputs    (c) Elementwise users
+//
+//   T[N+1] scatter       (T1, T2) scatter         T scatter  T constant
+//          v                v       v                  v     v
+//     T[N] slice          T1 gte    T2 gte            T maximum
+//                           v       v                     v
+//                         T1 slice  T2 slice           T slice
+//
+// This pattern is used when the last element of the scatter output is intended
+// to accumulate updates from the input elements that should be ignored.
+// This is slow if there are many indices mapped to the last output index and
+// the scatter is implemented using atomics, so everything collides on that one
+// memory location.
+// As OOB scatter indices are dropped by the GPU implementation, we can remove
+// the slice step entirely and avoid the memory congestion in the scatter step.
+
+class ScatterSliceSimplifier : public HloModulePass {
+ public:
+  absl::string_view name() const override { return "scatter-slice-simplifier"; }
+
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+};
+
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_SCATTER_SLICE_SIMPLIFIER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/sequential_thunk.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/sequential_thunk.h
new file mode 100644
index 0000000000000000000000000000000000000000..b674a5e24e7035b3e96138bcde063782dd8785e4
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/sequential_thunk.h
@@ -0,0 +1,54 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_SEQUENTIAL_THUNK_H_
+#define XLA_SERVICE_GPU_SEQUENTIAL_THUNK_H_
+
+#include <vector>
+
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/service/gpu/buffer_allocations.h"
+#include "xla/service/gpu/thunk.h"
+#include "xla/stream_executor/stream_executor.h"
+
+namespace xla {
+namespace gpu {
+
+// A thunk that wraps a list of sub-thunks. Executing this thunk executes all
+// the sub-thunks sequentially. This is useful to implement instructions that
+// require multiple kernel launches or library calls.
+class SequentialThunk : public Thunk {
+ public:
+  SequentialThunk(ThunkInfo thunk_info, ThunkSequence thunks);
+  SequentialThunk(const SequentialThunk&) = delete;
+  SequentialThunk& operator=(const SequentialThunk&) = delete;
+
+  ThunkSequence& thunks() { return thunks_; }
+  const ThunkSequence& thunks() const { return thunks_; }
+  std::string ToStringExtra(int indent) const override;
+
+  Status Initialize(const GpuExecutable& executable,
+                    se::StreamExecutor* executor) override;
+  Status ExecuteOnStream(const ExecuteParams& params) override;
+
+ private:
+  // The list of sub-thunks.
+  ThunkSequence thunks_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_SEQUENTIAL_THUNK_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/softmax_rewriter_triton.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/softmax_rewriter_triton.h
new file mode 100644
index 0000000000000000000000000000000000000000..fd131f8336d75483bdcc1f0506c453db9681153b
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/softmax_rewriter_triton.h
@@ -0,0 +1,70 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_SOFTMAX_REWRITER_TRITON_H_
+#define XLA_SERVICE_GPU_SOFTMAX_REWRITER_TRITON_H_
+
+#include <vector>
+
+#include "absl/container/flat_hash_set.h"
+#include "absl/strings/string_view.h"
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/service/hlo_pass_interface.h"
+#include "xla/status.h"
+#include "xla/statusor.h"
+#include "xla/stream_executor/device_description.h"
+
+namespace xla {
+namespace gpu {
+
+struct DiamondChainDescriptor {
+  HloInstruction* root = nullptr;
+  HloInstruction* producer = nullptr;
+};
+
+// Rewrite compatible Softmax into a custom fusion region to be code-generated
+// with the Triton-based Softmax emitter.
+class SoftmaxRewriterTriton : public HloModulePass {
+ public:
+  explicit SoftmaxRewriterTriton(se::GpuComputeCapability gpu_version)
+      : gpu_version_(gpu_version) {}
+  absl::string_view name() const override { return "triton-softmax-rewriter"; }
+
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+
+  // Finds and returns all the fusible diamond chains in the module. The
+  // resulting vector is sorted according to a post-order matching (i.e. within
+  // the same computation, producer diamonds appear before consumer diamonds).
+  std::vector<DiamondChainDescriptor> FindAllFusibleDiamondChains(
+      HloModule& module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) const;
+
+  // Constructs a Softmax fusion containing all the instructions between the
+  // root and the producer of a diamond chain. The producer is excluded from the
+  // fusion.
+  Status FuseDiamondChain(const DiamondChainDescriptor& diamond_chain);
+
+ private:
+  se::GpuComputeCapability gpu_version_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_SOFTMAX_REWRITER_TRITON_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/split_k_gemm_rewriter.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/split_k_gemm_rewriter.h
new file mode 100644
index 0000000000000000000000000000000000000000..436247be2a4b0b76835829eb1b054e249e4d6a7f
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/split_k_gemm_rewriter.h
@@ -0,0 +1,42 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef XLA_SERVICE_GPU_SPLIT_K_GEMM_REWRITER_H_
+#define XLA_SERVICE_GPU_SPLIT_K_GEMM_REWRITER_H_
+
+#include <cstdint>
+
+#include "absl/types/span.h"
+#include "xla/autotuning.pb.h"
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/status.h"
+
+namespace xla {
+namespace gpu {
+
+// Is there a non-empty suffix "s" of span such that product(s) % divisor = 0
+// and for all t != s non-empty suffixes of s: d % product(t) = 0?
+bool HasDivisibleSuffixAllowingSplit(absl::Span<int64_t const> span,
+                                     int64_t divisor);
+
+// Apply split K configuration from the tiling to the fusion instruction:
+// in addition to MakeDotComputationSplitKBatch on its computation add the
+// necessary reduction after it.
+Status MakeDotSplitKBatch(HloInstruction* dot_fusion,
+                          const AutotuneResult::TritonGemmKey& tiling);
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_SPLIT_K_GEMM_REWRITER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/stream_executor_util.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/stream_executor_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..4e291b5e9a04cc7b4398a63f5e679e445feab2f6
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/stream_executor_util.h
@@ -0,0 +1,123 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_STREAM_EXECUTOR_UTIL_H_
+#define XLA_SERVICE_GPU_STREAM_EXECUTOR_UTIL_H_
+
+#include <string_view>
+
+#include "absl/strings/string_view.h"
+#include "absl/types/span.h"
+#include "xla/autotuning.pb.h"
+#include "xla/layout.h"
+#include "xla/service/gpu/cublas_cudnn.h"
+#include "xla/service/gpu/launch_dimensions.h"
+#include "xla/service/hlo_module_config.h"
+#include "xla/statusor.h"
+#include "xla/stream_executor/kernel_spec.h"
+#include "xla/stream_executor/stream_executor.h"
+#include "xla/types.h"
+#include "xla/xla_data.pb.h"
+
+// Helper functions for interacting with StreamExecutor.
+
+namespace xla {
+namespace gpu {
+
+// Returns (input, filter, output) XLA Layout protos given the StreamExecutor
+// layouts.
+StatusOr<std::tuple<Layout, Layout, Layout>>
+StreamExecutorConvLayoutsToXlaLayouts(const ConvolutionDimensionNumbers& dnums,
+                                      se::dnn::DataLayout input,
+                                      se::dnn::FilterLayout filter,
+                                      se::dnn::DataLayout output);
+
+// Returns (input, filter, output) StreamExecutor layouts given the XLA layouts.
+StatusOr<
+    std::tuple<se::dnn::DataLayout, se::dnn::FilterLayout, se::dnn::DataLayout>>
+XlaConvShapesToStreamExecutorLayouts(const ConvolutionDimensionNumbers& dnums,
+                                     const Shape& input, const Shape& filter,
+                                     const Shape& output);
+
+// Finds the VECT_C dimension in input/filter/output, if present.
+//
+// A cudnn convolution may have layout NCHW_VECT_C, which means instead of
+// [N,C,H,W], the layout is [N,C/k,H,W,k] for some k (usually 4 or 32).
+//
+// ConvolutionDimensionNumbers doesn't explicitly store which is the `k`
+// dimension, because only cudnn convolutions have this feature; it's not
+// applicable elsewhere.  We find it by finding a dimension in the
+// input/filter/output shape that is *not* in dnums.
+std::tuple<std::optional<int64_t>, std::optional<int64_t>,
+           std::optional<int64_t>>
+FindVectorizedFeatureDims(const ConvolutionDimensionNumbers& dnums,
+                          const Shape& input, const Shape& filter,
+                          const Shape& output);
+
+// Generates and returns a unique lock per the provided executor.
+// Guarantees that blocks of code running for the same provided
+// executor will not be running concurrently if they lock the returned mutex.
+//
+// This is used to prevent other XLA instances from trying to autotune on a
+// device while another thread is using it.
+absl::Mutex& GetGpuMutex(const se::StreamExecutor* stream_exec);
+
+// Creates a kernel with a provided name, based from provided PTX in ptx.
+// The kernel should be executed using the provided executor.
+// The argument cubin_data represents compiled PTX and may be left empty.
+//
+// The canonical storage for both ptx and cubin_data should outlive
+// the lifetime of the kernel.
+StatusOr<std::unique_ptr<se::KernelBase>> CreateKernel(
+    absl::string_view kernel_name, uint64_t num_args, absl::string_view ptx,
+    absl::Span<const uint8_t> cubin_data, se::StreamExecutor* stream_exec,
+    uint32_t shared_mem_bytes = 0);
+
+// Runs loaded kernel on the stream with the provided arguments.
+Status ExecuteKernelOnStream(const se::KernelBase& kernel,
+                             absl::Span<const se::DeviceMemoryBase> args,
+                             const LaunchDimensions& dims, se::Stream* stream);
+
+// Initializes `buffer` with random data on `stream`.
+// `rng_state` is an inout parameter for the pseudorandom generator state.
+// `buffer_type` determines what buffer would be filled out with.
+//
+// Precondition: `buffer_type` is a floating point type, `rng_state` needs to be
+// initialized to zero on the first use.
+void InitializeBuffer(se::Stream* stream, PrimitiveType buffer_type,
+                      int64_t* rng_state, se::DeviceMemoryBase buffer);
+
+StatusOr<se::dnn::ConvolutionKind> GetDNNConvKindFromCudnnConvKind(
+    CudnnConvKind kind);
+
+StatusOr<se::dnn::FusedMHAKind> GetDNNFusedMHAKindFromCudnnfMHAKind(
+    CudnnfMHAKind kind);
+
+StatusOr<se::dnn::DataType> GetDNNDataTypeFromPrimitiveType(PrimitiveType type);
+
+// Returns result with the smallest time which has not failed.
+// If deterministic output is requested, returns first (not failing) result.
+StatusOr<AutotuneResult> PickBestResult(
+    absl::Span<AutotuneResult const> profile_results,
+    std::optional<std::string_view> instr_str,
+    HloModuleConfig hlo_module_config);
+
+// Returns whether determinism is required.
+bool RequireDeterminism(const HloModuleConfig& config);
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_STREAM_EXECUTOR_UTIL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/target_constants.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/target_constants.h
new file mode 100644
index 0000000000000000000000000000000000000000..92f31a6c13506806f9a11b60442ff238237e9ae1
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/target_constants.h
@@ -0,0 +1,60 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_TARGET_CONSTANTS_H_
+#define XLA_SERVICE_GPU_TARGET_CONSTANTS_H_
+
+namespace xla {
+namespace gpu {
+
+namespace nvptx {
+// The triple that represents our target.
+inline const char* TargetTriple() {
+  static constexpr char kTargetTriple[] = "nvptx64-nvidia-cuda";
+  return kTargetTriple;
+}
+
+// The data layout of the emitted module. Copied from computeDataLayout in
+// NVPTXTargetMachine.cpp.
+inline const char* DataLayout() {
+  static constexpr char kDataLayout[] =
+      "e-i64:64-i128:128-v16:16-v32:32-n16:32:64";
+  return kDataLayout;
+}
+}  // namespace nvptx
+
+namespace amdgpu {
+
+// The triple that represents our target on LLVM AMDGPU backend.
+inline const char* TargetTriple() {
+  static constexpr char kTargetTriple[] = "amdgcn-amd-amdhsa";
+  return kTargetTriple;
+}
+
+// The data layout of the emitted module.
+inline const char* DataLayout() {
+  static constexpr char kDataLayout[] =
+      "e-p:64:64-p1:64:64-p2:64:64-p3:32:32-p4:32:32-p5:32:32"
+      "-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128"
+      "-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-A5";
+  return kDataLayout;
+}
+
+}  // namespace amdgpu
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_TARGET_CONSTANTS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/target_util.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/target_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..19b00307b3fea1e68cce82acb5e72df0c16ec8d4
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/target_util.h
@@ -0,0 +1,97 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_TARGET_UTIL_H_
+#define XLA_SERVICE_GPU_TARGET_UTIL_H_
+
+#include <string>
+
+#include "absl/strings/string_view.h"
+#include "absl/types/span.h"
+#include "llvm/IR/IRBuilder.h"
+#include "llvm/IR/Intrinsics.h"
+#include "llvm/IR/Module.h"
+#include "llvm/TargetParser/Triple.h"
+#include "xla/hlo/ir/hlo_opcode.h"
+#include "xla/xla_data.pb.h"
+
+namespace xla {
+namespace gpu {
+
+// Enumeration to get target specific intrinsics.
+enum class TargetIntrinsicID {
+  kThreadIdx = 0,
+  kThreadIdy,
+  kThreadIdz,
+  kBlockIdx,
+  kBlockIdy,
+  kBlockIdz,
+  kBarrierId,
+  kBlockDimx,
+  kBlockDimy,
+  kBlockDimz,
+  kGroupBarrierId,
+};
+
+// Enumeration to get target specific device math function.
+enum class TargetDeviceFunctionID {
+  kAtan2 = 0,
+  kCbrt,
+  kCos,
+  kExp,
+  kExpm1,
+  kFmod,
+  kHypot,
+  kLog,
+  kLog1p,
+  kPow,
+  kRsqrt,
+  kSin,
+  kSqrt,
+  kTan,
+  kTanh,
+};
+
+// HLO opcode -> TargetDeviceFunctionID mapping.
+StatusOr<TargetDeviceFunctionID> GetTargetDeviceFunctionID(HloOpcode);
+
+// Emits IR to call a device function named "callee_name" on the given
+// operand. Returns the IR value that represents the return value.
+llvm::CallInst* EmitDeviceFunctionCall(
+    const std::string& callee_name, absl::Span<llvm::Value* const> operands,
+    absl::Span<const PrimitiveType> input_type, PrimitiveType output_type,
+    const llvm::AttrBuilder& attributes, llvm::IRBuilder<>* b,
+    absl::string_view name = "");
+
+// Emits a call to the specified target intrinsic with the given operands.
+// Overloaded intrinsics (for example, "minnum") must include a type
+// in overloaded_types  for each overloaded type. Typically, overloaded
+// intrinsics have only a single overloaded type.
+llvm::CallInst* EmitCallToTargetIntrinsic(
+    TargetIntrinsicID intrinsic_id, absl::Span<llvm::Value* const> operands,
+    absl::Span<llvm::Type* const> overloaded_types, llvm::IRBuilder<>* b);
+
+// Annotate the kernel as GPU kernel according to the GPU target.
+void AnnotateFunctionAsGpuKernel(llvm::Module* module, llvm::Function* func,
+                                 llvm::IRBuilder<>* b);
+
+std::string ObtainDeviceFunctionName(TargetDeviceFunctionID func_id,
+                                     PrimitiveType output_type,
+                                     llvm::Triple target_triple);
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_TARGET_UTIL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/thunk.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/thunk.h
new file mode 100644
index 0000000000000000000000000000000000000000..2bea9efc004b0058de09dfe1755bd69345e66094
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/thunk.h
@@ -0,0 +1,200 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_THUNK_H_
+#define XLA_SERVICE_GPU_THUNK_H_
+
+#include <functional>
+#include <memory>
+#include <optional>
+#include <ostream>
+#include <string>
+#include <vector>
+
+#include "mlir/IR/Operation.h"  // from @llvm-project
+#include "xla/service/gpu/buffer_allocations.h"
+#include "xla/service/gpu/gpu_executable_run_options.h"
+#include "xla/service/service_executable_run_options.h"
+#include "xla/stream_executor/stream_executor.h"
+#include "tsl/platform/status.h"
+
+namespace xla {
+namespace gpu {
+
+class GpuExecutable;
+
+enum AsyncStreamKind {
+  kAsyncStreamCollective = 0,  // Stream for asynchronous collective ops.
+  kAsyncStreamP2P = 1,         // Stream for P2P Send and Recv ops.
+};
+constexpr static int64_t kAsyncStreamTotal = kAsyncStreamP2P + 1;
+// Assigns a unique ID to a stream for asynchronous or synchronous execution.
+// These IDs can be used, for example, to look up the NCCL communicator.
+inline uint64_t GetStreamId(
+    bool is_async, AsyncStreamKind stream_kind = kAsyncStreamCollective) {
+  return is_async ? stream_kind + 1 : 0;
+}
+
+// Thunk acts as the bridge between IrEmitter and GpuExecutable. It stores the
+// metadata IrEmitter generates for GpuExecutable to invoke an HloInstruction.
+//
+// Thunk provides the Initialize and ExecuteOnStream interface for GpuExecutable
+// to initialize and execute the invocation respectively. Its subclasses are
+// supposed to override these interfaces to launch a generated kernel or call an
+// external library function (such as operations in cuBLAS).
+//
+// This is thread-compatible.
+class Thunk {
+ public:
+  enum Kind {
+    kCholesky,
+    kConditional,
+    kConvolution,
+    kConvolutionReorder,
+    kCopy,
+    kCublasLtMatmul,
+    kCustomCall,
+    kFft,
+    kFor,
+    kGemm,
+    kInfeed,
+    kKernel,
+    kMemset32BitValue,
+    kMemzero,
+    kNcclAllGather,
+    kNcclAllGatherStart,
+    kNcclAllGatherDone,
+    kNcclAllReduce,
+    kNcclAllReduceStart,
+    kNcclAllReduceDone,
+    kNcclCollectivePermute,
+    kNcclCollectivePermuteStart,
+    kNcclCollectivePermuteDone,
+    kNcclReduceScatter,
+    kNcclReduceScatterStart,
+    kNcclReduceScatterDone,
+    kNcclAllToAll,
+    kNcclAllToAllStart,
+    kNcclAllToAllDone,
+    kNcclSend,
+    kNcclRecv,
+    kOutfeed,
+    kReplicaId,
+    kPartitionId,
+    kSequential,
+    kTriangularSolve,
+    kWhile,
+    kFusedMHA
+  };
+
+  struct ThunkInfo {
+    explicit ThunkInfo(mlir::Operation* op) : op(op) {}
+    std::optional<int64_t> profile_index;
+    std::string profile_annotation;
+    mlir::Operation* op;
+
+    static ThunkInfo WithProfileAnnotation(mlir::Operation* op);
+  };
+
+  // The hlo_instruction argument is meant to be the instruction this thunk was
+  // generated from, but Thunk never uses this argument other than to save it
+  // to Thunk::hlo_instruction, so it can be null.
+  Thunk(Kind kind, ThunkInfo thunk_info)
+      : kind_(kind),
+        profile_index_(thunk_info.profile_index),
+        profile_annotation_(thunk_info.profile_annotation),
+        op_(thunk_info.op) {}
+  virtual ~Thunk() = default;
+  Thunk(const Thunk&) = delete;
+  Thunk& operator=(const Thunk&) = delete;
+
+  virtual std::string ToStringExtra(int indent) const { return ""; }
+  Kind kind() const { return kind_; }
+  std::string profile_annotation() const { return profile_annotation_; }
+  // Only valid during compilation, i.e., lowering thunks to kernel-launch
+  // related XLA runtime custom calls). nullptr at runtime. MLIR codegen will
+  // cease the practice of lowering thunks to XLA runtime custom calls.
+  mlir::Operation* op() { return op_; }
+
+  // Prepares the thunk for execution on the given StreamExecutor.
+  //
+  // This may be called multiple times.  Its main purpose is to give us a chance
+  // to do initialization outside of ExecuteOnStream() so that the
+  // time spent initializing doesn't count towards our execution profile.
+  virtual Status Initialize(const GpuExecutable& /*executable*/,
+                            se::StreamExecutor* /*executor*/) {
+    return OkStatus();
+  }
+
+  // Parameters passed to ExecuteOnStream.  Encapsulated in a struct so that
+  // when we add something we don't have to change every subclass of Thunk.
+  struct ExecuteParams {
+    ExecuteParams(const ServiceExecutableRunOptions& run_options,
+                  const BufferAllocations& buffer_allocations,
+                  se::Stream* stream,
+                  absl::Span<se::Stream* const> async_streams);
+
+    const BufferAllocations* buffer_allocations;  // never null
+    se::Stream* stream;
+    absl::InlinedVector<se::Stream*, kAsyncStreamTotal> async_comms_streams;
+    NcclExecuteParams nccl_params;
+  };
+
+  // Execute the kernel for the thunk on the given stream. This method must be
+  // called after Initialize and can be called multiple times over Thunk's
+  // lifetime.
+  //
+  // Precondition: Initialize(stream->parent()) has been called.
+  virtual Status ExecuteOnStream(const ExecuteParams& params) = 0;
+
+  // Clears metadata that is only valid during compile time.
+  virtual void ClearCompileTimeInfo() { op_ = nullptr; }
+
+  static absl::string_view KindToString(Thunk::Kind kind);
+
+ protected:
+  std::optional<int64_t> profile_index() const { return profile_index_; }
+
+ private:
+  Kind kind_;
+  std::optional<int64_t> profile_index_;
+  std::string profile_annotation_;
+  mlir::Operation* op_;
+};
+
+// A sequence of thunks.
+class ThunkSequence : public std::vector<std::unique_ptr<Thunk>> {
+ public:
+  std::string ToString(int indent = 0,
+                       std::function<std::string(const Thunk*)>
+                           get_thunk_annotation = nullptr) const;
+};
+
+std::ostream& operator<<(std::ostream& os, Thunk::Kind kind);
+
+// A struct that defines a shaped slice, i.e., a BufferAllocation::Slice and its
+// shape.
+struct ShapedSlice {
+  BufferAllocation::Slice slice;
+  Shape shape;
+};
+
+// Returns if the thunk implements a reduction collective (all-reduce or
+// reduce-scatter).
+bool IsReductionCollective(Thunk::Kind kind);
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_THUNK_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/topk_specializer.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/topk_specializer.h
new file mode 100644
index 0000000000000000000000000000000000000000..c2c02cfe1864fee6bc6fff9449c818a122d4e9f8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/topk_specializer.h
@@ -0,0 +1,43 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_TOPK_SPECIALIZER_H_
+#define XLA_SERVICE_GPU_TOPK_SPECIALIZER_H_
+
+#include "absl/container/flat_hash_set.h"
+#include "absl/strings/string_view.h"
+#include "xla/executable_run_options.h"
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/service/hlo_pass_interface.h"
+#include "xla/statusor.h"
+#include "tsl/platform/statusor.h"
+
+namespace xla::gpu {
+
+// This pass transforms eligible TopK CustomCall into a call to be executed by
+// runtime/topk.cc.
+class TopkSpecializer : public HloModulePass {
+ public:
+  absl::string_view name() const override { return "topk-specializer"; }
+
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+};
+
+}  // namespace xla::gpu
+
+#endif  // XLA_SERVICE_GPU_TOPK_SPECIALIZER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/topk_splitter.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/topk_splitter.h
new file mode 100644
index 0000000000000000000000000000000000000000..ac177d10151ec94cce7e11dfbb9d4522cf2ddcd5
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/topk_splitter.h
@@ -0,0 +1,55 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_TOPK_SPLITTER_H_
+#define XLA_SERVICE_GPU_TOPK_SPLITTER_H_
+
+#include <cstddef>
+#include <string_view>
+
+#include "absl/container/flat_hash_set.h"
+#include "absl/strings/string_view.h"
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/hlo/ir/hlo_instructions.h"
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/service/hlo_pass_interface.h"
+#include "xla/statusor.h"
+#include "tsl/platform/statusor.h"
+
+namespace xla {
+namespace gpu {
+
+// Splits large TopK into batches of smaller TopKs, followed by sorting and
+// slicing the results of those smaller topks. We consider TopKs to be 'large'
+// the last dimension of the TopK is larger than `split_threshold`.
+class TopKSplitter : public HloModulePass {
+ public:
+  explicit TopKSplitter(size_t split_threshold = 1024 * 1024)
+      : split_threshold_(split_threshold) {}
+  absl::string_view name() const override { return "topk-splitter"; }
+
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+
+ private:
+  const size_t split_threshold_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_TOPK_SPLITTER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/tree_reduction_rewriter.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/tree_reduction_rewriter.h
new file mode 100644
index 0000000000000000000000000000000000000000..5c3e8d9bf73116122e4d28dfd862d1fcc430e6de
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/tree_reduction_rewriter.h
@@ -0,0 +1,99 @@
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef XLA_SERVICE_GPU_TREE_REDUCTION_REWRITER_H_
+#define XLA_SERVICE_GPU_TREE_REDUCTION_REWRITER_H_
+
+#include <utility>
+
+#include "absl/strings/string_view.h"
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/service/hlo_pass_interface.h"
+#include "xla/statusor.h"
+#include "xla/stream_executor/device_description.h"
+
+namespace xla {
+namespace gpu {
+
+// Rewrites reductions in a way they can be implemented without atomics.
+//
+// Rule application: rewrite a single HLO reduce operation into two.
+//
+// Case 1: Row reduction, batched dimension is present, larger than
+// Z-tiling size.
+// -----------------------------------------------------------------
+//
+// Rewriting:
+//
+// f32[B] out = reduce(f32[A, B, C] input, dimensions={0, 2})
+//
+// Into:
+//
+// f32[A, B] tmp = reduce(f32[A, B, C] input, dimensions={2})
+// f32[B] out = reduce(f32[A, B] tmp, dimensions={0})
+//
+// Case 2: Row reduction
+// ------------------------------------------------------------------
+//
+// Let M be the thread tiling multiplied by the warp size.
+// We go from (assuming C > M):
+//
+// f32[B] out = reduce(f32[A, B, C] input, dimensions={0, 2})
+//
+// to:
+//
+// f32[A, B, P] padded = pad(input) // Let P = ceil(C/M) * M.
+// f32[A, B, Q, M] reshaped = bitcast(padded) // Let Q = ceil(C/M)
+// f32[B, Q] inner_reduce = reduce(reshaped, dimensions={0, 3})
+// f32[B] outer_reduce = reduce(inner_reduce, dimensions={1})
+//
+// Case 3: Column reduction
+// -------------------------------------------------------------------
+//
+// Let T be the tiling size for the column reduction.
+//
+// We go from (assuming B > T):
+//
+// f32[A, C] out = reduce(f32[A, B, C] input, dimensions={1})
+//
+// to:
+//
+// f32[A, P, C] padded = pad(input) // Let P = ceil(B/T) * T.
+// f32[A, Q, T, C] reshaped = bitcast(padded) // Let Q = ceil(B/T)
+// f32[A, Q, C] inner_reduce = reduce(reshaped, dimensions={2})
+// f32[A, C] outer_reduce = reduce(inner_reduce, dimensions={1})
+//
+class GpuTreeReductionRewriter : public HloModulePass {
+ public:
+  explicit GpuTreeReductionRewriter(se::GpuComputeCapability gpu_version)
+      : gpu_version_(gpu_version) {}
+
+  ~GpuTreeReductionRewriter() override = default;
+  absl::string_view name() const override {
+    return "gpu-tree-reduction-rewriter";
+  }
+
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+
+ private:
+  se::GpuComputeCapability gpu_version_;
+};
+
+}  // end namespace gpu
+}  // end namespace xla
+
+#endif  // XLA_SERVICE_GPU_TREE_REDUCTION_REWRITER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/triangular_solve_rewriter.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/triangular_solve_rewriter.h
new file mode 100644
index 0000000000000000000000000000000000000000..7e1e2e0c69538f3f43373ca6cf92ac12eb9e33b4
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/triangular_solve_rewriter.h
@@ -0,0 +1,59 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_TRIANGULAR_SOLVE_REWRITER_H_
+#define XLA_SERVICE_GPU_TRIANGULAR_SOLVE_REWRITER_H_
+
+#include "absl/strings/string_view.h"
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/service/hlo_pass_interface.h"
+#include "xla/statusor.h"
+
+namespace xla {
+namespace gpu {
+
+// Rewrites HLO TriangularSolve ops into a custom-call.
+//
+// The motivation for this is that we need to add temp memory to batched
+// triangular-solve ops in order to call cublas trsmBatched.  We rewrite batch 1
+// ops as well so that we have fewer codepaths to worry about in the backend.
+//
+// cublas trsmBatched takes arrays in GPU memory of pointers to the inputs and
+// outputs, `a` and `b`.  In XLA the inputs/outputs are always contiguous, but
+// we still have to materialize out these arrays.
+//
+// We use the same trick as for cudnn convolutions: This custom-call returns a
+// tuple (actual-result, temp-memory).  In this our case the temp buffer always
+// has size 2 * sizeof(void*) * batch_size, because we need two arrays of
+// pointers.
+//
+// The custom-call has a backend-config equal to the TriangularSolveOptions
+// object.
+class TriangularSolveRewriter : public HloModulePass {
+ public:
+  absl::string_view name() const override {
+    return "triangular-solve-rewriter";
+  }
+
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_TRIANGULAR_SOLVE_REWRITER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/triangular_solve_thunk.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/triangular_solve_thunk.h
new file mode 100644
index 0000000000000000000000000000000000000000..bb1a692ed83678a905a87778063d909687287bae
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/triangular_solve_thunk.h
@@ -0,0 +1,88 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_TRIANGULAR_SOLVE_THUNK_H_
+#define XLA_SERVICE_GPU_TRIANGULAR_SOLVE_THUNK_H_
+
+#include <optional>
+
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/service/buffer_assignment.h"
+#include "xla/service/gpu/buffer_allocations.h"
+#include "xla/service/gpu/thunk.h"
+#include "xla/stream_executor/blas.h"
+#include "xla/stream_executor/gpu/gpu_asm_opts.h"
+#include "xla/stream_executor/stream_executor.h"
+#include "xla/types.h"
+#include "xla/xla_data.pb.h"
+#include "tsl/platform/status.h"
+
+namespace xla {
+namespace gpu {
+
+// This class stores everything that StreamExecutor needs to launch a triangular
+// solve (BlasTrsm). It is generated by IrEmitter.
+//
+// Thread-compatible.
+class TriangularSolveThunk : public Thunk {
+ public:
+  TriangularSolveThunk(ThunkInfo thunk_info,
+                       const TriangularSolveOptions& options,
+                       se::GpuAsmOpts asm_opts,
+                       const BufferAllocation::Slice& a_buffer,
+                       const BufferAllocation::Slice& b_buffer,
+                       const BufferAllocation::Slice& temp_buffer,
+                       PrimitiveType type, int64_t batch_size, int64_t m,
+                       int64_t n, int64_t a_batch_stride,
+                       int64_t b_batch_stride);
+
+  TriangularSolveThunk(const TriangularSolveThunk&) = delete;
+  TriangularSolveThunk& operator=(const TriangularSolveThunk&) = delete;
+
+  Status ExecuteOnStream(const ExecuteParams& params) override;
+
+ private:
+  se::GpuAsmOpts asm_opts_;
+  const se::blas::UpperLower uplo_;
+  const se::blas::Side side_;
+  const se::blas::Diagonal unit_diagonal_;
+  se::blas::Transpose transpose_a_;
+
+  const BufferAllocation::Slice a_buffer_;
+  const BufferAllocation::Slice b_buffer_;
+  const BufferAllocation::Slice temp_buffer_;
+
+  const PrimitiveType type_;
+  const int64_t batch_size_;
+  const int64_t m_;
+  const int64_t n_;
+  const int64_t a_batch_stride_;
+  const int64_t b_batch_stride_;
+};
+
+Status RunTriangularSolve(se::DeviceMemoryBase a_data,
+                          se::DeviceMemoryBase b_data,
+                          se::DeviceMemoryBase temp_data,
+                          se::GpuAsmOpts asm_opts, se::blas::UpperLower uplo,
+                          se::blas::Side side, se::blas::Diagonal unit_diagonal,
+                          se::blas::Transpose transpose_a, PrimitiveType type,
+                          int64_t batch_size, int64_t m, int64_t n,
+                          int64_t a_batch_stride, int64_t b_batch_stride,
+                          se::Stream* stream);
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_TRIANGULAR_SOLVE_THUNK_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/triton_autotuner.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/triton_autotuner.h
new file mode 100644
index 0000000000000000000000000000000000000000..bff2f170e6e7b20c32a6aa4976503f5d927dd1e4
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/triton_autotuner.h
@@ -0,0 +1,64 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef XLA_SERVICE_GPU_TRITON_AUTOTUNER_H_
+#define XLA_SERVICE_GPU_TRITON_AUTOTUNER_H_
+
+#include <vector>
+
+#include "absl/container/flat_hash_set.h"
+#include "absl/strings/string_view.h"
+#include "xla/autotuning.pb.h"
+#include "xla/hlo/ir/hlo_computation.h"
+#include "xla/hlo/ir/hlo_instructions.h"
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/service/gpu/autotuner_util.h"
+#include "xla/service/hlo_pass_interface.h"
+#include "xla/statusor.h"
+#include "xla/stream_executor/device_description.h"
+#include "xla/xla.pb.h"
+#include "tsl/platform/threadpool.h"
+
+namespace xla {
+namespace gpu {
+
+// Find best tiling configuration for each triton fusion outlined.
+class TritonAutotuner : public HloModulePass {
+ public:
+  explicit TritonAutotuner(const AutotuneConfig& config,
+                           tsl::thread::ThreadPool* thread_pool)
+      : config_(config), thread_pool_(thread_pool) {}
+
+  absl::string_view name() const override { return "triton-autotuner"; }
+
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+
+ private:
+  AutotuneConfig config_;
+  tsl::thread::ThreadPool* thread_pool_;
+};
+
+// TODO(b/266210099): have a way to generate/load these dynamically.
+// Returns a list of possible tilings for a GEMM performed in Triton.
+std::vector<AutotuneResult::TritonGemmKey> GetPossibleMatmulAutotuneConfigs(
+    const HloDotInstruction& dot, se::CudaComputeCapability compute_capability,
+    const DebugOptions& debug_options, bool exhaustive_tiling_search = false);
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_TRITON_AUTOTUNER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/variadic_op_splitter.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/variadic_op_splitter.h
new file mode 100644
index 0000000000000000000000000000000000000000..bba95c0ae179d15d213b316eb509dd4dbef4f283
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/variadic_op_splitter.h
@@ -0,0 +1,41 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_VARIADIC_OP_SPLITTER_H_
+#define XLA_SERVICE_GPU_VARIADIC_OP_SPLITTER_H_
+
+#include "absl/strings/string_view.h"
+#include "xla/service/hlo_pass_interface.h"
+#include "xla/statusor.h"
+
+namespace xla {
+namespace gpu {
+
+// Splits variadic ops with many operands into pieces such that we don't exceed
+// the parameter space on the GPU. Currently only concatenate ops are split up.
+class VariadicOpSplitter : public HloModulePass {
+ public:
+  absl::string_view name() const override { return "variadic-op-splitter"; }
+
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_VARIADIC_OP_SPLITTER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/while_thunk.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/while_thunk.h
new file mode 100644
index 0000000000000000000000000000000000000000..a908885c1c33b4fc6b594dbbd4edb923f442c60e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/while_thunk.h
@@ -0,0 +1,66 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_WHILE_THUNK_H_
+#define XLA_SERVICE_GPU_WHILE_THUNK_H_
+
+#include <vector>
+
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/service/gpu/buffer_allocations.h"
+#include "xla/service/gpu/sequential_thunk.h"
+#include "xla/service/gpu/thunk.h"
+#include "xla/stream_executor/stream_executor.h"
+
+namespace xla {
+namespace gpu {
+
+// WhileThunk implements the while instruction on GPU by invoking a thunk
+// sequence for the while 'condition' computation, and (conditionally) another
+// thunk sequence for the while 'body' computation. WhileThunk assumes that
+// buffers for the following set of while-related instructions share the same
+// allocation:
+//   init, condition.parameter, body.parameter, body.root, while.result
+// WhileThunk synchronizes the stream to test the result of the 'condition'
+// computation.
+class WhileThunk : public Thunk {
+ public:
+  // Constructs a WhileThunk to compute while instruction 'hlo'.
+  WhileThunk(ThunkInfo thunk_info,
+             const BufferAllocation::Slice& condition_result_buffer_index,
+             std::unique_ptr<ThunkSequence> condition_thunk_sequence,
+             std::unique_ptr<ThunkSequence> body_thunk_sequence);
+  WhileThunk(const WhileThunk&) = delete;
+  WhileThunk& operator=(const WhileThunk&) = delete;
+
+  Status Initialize(const GpuExecutable& executable,
+                    se::StreamExecutor* executor) override;
+  Status ExecuteOnStream(const ExecuteParams& params) override;
+
+  SequentialThunk* condition_thunk_sequence() {
+    return condition_thunk_sequence_.get();
+  }
+  SequentialThunk* body_thunk_sequence() { return body_thunk_sequence_.get(); }
+
+ private:
+  const BufferAllocation::Slice condition_result_buffer_index_;
+  std::unique_ptr<SequentialThunk> condition_thunk_sequence_;
+  std::unique_ptr<SequentialThunk> body_thunk_sequence_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_WHILE_THUNK_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/xfeed_queue.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/xfeed_queue.h
new file mode 100644
index 0000000000000000000000000000000000000000..1cb8dec6d5f91c21c1518d2c6632eb620d8f7738
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/xfeed_queue.h
@@ -0,0 +1,160 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_XFEED_QUEUE_H_
+#define XLA_SERVICE_GPU_XFEED_QUEUE_H_
+
+#include <deque>
+#include <functional>
+#include <utility>
+#include <vector>
+
+#include "absl/base/thread_annotations.h"
+#include "absl/synchronization/mutex.h"
+#include "tsl/platform/logging.h"
+
+namespace xla {
+namespace gpu {
+
+// TODO(b/30467474) Once GPU outfeed implementation settles, consider
+// folding back the cpu and gpu outfeed implementations into a generic
+// one if possible.
+
+// Manages a thread-safe queue of buffers.
+template <typename BufferType>
+class XfeedQueue {
+ public:
+  // Adds a tree of buffers to the queue. The individual buffers correspond to
+  // the elements of a tuple and may be nullptr if the buffer is a tuple index
+  // buffer.
+  void EnqueueDestination(BufferType buffers) {
+    absl::MutexLock l(&mu_);
+    enqueued_buffers_.push_back(std::move(buffers));
+    enqueue_cv_.Signal();
+
+    EnqueueHook();
+  }
+
+  // Blocks until the queue is non-empty, then returns the buffer at the head of
+  // the queue.
+  BufferType BlockingGetNextDestination() {
+    for (const auto& callback : before_get_next_dest_callbacks_) {
+      callback();
+    }
+
+    bool became_empty;
+    BufferType current_buffer;
+    {
+      absl::MutexLock l(&mu_);
+      while (enqueued_buffers_.empty()) {
+        enqueue_cv_.Wait(&mu_);
+      }
+      current_buffer = std::move(enqueued_buffers_.front());
+      enqueued_buffers_.pop_front();
+      DequeueHook();
+      became_empty = enqueued_buffers_.empty();
+    }
+    if (became_empty) {
+      for (const auto& callback : on_empty_callbacks_) {
+        callback();
+      }
+    }
+    return current_buffer;
+  }
+
+  void RegisterOnEmptyCallback(std::function<void()> callback) {
+    on_empty_callbacks_.push_back(std::move(callback));
+  }
+  void RegisterBeforeGetNextDestinationCallback(
+      std::function<void()> callback) {
+    before_get_next_dest_callbacks_.push_back(std::move(callback));
+  }
+
+  virtual ~XfeedQueue() = default;
+
+ protected:
+  virtual void DequeueHook() ABSL_EXCLUSIVE_LOCKS_REQUIRED(this->mu_) {}
+  virtual void EnqueueHook() ABSL_EXCLUSIVE_LOCKS_REQUIRED(this->mu_) {}
+
+  absl::Mutex mu_;
+
+  // The queue of trees of buffers. Buffer* queue contents are not owned.
+  std::deque<BufferType> enqueued_buffers_ ABSL_GUARDED_BY(mu_);
+
+ private:
+  // Condition variable that is signaled every time a buffer is enqueued.
+  absl::CondVar enqueue_cv_;
+
+  // List of callbacks which will be called when 'enqueued_buffers_' becomes
+  // empty.
+  std::vector<std::function<void()>> on_empty_callbacks_;
+
+  // List of callbacks which will be called before BlockingGetNextDestination()
+  // is called. This lets you e.g. call EnqueueDestination() for each call to
+  // BlockingGetNextDestination().
+  std::vector<std::function<void()>> before_get_next_dest_callbacks_;
+};
+
+// Like XfeedQueue but with a maximum capacity.  Clients can call
+// `BlockUntilEnqueueSlotAvailable` to block until there are fewer than
+// `max_pending_xfeeds_` capacity pending infeed items.
+//
+// We introduce a separate `BlockUntilEnqueueSlotAvailable` (as opposed to
+// overriding `EnqueueDestination` to block) because we want to block before we
+// copy the buffer to GPU memory, in order to bound the memory consumption due
+// to pending infeeds.
+template <typename BufferType>
+class BlockingXfeedQueue : public XfeedQueue<BufferType> {
+ public:
+  explicit BlockingXfeedQueue(int max_pending_xfeeds)
+      : max_pending_xfeeds_(max_pending_xfeeds) {}
+
+  void BlockUntilEnqueueSlotAvailable() {
+    absl::MutexLock l{&this->mu_};
+    while (pending_buffers_ + this->enqueued_buffers_.size() >=
+           max_pending_xfeeds_) {
+      VLOG(2) << "Capacity "
+              << (pending_buffers_ + this->enqueued_buffers_.size())
+              << " >= max capacity " << max_pending_xfeeds_;
+      dequeue_cv_.Wait(&this->mu_);
+    }
+
+    pending_buffers_++;
+  }
+
+ protected:
+  void EnqueueHook() ABSL_EXCLUSIVE_LOCKS_REQUIRED(this->mu_) override {
+    pending_buffers_--;
+  }
+
+  void DequeueHook() ABSL_EXCLUSIVE_LOCKS_REQUIRED(this->mu_) override {
+    dequeue_cv_.Signal();
+  }
+
+ private:
+  const int max_pending_xfeeds_;
+
+  // Condition variable that is signaled every time a buffer is dequeued.
+  absl::CondVar dequeue_cv_;
+
+  // Keeps track of the number of buffers reserved but not added to
+  // enqueued_buffers_.
+  int pending_buffers_ ABSL_GUARDED_BY(this->mu_) = 0;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_XFEED_QUEUE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/xla_executor_state.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/xla_executor_state.h
new file mode 100644
index 0000000000000000000000000000000000000000..8714d0b24bb8125894795e7a50a77d14456007f8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/xla_executor_state.h
@@ -0,0 +1,64 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_XLA_EXECUTOR_STATE_H_
+#define XLA_SERVICE_GPU_XLA_EXECUTOR_STATE_H_
+
+#include <memory>
+
+#include "xla/service/gpu/infeed_manager.h"
+#include "xla/service/gpu/outfeed_manager.h"
+
+// Defines XLA:GPU specific state that will be attached to the GpuExecutor.
+
+namespace xla {
+namespace gpu {
+
+class GpuExecutorXLAState {
+ public:
+  explicit GpuExecutorXLAState(stream_executor::StreamExecutor *) {}
+
+  InfeedManager *getOrCreateInfeedManager(stream_executor::StreamExecutor *se) {
+    absl::MutexLock l(&this->mu_);
+    if (!infeed_manager_) infeed_manager_ = std::make_unique<InfeedManager>(se);
+    return infeed_manager_.get();
+  }
+
+  OutfeedManager *getOrCreateOutfeedManager(
+      stream_executor::StreamExecutor *se) {
+    absl::MutexLock l(&this->mu_);
+    if (!outfeed_manager_)
+      outfeed_manager_ = std::make_unique<OutfeedManager>();
+    return outfeed_manager_.get();
+  }
+
+ private:
+  template <typename T>
+  T *getOrCreate(stream_executor::StreamExecutor *se, std::unique_ptr<T> &ptr) {
+    if (!ptr) {
+      ptr = std::make_unique<T>(se);
+    }
+    return ptr.get();
+  }
+
+  absl::Mutex mu_;
+  std::unique_ptr<InfeedManager> infeed_manager_ ABSL_GUARDED_BY(mu_);
+  std::unique_ptr<OutfeedManager> outfeed_manager_ ABSL_GUARDED_BY(mu_);
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_XLA_EXECUTOR_STATE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/graphcycles/graphcycles.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/graphcycles/graphcycles.h
new file mode 100644
index 0000000000000000000000000000000000000000..778ed446fba70fdf96b3a6c1aa4ecbdca4688f2e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/graphcycles/graphcycles.h
@@ -0,0 +1,153 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GRAPHCYCLES_GRAPHCYCLES_H_
+#define XLA_SERVICE_GRAPHCYCLES_GRAPHCYCLES_H_
+
+#include <vector>
+
+// GraphCycles detects the introduction of a cycle into a directed
+// graph that is being built up incrementally.
+//
+// Nodes are identified by small integers.  It is not possible to
+// record multiple edges with the same (source, destination) pair;
+// requests to add an edge where one already exists are silently
+// ignored.
+//
+// It is also not possible to introduce a cycle; an attempt to insert
+// an edge that would introduce a cycle fails and returns false.
+//
+// GraphCycles uses no internal locking; calls into it should be
+// serialized externally.
+
+// Performance considerations:
+//   Works well on sparse graphs, poorly on dense graphs.
+//   Extra information is maintained incrementally to detect cycles quickly.
+//   InsertEdge() is very fast when the edge already exists, and reasonably fast
+//   otherwise.
+//   FindPath() is linear in the size of the graph.
+// The current implementation uses O(|V|+|E|) space.
+
+#include <optional>
+
+#include "absl/types/span.h"
+
+namespace tensorflow {
+
+// NOTE!!!
+// For now a copy of this is forked to net/plaque. If you
+// find a bug or add a feature, please inform the owners of the
+// net/plaque copy in case it should be integrated.
+// NOTE!!!
+class GraphCycles {
+ public:
+  GraphCycles();
+  ~GraphCycles();
+
+  // Allocate an unused node id and return it.
+  // The new node has a null pointer for its node data.
+  // All node identifiers passed to other routines in this interface
+  // must have been allocated by NewNode() and not yet deallocated
+  // by RemoveNode().
+  int32_t NewNode();
+
+  // Remove "node" from the graph, deleting all edges to and from it.
+  // After this call the identifier "node" it may no longer be used
+  // as an argument to any routine until it has been reallocated with
+  // NewNode().
+  void RemoveNode(int32_t node);
+
+  // Attempt to insert an edge from source_node to dest_node.  If the
+  // edge would introduce a cycle, return false without making any
+  // changes. Otherwise add the edge and return true.
+  bool InsertEdge(int32_t source_node, int32_t dest_node);
+
+  // Remove any edge that exists from source_node to dest_node.
+  void RemoveEdge(int32_t source_node, int32_t dest_node);
+
+  // Return whether there is an edge directly from source_node to dest_node.
+  bool HasEdge(int32_t source_node, int32_t dest_node) const;
+
+  // Contracts the edge from 'a' to node 'b', merging nodes 'a' and 'b'. One of
+  // the nodes is removed from the graph, and edges to/from it are added to
+  // the remaining one, which is returned. If contracting the edge would create
+  // a cycle, does nothing and return no value.
+  std::optional<int32_t> ContractEdge(int32_t a, int32_t b);
+
+  // Return true if can contract edge, otherwise return false.
+  bool CanContractEdge(int32_t a, int32_t b);
+
+  // Return whether dest_node is reachable from source_node
+  // by following edges.
+  bool IsReachable(int32_t source_node, int32_t dest_node) const;
+
+  // A faster non-thread-safe version of IsReachable.
+  bool IsReachableNonConst(int32_t source_node, int32_t dest_node);
+
+  // Return or set the node data for a node.  This data is unused
+  // by the implementation.
+  void *GetNodeData(int32_t node) const;
+  void SetNodeData(int32_t node, void *data);
+
+  // Find a path from "source" to "dest".  If such a path exists, place the
+  // node IDs of the nodes on the path in the array path[], and return the
+  // number of nodes on the path.  If the path is longer than max_path_len
+  // nodes, only the first max_path_len nodes are placed in path[].  The client
+  // should compare the return value with max_path_len" to see when this
+  // occurs.  If no path exists, return 0.  Any valid path stored in path[]
+  // will start with "source" and end with "dest".  There is no guarantee that
+  // the path is the shortest, but no node will appear twice in the path,
+  // except the source and destination node if they are identical; therefore,
+  // the return value is at most one greater than the number of nodes in the
+  // graph.
+  int FindPath(int32_t source, int32_t dest, int max_path_len,
+               int32_t path[]) const;
+
+  // Check internal invariants. Crashes on failure, returns true on success.
+  // Expensive: should only be called from graphcycles_test.cc.
+  bool CheckInvariants() const;
+
+  // Warning: Do not use these if iterating over the span and modifying the
+  // GraphCycles at the same time. Instead use SuccessorsCopy/PredecessorsCopy.
+  absl::Span<const int32_t> Successors(int32_t node) const;
+  absl::Span<const int32_t> Predecessors(int32_t node) const;
+
+  // Return a copy of the successors set. This is needed for code using the
+  // collection while modifying the GraphCycles.
+  std::vector<int32_t> SuccessorsCopy(int32_t node) const;
+  // Return a copy of the predecessors set. This is needed for code using the
+  // collection while modifying the GraphCycles.
+  std::vector<int32_t> PredecessorsCopy(int32_t node) const;
+
+  // Returns all nodes in post order.
+  //
+  // If there is a path from X to Y then X appears after Y in the
+  // returned vector.
+  std::vector<int32_t> AllNodesInPostOrder() const;
+
+  // Returns the graph in graphviz format.
+  std::string DebugString() const;
+
+  // ----------------------------------------------------
+  struct Rep;
+
+ private:
+  Rep *rep_;  // opaque representation
+  GraphCycles(const GraphCycles &) = delete;
+  GraphCycles &operator=(const GraphCycles &) = delete;
+};
+
+}  // namespace tensorflow
+#endif  // XLA_SERVICE_GRAPHCYCLES_GRAPHCYCLES_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/graphcycles/ordered_set.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/graphcycles/ordered_set.h
new file mode 100644
index 0000000000000000000000000000000000000000..16258a395ae43028c06a73c94c56cb26926afaac
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/graphcycles/ordered_set.h
@@ -0,0 +1,85 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GRAPHCYCLES_ORDERED_SET_H_
+#define XLA_SERVICE_GRAPHCYCLES_ORDERED_SET_H_
+
+#include <vector>
+
+#include "absl/container/flat_hash_map.h"
+#include "absl/types/span.h"
+#include "tsl/platform/logging.h"
+
+namespace tensorflow {
+// This is a set data structure that provides a deterministic iteration order.
+// The iteration order of elements only depends on the sequence of
+// inserts/deletes, so as long as the inserts/deletes happen in the same
+// sequence, the set will have the same iteration order.
+//
+// Assumes that T can be cheaply copied for simplicity.
+template <typename T>
+class OrderedSet {
+ public:
+  // Inserts `value` into the ordered set.  Returns true if the value was not
+  // present in the set before the insertion.
+  bool Insert(T value) {
+    bool new_insertion =
+        value_to_index_.insert({value, value_sequence_.size()}).second;
+    if (new_insertion) {
+      value_sequence_.push_back(value);
+    }
+    return new_insertion;
+  }
+
+  // Removes `value` from the set.  Assumes `value` is already present in the
+  // set.
+  void Erase(T value) {
+    auto it = value_to_index_.find(value);
+    DCHECK(it != value_to_index_.end());
+
+    // Since we don't want to move values around in `value_sequence_` we swap
+    // the value in the last position and with value to be deleted and then
+    // pop_back.
+    value_to_index_[value_sequence_.back()] = it->second;
+    std::swap(value_sequence_[it->second], value_sequence_.back());
+    value_sequence_.pop_back();
+    value_to_index_.erase(it);
+  }
+
+  void Reserve(size_t new_size) {
+    value_to_index_.reserve(new_size);
+    value_sequence_.reserve(new_size);
+  }
+
+  void Clear() {
+    value_to_index_.clear();
+    value_sequence_.clear();
+  }
+
+  bool Contains(T value) const { return value_to_index_.contains(value); }
+  size_t Size() const { return value_sequence_.size(); }
+
+  absl::Span<T const> GetSequence() const { return value_sequence_; }
+
+ private:
+  // The stable order that we maintain through insertions and deletions.
+  std::vector<T> value_sequence_;
+
+  // Maps values to their indices in `value_sequence_`.
+  absl::flat_hash_map<T, int> value_to_index_;
+};
+}  // namespace tensorflow
+
+#endif  // XLA_SERVICE_GRAPHCYCLES_ORDERED_SET_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/llvm_ir/alias_analysis.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/llvm_ir/alias_analysis.h
new file mode 100644
index 0000000000000000000000000000000000000000..9b55939679a6243bc31a7550fea11df5068bbeee
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/llvm_ir/alias_analysis.h
@@ -0,0 +1,92 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_LLVM_IR_ALIAS_ANALYSIS_H_
+#define XLA_SERVICE_LLVM_IR_ALIAS_ANALYSIS_H_
+
+#include "absl/container/flat_hash_map.h"
+#include "absl/strings/str_cat.h"
+#include "llvm/IR/Module.h"
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/service/buffer_assignment.h"
+#include "xla/service/llvm_ir/ir_array.h"
+#include "xla/types.h"
+
+namespace xla {
+namespace llvm_ir {
+
+// Helper functionality used to augment the LLVM IR emitted with alias-scope
+// metadata.
+class AliasAnalysis {
+ public:
+  AliasAnalysis(const HloModule& module, const BufferAssignment& assignment,
+                llvm::LLVMContext* context)
+      : module_(module), assignment_(assignment), context_(context) {}
+
+  // Augments IrArray with aliasing information.
+  void AddAliasingInformationToIrArray(const HloInstruction& hlo,
+                                       llvm_ir::IrArray* array,
+                                       const ShapeIndex& index = {});
+
+ private:
+  // Returns a unique alias domain for this emitter.
+  llvm::MDNode* GetAliasDomain();
+
+  // Returns an alias.scope metadata node corresponding to a given buffer slice.
+  llvm::MDNode* GetAliasScopeMetadataForBuffer(
+      const BufferAllocation::Slice& buffer_slice, llvm::MDNode* domain);
+
+  // Returns a noalias metadata node corresponding to a given buffer slice.
+  //
+  // |buffer_slice| is the buffer slice.
+  //
+  // |domain| corresponds to the alias scope domain as documented at
+  // http://llvm.org/docs/LangRef.html#noalias-and-alias-scope-metadata
+  //
+  // |hlo| is the instruction we are computing a noalias set for.
+  llvm::MDNode* GetNoaliasMetadataForBuffer(
+      const BufferAllocation::Slice& buffer_slice, llvm::MDNode* domain,
+      const BufferAssignment& assignment, const HloInstruction& hlo);
+
+  // The HLO module we are compiling for.
+  const HloModule& module_;
+
+  // Assignment of the temporary buffers needed by the computation and their
+  // shape information.
+  const BufferAssignment& assignment_;
+
+  // The LLVM context which we are using for IR emission.
+  llvm::LLVMContext* context_;
+
+  // Holds the alias domain for this computation.
+  llvm::MDNode* alias_domain_ = nullptr;
+
+  // A map from a buffer slice to metadata corresponding to its alias.scope
+  // metadata.  The index kParameterAliasSet is used to hold aliasing
+  // information for parameters.
+  absl::flat_hash_map<BufferAllocation::Slice, llvm::MDNode*>
+      alias_scope_metadata_;
+
+  // A map from a buffer slice and producer to metadata corresponding to its
+  // noalias metadata.
+  absl::flat_hash_map<std::pair<BufferAllocation::Slice, const HloInstruction*>,
+                      llvm::MDNode*>
+      noalias_metadata_;
+};
+
+}  // namespace llvm_ir
+}  // namespace xla
+
+#endif  // XLA_SERVICE_LLVM_IR_ALIAS_ANALYSIS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/llvm_ir/buffer_assignment_util.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/llvm_ir/buffer_assignment_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..d8b80a58d20a91e3540c6f4a21a9fe2fdb3acc6e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/llvm_ir/buffer_assignment_util.h
@@ -0,0 +1,44 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_LLVM_IR_BUFFER_ASSIGNMENT_UTIL_H_
+#define XLA_SERVICE_LLVM_IR_BUFFER_ASSIGNMENT_UTIL_H_
+
+#include "xla/service/buffer_assignment.h"
+
+namespace xla {
+namespace llvm_ir {
+// Sanitizes the HLO constant instruction name so that it can be used for the
+// name of the corresponding constant buffer. In particular, it replaces . and
+// - with _.
+std::string SanitizeConstantName(const HloInstruction& instr);
+std::string SanitizeConstantName(absl::string_view name);
+
+std::string ConstantHloToGlobalName(const HloInstruction& instr);
+std::string ConstantNameToGlobalName(absl::string_view name);
+
+// In XLA:GPU we map constant buffer allocations to globals in the generated
+// LLVM IR.  This function gives us the name of the global variable a constant
+// buffer is mapped to.  Not used on XLA:CPU.
+std::string ConstantBufferAllocationToGlobalName(
+    const BufferAllocation& allocation);
+
+// Returns the Literal corresponding to `allocation`, which must be a constant
+// allocation.
+const Literal& LiteralForConstantAllocation(const BufferAllocation& allocation);
+}  // namespace llvm_ir
+}  // namespace xla
+
+#endif  // XLA_SERVICE_LLVM_IR_BUFFER_ASSIGNMENT_UTIL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/llvm_ir/dynamic_update_slice_util.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/llvm_ir/dynamic_update_slice_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..88c43e55416b5aedb2d85acab3eae2e80d6fb263
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/llvm_ir/dynamic_update_slice_util.h
@@ -0,0 +1,94 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_LLVM_IR_DYNAMIC_UPDATE_SLICE_UTIL_H_
+#define XLA_SERVICE_LLVM_IR_DYNAMIC_UPDATE_SLICE_UTIL_H_
+#include <utility>
+
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/service/buffer_assignment.h"
+#include "xla/service/elemental_ir_emitter.h"
+#include "xla/service/gpu/launch_dimensions.h"
+#include "xla/service/llvm_ir/fused_ir_emitter.h"
+#include "xla/service/llvm_ir/ir_array.h"
+
+// Utilities related to emitting LLVM IR for various HLO ops.
+
+namespace xla {
+namespace llvm_ir {
+
+using GeneratorForOperandIrArrays =
+    std::function<std::vector<llvm_ir::IrArray>()>;
+
+// Determines whether the given instruction might be implemented as an
+// in-place dynamic-update-slice after we have a buffer assignment.
+//
+// If this returns false, then CanUpdateDynamicSliceInPlace and
+// CanEmitFusedDynamicUpdateSliceInPlace will also return false.
+//
+// This is useful if you want to check whether an instruction might be an
+// in-place DUS during an HLO pass, at which point you don't have a buffer
+// assignment.
+//
+// Note that simplifications to the HLO graph might change this function from
+// returning false to returning true.  Specifically, simplifying the contents of
+// fusion nodes might cause a false->true transition.  In general this isn't a
+// problem by the time you're calling this function, but beware.
+bool MayBeImplementedAsInPlaceDynamicUpdateSlice(const HloInstruction* instr);
+
+// Checks if we can emit code for the given DynamicUpdateSlice node that updates
+// its input in place.  Returns true if the dynamic-update-slice's
+// array-to-be-updated and output share the same BufferAllocation::Slice.
+//
+// dynamic_update_slice must be a DynamicUpdateSlice op.
+bool CanUpdateDynamicSliceInPlace(HloInstruction* dynamic_update_slice,
+                                  const BufferAssignment& assignment);
+
+// Checks if the given fusion node is amenable to being implemented by
+// EmitFusedDynamicUpdateSliceInPlace.
+bool CanEmitFusedDynamicUpdateSliceInPlace(HloInstruction* fusion,
+                                           const BufferAssignment& assignment);
+
+// Emits IR for running the given dynamic-update-slice op in-place -- that is,
+// where the input and output buffers share the same slice, so we can simply
+// modify the input/output buffer without touching any of the other elements.
+Status EmitDynamicUpdateSliceInPlace(absl::Span<const IrArray> operand_arrays,
+                                     const IrArray& output_array,
+                                     absl::string_view name,
+                                     llvm::IRBuilder<>* b);
+
+// Given a loop-fusion node whose root is a dynamic-update-slice op whose
+// array-to-be-updated and output share the same buffer slice, emits
+// (sequential) code for a fusion node that does the dynamic-update-slice in
+// place.
+Status EmitFusedDynamicUpdateSliceInPlace(HloInstruction* fusion,
+                                          const IrArray& fusion_output_array,
+                                          FusedIrEmitter* fused_emitter,
+                                          llvm::IRBuilder<>* b);
+
+// Same as EmitFusedDynamicUpdateSliceInPlace, except emits a parallel loop with
+// the given launch dimensions for arbitrarily many independent dynamic slice
+// updates.
+Status EmitParallelFusedDynamicUpdateSliceInPlace(
+    const HloComputation* fusion,
+    const std::vector<std::pair<const HloInstruction*, const IrArray>>&
+        dus_and_output_array,
+    FusedIrEmitter* fused_emitter,
+    const gpu::LaunchDimensions& launch_dimensions, llvm::IRBuilder<>* b);
+
+}  // namespace llvm_ir
+}  // namespace xla
+
+#endif  // XLA_SERVICE_LLVM_IR_DYNAMIC_UPDATE_SLICE_UTIL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/llvm_ir/fused_ir_emitter.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/llvm_ir/fused_ir_emitter.h
new file mode 100644
index 0000000000000000000000000000000000000000..ec958615ab67ee00e3cb9461a71568bd1fe370fe
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/llvm_ir/fused_ir_emitter.h
@@ -0,0 +1,85 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_LLVM_IR_FUSED_IR_EMITTER_H_
+#define XLA_SERVICE_LLVM_IR_FUSED_IR_EMITTER_H_
+
+#include <utility>
+
+#include "absl/container/flat_hash_map.h"
+#include "llvm/IR/Value.h"
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/service/elemental_ir_emitter.h"
+#include "xla/statusor.h"
+
+namespace xla {
+
+// FusedIrEmitter is used to generate code for fusion nodes.
+//
+// Unlike IrEmitter and its ilk, which directly create LLVM IR in an LLVM
+// Module, FusedIrEmitter is better understood as "IR generator generator".
+// FusedIrEmitter recursively creates a generator (a host function) which the
+// compiler can invoke at a later time.  Invoking the generator emits LLVM IR
+// that, when run, produces the value at a particular index of the output.
+//
+// After building this generator, the compiler creates a loop (or its moral
+// equivalent, e.g. a GPU kernel) and calls the generator from within the loop.
+// This generates code that produces each element of the output.
+//
+// This class handles both vanilla fusion and multi-output fusion.  In the MOF
+// case, the fusion node ends with a kTuple instruction, and the generator
+// created produces an LLVM struct with N elements, one for each element of the
+// arrays in the tuple.  It follows that the arrays in the tuple must have the
+// same length.
+class FusedIrEmitter {
+ public:
+  using IndexedGenerator = llvm_ir::ElementGenerator;
+
+  explicit FusedIrEmitter(ElementalIrEmitter& elemental_emitter)
+      : elemental_emitter_(elemental_emitter) {}
+
+  void BindGenerator(const HloInstruction& instruction,
+                     llvm_ir::ElementGenerator generator) {
+    indexed_generators_[&instruction] = std::move(generator);
+  }
+
+  // Returns the generator function for the given instruction.
+  StatusOr<IndexedGenerator> GetGenerator(const HloInstruction& instruction);
+
+ private:
+  StatusOr<IndexedGenerator> CreateGenerator(const HloInstruction& instruction);
+  StatusOr<IndexedGenerator> DefaultAction(const HloInstruction& instruction);
+  IndexedGenerator HandleConstant(const HloInstruction& constant);
+  StatusOr<IndexedGenerator> HandleTuple(const HloInstruction& tuple);
+
+  ElementalIrEmitter& elemental_emitter_;
+
+  // Map from instructions to functions that generate code for the output
+  // elements. If an instruction is a GetTupleElement instruction, the
+  // instruction produces non-tuple result.
+  absl::flat_hash_map<const HloInstruction*, IndexedGenerator>
+      indexed_generators_;
+
+  // Cache of generated values, lest we regenerate an element of a node with
+  // multiple outgoing edges.
+  // Use instruction and index values as the key.
+  using ValueCacheKey =
+      std::pair<const HloInstruction*, std::vector<llvm::Value*>>;
+  absl::flat_hash_map<ValueCacheKey, llvm::Value*> value_cache_;
+};
+
+}  // namespace xla
+
+#endif  // XLA_SERVICE_LLVM_IR_FUSED_IR_EMITTER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/llvm_ir/ir_array.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/llvm_ir/ir_array.h
new file mode 100644
index 0000000000000000000000000000000000000000..cfd55362215cc9553ff51b2a762205ee9cb0cf50
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/llvm_ir/ir_array.h
@@ -0,0 +1,378 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_LLVM_IR_IR_ARRAY_H_
+#define XLA_SERVICE_LLVM_IR_IR_ARRAY_H_
+
+#include <map>
+#include <vector>
+
+#include "absl/algorithm/container.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/span.h"
+#include "llvm/IR/IRBuilder.h"
+#include "llvm/IR/Value.h"
+#include "xla/map_util.h"
+#include "xla/shape.h"
+#include "xla/shape_util.h"
+#include "xla/types.h"
+#include "xla/xla_data.pb.h"
+#include "tsl/platform/logging.h"
+
+namespace xla {
+namespace llvm_ir {
+
+// IrArray represents an XLA array at the LLVM IR level. This class
+// encapsulates a base pointer to the buffer holding the array (as an LLVM
+// Value) and the shape of the array. The class includes methods for emitting
+// LLVM IR sequences which access elements of the array at a multidimensional
+// index (eg, [x, y, z] in a 3-dimensional array). Arbitrary shape and layouts
+// are supported.
+class IrArray {
+ public:
+  // A multidimensional index into an IrArray. The order of the runtime indices
+  // (multidim) corresponds to the order of dimensions in the Shape passed to
+  // the constructor.
+  //
+  // This may also keep a linear index and the layout and dimensions it was
+  // emitted for; if the shape where this `Index` is used matches, the linear
+  // index may be used, potentially sparing the cost of computing the
+  // multidimensional index, which LLVM DCE can delete.
+  class Index {
+   public:
+    // Constructs an index for a scalar shape.
+    explicit Index(llvm::Type* index_ty) : index_type_(index_ty) {
+      CHECK(index_ty->isIntegerTy());
+    }
+
+    // Constructs an index from linear index "linear" and computes the
+    // multi-dimensional index from "linear" and "shape". "b" is the IR
+    // builder to emit the index of each dimension in the multi-dimensional
+    // index.
+    //
+    // Precondition: "shape" has a layout.
+    Index(llvm::Value* linear, const Shape& shape, llvm::IRBuilder<>* b);
+
+    // As before, but also take a multidim to reuse.  multidim.size()
+    // == shape.rank() must be true.  If some of the multidim element
+    // are null we will use the value that would be used if
+    // deliearized from linear.
+    Index(llvm::Value* linear, absl::Span<llvm::Value* const> multidim,
+          const Shape& shape, llvm::IRBuilder<>* b);
+
+    // Similar to the above constructor except using "dynamic_dims" instead of
+    // shape's static dimension to constructs the index.
+    Index(llvm::Value* linear, const Shape& shape,
+          absl::Span<llvm::Value*> dynamic_dims, llvm::IRBuilder<>* b);
+
+    // Constructs an index from a multi-dimensional index. 'shape' is the shape
+    // for which the multi-dimensional index is used. 'index_type' is the type
+    // of the index.
+    //
+    // Precondition: "shape" has a layout.
+    Index(absl::Span<llvm::Value* const> multidim, const Shape& shape,
+          llvm::Type* index_type);
+
+    // Same as above, but only the dimensions of the shape without layout is
+    // passed. The layout is assumed to be the default (descending
+    // minor-to-major) layout.
+    Index(absl::Span<llvm::Value* const> multidim,
+          absl::Span<int64_t const> dimensions, llvm::Type* index_type);
+
+    // Returns an index that adds `addend` to the given `dim` of the object.
+    Index AddOffsetToDim(llvm::Value* addend, int64_t dim,
+                         llvm::IRBuilder<>* b) const {
+      Index with_offset = *this;
+      with_offset.linear_ = nullptr;
+      with_offset.multidim_[dim] =
+          b->CreateAdd(with_offset.multidim_[dim], addend);
+      return with_offset;
+    }
+
+    const std::vector<llvm::Value*>& multidim() const { return multidim_; }
+    const std::vector<int64_t>& dims() const { return dims_; }
+    llvm::Value* linear() const { return linear_; }
+
+    size_t size() const { return multidim().size(); }
+
+    llvm::Value* operator[](size_t i) const { return multidim()[i]; }
+
+    using const_iterator = std::vector<llvm::Value*>::const_iterator;
+
+    const_iterator begin() const { return multidim().begin(); }
+    const_iterator end() const { return multidim().end(); }
+
+    bool LinearValidOnShape(const Shape& a) const;
+
+    static bool ShapeIsCompatible(const Shape& a, const Shape& b);
+
+    bool ShapeIsCompatible(const Shape& a) const {
+      return ShapeIsCompatible(a, AsShapeWithType(a.element_type()));
+    }
+
+    Shape AsShapeWithType(PrimitiveType element_type) const {
+      return ShapeUtil::MakeShapeWithDenseLayout(element_type, dims_,
+                                                 layout_.minor_to_major());
+    }
+
+    // Given that "this" is the target index of a reshape from `input_shape`
+    // to `output_shape`, returns the source index.
+    Index SourceIndexOfReshape(const Shape& output_shape,
+                               const Shape& input_shape,
+                               llvm::IRBuilder<>* builder) const;
+
+    // Returns the index into the source operand from which a slice operation
+    // selects a value to be placed into index "this". The slice is described
+    // by starting indices `starts` and stride values `strides`.
+    //
+    // Precondition: "this" is an index into a slice whose operand shape is
+    // `operand_shape`.
+    Index SourceIndexOfSlice(const Shape& operand_shape,
+                             absl::Span<const int64_t> starts,
+                             absl::Span<const int64_t> strides,
+                             llvm::IRBuilder<>* builder) const;
+
+    // Given that "this" is the target index of a transpose from `operand_shape`
+    // to `shape` with the given dimension mapping, returns the source index.
+    Index SourceIndexOfTranspose(
+        const Shape& shape, const Shape& operand_shape,
+        absl::Span<const int64_t> dimension_mapping) const;
+
+    // Given that "this" is the target index of a bitcast from `operand_shape`
+    // to `shape`, returns the source index.
+    Index SourceIndexOfBitcast(const Shape& shape, const Shape& operand_shape,
+                               llvm::IRBuilder<>* builder) const;
+
+    // Given that "this" is the target index of a broadcast from `operand_shape`
+    // to `shape` with the given dimension mapping, returns the source index.
+    Index SourceIndexOfBroadcast(const Shape& shape, const Shape& operand_shape,
+                                 absl::Span<const int64_t> dimension_mapping,
+                                 llvm::IRBuilder<>* builder) const;
+
+    // Linearizes the index into the given shape, i.e. reshapes it to rank-1 and
+    // returns the index into the sole dimension 0 of the new shape.
+    llvm::Value* Linearize(absl::Span<const int64_t> dimensions,
+                           llvm::IRBuilder<>* builder) const;
+
+    // Linearizes the index into the given dynamic dimensions.
+    llvm::Value* Linearize(const std::vector<llvm::Value*>& dynamic_dims,
+                           llvm::IRBuilder<>* builder) const;
+
+    llvm::Type* GetType() const { return index_type_; }
+
+    llvm::Constant* GetConstantWithIndexType(int64_t c) const {
+      // The LLVM function makes sure that the value can be represented by the
+      // specified type, see ConstantInt::ConstantInt(IntegerType *Ty, const
+      // APInt &V).
+      return llvm::ConstantInt::get(index_type_, c);
+    }
+
+   private:
+    // Constructs an index from both a multi-dimensional index and a linear
+    // index. 'shape' is the shape on which the index is used. 'index_type' is
+    // the type of the index.
+    //
+    // Precondition: "shape" has a layout.
+    Index(absl::Span<llvm::Value* const> multidim, llvm::Value* linear,
+          const Shape& shape, llvm::Type* index_type);
+
+    void Delinearize(std::vector<llvm::Value*>* multidim, llvm::Value* linear,
+                     const Shape& shape, llvm::IRBuilder<>* b) const;
+
+    // Delinearize the linear index with the dynamic dimensions.
+    void Delinearize(std::vector<llvm::Value*>* multidim, llvm::Value* linear,
+                     const Shape& shape, absl::Span<llvm::Value*> dynamic_dims,
+                     llvm::IRBuilder<>* b) const;
+
+    std::vector<llvm::Value*> multidim_;
+
+    // These values are purely for efficiency; `multidim_` is enough to find the
+    // element at a given `Index`, but if a loop is emitted with a linear index
+    // space, that linear index can be saved in `linear_`, and the layout and
+    // dimensions of the shape the loop was emitted for in `layout_` and
+    // `dims_`, and if the `Index` is used in another array, and its layout and
+    // dimensions match, the linear index can be used, sparing the cost of
+    // computing `multidim_`, which LLVM DCE could potentially so delete.
+    // Modifying `multidim_` after construction nullifies `linear_`, lest it
+    // be used wrongly, as it would be valid no more.
+    // If a loop is emitted with a multidimensional index space, `linear_` would
+    // be null and `layout_` and `dims_` would be ignored.
+    llvm::Value* linear_ = nullptr;
+    Layout layout_;
+    std::vector<int64_t> dims_;
+
+    llvm::Type* index_type_;
+  };
+
+  // Default constructor. Constructs an IrArray in a null status.
+  IrArray() : base_ptr_(nullptr) {}
+
+  // Construct an IrArray with the given base pointer, pointee type, and shape.
+  // base_ptr is a pointer type pointing to the first element(lowest address)
+  // of the array.
+  //
+  // For int4 arrays, pointee_type should be i8, not i4, as int4
+  // IrArrays are represented as i8 arrays where each i8 value stores two 4-bit
+  // values. Additionally, reads and write return or take in i8 values which
+  // hold a value representable by i4, instead of directly returning or taking
+  // in i4 values. Specifically, the i8 values returned or passed in are between
+  // 0 and 15 for U4 arrays and between -8 and 7 for S4 arrays.
+  IrArray(llvm::Value* base_ptr, llvm::Type* pointee_type, Shape shape);
+
+  // Default implementations of copying and moving.
+  IrArray(IrArray&& other) = default;
+  IrArray(const IrArray& other) = default;
+  IrArray& operator=(IrArray&& other) = default;
+  IrArray& operator=(const IrArray& other) = default;
+
+  llvm::Value* GetBasePointer() const { return base_ptr_; }
+  llvm::Type* GetBasePointeeType() const { return pointee_type_; }
+  llvm::Type* GetElementLlvmType() const { return element_type_; }
+
+  const Shape& GetShape() const { return shape_; }
+
+  // Emit a sequence of instructions to compute the address of the element in
+  // the given array at the given index. Returns the address of the element as
+  // an LLVM Value.
+  //
+  // The optional name is useful for debugging when looking at
+  // the emitted LLVM IR.
+  //
+  // For int4 values, 'is_high_order_bits' must be non-null and this function
+  // sets '*is_high_order_bits' to a boolean value indicating whether the 4-bit
+  // value resides in the high-order or low- order bits of the byte that the
+  // address points to.
+  llvm::Value* EmitArrayElementAddress(
+      const Index& index, llvm::IRBuilder<>* b, absl::string_view name = "",
+      bool use_linear_index = true,
+      llvm::Value** is_high_order_bits = nullptr) const;
+
+  // Attach metadata this IrArray instance knows about to "instruction".
+  void AnnotateLoadStoreInstructionWithMetadata(
+      llvm::Instruction* instruction) const;
+
+  // Emit IR to read an array element at the given index. Returns the read
+  // result (effectively, a Value loaded from memory). This method seamlessly
+  // handles scalar shapes by broadcasting their value to all indices (index is
+  // ignored).
+  //
+  // The optional name is useful for debugging when looking at
+  // the emitted LLVM IR.
+  // 'use_linear_index' can be used to specify whether the linear index (if
+  // available) or the multi-dimensional index should be used.
+  //
+  // For int4 arrays, returns an i8 value that is representable by i4. The
+  // returned i8 value will be between 0 and 15 for U4 arrays and between -8 and
+  // 7 for S4 arrays.
+  llvm::Value* EmitReadArrayElement(const Index& index, llvm::IRBuilder<>* b,
+                                    absl::string_view name = "",
+                                    bool use_linear_index = true) const;
+
+  // Emit IR to write the given value to the array element at the given index.
+  // 'use_linear_index' can be used to specify whether the linear index (if
+  // available) or the multi-dimensional index should be used.
+  //
+  // For int4 arrays, the given value must be an i8 value representable by i4.
+  // Only 4 bits of a byte in the array are written. First the appropriate byte
+  // is read from the array, then 4 bits are modified and written back. To avoid
+  // race conditions, the caller must ensure that the two different 4-bit values
+  // within a byte are not written to in parallel.
+  void EmitWriteArrayElement(const Index& index, llvm::Value* value,
+                             llvm::IRBuilder<>* b,
+                             bool use_linear_index = true) const;
+
+  // Returns a new IrArray whose shape is "new_shape" and base pointer is a
+  // bitcast of the base pointer of "this" IrArray.
+  // 'use_linear_index' can be used to specify whether the linear index (if
+  // available) or the multi-dimensional index should be used.
+  IrArray CastToShape(const Shape& new_shape, llvm::IRBuilder<>* b) const;
+
+  void AddAliasScopeMetadata(llvm::MDNode* alias_scope) {
+    CHECK_NE(alias_scope, nullptr);
+    AddMetadata(llvm::LLVMContext::MD_alias_scope, alias_scope);
+  }
+
+  void AddNoaliasMetadata(llvm::MDNode* noalias) {
+    CHECK_NE(noalias, nullptr);
+    AddMetadata(llvm::LLVMContext::MD_noalias, noalias);
+  }
+
+  // Promises LLVM that the data pointed to by this IrArray never changes after
+  // it's first loaded.
+  //
+  // The temporal scope of this promise is the "whole program" from LLVM's point
+  // of view, but how this translates to HLOs differs between backends.
+  //
+  // In the single-threaded CPU backend, we emit one function that
+  // runs all the HLOs in sequence, so the whole program is the whole HLO
+  // module.
+  //
+  // In the GPU backend, we emit one GPU kernel per top-level HLO (i.e. per HLO
+  // in the entry computation).  From LLVM's perspective, launching a new kernel
+  // is like launching a new program, and so the whole program is one top-level
+  // HLO.  Since the scope of the promise is smaller than in the CPU backend, we
+  // can mark more things as invariant in the GPU backend.
+  //
+  // Marking loads as invariant is particularly helpful on GPUs because
+  // invariant loads can be lowered to PTX ld.global.nc (equivalent to CUDA's
+  // __ldg intrinsic).  These loads use a special cache, and can be
+  // significantly faster than regular loads.
+  void MarkInvariantOverWholeProgram(llvm::LLVMContext* context) {
+    if (is_invariant_) {
+      return;
+    }
+    is_invariant_ = true;
+    AddMetadata(llvm::LLVMContext::MD_invariant_load,
+                llvm::MDNode::get(*context, {}));
+  }
+
+  const std::map<int, llvm::MDNode*>& metadata() const { return metadata_; }
+
+ private:
+  // Add the specified LLVM IR metadata to loads/stores associated with this
+  // IrArray.
+  void AddMetadata(int kind, llvm::MDNode* md) {
+    InsertOrDie(&metadata_, kind, md);
+  }
+
+  // Like EmitArrayElementAddress, but always uses a linear index.
+  llvm::Value* EmitLinearArrayElementAddress(
+      const Index& index, llvm::IRBuilder<>* b, absl::string_view name = "",
+      llvm::Value** is_high_order_bits = nullptr) const;
+
+  // Address of the base of the array as an LLVM Value.
+  llvm::Value* base_ptr_;
+
+  // The pointee type of base_ptr_;
+  llvm::Type* pointee_type_;
+
+  // The LLVM type of the elements in the array.
+  llvm::Type* element_type_;
+
+  // Shape of the XLA array.
+  Shape shape_;
+
+  // The list of key/value pairs used when attaching metadata to emitted
+  // loads/stores for this array.  They keys are the metadata kinds and the
+  // values are the metadata nodes.
+  std::map<int, llvm::MDNode*> metadata_;
+
+  bool is_invariant_ = false;
+};
+
+}  // namespace llvm_ir
+}  // namespace xla
+
+#endif  // XLA_SERVICE_LLVM_IR_IR_ARRAY_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/llvm_ir/ir_builder_mixin.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/llvm_ir/ir_builder_mixin.h
new file mode 100644
index 0000000000000000000000000000000000000000..6f5f6a3f615c30596b2f27475b23bff95a1825a9
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/llvm_ir/ir_builder_mixin.h
@@ -0,0 +1,446 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_LLVM_IR_IR_BUILDER_MIXIN_H_
+#define XLA_SERVICE_LLVM_IR_IR_BUILDER_MIXIN_H_
+
+#include <optional>
+
+#include "llvm/IR/IRBuilder.h"
+
+namespace xla {
+
+// Mixin class that injects more ergonomic versions of llvm::IRBuilder methods
+// into a class.  Intended to be used as a CRTP base class, like:
+//
+//  class MyIrEmitter : public IrBuilderMixin<MyIrEmitter> {
+//    llvm::IRBuilder<>* builder() { return builder_; }
+//
+//    void EmitFoo(HloInstruction* foo) {
+//      Add(Mul(...), FPToUI(...));
+//    }
+//  };
+
+template <typename Derived>
+class IrBuilderMixin {
+ protected:
+  template <class... Args>
+  llvm::Value* Add(Args&&... args) {
+    return mixin_builder()->CreateAdd(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::LoadInst* AlignedLoad(Args&&... args) {
+    return mixin_builder()->CreateAlignedLoad(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::StoreInst* AlignedStore(Args&&... args) {
+    return mixin_builder()->CreateAlignedStore(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::AllocaInst* Alloca(Args&&... args) {
+    return mixin_builder()->CreateAlloca(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* And(Args&&... args) {
+    return mixin_builder()->CreateAnd(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* AtomicCmpXchg(Args&&... args) {
+    return mixin_builder()->CreateAtomicCmpXchg(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* AtomicRMW(Args&&... args) {
+    return mixin_builder()->CreateAtomicRMW(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* BitCast(Args&&... args) {
+    return mixin_builder()->CreateBitCast(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* Br(Args&&... args) {
+    return mixin_builder()->CreateBr(std::forward<Args>(args)...);
+  }
+
+  llvm::CallInst* Call(llvm::FunctionCallee func_callee,
+                       llvm::ArrayRef<llvm::Value*> args = std::nullopt,
+                       const llvm::Twine& name = "",
+                       llvm::MDNode* fp_math_tag = nullptr) {
+    return mixin_builder()->CreateCall(func_callee, args, name, fp_math_tag);
+  }
+
+  llvm::CallInst* Call(llvm::FunctionType* func_type, llvm::Value* callee,
+                       llvm::ArrayRef<llvm::Value*> args = std::nullopt,
+                       const llvm::Twine& name = "",
+                       llvm::MDNode* fp_math_tag = nullptr) {
+    return mixin_builder()->CreateCall(func_type, callee, args, name,
+                                       fp_math_tag);
+  }
+
+  template <class... Args>
+  llvm::BranchInst* CondBr(Args&&... args) {
+    return mixin_builder()->CreateCondBr(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* ConstInBoundsGEP1_32(Args&&... args) {
+    return mixin_builder()->CreateConstInBoundsGEP1_32(
+        std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* FAdd(Args&&... args) {
+    return mixin_builder()->CreateFAdd(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* FMul(Args&&... args) {
+    return mixin_builder()->CreateFMul(std::forward<Args>(args)...);
+  }
+
+  llvm::Value* GEP(llvm::Type* type, llvm::Value* ptr,
+                   llvm::ArrayRef<llvm::Value*> idx_list,
+                   const llvm::Twine& name = "") {
+    return mixin_builder()->CreateGEP(type, ptr, idx_list, name);
+  }
+
+  template <class... Args>
+  llvm::Value* ICmpEQ(Args&&... args) {
+    return mixin_builder()->CreateICmpEQ(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* ICmpNE(Args&&... args) {
+    return mixin_builder()->CreateICmpNE(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* ICmpULE(Args&&... args) {
+    return mixin_builder()->CreateICmpULE(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* ICmpULT(Args&&... args) {
+    return mixin_builder()->CreateICmpULT(std::forward<Args>(args)...);
+  }
+
+  llvm::Value* InBoundsGEP(llvm::Type* type, llvm::Value* ptr,
+                           llvm::ArrayRef<llvm::Value*> idx_list,
+                           const llvm::Twine& name = "") {
+    return mixin_builder()->CreateInBoundsGEP(type, ptr, idx_list, name);
+  }
+
+  llvm::Value* ExtractValue(llvm::Value* agg, llvm::ArrayRef<unsigned> idxs,
+                            const llvm::Twine& name = "") {
+    return mixin_builder()->CreateExtractValue(agg, idxs, name);
+  }
+
+  llvm::Value* InsertValue(llvm::Value* agg, llvm::Value* val,
+                           llvm::ArrayRef<unsigned> idxs,
+                           const llvm::Twine& name = "") {
+    return mixin_builder()->CreateInsertValue(agg, val, idxs, name);
+  }
+
+  template <class... Args>
+  llvm::Value* IntToPtr(Args&&... args) {
+    return mixin_builder()->CreateIntToPtr(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::LoadInst* Load(Args&&... args) {
+    return mixin_builder()->CreateLoad(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::CallInst* MemCpy(Args&&... args) {
+    return mixin_builder()->CreateMemCpy(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* Mul(Args&&... args) {
+    return mixin_builder()->CreateMul(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* NSWAdd(Args&&... args) {
+    return mixin_builder()->CreateNSWAdd(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* NSWMul(Args&&... args) {
+    return mixin_builder()->CreateNSWMul(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* NSWSub(Args&&... args) {
+    return mixin_builder()->CreateNSWSub(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* Or(Args&&... args) {
+    return mixin_builder()->CreateOr(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* PointerCast(Args&&... args) {
+    return mixin_builder()->CreatePointerCast(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* PtrToInt(Args&&... args) {
+    return mixin_builder()->CreatePtrToInt(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* SDiv(Args&&... args) {
+    return mixin_builder()->CreateSDiv(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* Select(Args&&... args) {
+    return mixin_builder()->CreateSelect(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* SRem(Args&&... args) {
+    return mixin_builder()->CreateSRem(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::StoreInst* Store(Args&&... args) {
+    return mixin_builder()->CreateStore(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* UDiv(Args&&... args) {
+    return mixin_builder()->CreateUDiv(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* URem(Args&&... args) {
+    return mixin_builder()->CreateURem(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* VectorSplat(Args&&... args) {
+    return mixin_builder()->CreateVectorSplat(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* ZExtOrTrunc(Args&&... args) {
+    return mixin_builder()->CreateZExtOrTrunc(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* AShr(Args&&... args) {
+    return mixin_builder()->CreateAShr(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* FCmpOEQ(Args&&... args) {
+    return mixin_builder()->CreateFCmpOEQ(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* FCmpOGT(Args&&... args) {
+    return mixin_builder()->CreateFCmpOGT(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* FCmpOGE(Args&&... args) {
+    return mixin_builder()->CreateFCmpOGE(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* FCmpOLT(Args&&... args) {
+    return mixin_builder()->CreateFCmpOLT(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* FCmpULT(Args&&... args) {
+    return mixin_builder()->CreateFCmpULT(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* FCmpULE(Args&&... args) {
+    return mixin_builder()->CreateFCmpULE(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* FCmpOLE(Args&&... args) {
+    return mixin_builder()->CreateFCmpOLE(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* FCmpONE(Args&&... args) {
+    return mixin_builder()->CreateFCmpONE(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* FCmpUNE(Args&&... args) {
+    return mixin_builder()->CreateFCmpUNE(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* FCmpUNO(Args&&... args) {
+    return mixin_builder()->CreateFCmpUNO(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* FCmpUGE(Args&&... args) {
+    return mixin_builder()->CreateFCmpUGE(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* FDiv(Args&&... args) {
+    return mixin_builder()->CreateFDiv(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* FNeg(Args&&... args) {
+    return mixin_builder()->CreateFNeg(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* FPCast(Args&&... args) {
+    return mixin_builder()->CreateFPCast(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* FPToSI(Args&&... args) {
+    return mixin_builder()->CreateFPToSI(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* FPToUI(Args&&... args) {
+    return mixin_builder()->CreateFPToUI(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* FPTrunc(Args&&... args) {
+    return mixin_builder()->CreateFPTrunc(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* FRem(Args&&... args) {
+    return mixin_builder()->CreateFRem(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* FSub(Args&&... args) {
+    return mixin_builder()->CreateFSub(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* ICmpSGE(Args&&... args) {
+    return mixin_builder()->CreateICmpSGE(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* ICmpSLT(Args&&... args) {
+    return mixin_builder()->CreateICmpSLT(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* IntCast(Args&&... args) {
+    return mixin_builder()->CreateIntCast(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* LShr(Args&&... args) {
+    return mixin_builder()->CreateLShr(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* MemSet(Args&&... args) {
+    return mixin_builder()->CreateMemSet(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* Neg(Args&&... args) {
+    return mixin_builder()->CreateNeg(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* Not(Args&&... args) {
+    return mixin_builder()->CreateNot(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::PHINode* PHI(Args&&... args) {
+    return mixin_builder()->CreatePHI(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* RetVoid(Args&&... args) {
+    return mixin_builder()->CreateRetVoid(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* SExtOrTrunc(Args&&... args) {
+    return mixin_builder()->CreateSExtOrTrunc(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* Shl(Args&&... args) {
+    return mixin_builder()->CreateShl(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* SIToFP(Args&&... args) {
+    return mixin_builder()->CreateSIToFP(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* Sub(Args&&... args) {
+    return mixin_builder()->CreateSub(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* Trunc(Args&&... args) {
+    return mixin_builder()->CreateTrunc(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* UIToFP(Args&&... args) {
+    return mixin_builder()->CreateUIToFP(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* Unreachable(Args&&... args) {
+    return mixin_builder()->CreateUnreachable(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  llvm::Value* Xor(Args&&... args) {
+    return mixin_builder()->CreateXor(std::forward<Args>(args)...);
+  }
+
+ private:
+  llvm::IRBuilder<>* mixin_builder() {
+    return static_cast<Derived*>(this)->builder();
+  }
+};
+
+}  // namespace xla
+
+#endif  // XLA_SERVICE_LLVM_IR_IR_BUILDER_MIXIN_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/llvm_ir/kernel_support_library.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/llvm_ir/kernel_support_library.h
new file mode 100644
index 0000000000000000000000000000000000000000..6f8600f42b105c86f501c5f42075f6734bf833c2
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/llvm_ir/kernel_support_library.h
@@ -0,0 +1,311 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_LLVM_IR_KERNEL_SUPPORT_LIBRARY_H_
+#define XLA_SERVICE_LLVM_IR_KERNEL_SUPPORT_LIBRARY_H_
+
+#include <string>
+
+#include "absl/strings/string_view.h"
+#include "llvm/IR/BasicBlock.h"
+#include "llvm/IR/IRBuilder.h"
+#include "llvm/IR/Value.h"
+#include "xla/service/llvm_ir/llvm_loop.h"
+#include "xla/service/llvm_ir/llvm_util.h"
+
+namespace xla {
+// A thin wrapper around llvm_loop.h to make code generating structured control
+// flow more readable.
+class KernelSupportLibrary {
+ public:
+  // `b` is the llvm::IRBuilder instance used to generate LLVM IR.
+  // `unroll_mode` specifies the desired LLVM unrolling behavior for every loop
+  // generated by this instance of KernelSupportLibrary.
+  explicit KernelSupportLibrary(
+      llvm::IRBuilder<>* b,
+      llvm_ir::UnrollMode unroll_mode = llvm_ir::UnrollMode::kNoUnroll,
+      bool prevent_vectorization = true)
+      : b_(b),
+        unroll_mode_(unroll_mode),
+        prevent_vectorization_(prevent_vectorization) {}
+
+  // Generates the following control flow structure:
+  //
+  //   if (`start` < `end`) {
+  //     `for_body_generator(/*ind_var=*/start, /*is_first_iteration=*/true)`;
+  //     for (i64 i = `start` + `step`; i s< `end`; i += `step`)
+  //       `for_body_generator(/*ind_var=*/,i, /*is_first_iteration=*/false)`;
+  //   }
+  Status ForWithStatus(
+      absl::string_view name, llvm::Value* start, llvm::Value* end,
+      llvm::Value* step,
+      const std::function<Status(llvm::Value* ind_var,
+                                 bool is_first_iteration)>& for_body_generator);
+
+  void For(
+      absl::string_view name, llvm::Value* start, llvm::Value* end,
+      llvm::Value* step,
+      const std::function<void(llvm::Value* ind_var, bool is_first_iteration)>&
+          for_body_generator) {
+    CHECK_EQ(OkStatus(),
+             ForWithStatus(
+                 name, start, end, step,
+                 [&](llvm::Value* ind_var, bool is_first_iteration) -> Status {
+                   for_body_generator(ind_var, is_first_iteration);
+                   return OkStatus();
+                 }));
+  }
+
+  Status ForWithStatus(
+      absl::string_view name, int64_t start, int64_t end, int64_t step,
+      const std::function<Status(
+          llvm::Value* ind_var, bool is_first_iteration)>& for_body_generator) {
+    return ForWithStatus(name, /*start=*/b_->getInt64(start),
+                         /*end=*/b_->getInt64(end),
+                         /*step=*/b_->getInt64(step), for_body_generator);
+  }
+
+  void For(
+      absl::string_view name, int64_t start, int64_t end, int64_t step,
+      const std::function<void(llvm::Value* ind_var, bool is_first_iteration)>&
+          for_body_generator) {
+    For(name, /*start=*/b_->getInt64(start),
+        /*end=*/b_->getInt64(end),
+        /*step=*/b_->getInt64(step), for_body_generator);
+  }
+
+  // Generates the following control flow structure if `peel_first_iteration` is
+  // true:
+  //
+  //   if (`start` < `end`) {
+  //     `for_body_generator(/*ind_var=*/start, /*is_first_iteration=*/,true)`;
+  //     for (i64 i = `start` + `step`; i s< `end`; i += `step`)
+  //       `for_body_generator(/*ind_var=*/,i, /*is_first_iteration=*/,false)`;
+  //   }
+  //
+  // and the following if `peel_first_iteration` is false:
+  //
+  //   for (i64 i = `start`; i s< `end`; i += `step`)
+  //     `for_body_generator(/*ind_var=*/,i,
+  //                         /*is_first_iteration=*/,(i != `start`))`;
+  Status ForWithStatus(
+      absl::string_view name, llvm::Value* start, llvm::Value* end,
+      llvm::Value* step, bool peel_first_iteration,
+      const std::function<Status(llvm::Value* ind_var,
+                                 llvm::Value* is_first_iteration)>&
+          for_body_generator);
+
+  void For(absl::string_view name, llvm::Value* start, llvm::Value* end,
+           llvm::Value* step, bool peel_first_iteration,
+           const std::function<void(llvm::Value* ind_var,
+                                    llvm::Value* is_first_iteration)>&
+               for_body_generator) {
+    TF_CHECK_OK(ForWithStatus(
+        name, start, end, step, peel_first_iteration,
+        [&](llvm::Value* ind_var, llvm::Value* is_first_iteration) -> Status {
+          for_body_generator(ind_var, is_first_iteration);
+          return OkStatus();
+        }));
+  }
+
+  Status ForWithStatus(
+      absl::string_view name, llvm::Value* start, llvm::Value* end,
+      int64_t step, bool peel_first_iteration,
+      const std::function<Status(llvm::Value* ind_var,
+                                 llvm::Value* is_first_iteration)>&
+          for_body_generator) {
+    return ForWithStatus(
+        name, /*start=*/start, /*end=*/end,
+        /*step=*/llvm::ConstantInt::get(start->getType(), step),
+        peel_first_iteration, for_body_generator);
+  }
+
+  void For(absl::string_view name, llvm::Value* start, llvm::Value* end,
+           int64_t step, bool peel_first_iteration,
+           const std::function<void(llvm::Value* ind_var,
+                                    llvm::Value* is_first_iteration)>&
+               for_body_generator) {
+    For(name, /*start=*/start, /*end=*/end,
+        /*step=*/llvm::ConstantInt::get(start->getType(), step),
+        peel_first_iteration, for_body_generator);
+  }
+
+  Status ForWithStatus(
+      absl::string_view name, llvm::Value* start, llvm::Value* end,
+      llvm::Value* step,
+      const std::function<Status(llvm::Value* ind_var)>& for_body_generator) {
+    return ForWithStatus(name, start, end, step,
+                         /*peel_first_iteration=*/false,
+                         [&](llvm::Value* indvar, llvm::Value*) -> Status {
+                           return for_body_generator(indvar);
+                         });
+  }
+
+  void For(
+      absl::string_view name, llvm::Value* start, llvm::Value* end,
+      llvm::Value* step,
+      const std::function<void(llvm::Value* ind_var)>& for_body_generator) {
+    For(name, start, end, step,
+        /*peel_first_iteration=*/false, [&](llvm::Value* indvar, llvm::Value*) {
+          return for_body_generator(indvar);
+        });
+  }
+
+  Status ForWithStatus(
+      absl::string_view name, llvm::Value* start, llvm::Value* end,
+      int64_t step,
+      const std::function<Status(llvm::Value* ind_var)>& for_body_generator) {
+    return ForWithStatus(name, start, end,
+                         llvm::ConstantInt::get(start->getType(), step),
+                         /*peel_first_iteration=*/false,
+                         [&](llvm::Value* indvar, llvm::Value*) -> Status {
+                           return for_body_generator(indvar);
+                         });
+  }
+
+  void For(
+      absl::string_view name, llvm::Value* start, llvm::Value* end,
+      int64_t step,
+      const std::function<void(llvm::Value* ind_var)>& for_body_generator) {
+    For(name, start, end, llvm::ConstantInt::get(start->getType(), step),
+        for_body_generator);
+  }
+
+  Status ForWithStatus(
+      absl::string_view name, int64_t start, int64_t end, int64_t step,
+      const std::function<Status(llvm::Value* ind_var)>& for_body_generator) {
+    return ForWithStatus(name, /*start=*/b_->getInt64(start),
+                         /*end=*/b_->getInt64(end),
+                         /*step=*/b_->getInt64(step), for_body_generator);
+  }
+
+  void For(
+      absl::string_view name, int64_t start, int64_t end, int64_t step,
+      const std::function<void(llvm::Value* ind_var)>& for_body_generator) {
+    For(name, /*start=*/b_->getInt64(start),
+        /*end=*/b_->getInt64(end),
+        /*step=*/b_->getInt64(step), for_body_generator);
+  }
+
+  // Generates the following control flow structure:
+  //
+  //   if (`condition`)
+  //     `true_block_generator()`;
+  //   else
+  //      `false_block_generator()`;
+  // The else is skipped if false_block_generator is null.
+  Status IfWithStatus(
+      absl::string_view name, llvm::Value* condition,
+      const std::function<Status()>& true_block_generator,
+      const std::function<Status()>& false_block_generator = nullptr);
+
+  Status IfWithStatus(
+      llvm::Value* condition,
+      const std::function<Status()>& true_block_generator,
+      const std::function<Status()>& false_block_generator = []() -> Status {
+        return OkStatus();
+      }) {
+    return IfWithStatus("", condition, true_block_generator,
+                        false_block_generator);
+  }
+
+  void If(llvm::Value* condition,
+          const std::function<void()>& true_block_generator,
+          const std::function<void()>& false_block_generator = nullptr) {
+    If("", condition, true_block_generator, false_block_generator);
+  }
+
+  void If(absl::string_view name, llvm::Value* condition,
+          const std::function<void()>& true_block_generator,
+          const std::function<void()>& false_block_generator = nullptr) {
+    if (false_block_generator != nullptr) {
+      TF_CHECK_OK(IfWithStatus(
+          name, condition,
+          [&]() {
+            true_block_generator();
+            return OkStatus();
+          },
+          [&]() {
+            false_block_generator();
+            return OkStatus();
+          }));
+    } else {
+      TF_CHECK_OK(IfWithStatus(name, condition, [&]() {
+        true_block_generator();
+        return OkStatus();
+      }));
+    }
+  }
+
+  using ArgumentVector = absl::Span<llvm::Value* const>;
+
+  // Generates the following control flow structure:
+  //
+  //  define @`kernel_name`(arg0, arg1, ... arg`arguments.size()`) {
+  //    kernel_body_generator({arg0, arg1, ... arg`arguments.size()`});
+  //  }
+  //
+  //  ...
+  //  call @`kernel_name`(arguments[0], arguments[1] ...)
+  //  ...
+  //
+  // If a function called `kernel_name` is already present in the module then
+  // that function is re-used.  In that sense we're using the llvm::Module as a
+  // cache of outlined kernels, keyed by function name.
+  //
+  // If any of the values in `arguments` is nullptr (i.e. a nullptr
+  // llvm::Value*) then we ignore it when generating LLVM IR, and instead pass
+  // in a nullptr llvm::Value* in its position to `kernel_body_generator`.
+  // Currently we only support at most one nullptr value in `arguments`.
+  static void EmitAndCallOutlinedKernel(
+      const HloModuleConfig& module_config, llvm::IRBuilder<>* b,
+      absl::string_view kernel_name, ArgumentVector arguments,
+      const std::function<void(ArgumentVector)>& kernel_body_generator);
+
+  // Thin wrappers around the more general EmitAndCallOutlinedKernel above.
+  static void EmitAndCallOutlinedKernel(
+      const HloModuleConfig& module_config, llvm::IRBuilder<>* b,
+      absl::string_view kernel_name, llvm::Value* arg0, llvm::Value* arg1,
+      llvm::Value* arg2,
+      const std::function<void(llvm::Value*, llvm::Value*, llvm::Value*)>&
+          kernel_body_generator) {
+    EmitAndCallOutlinedKernel(module_config, b, kernel_name, {arg0, arg1, arg2},
+                              [&](ArgumentVector args) {
+                                kernel_body_generator(args[0], args[1],
+                                                      args[2]);
+                              });
+  }
+
+  static void EmitAndCallOutlinedKernel(
+      const HloModuleConfig& module_config, llvm::IRBuilder<>* b,
+      absl::string_view kernel_name, llvm::Value* arg0, llvm::Value* arg1,
+      llvm::Value* arg2, llvm::Value* arg3,
+      const std::function<void(llvm::Value*, llvm::Value*, llvm::Value*,
+                               llvm::Value*)>& kernel_body_generator) {
+    EmitAndCallOutlinedKernel(
+        module_config, b, kernel_name, {arg0, arg1, arg2, arg3},
+        [&](ArgumentVector args) {
+          kernel_body_generator(args[0], args[1], args[2], args[3]);
+        });
+  }
+
+ private:
+  llvm::IRBuilder<>* b_;
+  llvm_ir::UnrollMode unroll_mode_;
+  bool prevent_vectorization_;
+};
+}  // namespace xla
+
+#endif  // XLA_SERVICE_LLVM_IR_KERNEL_SUPPORT_LIBRARY_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/llvm_ir/llvm_command_line_options.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/llvm_ir/llvm_command_line_options.h
new file mode 100644
index 0000000000000000000000000000000000000000..aa55982ff03949e946ec7ae418ae37492a1a52f9
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/llvm_ir/llvm_command_line_options.h
@@ -0,0 +1,61 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_LLVM_IR_LLVM_COMMAND_LINE_OPTIONS_H_
+#define XLA_SERVICE_LLVM_IR_LLVM_COMMAND_LINE_OPTIONS_H_
+
+#include <string>
+#include <vector>
+
+#include "absl/strings/match.h"
+#include "llvm/Support/CommandLine.h"
+#include "tsl/platform/logging.h"
+
+namespace xla {
+namespace llvm_ir {
+
+// Given a map with options (e.g. originating from xla_backend_extra_options())
+// pass those that don't start with xla_ to LLVM.
+template <typename T>
+void InitializeLLVMCommandLineOptions(const T& options) {
+  if (!options.empty()) {
+    std::vector<std::string> fake_argv_storage;
+    fake_argv_storage.push_back("");
+    for (const auto& it : options) {
+      // Skip options the XLA backend itself consumes.
+      if (!absl::StartsWith(it.first, "xla_")) {
+        if (it.second.empty()) {
+          fake_argv_storage.push_back(it.first);
+        } else {
+          fake_argv_storage.push_back(it.first + "=" + it.second);
+        }
+      }
+    }
+
+    VLOG(2) << "Passing argv to LLVM:";
+    std::vector<const char*> fake_argv;
+    for (const auto& s : fake_argv_storage) {
+      fake_argv.push_back(s.c_str());
+      VLOG(2) << s;
+    }
+    llvm::cl::ParseCommandLineOptions(static_cast<int>(fake_argv.size()),
+                                      &fake_argv[0]);
+  }
+}
+
+}  // namespace llvm_ir
+}  // namespace xla
+
+#endif  // XLA_SERVICE_LLVM_IR_LLVM_COMMAND_LINE_OPTIONS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/llvm_ir/llvm_loop.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/llvm_ir/llvm_loop.h
new file mode 100644
index 0000000000000000000000000000000000000000..a30ec8c8bea92a9072e56efa1fcd6ee8834c750b
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/llvm_ir/llvm_loop.h
@@ -0,0 +1,293 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_LLVM_IR_LLVM_LOOP_H_
+#define XLA_SERVICE_LLVM_IR_LLVM_LOOP_H_
+
+#include <memory>
+#include <string>
+
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/span.h"
+#include "llvm/IR/BasicBlock.h"
+#include "llvm/IR/IRBuilder.h"
+#include "llvm/IR/Value.h"
+#include "xla/service/llvm_ir/ir_array.h"
+#include "xla/types.h"
+#include "xla/xla_data.pb.h"
+
+namespace xla {
+namespace llvm_ir {
+
+enum class UnrollMode {
+  kDefaultUnroll,
+  kFullyUnroll,
+  kNoUnroll,
+};
+
+// A class for constructing a for-loop in LLVM IR.
+class ForLoop {
+ public:
+  ForLoop(const ForLoop&) = delete;
+  ForLoop& operator=(const ForLoop&) = delete;
+
+  // Emit a for-loop at the current insert point of the given IRBuilder.
+  //
+  // start_index and end_index are the loop bounds (end_index is not inclusive).
+  // `step` is the increment of the loop index after each iteration.
+  //
+  // The current insert basic block of the builder is the preheader to the loop
+  // (see below for definition of basic block names). All instructions (if any)
+  // at or after the insert point in the insert basic block are moved to a newly
+  // created exit basic block. Instructions before the insert point remain in
+  // the insert BB:
+  //
+  //                   +--------------+         +----------------+
+  //                   |  insert BB   |         |   insert BB    |
+  //                   |     ...      |         | (preheader BB) |
+  //                   | %foo = ...   |         |      ...       |
+  //    insert point ->| %bar = ...   |  ===>   | %foo = ...     |
+  //                   |     ...      |         +----------------+
+  //                   +--------------+                 |
+  //                                                    V
+  //                                              [[ LOOP BBs ]]
+  //                                                    |
+  //                                                    V
+  //                                             +--------------+
+  //                                             |   exit BB    |
+  //                                             | %bar = ...   |
+  //                                             |     ...      |
+  //                                             +--------------+
+  //
+  // `prefix` is used to disambiguate variable and basic block names emitted in
+  // LLVM IR. If non-empty, it is prepended to the name of the induction
+  // variable value and each basic block created for the loop.
+  //
+  // `unroll_mode` specifies the desired LLVM unrolling behavior for generated
+  //  loop.
+  static std::unique_ptr<ForLoop> EmitForLoop(
+      absl::string_view prefix, llvm::Value* start_index,
+      llvm::Value* end_index, llvm::Value* step, llvm::IRBuilder<>* b,
+      UnrollMode unroll_mode = llvm_ir::UnrollMode::kDefaultUnroll,
+      bool prevent_vectorization = false);
+
+  // The names of the blocks follow LLVM's conventions. Control flow amongst the
+  // blocks for the example C code looks like:
+  //
+  //   for (int i = 0; i < n; ++i) {
+  //     do_stuff(i);
+  //   }
+  //
+  //      +--------------+
+  //      | preheader BB |
+  //      |     i = 0    |
+  //      +--------------+
+  //              |
+  //              V
+  //      +-------------+
+  //      |  header BB  |<-+
+  //      | if i < n:   |  |
+  //      |   goto body |  |
+  //      | else:       |  |
+  //      |   goto exit |  |
+  //      +-------------+  |
+  //            | |        |
+  //   +--------+ |        |
+  //   |          V        |
+  //   |  +-------------+  |
+  //   |  |   body BB   |  |
+  //   |  | dostuff(i)  |--+
+  //   |  | ++i         |
+  //   |  +-------------+
+  //   |
+  //   |  +-------------+
+  //   +->|   exit BB   |
+  //      +-------------+
+  //
+  // Caller-emitted code to execute within the loop should be placed within the
+  // "body" basic block.
+  //
+  // Return pointers to various blocks in the loop.
+  llvm::BasicBlock* GetPreheaderBasicBlock() const { return preheader_bb_; }
+  llvm::BasicBlock* GetHeaderBasicBlock() const { return header_bb_; }
+  llvm::BasicBlock* GetBodyBasicBlock() const { return body_bb_; }
+  llvm::BasicBlock* GetExitBasicBlock() const { return exit_bb_; }
+
+  // Return the Value representing the induction variable in the body basic
+  // block of the loop.
+  llvm::Value* GetIndVarValue() const { return indvar_; }
+
+ private:
+  // Allow ForLoopNest to call this private constructor.
+  friend class ForLoopNest;
+
+  ForLoop(absl::string_view prefix, absl::string_view suffix,
+          llvm::Value* start_index, llvm::Value* end_index, llvm::Value* step,
+          UnrollMode unroll_mode, bool prevent_vectorization);
+
+  // Emit the loop at the insert point of the builder.
+  void Emit(llvm::IRBuilder<>* b);
+
+  llvm::BasicBlock* CreateLoopBB(absl::string_view name, llvm::IRBuilder<>* b);
+
+  // Creates a name for an LLVM construct, appending prefix_ and suffix_, if
+  // they are set.
+  std::string GetQualifiedName(absl::string_view name);
+
+  // Return a list of metadata nodes that should be associated with the
+  // llvm::Loop for this `ForLoop`.
+  std::vector<llvm::Metadata*> GetLoopMetadata(llvm::IRBuilder<>* b);
+
+  std::string prefix_;
+  std::string suffix_;
+  llvm::Value* start_index_;
+  llvm::Value* end_index_;
+  llvm::Value* step_;
+
+  // To improve readability of the IR, we want the basic blocks to appear
+  // consecutively in the following order: preheader, header, body, loop,
+  // exit. The member insert_before_bb_ points to where the next basic block
+  // should be created to ensure this ordering.
+  llvm::BasicBlock* insert_before_bb_;
+
+  llvm::BasicBlock* preheader_bb_;
+  llvm::BasicBlock* header_bb_;
+  llvm::BasicBlock* body_bb_;
+  llvm::BasicBlock* exit_bb_;
+  llvm::Value* indvar_;
+  UnrollMode unroll_mode_;
+  bool prevent_vectorization_;
+};
+
+// A simple class for constructing nested for-loops.
+class ForLoopNest {
+ public:
+  ForLoopNest(absl::string_view name, llvm::IRBuilder<>* b,
+              llvm::Type* index_ty = nullptr)
+      : name_(name),
+        outer_loop_preheader_bb_(nullptr),
+        outer_loop_exit_bb_(nullptr),
+        inner_loop_body_bb_(nullptr),
+        b_(b) {
+    SetIndexType(index_ty);
+  }
+  ForLoopNest(const ForLoopNest&) = delete;
+  ForLoopNest& operator=(const ForLoopNest&) = delete;
+
+  // Adds a loop to the nest. If no loop has been added yet then emit a loop at
+  // the current insert point of the given builder. If one or more loops have
+  // been added then emit loop inside the body of the last added loop.
+  // unroll_mode is used to emit metadata that controls LLVM unrolling.
+  std::unique_ptr<ForLoop> AddLoop(
+      absl::string_view suffix, llvm::Value* start_index,
+      llvm::Value* end_index, llvm::Value* stride,
+      UnrollMode unroll_mode = xla::llvm_ir::UnrollMode::kDefaultUnroll,
+      bool prevent_vectorization = false);
+
+  // Like the above, except that it defaults to a stride of one.
+  std::unique_ptr<ForLoop> AddLoop(
+      absl::string_view suffix, llvm::Value* start_index,
+      llvm::Value* end_index,
+      UnrollMode unroll_mode = xla::llvm_ir::UnrollMode::kDefaultUnroll,
+      bool prevent_vectorization = false);
+
+  // A convenient wrapper of the other flavor of AddLoop. The given start and
+  // end index are constant.
+  std::unique_ptr<ForLoop> AddLoop(
+      int64_t start_index, int64_t end_index, int64_t stride,
+      absl::string_view suffix,
+      UnrollMode unroll_mode = xla::llvm_ir::UnrollMode::kDefaultUnroll,
+      bool prevent_vectorization = false);
+
+  // Like the above, except that it defaults to a stride of one.
+  std::unique_ptr<ForLoop> AddLoop(
+      int64_t start_index, int64_t end_index, absl::string_view suffix,
+      UnrollMode unroll_mode = xla::llvm_ir::UnrollMode::kDefaultUnroll,
+      bool prevent_vectorization = false);
+
+  // Add loops to iterate through the indices within the specified
+  // shape. The returned index collects the induction variables of the
+  // loops so that it will iterate through all coordinates within the
+  // specified shape.
+  //
+  // E.g. if you pass in a 2x3 shape, you will get back an index with
+  // two entries that are induction variables of the two loops that
+  // will be added. That index will iterate through the 6 coordinates
+  // within the shape. One possible order for that sequence would be:
+  //
+  //   (0,0), (0,1), (0,2), (1,0), (1,1), (1,2)
+  IrArray::Index AddLoopsForShape(const Shape& shape, absl::string_view suffix);
+
+  // Add a loop for each dimension in "dimensions". "suffix" is the
+  // name suffix of the indvar and basic blocks in this new loop nest.
+  //
+  // The return value is an index with the induction variables. The
+  // size equals the rank of shape and there is a null for each
+  // dimension that is not in "dimensions".
+  std::vector<llvm::Value*> AddLoopsForShapeOnDimensions(
+      const Shape& shape, absl::Span<const int64_t> dimensions,
+      absl::string_view suffix);
+
+  // Emits a series of nested loops for iterating over an operand array. Loops
+  // are constructed in major to minor dimension layout order. No loop is
+  // emitted for the given 'dimension_to_skip'. The function returns an IrArray
+  // index for the given operand_array containing the indvars of the loops. All
+  // dimensions of the index are filled except for 'dimension_to_skip'.
+  // name_suffix is the string to append to the names of LLVM constructs (eg,
+  // basic blocks) constructed by this method.
+  std::vector<llvm::Value*> EmitOperandArrayLoopNest(
+      const llvm_ir::IrArray& operand_array, int64_t dimension_to_skip,
+      absl::string_view name_suffix);
+
+  // Convenience methods which return particular basic blocks of the outermost
+  // or innermost loops. These methods return nullptr if no loops have been
+  // added yet.
+  llvm::BasicBlock* GetOuterLoopPreheaderBasicBlock() {
+    return outer_loop_preheader_bb_;
+  }
+  llvm::BasicBlock* GetOuterLoopExitBasicBlock() { return outer_loop_exit_bb_; }
+  llvm::BasicBlock* GetInnerLoopBodyBasicBlock() { return inner_loop_body_bb_; }
+
+ private:
+  void SetIndexType(llvm::Type* index_ty) {
+    index_type_ = index_ty == nullptr ? b_->getInt64Ty() : index_ty;
+  }
+
+  llvm::Constant* GetConstantWithIndexType(int64_t c) const {
+    return llvm::ConstantInt::get(index_type_, c);
+  }
+
+  // Human-friendly name of the loop nest.
+  std::string name_;
+
+  // The preheader and exit basic block of the outermost loop, or nullptr if no
+  // loop has been added yet.
+  llvm::BasicBlock* outer_loop_preheader_bb_;
+  llvm::BasicBlock* outer_loop_exit_bb_;
+
+  // The body basic block of the most-recently added loop, or nullptr if no loop
+  // has been added yet.
+  llvm::BasicBlock* inner_loop_body_bb_;
+
+  llvm::IRBuilder<>* b_;
+
+  llvm::Type* index_type_;
+};
+
+}  // namespace llvm_ir
+}  // namespace xla
+
+#endif  // XLA_SERVICE_LLVM_IR_LLVM_LOOP_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/llvm_ir/llvm_type_conversion_util.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/llvm_ir/llvm_type_conversion_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..033c933deb1577a724518b56be83a132b6a99ce3
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/llvm_ir/llvm_type_conversion_util.h
@@ -0,0 +1,55 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_LLVM_IR_LLVM_TYPE_CONVERSION_UTIL_H_
+#define XLA_SERVICE_LLVM_IR_LLVM_TYPE_CONVERSION_UTIL_H_
+
+#include <string>
+#include <vector>
+
+#include "absl/strings/string_view.h"
+#include "absl/types/span.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/StringRef.h"
+
+namespace xla {
+namespace llvm_ir {
+
+// Convert a absl::string_view to a llvm::StringRef. Note: both
+// absl::string_view and llvm::StringRef are non-owning pointers into a
+// string in memory. This method is used to feed strings to LLVM
+// & Clang APIs that expect llvm::StringRef.
+inline llvm::StringRef AsStringRef(absl::string_view str) {
+  return llvm::StringRef(str.data(), str.size());
+}
+
+inline absl::string_view AsStringView(llvm::StringRef str) {
+  return absl::string_view(str.data(), str.size());
+}
+
+template <typename T>
+llvm::ArrayRef<T> AsArrayRef(const std::vector<T>& vec) {
+  return llvm::ArrayRef<T>(vec.data(), vec.size());
+}
+
+template <typename T>
+llvm::ArrayRef<T> AsArrayRef(const absl::Span<const T> slice) {
+  return llvm::ArrayRef<T>(slice.data(), slice.size());
+}
+
+}  // namespace llvm_ir
+}  // namespace xla
+
+#endif  // XLA_SERVICE_LLVM_IR_LLVM_TYPE_CONVERSION_UTIL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/llvm_ir/llvm_util.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/llvm_ir/llvm_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..10f710309781e4f18666a9e7ff05d85d0322db85
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/llvm_ir/llvm_util.h
@@ -0,0 +1,326 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_LLVM_IR_LLVM_UTIL_H_
+#define XLA_SERVICE_LLVM_IR_LLVM_UTIL_H_
+
+#include <cstdint>
+#include <map>
+#include <optional>
+#include <string>
+#include <utility>
+
+#include "absl/strings/string_view.h"
+#include "absl/types/span.h"
+#include "llvm/IR/BasicBlock.h"
+#include "llvm/IR/FPEnv.h"
+#include "llvm/IR/GlobalVariable.h"
+#include "llvm/IR/IRBuilder.h"
+#include "llvm/IR/InstrTypes.h"
+#include "llvm/IR/Instructions.h"
+#include "llvm/IR/Module.h"
+#include "llvm/IR/Value.h"
+#include "mlir/IR/BuiltinOps.h"  // from @llvm-project
+#include "mlir/IR/Location.h"  // from @llvm-project
+#include "mlir/IR/Operation.h"  // from @llvm-project
+#include "mlir/IR/OwningOpRef.h"  // from @llvm-project
+#include "mlir/IR/Types.h"  // from @llvm-project
+#include "mlir/IR/Value.h"  // from @llvm-project
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/literal.h"
+#include "xla/service/hlo_module_config.h"
+#include "xla/shape.h"
+#include "xla/statusor.h"
+#include "xla/xla_data.pb.h"
+
+namespace llvm {
+class FastMathFlags;
+class TargetOptions;
+};  // namespace llvm
+
+namespace xla {
+namespace llvm_ir {
+
+// We have different DumpToString functions for each type for findability. We
+// use pointers / values based on the usual semantics of the parameter type.
+
+std::string DumpToString(const llvm::Module* module);
+std::string DumpToString(const llvm::Type* type);
+std::string DumpToString(const llvm::Value* value);
+
+// This also works for mlir::Op<...> descendants, such as mlir::ModuleOp and
+// mlir::lmhlo::FusionOp.
+//
+// For findability:
+//   std::string DumpToString(mlir::Op<...>& op);
+//   std::string DumpToString(mlir::ModuleOp& module_op);
+//   std::string DumpToString(mlir::lmhlo::FusionOp& fusion_op);
+//
+// The `operation` parameter is not const, because the used print() method is
+// not const.
+std::string DumpToString(mlir::Operation* operation);
+std::string DumpToString(mlir::Type type);
+std::string DumpToString(mlir::Value value);
+
+// Constructs a human-friendly name from the given inputs.  The result is
+// suitable for use as an llvm::Value's name.
+//
+// This is equivalent to
+//
+//   - changing the HloInstruction* to its name() (if we called that overload),
+//   - joining all of the nonempty inputs by '.', and then
+//   - removing all '%'s.
+//
+std::string IrName(absl::string_view a);
+std::string IrName(absl::string_view a, absl::string_view b);
+std::string IrName(const HloInstruction* a, absl::string_view b = "");
+
+// Construct a module from the given location with an optional name.
+//
+// The underlying "create" method is unsafe, because it leaks the new module by
+// default. This function avoids this by always returning an OwningOpRef.
+mlir::OwningOpRef<mlir::ModuleOp> CreateMlirModuleOp(
+    mlir::Location loc, std::optional<llvm::StringRef> name = std::nullopt);
+
+// Removes special characters from a function name.
+//
+// Note that this can cause different inputs to map to the same output, so after
+// sanitizing a function name, you must run it through a uniquer.
+std::string SanitizeFunctionName(std::string function_name);
+
+// Emits a call to the specified intrinsic with the given operands. Overloaded
+// intrinsics (for example, "minnum") must include a type in overloaded_types
+// for each overloaded type. Typically, overloaded intrinsics have only a single
+// overloaded type.
+llvm::CallInst* EmitCallToIntrinsic(
+    llvm::Intrinsic::ID intrinsic_id, absl::Span<llvm::Value* const> operands,
+    absl::Span<llvm::Type* const> overloaded_types, llvm::IRBuilder<>* b,
+    absl::string_view name = "");
+
+// Emit float max. Emit maxnum intrinsic is fast math is disabled, or
+// fcmp+select otherwise
+llvm::Value* EmitFloatMax(llvm::Value* lhs_value, llvm::Value* rhs_value,
+                          llvm::IRBuilder<>* b, bool enable_fast_min_max,
+                          absl::string_view name = "");
+
+// Emit float min. Emit minnum intrinsic is fast math is disabled, or
+// fcmp+select otherwise
+llvm::Value* EmitFloatMin(llvm::Value* lhs_value, llvm::Value* rhs_value,
+                          llvm::IRBuilder<>* b, bool enable_fast_min_max,
+                          absl::string_view name = "");
+
+// Convenience methods for emitting a GEP instruction that indexes into a buffer
+// (1-dimensional array), equivalent to array[index]. The element type of the
+// array must be explicitly passed in.  The int64_t index overload
+// wraps the index in a i64 llvm::Value.
+llvm::Value* EmitBufferIndexingGEP(llvm::Value* array, llvm::Type* element_type,
+                                   llvm::Value* index, llvm::IRBuilder<>* b);
+llvm::Value* EmitBufferIndexingGEP(llvm::Value* array, llvm::Type* element_type,
+                                   int64_t index, llvm::IRBuilder<>* b);
+
+// Returns the LLVM type which represents the given XLA primitive type.
+llvm::Type* PrimitiveTypeToIrType(PrimitiveType element_type,
+                                  llvm::Module* module);
+
+// Returns the type size in bits. If "type" is a struct, it must be packed.
+int GetSizeInBits(llvm::Type* type);
+
+// Returns the LLVM type which represents the given XLA shape. For example,
+// if "shape" is [5 x [10 x f32]], the function returns [5 x [10 x float]].
+llvm::Type* ShapeToIrType(const Shape& shape, llvm::Module* module);
+
+// Returns a value that represents a pointer to a global string constant that
+// encodes the shape as a serialized protobuf.
+StatusOr<llvm::Value*> EncodeSelfDescribingShapeConstant(const Shape& shape,
+                                                         int32_t* shape_size,
+                                                         llvm::IRBuilder<>* b);
+
+// Converts a given literal to an IR Constant. Literals have known constant
+// values at IR emission time.
+llvm::Constant* ConvertLiteralToIrConstant(const Literal& literal,
+                                           llvm::Module* module);
+
+// Allocates a tile of shared memory.
+llvm::GlobalVariable* AllocateSharedMemoryTile(llvm::Module* module,
+                                               llvm::Type* tile_type,
+                                               absl::string_view name);
+
+// Inserts an allocate of the requested type at the entry point of the
+// function that the builder is currently building. The insert point
+// of the builder is set to the same place after calling this function
+// as before.
+//
+// This can be useful to avoid e.g. executing an alloca every time
+// through a loop.
+llvm::AllocaInst* EmitAllocaAtFunctionEntry(llvm::Type* type,
+                                            absl::string_view name,
+                                            llvm::IRBuilder<>* b,
+                                            int alignment = 0);
+
+// As EmitAllocaAtFunctionEntry, but allocates element_count entries
+// instead of a single element.
+llvm::AllocaInst* EmitAllocaAtFunctionEntryWithCount(llvm::Type* type,
+                                                     llvm::Value* element_count,
+                                                     absl::string_view name,
+                                                     llvm::IRBuilder<>* b,
+                                                     int alignment = 0);
+
+// Creates a basic block with the same context and function as for the
+// builder. Inserts at the end of the function if insert_before is
+// null.
+llvm::BasicBlock* CreateBasicBlock(llvm::BasicBlock* insert_before,
+                                   absl::string_view name,
+                                   llvm::IRBuilder<>* b);
+
+// Struct with data on a conditional branch in a diamond shape created
+// via EmitIfThenElse.
+struct LlvmIfData {
+  // The block that has the conditional branch.
+  llvm::BasicBlock* if_block;
+
+  // The block that is executed if the condition is true.
+  llvm::BasicBlock* true_block;
+
+  // The block that is executed if the condition is false.
+  llvm::BasicBlock* false_block;
+
+  // The block that follows after both the true_block and the
+  // false_block.
+  llvm::BasicBlock* after_block;
+};
+
+// Inserts a diamond-shaped if-then-else construct at the current
+// insertion point of the builder. This involves splitting the current
+// block into two blocks, at the insertion point, and introducing a
+// true-block and a false-block that connect the two split pieces. The
+// true-block is executed if the condition parameter evaluates to true
+// and otherwise the false-block is executed. If `emit_else` is false,
+// it jumps to the after-block rather than the false-block if the
+// condition is false, and the returned `false_block` is null.
+//
+// Currently the insertion point of the builder must be a well-formed
+// block with a terminator. If you need to use this for a
+// non-terminated block, just make the function able to do that too.
+LlvmIfData EmitIfThenElse(llvm::Value* condition, absl::string_view name,
+                          llvm::IRBuilder<>* b, bool emit_else = true);
+
+// Emits a compare operation between "lhs" and "rhs" with the given predicate,
+// and then converts the result to i8 so that it is addressable.
+llvm::Value* EmitComparison(llvm::CmpInst::Predicate predicate,
+                            llvm::Value* lhs, llvm::Value* rhs,
+                            llvm::IRBuilder<>* b, absl::string_view name = "");
+
+// Emits a call that logs the given value with the given tag as a prefix.
+// The provided tag and value are passed to a runtime logging call that is
+// embedded in this translation unit when the emitted code is executed.
+//
+// This can be very useful for debugging generated programs in short order when
+// developing new generated routines.
+//
+// Precondition: value must be an int64_t.
+// Precondition: tag must be a stable pointer for the lifetime of the generated
+// program (the constant pointer is burned in to the program).
+void EmitLogging(const char* tag, llvm::Value* value, llvm::IRBuilder<>* b);
+
+// Adds alignment metadata to a load instruction using the given alignment.
+// The alignment refers to the result of the load, not the load itself.
+void SetAlignmentMetadataForLoad(llvm::LoadInst* load, uint64_t alignment);
+
+// Adds dereferenceable metadata to a load instruction using the given
+// the number of dereferenceable bytes.
+// Dereferenceable refers to the result of the load, not the load itself.
+void SetDereferenceableMetadataForLoad(llvm::LoadInst* load,
+                                       uint64_t dereferenceable_bytes);
+
+// Tells LLVM `inst >= lower && inst < upper`. Returns `inst` for convenience.
+llvm::Instruction* AddRangeMetadata(int32_t lower, int32_t upper,
+                                    llvm::Instruction* inst);
+
+void SetToFirstInsertPoint(llvm::BasicBlock* blk, llvm::IRBuilder<>* builder);
+
+void SetToLastInsertPoint(llvm::BasicBlock* blk, llvm::IRBuilder<>* builder);
+
+// Create a bitwise rotation of `rotand` by `rotor`.
+llvm::Value* CreateRor(llvm::Value* rotand, llvm::Value* rotor,
+                       llvm::IRBuilder<>* builder);
+
+// Returns the number of bytes within the shape.
+int64_t ByteSizeOf(const Shape& shape, const llvm::DataLayout& data_layout);
+
+// Gets an llvm::FastMathFlags that reflects the settings in the given
+// module config.
+llvm::FastMathFlags GetCpuFastMathFlags(const HloModuleConfig& module_config);
+
+// Computes a conservative union of the metadata in "a" and "b".  For
+// aliasing-related metadata, this means the result can be applied to
+// instructions whose aliasing relationship can be described either by "a" *or*
+// by "b".
+std::map<int, llvm::MDNode*> MergeMetadata(
+    llvm::LLVMContext* context, const std::map<int, llvm::MDNode*>& a,
+    const std::map<int, llvm::MDNode*>& b);
+
+// Dumps out `llvm_module` to the path specified in DebugOptions, if dumping is
+// enabled for the given HLO module.
+//
+// A sanitized version of `hlo_module_name` is incorporated into the file name.
+// If `optimized` is true then a suffix of "-with-opt.ll" is used, else a suffix
+// of "-no-opt.ll" is used.
+void DumpIrIfEnabled(const HloModule& hlo_module,
+                     const llvm::Module& llvm_module, bool optimized,
+                     absl::string_view filename_suffix = "");
+
+llvm::Function* CreateCpuFunction(llvm::FunctionType* function_type,
+                                  llvm::GlobalValue::LinkageTypes linkage,
+                                  const HloModuleConfig& module_config,
+                                  absl::string_view name, llvm::Module* module);
+
+// Zero-extends two 32-bit values to 64 bits, multiplies them, and returns the
+// result as a pair of (low 32 bits, high 32 bits).
+std::pair<llvm::Value*, llvm::Value*> UMulLowHigh32(llvm::IRBuilder<>* b,
+                                                    llvm::Value* src0,
+                                                    llvm::Value* src1);
+// Splits the 64-bit integer value into its high and low 32 bits.
+std::pair<llvm::Value*, llvm::Value*> SplitInt64ToInt32s(
+    llvm::IRBuilder<>* b, llvm::Value* value_64bits);
+
+// Checks whether a global variable is already created to represent the state
+// of a random number generator. If not, creates such a variable. Returns the
+// global variable.
+llvm::GlobalVariable* GetOrCreateVariableRngState(llvm::Module* module,
+                                                  llvm::IRBuilder<>* b);
+
+// Adds a delta value to the global state variable and return the old value of
+// the variable.
+llvm::Value* RngGetAndUpdateState(uint64_t delta, llvm::Module* module,
+                                  llvm::IRBuilder<>* b);
+
+// Gets the LLVM address space that should be used for global variables (e.g.
+// XLA's rng state).
+unsigned GetGlobalMemoryAddressSpace();
+
+// Emits a block which does "return void". Leaves the insert point as is.
+llvm::BasicBlock* EmitReturnBlock(llvm::IRBuilder<>* b);
+
+// Emits `if (condition) return`. Assumes that the current function returns
+// void.
+//
+// Can either use a supplied `return_block`, or generate a new one.
+void EmitEarlyReturn(llvm::Value* condition, llvm::IRBuilder<>* b,
+                     llvm::BasicBlock* return_block = nullptr);
+
+}  // namespace llvm_ir
+}  // namespace xla
+
+#endif  // XLA_SERVICE_LLVM_IR_LLVM_UTIL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/llvm_ir/loop_emitter.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/llvm_ir/loop_emitter.h
new file mode 100644
index 0000000000000000000000000000000000000000..c5f3c2322db059e036b8a105eba6e20f57f46ee2
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/llvm_ir/loop_emitter.h
@@ -0,0 +1,112 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_LLVM_IR_LOOP_EMITTER_H_
+#define XLA_SERVICE_LLVM_IR_LOOP_EMITTER_H_
+
+#include <functional>
+
+#include "llvm/IR/BasicBlock.h"
+#include "llvm/IR/IRBuilder.h"
+#include "llvm/IR/Value.h"
+#include "xla/service/llvm_ir/ir_array.h"
+#include "xla/service/llvm_ir/llvm_loop.h"
+#include "xla/statusor.h"
+
+namespace xla {
+namespace llvm_ir {
+
+// A function type for emitting code that generates an element in the target
+// array. The function gets a multi-dimensional index as its only input. This
+// index specifies the target element for which a value needs to be computed.
+// The function has to emit code to compute this value and return the resulting
+// llvm::Value*.
+using ElementGenerator =
+    std::function<StatusOr<llvm::Value*>(const IrArray::Index& index)>;
+using BodyEmitter = std::function<Status(const IrArray::Index& index)>;
+
+// Creates the body emitter from target arrays.
+BodyEmitter MakeBodyEmitter(const ElementGenerator& target_element_generator,
+                            absl::Span<IrArray const> target_arrays,
+                            llvm::IRBuilder<>* b, bool is_tuple);
+
+// Emits a loop for every element in the given shape.
+class LoopEmitter {
+ public:
+  LoopEmitter(const BodyEmitter& body_emitter, const Shape& shape,
+              llvm::IRBuilder<>* b);
+
+  // Constructs a LoopEmitter from an body_emitter that generates
+  // element of the given target array in the dynamic dimension.
+  LoopEmitter(const BodyEmitter& body_emitter, const Shape& shape,
+              std::vector<llvm::Value*> dynamic_dims, llvm::IRBuilder<>* b);
+
+  // Constructs a LoopEmitter from an element generator that generates each
+  // element of the given target array.
+  LoopEmitter(const ElementGenerator& target_element_generator,
+              const IrArray& target_array, llvm::IRBuilder<>* b);
+
+  // Constructs a LoopEmitter that emits one element into each of N separate
+  // arrays on each iteration of the loop.
+  //
+  // This is used for multi-output fusion.  target_element_generator must
+  // produce an LLVM struct with N elements.
+  LoopEmitter(const ElementGenerator& target_element_generator,
+              absl::Span<const IrArray> target_arrays, llvm::IRBuilder<>* b);
+
+  LoopEmitter(const LoopEmitter&) = delete;
+  LoopEmitter& operator=(const LoopEmitter&) = delete;
+  virtual ~LoopEmitter() = default;
+
+  // Emits a loop nest (with a yet-to-be-filled loop body) that iterates through
+  // every element in the given shape. Returns the multi-dimensional index that
+  // specifies the element, will return multiple indices if the loop is
+  // unrolled.
+  virtual std::vector<IrArray::Index> EmitIndexAndSetExitBasicBlock(
+      absl::string_view loop_name, llvm::Type* index_type,
+      llvm::Value* base_index);
+
+  // Emits a complete loop nest for every element in the given shape.
+  Status EmitLoop(absl::string_view loop_name = "",
+                  llvm::Type* index_type = nullptr);
+
+ protected:
+  // An IR emitter that generates the loop body.
+  BodyEmitter body_emitter_;
+
+  // The shape that the emitted loop iterates through.
+  Shape shape_;
+
+  // Dynamic dimensions that  emitted loop iterates through. Generate the
+  // loop based on the dynamic dimensions if this vector is not empty.
+  std::vector<llvm::Value*> dynamic_dims_;
+
+  // Points to the exit block of the emitted loop. If the given shape is
+  // scalar, no loops are emitted and exit_bb_ is nullptr in that case.
+  llvm::BasicBlock* exit_bb_;
+
+  llvm::IRBuilder<>* b_;
+
+ private:
+  IrArray::Index EmitStaticIndex(ForLoopNest* loop_nest,
+                                 llvm::Type* index_type);
+  IrArray::Index EmitDynamicIndex(ForLoopNest* loop_nest,
+                                  llvm::Type* index_type);
+};
+
+}  // namespace llvm_ir
+}  // namespace xla
+
+#endif  // XLA_SERVICE_LLVM_IR_LOOP_EMITTER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/llvm_ir/math_ops.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/llvm_ir/math_ops.h
new file mode 100644
index 0000000000000000000000000000000000000000..bc16d4cc593d647847106dd0b134beb9d7e48619
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/llvm_ir/math_ops.h
@@ -0,0 +1,32 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_LLVM_IR_MATH_OPS_H_
+#define XLA_SERVICE_LLVM_IR_MATH_OPS_H_
+
+#include "llvm/IR/IRBuilder.h"
+#include "llvm/IR/Value.h"
+
+namespace xla {
+namespace llvm_ir {
+
+// Emits an approximation of tanh. The implementation uses the same rational
+// interpolant as implemented in Eigen3.
+llvm::Value* EmitFastTanh(llvm::IRBuilder<>* b, llvm::Value* input);
+
+}  // namespace llvm_ir
+}  // namespace xla
+
+#endif  // XLA_SERVICE_LLVM_IR_MATH_OPS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/llvm_ir/sort_util.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/llvm_ir/sort_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..92cfa679ae284700f8c648376338d3615d54cc0b
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/llvm_ir/sort_util.h
@@ -0,0 +1,45 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_LLVM_IR_SORT_UTIL_H_
+#define XLA_SERVICE_LLVM_IR_SORT_UTIL_H_
+
+#include <vector>
+
+#include "absl/strings/string_view.h"
+#include "absl/types/span.h"
+#include "llvm/IR/Value.h"
+#include "xla/service/gpu/launch_dimensions.h"
+#include "xla/service/llvm_ir/ir_array.h"
+#include "tsl/platform/status.h"
+
+namespace xla {
+namespace llvm_ir {
+using EmitCallToNestedComputationCallback =
+    std::function<Status(absl::Span<llvm::Value* const>, llvm::Value*)>;
+// Emits llvm IR to do pairwise comparisons/swaps in the 'dimension_to_sort'
+// dimension of each array in 'values_arrays'. All other dimensions are kept
+// as-is. This implements the inner loop of BitonicSort. It is assumed that
+// 'xor_masks' contains only powers of 2, or values 2^k - 1 (k > 0).
+Status EmitSortInPlace(
+    int64_t dimension_to_sort, const std::vector<IrArray>& values_arrays,
+    absl::string_view name, absl::Span<const int64_t> xor_masks,
+    llvm::IRBuilder<>* b, const gpu::LaunchDimensions& launch_dimensions,
+    int64_t num_iterations_in_sort_dim, int64_t tile_size,
+    const EmitCallToNestedComputationCallback& emit_compare_callback);
+}  // namespace llvm_ir
+}  // namespace xla
+
+#endif  // XLA_SERVICE_LLVM_IR_SORT_UTIL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/llvm_ir/tuple_ops.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/llvm_ir/tuple_ops.h
new file mode 100644
index 0000000000000000000000000000000000000000..0ce8249caa9f1e6dc600a63fd82bd6384f5a7304
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/llvm_ir/tuple_ops.h
@@ -0,0 +1,56 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_LLVM_IR_TUPLE_OPS_H_
+#define XLA_SERVICE_LLVM_IR_TUPLE_OPS_H_
+
+#include "absl/types/span.h"
+#include "llvm/IR/IRBuilder.h"
+#include "llvm/IR/Value.h"
+#include "xla/service/llvm_ir/ir_array.h"
+
+// Utilities for emitting LLVM IR related to HLO tuples.
+
+namespace xla {
+namespace llvm_ir {
+
+// A tuple is an array of pointers, one for each operand. Each pointer points to
+// the output buffer of its corresponding operand.
+void EmitTuple(const IrArray& tuple, absl::Span<llvm::Value* const> operands,
+               llvm::IRBuilder<>* b);
+
+// Emits one alloca for each element in the tuple of shape tuple_shape,
+// returns the emitted allocas.
+// Precondition: tuple_shape should be a tuple of scalars.
+std::vector<llvm::Value*> EmitTupleAllocasAtFunctionEntry(
+    const Shape& tuple_shape, llvm::IRBuilder<>* b);
+
+// Similar to EmitTuple above, except that the output buffers are provided in
+// the form of IrArray.
+void EmitTuple(const IrArray& tuple, absl::Span<const IrArray> buffers,
+               llvm::IRBuilder<>* b);
+
+// A tuple is an array of pointers, one for each operand. Each pointer points to
+// the output buffer of its corresponding operand. A GetTupleElement instruction
+// forwards the pointer to underlying tuple element buffer at the given index.
+// Returns an llvm value representing a pointer to the tuple element buffer.
+llvm::Value* EmitGetTupleElement(const Shape& target_shape, int64_t index,
+                                 int alignment, llvm::Value* operand,
+                                 llvm::Type* operand_pointee_type,
+                                 llvm::IRBuilder<>* b);
+}  // namespace llvm_ir
+}  // namespace xla
+
+#endif  // XLA_SERVICE_LLVM_IR_TUPLE_OPS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/memory_space_assignment/memory_space_assignment.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/memory_space_assignment/memory_space_assignment.h
new file mode 100644
index 0000000000000000000000000000000000000000..384c5bc46d985bf293aaa57080e94561c9fdc397
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/memory_space_assignment/memory_space_assignment.h
@@ -0,0 +1,2670 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_MEMORY_SPACE_ASSIGNMENT_MEMORY_SPACE_ASSIGNMENT_H_
+#define XLA_SERVICE_MEMORY_SPACE_ASSIGNMENT_MEMORY_SPACE_ASSIGNMENT_H_
+
+#include <cstdint>
+#include <functional>
+#include <list>
+#include <map>
+#include <memory>
+#include <optional>
+#include <ostream>
+#include <set>
+#include <string>
+#include <tuple>
+#include <utility>
+#include <variant>
+#include <vector>
+
+// TODO(b/210891274): Use btree_map after build issue in Windows is resolved.
+#if defined(__GNUC__) || defined(__clang__)
+#include "absl/container/btree_map.h"
+#endif
+#include "absl/container/flat_hash_map.h"
+#include "absl/functional/function_ref.h"
+#include "absl/types/span.h"
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/service/heap_simulator.h"
+#include "xla/service/hlo.pb.h"
+#include "xla/service/hlo_cost_analysis.h"
+#include "xla/service/hlo_value.h"
+#include "xla/service/memory_space_assignment/memory_space_assignment.pb.h"
+#include "xla/service/memory_space_assignment/repacking.h"
+#include "xla/shape.h"
+#include "xla/statusor.h"
+
+namespace xla {
+
+namespace memory_space_assignment {
+// Forward Declaration of Options.
+class Options;
+
+inline constexpr char kConcatBitcastCustomCall[] = "ConcatBitcast";
+
+// This class contains pre-set assignments determined by memory space
+// assignment. It contains two data structures: (1) a chunks vector that maps a
+// defining HloPosition to a Chunk (offset and size), and (2) an assignment_info
+// vector that maps the memory space to information like its allocated size and
+// heap memory trace. If there is only one alternate memory space like there is
+// currently, there will be one entry in assignment_info.
+class PresetAssignments {
+ public:
+  // Contains per-memory-space information like the allocated size and heap
+  // simulator trace.
+  struct AssignmentInformation {
+    int64_t size;
+    HeapSimulatorTrace heap_simulator_trace;
+  };
+
+  PresetAssignments() = default;
+
+  void add_chunk(const HloPosition& position,
+                 const HeapSimulator::Chunk& chunk) {
+    chunks_.emplace_back(position, chunk);
+  }
+
+  void add_scoped_allocation_chunk(HloInstruction* instruction,
+                                   const HeapSimulator::Chunk& chunk) {
+    scoped_allocation_chunks_.emplace_back(instruction, chunk);
+  }
+
+  AssignmentInformation* assignment_information_for_space(
+      int64_t memory_space) {
+    for (auto& space_and_info : assignment_info_) {
+      if (space_and_info.first == memory_space) {
+        return &space_and_info.second;
+      }
+    }
+    assignment_info_.emplace_back(memory_space, AssignmentInformation());
+    return &assignment_info_.back().second;
+  }
+
+  absl::Span<const std::pair<HloPosition, HeapSimulator::Chunk>> chunks()
+      const {
+    return chunks_;
+  }
+
+  absl::Span<const std::pair<HloInstruction*, HeapSimulator::Chunk>>
+  scoped_allocation_chunks() const {
+    return scoped_allocation_chunks_;
+  }
+
+  absl::Span<const std::pair<int64_t, AssignmentInformation>>
+  assignment_informations() const {
+    return assignment_info_;
+  }
+
+  // Get debugging information.
+  std::string buffer_info_str() const { return buffer_info_str_; }
+  std::string allocation_info_str() const { return allocation_info_str_; }
+  std::string instruction_schedule_str() const {
+    return instruction_schedule_str_;
+  }
+
+ private:
+  std::vector<std::pair<HloPosition, HeapSimulator::Chunk>> chunks_;
+  std::vector<std::pair<HloInstruction*, HeapSimulator::Chunk>>
+      scoped_allocation_chunks_;
+  std::vector<std::pair<int64_t, AssignmentInformation>> assignment_info_;
+  std::string buffer_info_str_;
+  std::string allocation_info_str_;
+  std::string instruction_schedule_str_;
+};
+
+// A wrapper class around HloCostAnalysis with additional knowledge about the
+// bandwidths of different memory spaces.
+class MemorySpaceAssignmentCostAnalysis {
+ public:
+  // An optional Cache object may be provided to some of the methods below to
+  // speed up the lookup.
+  struct Cache {
+    absl::flat_hash_map<const HloInstruction*, float> while_nest_multiplier;
+    absl::flat_hash_map<HloPosition, float> memory_boundedness;
+  };
+
+  // Function type that can be used to indicate which input/output values are in
+  // the alternate memory.
+  using IsInAlternateMemoryFun = absl::FunctionRef<bool(
+      std::optional<int> /*operand_num*/, const ShapeIndex& /*index*/,
+      const Shape& /*shape*/)>;
+
+  virtual ~MemorySpaceAssignmentCostAnalysis() = default;
+
+  static StatusOr<std::unique_ptr<MemorySpaceAssignmentCostAnalysis>> Create(
+      const HloCostAnalysis& cost_analysis, const Options& options,
+      const HloModule& module);
+
+  const HloCostAnalysis& cost_analysis() const { return cost_analysis_; }
+
+  // Returns a heuristic value that captures how much putting this tensor to the
+  // alternate memory would help if the op is memory bound, or otherwise how far
+  // off is the op to memory boundedness. The larger this number, the higher
+  // priority it will be placed in the alternate memory.
+  float GetAlternateMemoryBenefit(const HloInstruction& instruction,
+                                  float elapsed_time_due_to_alternate_mem,
+                                  Cache* cache = nullptr) const;
+  // Like above, return the benefit of putting the output tensor in the
+  // alternate memory.
+  float GetAlternateMemoryBenefit(const HloPosition& position,
+                                  Cache* cache = nullptr) const;
+  // Like above, return the benefit of putting the input tensor in the alternate
+  // memory.
+  float GetAlternateMemoryBenefit(const HloUse& use,
+                                  Cache* cache = nullptr) const;
+
+  // Returns a heuristic value of memory boundedness for the given
+  // BufferInterval.  The larger this number, the higher priority it will be
+  // placed in the alternate memory.
+  float GetMemoryBoundedness(
+      const GlobalDecreasingSizeBestFitHeap<HloValue>::BufferInterval& interval,
+      Cache* cache = nullptr) const;
+
+  // If enabled in Options::pipeline_overhead_window_size_mib, returns the
+  // overhead of accessing the default memory, in seconds. The source of the
+  // overhead is the software pipelining ovehead. The lowering of the operations
+  // typically use tiling to copy one window at a time from default memory, and
+  // perform compute:
+  //
+  // Pipeline overhead:                          <->
+  //                        +----+----+----+----+
+  // Copy from default mem: |    |    |    |    |
+  //                        +----+----+----+----+
+  //                            \    \    \    \
+  //                             \    \    \    \
+  //                              V    V    V    V
+  //                             +--+ +--+ +--+ +--+
+  // Compute:                    |  | |  | |  | |  |
+  //                             +--+ +--+ +--+ +--+
+  float GetDefaultMemoryAccessOverhead(
+      const HloInstruction& instruction,
+      absl::Span<const std::pair<int64_t, ShapeIndex>>
+          operands_in_alternate_mem = {},
+      absl::Span<const ShapeIndex> outputs_in_alternate_mem = {}) const;
+
+  // Returns the amount of time the default memory bandwidth is idle, while
+  // executing this instruction, in seconds.  This value can be multiplied with
+  // the default memory bandwidth to get the amount of bytes that are available
+  // to be copied to/from default memory during the execution of this
+  // instruction.
+  float GetDefaultMemoryBandwidthIdleTime(
+      const HloInstruction& instruction,
+      absl::Span<const std::pair<int64_t, ShapeIndex>>
+          operands_in_alternate_mem = {},
+      absl::Span<const ShapeIndex> outputs_in_alternate_mem = {}) const;
+
+  // Returns the bytes accessed from alternate memory.
+  float GetBytesAccessedFromAlternateMemory(
+      const HloInstruction& instruction,
+      absl::Span<const std::pair<int64_t, ShapeIndex>>
+          operands_in_alternate_mem = {},
+      absl::Span<const ShapeIndex> outputs_in_alternate_mem = {}) const;
+
+  // Returns the elapsed time in seconds due to compute only.
+  float GetInstructionElapsedDueToCompute(
+      const HloInstruction& instruction) const;
+
+  // Returns the elapsed time in seconds due to memory only. If
+  // operands_in_alternate_mem or outputs_in_alternate_mem is provided, it will
+  // assume that the corresponding operands or output will be in the alternate
+  // memory space. This is useful for calculating the benefit of placing the
+  // buffer in alternate memory.
+  float GetInstructionElapsedDueToMemory(
+      const HloInstruction& instruction,
+      absl::Span<const std::pair<int64_t, ShapeIndex>>
+          operands_in_alternate_mem = {},
+      absl::Span<const ShapeIndex> outputs_in_alternate_mem = {}) const;
+
+  // Like above, only the inputs/outputs indicated by is_in_alternate_mem are in
+  // the alternate memory.
+  float GetInstructionElapsedDueToMemory(
+      const HloInstruction& instruction,
+      IsInAlternateMemoryFun is_in_alternate_mem) const;
+
+  // Returns the estimated elapsed duration of the instruction in seconds.  It
+  // assumes all operands and outputs of the instruction are in the default
+  // memory.
+  virtual float GetInstructionElapsed(const HloInstruction& instruction) const;
+
+  // Returns the estimated elapsed duration of the instruction in seconds.  It
+  // assumes all operands and outputs of the instruction are in the default
+  // memory, except for the operands and outputs specified to be in the
+  // alternate memory.
+  virtual float GetInstructionElapsedInAlternateMemory(
+      const HloInstruction& instruction,
+      absl::Span<const std::pair<int64_t, ShapeIndex>>
+          operands_in_alternate_mem,
+      absl::Span<const ShapeIndex> outputs_in_alternate_mem) const;
+
+  // Like above, only the inputs/outputs indicated by is_in_alternate_mem are in
+  // the alternate memory.
+  float GetInstructionElapsedInAlternateMemory(
+      const HloInstruction& instruction,
+      IsInAlternateMemoryFun is_in_alternate_mem) const;
+
+  // Returns the elapsed time it would take to asynchronously copy the shape
+  // from default to alternate memory space (or vice versa).
+  virtual float GetAsyncCopyElapsed(const Shape& shape) const;
+
+  int64_t GetScheduleEndTime() const;
+
+  // Returns the number of nested computation levels this instruction resides
+  // in. If while_only is true, it returns the while loop nest level and 0
+  // means the instruction is not in a while loop.
+  int CalculateComputationNestLevel(const HloInstruction* instruction,
+                                    bool while_only) const;
+
+  const HloLiveRange& hlo_live_range() const { return *hlo_live_range_; }
+  const Options& options() const { return options_; }
+
+ protected:
+  MemorySpaceAssignmentCostAnalysis(
+      const HloCostAnalysis& cost_analysis, const Options& options,
+      std::unique_ptr<HloAliasAnalysis> alias_analysis,
+      std::unique_ptr<HloLiveRange> hlo_live_range,
+      std::unique_ptr<CallGraph> call_graph)
+      : cost_analysis_(cost_analysis),
+        options_(options),
+        alias_analysis_(std::move(alias_analysis)),
+        hlo_live_range_(std::move(hlo_live_range)),
+        call_graph_(std::move(call_graph)) {}
+
+ private:
+  const HloCostAnalysis& cost_analysis_;
+  const Options& options_;
+  std::unique_ptr<HloAliasAnalysis> alias_analysis_;
+  std::unique_ptr<HloLiveRange> hlo_live_range_;
+  std::unique_ptr<CallGraph> call_graph_;
+};
+
+// Abstract base class that memory space assignment uses to pick prefetch
+// intervals.
+class PrefetchIntervalPicker {
+ public:
+  PrefetchIntervalPicker() = default;
+  virtual ~PrefetchIntervalPicker() = default;
+
+  // Returns true if the buffer can be allocated in alternate memory space
+  // without any copies (prefetches).
+  virtual bool CanAllocateInAlternateMemoryNoCopy(const Shape& shape,
+                                                  int64_t start_time,
+                                                  int64_t end_time) const = 0;
+
+  // Returns the preferred end time for an eviction that starts at a given time
+  // and must end by the given end time.
+  virtual int64_t PreferredEvictionEndTime(const Shape& shape,
+                                           int64_t start_time,
+                                           int64_t latest_end_time) const = 0;
+
+  // Returns the latest time that a prefetch can start.
+  virtual int64_t LatestPrefetchStartTime(const Shape& shape,
+                                          int64_t start_time, int64_t end_time,
+                                          const HloUse* use) const = 0;
+
+  // Returns the preferred time that a prefetch can start.
+  virtual int64_t PreferredPrefetchStartTime(
+      const Shape& shape, int64_t earliest_prefetch_start_time,
+      int64_t latest_prefetch_start_time, int64_t prefetch_end_time) const = 0;
+
+  // Returns the latest time that a prefetch can end that is less than or equal
+  // to proposed_prefetch_end_time.
+  virtual int64_t LatestPrefetchEndTime(
+      int64_t original_prefetch_end_time,
+      int64_t proposed_prefetch_end_time) const {
+    return proposed_prefetch_end_time;
+  }
+
+  // Returns the estimated end time of a prefetch that starts at the given time.
+  virtual int64_t EstimatedPrefetchEndTime(const Shape& shape,
+                                           int64_t start_time,
+                                           int64_t end_time) const = 0;
+
+  // Returns the elapsed time in seconds between the logical interval that
+  // corresponds to the instruction schedule.
+  virtual float GetLogicalIntervalElapsed(int64_t start_time,
+                                          int64_t end_time) const = 0;
+
+  // Begins the iterator for the first start time of the prefetch.
+  virtual void Begin(const HloUse& use, int64_t start_time, int64_t end_time,
+                     std::optional<int64_t> preferred_time) = 0;
+
+  // Advances the start time of the prefetch and returns that value.
+  virtual int64_t Next() = 0;
+
+  // Returns true if the available prefetch intervals have been exhausted.
+  virtual bool Done() const = 0;
+
+  // Returns the latest time the prefetch interval picker will have pick.
+  virtual int64_t latest_time() const = 0;
+
+  // The retry number can be used to modify the interval picking policies. The
+  // first attempt will have a retry_number of 0, then 1, etc.
+  virtual void SetRetryNumber(int retry_number) {
+    retry_number_ = retry_number;
+  }
+  int retry_number() const { return retry_number_; }
+
+  // Returns a debug string for the current state of the prefetch interval
+  // picker.
+  virtual std::string ToDebugString() const = 0;
+
+  // Returns a debug string for no-copy allocation.
+  virtual std::string ToNoCopyDebugString(const Shape& shape,
+                                          int64_t start_time,
+                                          int64_t end_time) const = 0;
+
+  // Prefetch interval pickers may return a value corresponding to the benefit
+  // of placing the BufferInterval in the alternate memory. The larger value,
+  // the more beneficial.
+  virtual std::optional<float> BufferIntervalAlternateMemoryBenefit(
+      const GlobalDecreasingSizeBestFitHeap<HloValue>::BufferInterval& interval)
+      const {
+    return std::nullopt;
+  }
+
+ protected:
+  const absl::flat_hash_map<const HloInstruction*, int64_t>*
+      instruction_schedule_ = nullptr;
+  int retry_number_ = 0;
+};
+
+// Prefetch interval picker that uses instruction count to overlap asynchronous
+// copies with independent computation. The min and max overlap counts describe
+// the number of independent HLOs overlapped while a value is being prefetched
+// into the alternate memory (between CopyStart and CopyDone HLO instructions).
+// max_overlap_count attempts to prevent bringing tensors into the alternate
+// memory too eagerly and hence occupying the space for other tensors which
+// might use it.  min_overlap_count attempts to prevent cases where tensors are
+// prefetched into the alternate memory without sufficient time for the copy to
+// take place.  In those cases, it's just better to keep the tensor in the
+// default memory instead of hurting the critical path with this copy that
+// likely won't finish in time.
+class InstructionCountPrefetchIntervalPicker : public PrefetchIntervalPicker {
+ public:
+  InstructionCountPrefetchIntervalPicker(int64_t min_overlap_count,
+                                         int64_t max_overlap_count)
+      : min_overlap_count_(min_overlap_count),
+        max_overlap_count_(max_overlap_count) {}
+
+  bool CanAllocateInAlternateMemoryNoCopy(const Shape& shape,
+                                          int64_t start_time,
+                                          int64_t end_time) const override;
+
+  int64_t PreferredEvictionEndTime(const Shape& shape, int64_t start_time,
+                                   int64_t latest_end_time) const override;
+
+  int64_t LatestPrefetchStartTime(const Shape& shape, int64_t start_time,
+                                  int64_t end_time,
+                                  const HloUse* use) const override;
+
+  int64_t PreferredPrefetchStartTime(const Shape& shape,
+                                     int64_t earliest_prefetch_start_time,
+                                     int64_t latest_prefetch_start_time,
+                                     int64_t prefetch_end_time) const override;
+
+  int64_t EstimatedPrefetchEndTime(const Shape& shape, int64_t start_time,
+                                   int64_t end_time) const override;
+  float GetLogicalIntervalElapsed(int64_t start_time,
+                                  int64_t end_time) const override;
+
+  void Begin(const HloUse& use, int64_t start_time, int64_t end_time,
+             std::optional<int64_t> preferred_time) override;
+
+  int64_t Next() override;
+  bool Done() const override;
+
+  int64_t latest_time() const override;
+
+  std::string ToDebugString() const override;
+  std::string ToNoCopyDebugString(const Shape& shape, int64_t start_time,
+                                  int64_t end_time) const override;
+
+ private:
+  int64_t min_overlap_count_;
+  int64_t max_overlap_count_;
+  int64_t end_time_;
+  int64_t current_prefetch_time_;
+};
+
+// Forward Declaration of MemorySpaceAssignmentCostAnalysis
+class MemorySpaceAssignmentCostAnalysis;
+// Prefetch interval picker that uses cost analysis to overlap asynchronous
+// copies with independent computation. It uses min (independent computation
+// duration) / (asynchronous copy duration) ratio to guide whether the prefetch
+// is within the lower bound. For the upper bound, it restricts the maximum
+// duration that a buffer may occupy the alternate memory space as a multiple of
+// the time it would take to copy a buffer that is the size of the alternate
+// memory. It starts with the preferred ratio in Begin() and works its way for
+// alternately earlier and later prefetches until hitting min and max ratios.
+// The value for buffer size for max async copy is a mechanism to prevent
+// copying small buffers between the two memories unnecessarily. For calculating
+// the max time that the buffer can reside in alternate memory, we use the
+// larger of this value and the actual size of the buffer. A shape override can
+// also be provided which causes the interval picker to use that shape for async
+// copy durations instead of the actual shape of the copy.
+class CostAnalysisPrefetchIntervalPicker : public PrefetchIntervalPicker {
+ public:
+  CostAnalysisPrefetchIntervalPicker(
+      const MemorySpaceAssignmentCostAnalysis& cost_analysis,
+      float min_overlap_to_async_copy_ratio,
+      float preferred_overlap_to_async_copy_ratio,
+      float max_overlap_to_mem_size_async_copy_ratio, int64_t mem_size_bytes,
+      const Shape* shape_override = nullptr);
+
+  bool CanAllocateInAlternateMemoryNoCopy(const Shape& shape,
+                                          int64_t start_time,
+                                          int64_t end_time) const override;
+
+  int64_t PreferredEvictionEndTime(const Shape& shape, int64_t start_time,
+                                   int64_t latest_end_time) const override;
+
+  int64_t LatestPrefetchEndTime(
+      int64_t original_prefetch_end_time,
+      int64_t proposed_prefetch_end_time) const override;
+
+  int64_t LatestPrefetchStartTime(const Shape& shape, int64_t start_time,
+                                  int64_t end_time,
+                                  const HloUse* use) const override;
+
+  int64_t PreferredPrefetchStartTime(const Shape& shape,
+                                     int64_t earliest_prefetch_start_time,
+                                     int64_t latest_prefetch_start_time,
+                                     int64_t prefetch_end_time) const override;
+
+  int64_t EstimatedPrefetchEndTime(const Shape& shape, int64_t start_time,
+                                   int64_t end_time) const override;
+  float GetLogicalIntervalElapsed(int64_t start_time,
+                                  int64_t end_time) const override;
+
+  void Begin(const HloUse& use, int64_t start_time, int64_t end_time,
+             std::optional<int64_t> preferred_time) override;
+
+  int64_t Next() override;
+  bool Done() const override;
+
+  int64_t latest_time() const override;
+
+  void SetRetryNumber(int retry_number) override;
+
+  std::string ToDebugString() const override;
+  std::string ToNoCopyDebugString(const Shape& shape, int64_t start_time,
+                                  int64_t end_time) const override;
+
+  std::optional<float> BufferIntervalAlternateMemoryBenefit(
+      const GlobalDecreasingSizeBestFitHeap<HloValue>::BufferInterval& interval)
+      const override;
+
+ private:
+  // Finds the minimum nest level in the given interval.
+  int GetMinWhileNestLevel(int64_t start_time, int64_t end_time) const;
+
+  // Given the elapsed time to copy this buffer to the alternate memory, returns
+  // the longest time that this buffer may reside in the alternate memory space.
+  float GetMaxElapsedInAlternateMemory(float async_copy_elapsed) const;
+
+  // For each instruction in the flattened schedule, maintain their elapsed time
+  // (in cumulative sum) and while nesting level.
+  std::vector<float> elapsed_time_cumsum_;
+  std::vector<int> while_nest_level_;
+  std::vector<int> computation_nest_level_;
+  // Maintain the index of the most recent (before this instruction) nest level
+  // change in order to efficiently determine the minimum nest level in an
+  // interval.
+  std::vector<int> while_nest_level_change_;
+
+  const MemorySpaceAssignmentCostAnalysis& cost_analysis_;
+  float min_overlap_to_async_copy_ratio_;
+  float preferred_overlap_to_async_copy_ratio_;
+  float max_async_copy_elapsed_;
+  float max_overlap_multiplier_ = 1.0;
+
+  float async_copy_elapsed_;
+  float inst_elapsed_reduction_;
+  int64_t end_logical_time_;
+  int64_t earliest_prefetch_time_;
+  int64_t latest_prefetch_time_;
+  bool using_increasing_prefetch_time_iterator_ = true;
+  int64_t increasing_prefetch_time_iterator_;
+  int64_t decreasing_prefetch_time_iterator_;
+
+  std::vector<float> while_execution_counts_;
+  // Shape override is used to override the shape of the shape of the async copy
+  // to treat all async copies the same duration. Having an override forces
+  // prefetches to be scheduled roughly in FIFO order.
+  std::optional<Shape> shape_override_;
+};
+
+// MemorySpaceAssignment assigns memory spaces (default or alternate) to each
+// instruction in the module. It will greedily try placing as as many values in
+// the alternate memory space as possible. It uses the heap simulator to
+// determine the actual allocation offsets of values in the alternate memory
+// space to account for fragmentation. The default memory space is assumed to be
+// large enough to hold the values that could not be placed in the alternate
+// memory space.
+class MemorySpaceAssignment {
+ public:
+  using Chunk = HeapSimulator::Chunk;
+  using BufferInterval =
+      GlobalDecreasingSizeBestFitHeap<HloValue>::BufferInterval;
+  using BufferIntervalCompare =
+      GlobalDecreasingSizeBestFitHeap<HloValue>::BufferIntervalCompare;
+  using IsAllowedInAlternateMemoryFunction =
+      std::function<bool(const HloValue&)>;
+  using IsUseAllowedInAlternateMemoryFunction =
+      std::function<bool(const HloUse&)>;
+  using IsPositionAllowedInAlternateMemoryFunction =
+      std::function<bool(const HloPosition&)>;
+  using ReservedScopedMemoryFunction = std::function<int64_t(
+      const HloInstruction*,
+      const absl::flat_hash_set<
+          std::pair<int, ShapeIndex>>& /*operands_in_alternate_memory*/,
+      const absl::flat_hash_set<ShapeIndex>& /*outputs_in_alternate_memory*/)>;
+  using UpdateLayoutFunction = std::function<void(Shape*)>;
+
+  // MemorySpaceAssignment uses a notion of a slow and large default memory
+  // space and a fast and small alternate memory space.
+  enum class MemorySpace { kDefault, kAlternate };
+
+  // Forward declaration for Allocation.
+  class Allocation;
+  class ParentAllocation;
+
+  // This class represents an allocation that might either be in the default or
+  // alternate memory. An HloValue might live in multiple different allocations
+  // over its lifetime. The lifetimes of the allocations are defined using
+  // start_time and end_time, which corresponds to the instruction indexes in
+  // the flattened schedule. Each of these allocations might partially overlap
+  // with each other. CopyAllocation defined below represents asynchronous
+  // copies between Allocations.
+  //
+  // Consider an instruction Foo, and its users Bar and Baz, and the times given
+  // in terms of the flattened schedule of the entire module:
+  //
+  //      Foo:10
+  //       /   \
+  //    Bar:14  \
+  //           Baz:25
+  //
+  // A valid memory space assignment could be like the following:
+  //
+  //  Time:         10 ... 14        ...      25
+  //                Foo    Bar                Baz
+  //  Alternate     +-------+           +-----+
+  //  Default           +---------------------+
+  //                    ^   ^           ^     ^
+  //                    |   |           |     |
+  //                evict   evict  prefetch  prefetch
+  //                start    end    start      end
+  //
+  // This would be represented with:
+  //   - Allocation(memory_space=kAlternate, start_time=10, end_time=14)
+  //   - CopyAllocation(memory_space=kDefault, start_time=12, end_time=25)
+  //   - CopyAllocation(memory_space=kAlternate, start_time=22, end_time=25)
+  class Allocation {
+    friend class ParentAllocation;
+
+   public:
+    Allocation(HloPosition defining_position, MemorySpace memory_space,
+               std::optional<Chunk> chunk, int64_t start_time, int64_t end_time,
+               bool is_scoped_allocation)
+        : defining_position_(defining_position),
+          memory_space_(memory_space),
+          chunk_(chunk),
+          start_time_(start_time),
+          end_time_(end_time),
+          is_scoped_allocation_(is_scoped_allocation) {
+      CHECK(!is_scoped_allocation || defining_position.index == ShapeIndex({}));
+    }
+    virtual ~Allocation() = default;
+
+    // True if the allocation is for a copy or a sliced-copy.
+    bool is_copy_like_allocation() const;
+
+    virtual bool is_copy_allocation() const { return false; }
+    virtual bool is_sliced_copy_allocation() const { return false; }
+
+    // Adds a use to this allocation.
+    void AddUse(HloUse use);
+
+    // Extends the end time of this allocation.
+    void Extend(int64_t end_time) { end_time_ = std::max(end_time_, end_time); }
+
+    // After all of the time ranges for the allocations have been assigned,
+    // Process morphs the instructions affected to assign the memory spaces and
+    // insert asynchronous copy instructions if necessary.
+    virtual Status Process();
+
+    // An optional post-process step that will be called after all allocations
+    // have been processed.
+    virtual Status PostProcess() { return OkStatus(); }
+
+    // Marks (adds this allocation to needed_allocations) if this allocation is
+    // needed. Allocation and CopyAllocations are always needed and
+    // ParentAllocations are needed if they have any uses or if other
+    // CopyAllocation or ParentAllocations depend on them.
+    virtual void MarkIfNeeded(
+        absl::flat_hash_set<const Allocation*>& needed_allocations) const;
+
+    // Marks this allocation as needed.
+    virtual void MarkNeeded(
+        absl::flat_hash_set<const Allocation*>& needed_allocations) const;
+
+    // Returns the defining position for this allocation.
+    virtual HloPosition defining_position() const { return defining_position_; }
+
+    // Returns the time the buffer is first available to be used. For
+    // Allocation, this is start_time.
+    virtual int64_t earliest_available_time() const { return start_time_; }
+
+    const std::vector<HloUse>& uses() const { return uses_; }
+    void clear_uses() { uses_.clear(); }
+    MemorySpace memory_space() const { return memory_space_; }
+    // Returns the associated chunk that may be a nullopt if the allocation is
+    // in the default memory space.
+    std::optional<Chunk> maybe_chunk() const { return chunk_; }
+    // Returns the associated chunk. The caller should ensure that the chunk is
+    // defined (the allocation should be in the alternate memory space).
+    Chunk chunk() const {
+      CHECK(chunk_.has_value());
+      return *chunk_;
+    }
+    Chunk* mutable_chunk() { return &*chunk_; }
+    void set_offset(int64_t offset);
+    void set_start_time(int64_t start_time) { start_time_ = start_time; }
+    void set_end_time(int64_t end_time) { end_time_ = end_time; }
+    int64_t start_time() const { return start_time_; }
+    int64_t end_time() const { return end_time_; }
+    bool is_scoped_allocation() const { return is_scoped_allocation_; }
+    virtual std::optional<int64_t> cross_program_prefetch_index() const {
+      return std::nullopt;
+    }
+
+    bool operator==(const Allocation& other) const;
+    virtual std::string ToString() const;
+
+    bool is_in_alternate_mem() const {
+      return memory_space_ == MemorySpace::kAlternate;
+    }
+    bool is_in_default_mem() const {
+      return memory_space_ == MemorySpace::kDefault;
+    }
+
+   protected:
+    // Recursively create kGetTupleElement instructions if the defining position
+    // shape is not an array. Returns the new instruction that has array shape.
+    HloInstruction* AddGetTupleElements() const;
+
+    HloPosition defining_position_;
+    std::vector<HloUse> uses_;
+    MemorySpace memory_space_;
+    std::optional<Chunk> chunk_;
+    int64_t start_time_;
+    int64_t end_time_;
+    const bool is_scoped_allocation_;
+  };
+
+  // This class represents an allocation as a result of an asynchronous copy.
+  // Note: CopyStart instructions are inserted after `start_time` or later,
+  // while CopyDone instructions are inserted before
+  // `copy_done_schedule_before_time` or earlier.
+  class CopyAllocation : public Allocation {
+   public:
+    CopyAllocation(
+        Allocation& prev_allocation, MemorySpace memory_space,
+        std::optional<Chunk> chunk, int64_t start_time, int64_t end_time,
+        int64_t copy_done_schedule_before_time,
+        std::optional<int64_t> cross_program_prefetch_index = std::nullopt)
+        : Allocation(/*defining_position=*/{nullptr, {}}, memory_space, chunk,
+                     start_time, end_time, /*is_scoped_allocation=*/false),
+          prev_allocation_(prev_allocation),
+          copy_start_schedule_after_(start_time),
+          copy_done_schedule_before_(copy_done_schedule_before_time),
+          cross_program_prefetch_index_(cross_program_prefetch_index) {}
+
+    bool is_copy_allocation() const override { return true; }
+
+    Status Process() override;
+
+    void MarkNeeded(absl::flat_hash_set<const Allocation*>& needed_allocations)
+        const override;
+
+    HloPosition defining_position() const override {
+      // Unless explicitly set, the defining position of a copy allocation in
+      // retrieved from the previous allocation. This is because we don't create
+      // new CopyStart/CopyDone instructions until later and the position should
+      // point to the previous (copy or otherwise) allocation's position for the
+      // original defining position.
+      if (defining_position_.instruction == nullptr) {
+        return prev_allocation_.defining_position();
+      }
+      return defining_position_;
+    }
+
+    HloInstruction* copy_start() const { return copy_start_; }
+    HloInstruction* copy_done() const { return copy_done_; }
+
+    // Returns the time the buffer is first available to be used. For
+    // CopyAllocation, this is when the copy ends, which is
+    // copy_done_schedule_before.
+    int64_t earliest_available_time() const override {
+      return copy_done_schedule_before_;
+    }
+
+    int64_t copy_start_schedule_after() const {
+      return copy_start_schedule_after_;
+    }
+    int64_t copy_done_schedule_before() const {
+      return copy_done_schedule_before_;
+    }
+
+    void set_copy_start_schedule_after(int64_t copy_start_schedule_after) {
+      copy_start_schedule_after_ = copy_start_schedule_after;
+    }
+
+    void set_copy_done_schedule_before(int64_t copy_done_schedule_before) {
+      copy_done_schedule_before_ = copy_done_schedule_before;
+    }
+
+    std::optional<int64_t> cross_program_prefetch_index() const override {
+      return cross_program_prefetch_index_;
+    }
+
+    bool operator==(const CopyAllocation& other) const;
+    std::string ToString() const override;
+
+    const Allocation& prev_allocation() { return prev_allocation_; }
+    Allocation& mutable_prev_allocation() { return prev_allocation_; }
+
+   private:
+    Allocation& prev_allocation_;
+    // These variables define the scheduling boundaries where CopyStart and
+    // CopyDone can be scheduled. The earliest CopyStart can be scheduled is
+    // after copy_start_schedule_after_ and the latest CopyDone can be scheduled
+    // is before copy_done_schedule_before_.
+    int64_t copy_start_schedule_after_;
+    int64_t copy_done_schedule_before_;
+    HloInstruction* copy_start_;
+    HloInstruction* copy_done_;
+    std::optional<int64_t> cross_program_prefetch_index_;
+  };
+
+  // The parameters for slicing a single dimension of a tensor.
+  struct SliceParam {
+    std::string ToString() const;
+    bool operator==(const SliceParam& other) const;
+
+    int64_t start_inclusive;
+    int64_t end_exclusive;
+  };
+
+  // A proposed way to slice a buffer.
+  struct SliceProposal {
+    std::string ToString() const;
+    friend std::ostream& operator<<(std::ostream& os,
+                                    const SliceProposal& proposal);
+    std::tuple<const Shape&,
+               const std::vector<MemorySpaceAssignment::SliceParam>&, int64_t>
+    ToTuple() const;
+    bool operator==(const SliceProposal& other) const;
+
+    // Shape resulting from the slice.
+    Shape slice_shape;
+
+    // slice_params map to the parameters that would be passed to a slice
+    // instruction. Thus:
+    // * There should be a slice parameter for every dimension in the shape of
+    //   the tensor being sliced.
+    // * The ith slice_param applies to the ith logical dimension in the shape
+    //   being sliced.
+    // * If a dimension is not being sliced, it should have a SliceParam of
+    //   {0, dim size}.
+    std::vector<MemorySpaceAssignment::SliceParam> slice_params;
+
+    // The size to be allocated for the slice. Note, this may be > the size of
+    // the slice shape, due to additional padding that may occur when the slices
+    // are concatenated back together.
+    int64_t slice_size;
+  };
+
+  // A SliceProposalCollection proposes a way to to slice an AllocationRequest.
+  // A SliceProposalCollection is generated from a SliceProposalFunction and is
+  // used when we want to slice a prefetch.
+  using SliceProposalCollection = std::vector<SliceProposal>;
+  using SliceProposalFunction = std::function<StatusOr<SliceProposalCollection>(
+      const Shape& shape, const SlicedPrefetchOptions& options)>;
+
+  // A SliceDecision is a SliceProposal that we've determined where and when to
+  // allocate.
+  struct SliceDecision {
+    std::string ToString() const;
+    bool operator==(const SliceDecision& other) const;
+
+    Chunk chunk;
+    int64_t start_time;
+    SliceProposal sizing;
+    float copy_resource_consumed;
+  };
+
+  // This class represents an allocation resulting from asynchronous sliced
+  // copies.
+  //
+  // Let the sliced allocation be represented as follows, and imagine that t3
+  // is the time when the entire buffer [p0, p3) is available for use
+  //
+  //   space
+  //    ^
+  // p3 |       +-----------+
+  //    |       |           |
+  // p2 |   +---+           |
+  //    |   |               |
+  // p1 |   +-------+       |
+  //    |           |       |
+  // p0 |           +-------+
+  //    +---|---|---|---|---|----> time
+  //        t0  t1  t2  t3  t4
+  //
+  // The Allocation underlying the SlicedCopyAllocation will use the following
+  // dimensions:
+  // - chunk = [p0, p3)
+  // - start time = t2
+  // - earliest_available_time = t3
+  // - end_time = t4
+  class SlicedCopyAllocation : public Allocation {
+   public:
+    // Full details about a slice in the sliced allocation.
+    struct SliceDetail {
+      std::string ToString() const;
+      std::tuple<const SliceDecision&, int64_t, int64_t, const HloInstruction*,
+                 const HloInstruction*>
+      ToTuple() const;
+      bool operator==(const SliceDetail& other) const;
+
+      // Create the instructions to copy the slice. This method updates
+      // copy_start and copy_done. Given a Shape, the hardware may have
+      // constraints on how the shape is physically laid out in memory.
+      // update_layout_fn updates a Shape's layout in accordance with those
+      // constraints.
+      Status CreateAsyncSlice(const Shape& original_shape,
+                              HloInstruction& producer, HloComputation& parent,
+                              absl::FunctionRef<void(Shape*)> update_layout_fn);
+
+      SliceDecision slice_decision;
+      int64_t copy_start_after_time = -1;
+      int64_t copy_done_before_time = -1;
+      HloInstruction* copy_start = nullptr;
+      HloInstruction* copy_done = nullptr;
+    };
+
+    // REQUIRES:
+    // - slice_decisions_sorted_by_start_time.size() >= 2, otherwise,
+    //   CopyAllocation should be used.
+    SlicedCopyAllocation(
+        const Allocation& prev_allocation, MemorySpace memory_space,
+        std::vector<SliceDecision> slice_decisions_sorted_by_start_time,
+        int64_t end_time, int64_t copy_done_schedule_before_time,
+        absl::FunctionRef<void(Shape*)> update_layout_fn);
+
+    bool is_sliced_copy_allocation() const override { return true; }
+
+    // MemorySpaceAssignment::Process() calls Process() to create asynchronous
+    // slice copies, and a bitcast-concat call to glue the slices back together.
+    Status Process() override;
+
+    // Marks the allocation as needed.
+    void MarkNeeded(absl::flat_hash_set<const Allocation*>& needed_allocations)
+        const override;
+
+    // Returns the defining position for this allocation.
+    HloPosition defining_position() const override;
+
+    // Returns the time the buffer is first available to be used. For
+    // SlicedCopyAllocation, this is when all copies have ended.
+    int64_t earliest_available_time() const override;
+
+    std::vector<int64_t> SliceOffsetsSortedByStartTime() const;
+    void AddDiffToAllSliceOffsets(int64_t diff);
+
+    // Used to update offsets and start times after repacking.
+    void ImportRepackedSliceData(
+        const MemorySpaceAssignmentRepacker::SlicedAllocationData& data);
+
+    const std::vector<SliceDetail>& slice_details_sorted_by_start_time() const;
+    std::vector<SliceDetail>& mutable_slice_details_sorted_by_start_time();
+    HloInstruction* concat() const { return concat_; }
+
+    std::tuple<const Allocation&, const std::vector<SliceDetail>&,
+               const HloInstruction*>
+    ToTuple() const;
+    bool operator==(const SlicedCopyAllocation& other) const;
+    std::string ToString() const override;
+
+   private:
+    SlicedCopyAllocation() = delete;
+
+    // Create an instruction to concatenate the slices. Populates concat_.
+    Status CreateBitcastConcat(const Shape& shape,
+                               absl::Span<HloInstruction* const> slices);
+
+    Shape original_shape_to_slice_;
+    const Allocation& prev_allocation_;
+    // REQUIRES:
+    // - sorted_segments_[i].copy_start_after_time <=
+    //   sorted_segments_[i+j].copy.start_after_time
+    // - sorted_segments_[i].copy_done_before_time <=
+    //   sorted_segments_[i+j].copy.start_before_time
+    std::vector<SliceDetail> slice_details_sorted_by_start_time_;
+    HloInstruction* concat_ = nullptr;
+    absl::FunctionRef<void(Shape*)> update_layout_fn_;
+  };
+
+  // An allocation in the default memory space that mirrors another Allocation
+  // object. This is useful to model an eviction that happens before a while op
+  // so that we don't need to redundantly evict the buffer after the while op as
+  // well.
+  class MirroredAllocation : public Allocation {
+   public:
+    MirroredAllocation(const Allocation& original_allocation, int64_t time)
+        : Allocation(original_allocation.defining_position(),
+                     MemorySpace::kDefault, original_allocation.maybe_chunk(),
+                     /*start_time=*/time,
+                     /*end_time=*/time, /*is_scoped_allocation=*/false),
+          original_allocation_(original_allocation) {}
+
+    Status Process() override;
+
+    void MarkNeeded(absl::flat_hash_set<const Allocation*>& needed_allocations)
+        const override;
+
+    std::string ToString() const override;
+
+   private:
+    const Allocation& original_allocation_;
+  };
+
+  // An allocation in default memory space that is defined in the parent
+  // computation. If a value has a copy in the default memory space in the
+  // parent computation, we don't need to evict this buffer in a while loop.
+  class ParentAllocation : public Allocation {
+   public:
+    ParentAllocation(const Allocation& original_allocation,
+                     HloInstruction* calling_instruction, HloPosition position,
+                     int64_t time)
+        : Allocation(position, MemorySpace::kDefault,
+                     original_allocation.maybe_chunk(), /*start_time=*/time,
+                     /*end_time=*/time, /*is_scoped_allocation=*/false),
+          original_allocation_(original_allocation),
+          calling_instruction_(calling_instruction) {}
+
+    Status Process() override;
+    Status PostProcess() override;
+
+    void MarkIfNeeded(absl::flat_hash_set<const Allocation*>&
+                          needed_allocations) const override;
+    void MarkNeeded(absl::flat_hash_set<const Allocation*>& needed_allocations)
+        const override;
+
+    std::string ToString() const override;
+
+   private:
+    const Allocation& original_allocation_;
+    HloInstruction* calling_instruction_;
+  };
+
+  using AllocationSequence = std::vector<std::unique_ptr<Allocation>>;
+  // AllocationValue is used to break up HloValues for each non-trivial position
+  // (trivial positions are considered Tuple, GetTupleElement, and Bitcast). An
+  // HloValue may include positions and uses that alias with each other across
+  // multiple computations. We use this class to break these HloValues such that
+  // every AllocationValue has one defining position (that may alias with other
+  // AllocationValues). The uses field of the AllocationValue contains only the
+  // direct uses of the AllocationValue's defining position.
+  //
+  // For example, consider the following HLO snippet:
+  //
+  // Body {
+  //   body_param = (f32[4,3]{1,0}, f32[]) parameter(0)
+  //   get-tuple-element.3 = f32[4,3]{1,0} get-tuple-element(body_param),
+  //   index=0
+  //   ...
+  //   ROOT tuple = (f32[4,3]{1,0}, f32[]) tuple(get-tuple-element.3, ...)
+  // }
+  //
+  // Cond {
+  //   cond_param = (f32[4,3]{1,0}, f32[]) parameter(0)
+  //   ...
+  // }
+  //
+  // add.4 = f32[4,3]{1,0} add(...)
+  // tuple.1 = (f32[4,3]{1,0}, f32[]) tuple(add.4, ...)
+  // while = (f32[4,3]{1,0}, f32[]) while(tuple.1), body=Body, condition=Cond
+  // get-tuple-element.5 = f32[4,3]{1,0} get-tuple-element(while), index=0
+  // add.5 = f32[4,3]{1,0} add(get-tuple-element.5, ...)
+  //
+  // This contains an HloValue that looks like the following:
+  // positions:
+  //  add.4
+  //  body_param {0}
+  //  get-tuple-element.3
+  //  tuple {0}
+  //  cond_param {0}
+  //  tuple.1 {0}
+  //  while {0}
+  //  get-tuple-element.5
+  // uses:
+  //  add.1, operand 0
+  //  tuple, operand 0
+  //  while, operand 0 {0}
+  //  add.5, operand 0
+  //
+  // We break this HloValue up into the following AllocationValues for each
+  // non-trivial position:
+  // AllocationValue1: computation = Entry
+  //  position:
+  //   add.4
+  //  uses:
+  //   while, operand 0 {0}
+  // AllocationValue2: computation = Cond
+  //  position:
+  //   cond_param {0}
+  //  uses:
+  // AllocationValue3: computation = Body
+  //  position:
+  //   body_param {0}
+  //  uses:
+  //   add.1, operand 0
+  //   tuple, operand 0
+  // AllocationValue4: computation = Entry
+  //  position:
+  //   while {0}
+  //  uses:
+  //   add.5, operand 0
+  class AllocationValue {
+   public:
+    // This data structure wraps an HloUse and adds additional metadata that are
+    // useful for allocation.
+    struct Use {
+      // The wrapped HloUse object.
+      HloUse hlo_use;
+      // The logical time this use is scheduled.
+      int64_t time;
+      // All the positions where this use aliases with. The aliased positions
+      // must get the same allocation.
+      std::vector<HloPosition> aliases;
+
+      bool operator==(const Use& other) const {
+        return hlo_use == other.hlo_use && time == other.time &&
+               aliases == other.aliases;
+      }
+
+      template <typename H>
+      friend H AbslHashValue(H h, const Use& s) {
+        return H::combine(std::move(h), s.hlo_use, s.time, s.aliases);
+      }
+    };
+
+    AllocationValue(const HloValue* value, const HloPosition& position,
+                    int64_t size)
+        : value_(value),
+          defining_position_(position),
+          size_(size),
+          requires_contiguous_allocation_(false) {}
+
+    const HloPosition& defining_position() const { return defining_position_; }
+    const HloInstruction* defining_instruction() const {
+      return defining_position().instruction;
+    }
+    int64_t size() const { return size_; }
+    const std::vector<Use>& uses() const { return uses_; }
+    std::vector<Use>& uses() { return uses_; }
+    const HloValue* value() const { return value_; }
+    const HloComputation* computation() const {
+      return defining_instruction()->parent();
+    }
+    AllocationSequence* mutable_allocation_sequence() {
+      return &allocation_sequence_;
+    }
+    const AllocationSequence* allocation_sequence() const {
+      return &allocation_sequence_;
+    }
+
+    // Sets/gets whether this AllocationValue requires allocating it
+    // contiguously throughout its live range (without any copies).
+    bool requires_contiguous_allocation() const {
+      return requires_contiguous_allocation_;
+    }
+    void set_requires_contiguous_allocation(
+        bool requires_contiguous_allocation) {
+      requires_contiguous_allocation_ = requires_contiguous_allocation;
+    }
+
+    void AddUse(const HloUse& use, int64_t use_time) {
+      uses_.push_back({use, use_time, {}});
+    }
+
+    std::string ToString() const;
+    std::string ToShortString() const;
+
+   private:
+    const HloValue* value_;
+    HloPosition defining_position_;
+    int64_t size_;
+    // If true, there must be a contiguous allocation for this buffer without
+    // any copies.
+    bool requires_contiguous_allocation_;
+    std::vector<Use> uses_;
+    AllocationSequence allocation_sequence_;
+  };
+
+  // Statistics of asynchronous copies.
+  struct AsyncCopyStats {
+    // Includes both async copies and async sliced copies.
+    int64_t max_outstanding_async_copies = 0;
+    // Includes both async copies and async sliced copies.
+    int64_t num_prefetches = 0;
+    int64_t num_sliced_prefetches = 0;
+    int64_t num_sliced_prefetch_slices = 0;
+    int64_t prefetch_bytes = 0;
+    int64_t num_evictions = 0;
+    int64_t eviction_bytes = 0;
+  };
+
+  virtual ~MemorySpaceAssignment() = default;
+
+  // Runs the MemorySpaceAssignment pass.
+  static StatusOr<std::unique_ptr<PresetAssignments>> Run(
+      HloModule* module, const HloLiveRange& hlo_live_range,
+      const HloAliasAnalysis& alias_analysis, const Options& options);
+
+  // Calculates asynchronous copy statistics.
+  StatusOr<AsyncCopyStats> CalculateAsyncCopyStats() const;
+
+  static BufferIntervalCompare GetMemoryBoundednessBufferIntervalCompare(
+      const MemorySpaceAssignmentCostAnalysis& cost_analysis,
+      MemorySpaceAssignmentCostAnalysis::Cache* cache = nullptr);
+
+  // Verify that the memory space assignment is free of overlapping buffers and
+  // export heap simulator trace to be used by buffer_assignment.
+  Status VerifyAndExportHeapSimulatorTrace();
+
+ protected:
+  // Main driver of the memory space assignment pass.
+  virtual StatusOr<std::unique_ptr<PresetAssignments>> RunMemorySpaceAssignment(
+      const HloLiveRange& hlo_live_range,
+      const HloAliasAnalysis& alias_analysis);
+
+  // Finds an AllocationSequence for placing buffers in alternate memory using
+  // the AlternateMemoryBestFitHeap algorithm. Must be set before Process() is
+  // called.
+  virtual Status FindAllocationSequence(const HloLiveRange& hlo_live_range,
+                                        const HloAliasAnalysis& alias_analysis);
+
+  const Options& options() const { return options_; }
+
+  MemorySpaceAssignment(HloModule* module, const Options& options,
+                        const HloLiveRange& hlo_live_range)
+      : module_(module),
+        options_(options),
+        flattened_instructions_(hlo_live_range.flattened_instruction_sequence()
+                                    .instructions()
+                                    .begin(),
+                                hlo_live_range.flattened_instruction_sequence()
+                                    .instructions()
+                                    .end()),
+        computations_in_schedule_(),
+        preset_assignments_(std::make_unique<PresetAssignments>()) {
+    for (const auto& computation_and_bound :
+         hlo_live_range.computation_span_times()) {
+      computations_in_schedule_.insert(computation_and_bound.first);
+    }
+  }
+
+  AllocationSequence allocations_;
+
+  HloModule* module() { return module_; }
+
+ private:
+  // Process calls Process methods of the allocations after the allocations have
+  // been finalized.
+  Status Process(const HloLiveRange& hlo_live_range);
+
+  // Process() might have altered the computation graph by inserting kTuple and
+  // kGetTupleElement instructions. SimplifyGraph performs a simple DCE and
+  // tuple simplification operation (e.g., given GetTupleElement(Tuple(a, b),
+  // 1), simply forwards b). Runs to fixed point.
+  Status SimplifyGraph();
+
+  // FixSchedule inserts asynchronous copies in the schedule.
+  Status FixSchedule();
+
+  // Export the alternate memory assignments to the PresetAssignments and color
+  // the HLO graph with the determined memory spaces.
+  Status ExportAndColorBuffers();
+
+  // Schedules asynchronous copies and ensures that the CopyStarts and their
+  // corresponding CopyDones follow the same order.
+  void ScheduleAsynchronousCopies();
+
+  // Remove the positions and chunks associated with the instruction from
+  // alternate_memory_assignments_.
+  void RemoveAssignmentForInstruction(const HloInstruction* instruction);
+
+  // Returns the estimated elapsed duration of the hlo module in seconds. It
+  // uses the 'allocations' argument to determine the location (default memory
+  // or alternate memory) of each operand and output of an instruction.
+  float ComputeEstimatedElapsedTime(const HloLiveRange& hlo_live_range,
+                                    const AllocationSequence& allocations);
+
+  HloModule* module_;
+  const Options& options_;
+  std::vector<HloInstruction*> flattened_instructions_;
+  absl::flat_hash_set<const HloComputation*> computations_in_schedule_;
+  std::unique_ptr<PresetAssignments> preset_assignments_;
+  std::vector<std::pair<HloPosition, Chunk>> alternate_memory_assignments_;
+  std::vector<std::pair<HloInstruction*, Chunk>> scoped_memory_assignments_;
+  int64_t alternate_memory_size_ = 0;
+
+  // These maps hold vectors of new instructions that need to be scheduled after
+  // (or before) the instruction index in the key. FixSchedule uses these maps
+  // to modify and fix the schedule.
+  absl::flat_hash_map<int64_t, std::vector<HloInstruction*>> schedule_after_;
+  absl::flat_hash_map<int64_t, std::vector<HloInstruction*>> schedule_before_;
+};
+
+// Filters prefetches by matching against multiple filters and overrides the
+// preferred prefetch time for matching prefetches by the provided override
+// strategy.
+class FilterUpdatePreferredPrefetch {
+ public:
+  // Supported filters for prefetch filtering by operand size, instruction name,
+  // operand number and operand index matching.
+  enum class FilterType {
+    OP_SIZE_LTE,  // sting value: op_size_lte, filter value type: integer
+    OP_SIZE_GTE,  // sting value: op_size_gte, filter value type: integer
+    INSTRUCTION_NAME_EXACT,  // sting value: instruction_name_exact,
+                             // filter value type: string
+    OP_NUMBER_EXACT,         // sting value: op_number_exact,
+                             // filter value type: integer
+    OP_INDEX_EXACT  // sting value: op_index_exact, filter value type: string
+                    // (empty string for {}, 1 for {1} and 1#2 for {1,2})
+  };
+  // Strategies to compute new perferred prefetch time. Prefetch eagerness
+  // sets prefetch time to a time within the live-range depending on a value,
+  // e.g. 0.5 sets it exactly in the middle of the live-range. Put after
+  // instruction or put before instruction finds an instruction in the schedule
+  // and puts the preferred prefetch time before or after the found instruction.
+  enum class OverrideType {
+    PREFETCH_EAGERNESS,     // sting value: prefetch_eagerness,
+                            // override value type : float
+    PUT_AFTER_INSTRUCTION,  // sting value: put_after_instruction,
+                            // override value type: string
+    PUT_BEFORE_INSTRUCTION  // sting value: put_before_instruction,
+                            // override value type: string
+  };
+  std::vector<std::pair<FilterType, std::string>> filter_list_;
+  OverrideType override_type_;
+  std::string override_value_;
+
+  std::string ToString() const { return config_string_; }
+
+  static StatusOr<std::vector<FilterUpdatePreferredPrefetch>>
+  ParseFilterUpdatePreferredPrefetches(std::string config);
+
+  static StatusOr<bool> IsOpSizeGte(int64_t operand_size, std::string config);
+
+  static StatusOr<bool> IsOpSizeLte(int64_t operand_size, std::string config);
+
+  static StatusOr<bool> IsInstructionNameExact(
+      absl::string_view instruction_name, std::string config);
+
+  static StatusOr<bool> IsOpNumberExact(int64_t operand_number,
+                                        std::string config);
+
+  static StatusOr<bool> IsOpIndexExact(const ShapeIndex& operand_index,
+                                       std::string config);
+
+  StatusOr<std::optional<int64_t>> GetPrefetchByEagerness(
+      int64_t earliest_prefetch_time, int64_t latest_prefetch_time) const;
+
+  StatusOr<std::optional<int64_t>> GetPrefetchTimeAfterInstruction(
+      const absl::flat_hash_map<const xla::HloInstruction*,
+                                xla::HloLiveRange::LogicalTime>& schedule)
+      const;
+
+  StatusOr<std::optional<int64_t>> GetPrefetchTimeBeforeInstruction(
+      const absl::flat_hash_map<const xla::HloInstruction*,
+                                xla::HloLiveRange::LogicalTime>& schedule)
+      const;
+
+ private:
+  std::string config_string_;
+  StatusOr<xla::HloLiveRange::LogicalTime> GetScheduleTimeFromInstructionName(
+      const absl::flat_hash_map<const xla::HloInstruction*,
+                                xla::HloLiveRange::LogicalTime>& schedule)
+      const;
+
+  static StatusOr<FilterType> ParseFilterType(std::string config);
+
+  static StatusOr<OverrideType> ParseOverrideType(std::string config);
+
+  static StatusOr<ShapeIndex> ParseOperandIndex(std::string config);
+
+  static StatusOr<FilterUpdatePreferredPrefetch>
+  ParseFilterUpdatePreferredPrefetch(std::string config);
+};
+
+// The different options to be passed to the Run() API.
+struct Options {
+  // Backend-specific integer value that describes the alternate memory.
+  int64_t alternate_memory_space = 0;
+
+  // Maximum size of the alternate memory space.
+  int64_t max_size_in_bytes = 0;
+
+  // Memory alignment of the alternate memory space.
+  int64_t alignment_in_bytes = 1;
+
+  // If provided, we sort the buffers using this comparison function
+  // otherwise, we use GlobalDecreasingSizeBestFitHeap::kSpatial.
+  std::optional<MemorySpaceAssignment::BufferIntervalCompare>
+      buffer_interval_compare = std::nullopt;
+
+  // This object determines how early and how late prefetches can occur.
+  PrefetchIntervalPicker* prefetch_interval_picker = nullptr;
+
+  // This object is used to determine the benefit of a particular allocation.
+  MemorySpaceAssignmentCostAnalysis* cost_analysis = nullptr;
+
+  // Size function for buffer values.
+  BufferValue::SizeFunction size_fn;
+
+  // This function can be used to prevent certain HloValues (e.g., based on
+  // the opcode) to be placed on the alternate memory.
+  MemorySpaceAssignment::IsAllowedInAlternateMemoryFunction
+      is_allowed_in_alternate_mem_fn;
+
+  // This function can be used to prevent certain HloUses (e.g., based on
+  // the opcode) to be placed on the alternate memory.
+  MemorySpaceAssignment::IsUseAllowedInAlternateMemoryFunction
+      is_use_allowed_in_alternate_mem_fn = [](const HloUse&) { return true; };
+
+  // Specifies if the given position is allowed in the alternate memory.
+  MemorySpaceAssignment::IsPositionAllowedInAlternateMemoryFunction
+      is_position_allowed_in_alternate_mem_fn =
+          [](const HloPosition&) { return true; };
+
+  // This function returns the amount of scoped memory in bytes that should be
+  // reserved during the execution of this instruction.
+  MemorySpaceAssignment::ReservedScopedMemoryFunction
+      reserved_scoped_memory_fn =
+          [](const HloInstruction*,
+             const absl::flat_hash_set<
+                 std::pair<int, ShapeIndex>>& /*operands_in_alternate_memory*/,
+             const absl::flat_hash_set<
+                 ShapeIndex>& /*outputs_in_alternate_memory*/) { return 0; };
+
+  // If true, we will try to reduce scoped allocation buffer size for all
+  // instructions if their operand/output has been allocated in alternate
+  // memory.
+  bool reduce_scoped_memory_limit = false;
+
+  // If true, we allocate the reserved scoped memory at the same offset. This
+  // is useful to enable more deduplication between HLOs that have reserved
+  // scoped memories, but may result in less efficient memory packing.
+  bool allocate_reserved_scoped_memory_at_same_offset = true;
+
+  // Specifies the upper bound for number of outstanding prefetches and
+  // evictions, -1 for unlimited.
+  int64_t max_outstanding_prefetches = -1;
+  int64_t max_outstanding_evictions = -1;
+
+  // Extra outstanding prefetch limit for while uses (in addition to
+  // max_outstanding_prefetches).
+  int64_t while_use_extra_outstanding_prefetch_limit = 0;
+
+  // Specifies the maximum number of retries that will be performed for each
+  // value in case prefetching failed due to running out of asynchronous
+  // copies or asynchronous copy resource.
+  int64_t max_retries = 1;
+
+  // The maximum number of repacks that we are willing to perform in case we
+  // can't allocate a buffer due to running out of memory. If this value is
+  // greater than 0, repacker must be non-nullptr.
+  int64_t max_repacks = 0;
+
+  // This variable is used by the cost analysis in estimating how many times
+  // each while loop will execute. Nested loops will be assumed to have
+  // executed pow(while_execution_count, nesting_level) times.
+  uint64_t xla_tpu_memory_space_assignment_while_execution_count = 5ULL;
+
+  // This variable is used to scale the alternate memory benefit factor for
+  // large buffers. The default scaling function is sqrt.
+  std::string
+      xla_tpu_alternate_memory_benefit_scaling_factor_for_large_buffers =
+          "SQRT";
+
+  float async_copy_bandwidth_bytes_per_second = 0.0f;
+
+  float alternate_mem_bandwidth_bytes_per_second = 0.0f;
+
+  // The repacking algorithm to reduce fragmentation. Must be non-null if
+  // max_repacks is greater than 0.
+  MemorySpaceAssignmentRepacker* repacker = nullptr;
+
+  // This is only useful for testing, repack after every allocation.
+  bool repack_after_every_allocation = false;
+
+  // If true, tries allocating buffers across (e.g., before and inside a while
+  // loop body) sequential calls (kWhile, kCall, and kConditional).
+  bool allocate_across_sequential_calls = false;
+
+  // If true, verifies the memory space assignment against overlapping
+  // buffers.
+  bool verify = false;
+
+  // If not nullptr, this function is called to dump debugging information.
+  // The first argument is appended to the file name and the second argument
+  // is the contents of the file.
+  std::function<void(absl::string_view, absl::string_view)> dump_fn = nullptr;
+
+  // Enable prefetching buffers into preferred memory across program
+  // boundaries
+  bool enable_cross_program_prefetch = true;
+
+  // If true, use buffer_interval_compare to determine which buffers to
+  // prefetch across program boundaries.
+  bool default_cross_program_prefetch_heuristic = false;
+
+  // Enable cross-program prefetch freeing optimization where the
+  // cross-program-prefetched buffer can be reused.
+  bool enable_cross_program_prefetch_freeing = true;
+
+  // The maximum number of cross program prefetches.
+  // TODO(tjablin): Use a heuristic to determine this automatically.
+  int max_cross_program_prefetches = 1;
+
+  // Enable redundant eviction optimization in/around while loops. If enabled,
+  // this optimization would keep a copy of the buffer in the default memory in
+  // addition to alternate memory to eliminate redundant evictions.
+  bool enable_while_redundant_eviction_elimination = true;
+
+  // An optional memory space assignment autotuning config, which is used
+  // to sort allocated buffers.
+  std::optional<std::vector<uint64_t>> autotuning_config = std::nullopt;
+
+  // Scales effective bandwidth for async copies. Valid range is (0, 1].
+  float async_copy_bandwidth_scaling_factor = 1.0;
+
+  // If true, uses the earlier instance of the same instruction to use as
+  // preferred prefetch start time.
+  bool use_repeated_instance_for_preferred_prefetch_time = false;
+
+  // If true, enforces the FIFO order for prefetches.
+  bool enforce_prefetch_fifo_order = false;
+
+  // The ratio of use bytes to copy bytes for a given allocation site below
+  // which we consider the site to be inefficient. A value of 0 would treat all
+  // sites as efficient and a value of 1 would require the amount of bytes used
+  // at the site to be at least as much as the async copy bytes. There are two
+  // factors that determine the copy and use bytes:
+  //   - Some uses don't actually access the entire tensor, e.g. in
+  //     dynamic-update-slice.
+  //   - copy_bytes may be larger than the size of the tensor as well. An
+  //     example is a tensor may be prefetched, used, and then evicted. In that
+  //     case copy_bytes would be twice the size of the tensor.
+  float inefficient_use_to_copy_ratio = 0.0;
+
+  // This is mostly used for testing, it allows a test case to inject its own
+  // logic for AlternateMemoryBestFitHeap::GetInefficientAllocationSites.
+  std::function<std::vector<std::variant<HloPosition, HloUse>>(
+      absl::Span<HloPosition>)>
+      get_inefficient_allocation_sites_fn = nullptr;
+
+  // The window size used to calculate the pipeline overhead when HLO accesses
+  // the default memory, in MiB.
+  float pipeline_overhead_window_size_mib = 0;
+
+  // Config to filter prefetches and update preferred prefetch times for the
+  // filtered prefetches according to an update config.
+  std::vector<FilterUpdatePreferredPrefetch> filter_update_preferred_prefetches;
+
+  // Options for slicing prefetches into smaller asynchronously copied pieces.
+  SlicedPrefetchOptions sliced_prefetch_options;
+
+  // Options for the memory-bound loop optimizer feature.
+  MemoryBoundLoopOptimizerOptions memory_bound_loop_optimizer_options;
+
+  // A function for updating shape layouts.
+  MemorySpaceAssignment::UpdateLayoutFunction update_layout_fn = [](Shape*) {};
+
+  MemorySpaceAssignment::SliceProposalFunction propose_slice_fn =
+      [](const Shape&, const SlicedPrefetchOptions&)
+      -> xla::StatusOr<MemorySpaceAssignment::SliceProposalCollection> {
+    return UnimplementedStrCat("Generation of SliceProposals unimplemented");
+  };
+
+  // Option to always spill buffers from alternate memory to default memory
+  // and prefetching back to alternate memory(if needed) just in time for use.
+  bool always_spill_to_default_memory = false;
+};
+
+// A struct representing an asynchronous copy with its logical start and end
+// time (time that copy done is scheduled), the resource this copy would use,
+// its destination memory space, and a unique ID.
+struct AsynchronousCopy {
+  int64_t start_time;
+  int64_t end_time;
+  float resource;
+  MemorySpaceAssignment::MemorySpace destination;
+  int64_t id;
+
+  std::tuple<int64_t, int64_t, float, MemorySpaceAssignment::MemorySpace,
+             int64_t>
+  AsTuple() const {
+    return std::make_tuple(start_time, end_time, resource, destination, id);
+  }
+};
+
+// Compare asynchronous copies such that an earlier start time has the same or
+// earlier end time and an earlier end time has the same or earlier start time.
+bool operator<(const AsynchronousCopy& a, const AsynchronousCopy& b);
+
+bool operator==(const AsynchronousCopy& a, const AsynchronousCopy& b);
+bool operator!=(const AsynchronousCopy& a, const AsynchronousCopy& b);
+
+// Helper class to enforce asynchronous copy ordering. If the appropriate option
+// is enabled, we only allow asynchronous copies that are pipelined: if an
+// asynchronous copy ends earlier than another asynchronous copy, it must start
+// the same time or earlier than the other asynchronous copy; and if an
+// asynchronous copy starts earlier than another asynchronous copy, it must end
+// the same time or earlier than the other asynchronous copy.
+class AsynchronousCopyOrdering {
+ public:
+  AsynchronousCopyOrdering() = default;
+
+  // Adds an asynchronous copy.
+  void AddCopy(const AsynchronousCopy& copy);
+
+  // Removes an asynchronous copy. CHECKs that it is removed.
+  void RemoveCopy(const AsynchronousCopy& copy);
+
+  // Returns true if the addition of an asynchronous copy in the given time
+  // interval would violate the asynchronous copy ordering. E.g., consider the
+  // following scenario:
+  //                                  CS          CD
+  //  already committed async copy:   +-----------+
+  //                new async copy:     +--------+
+  //
+  // The new asynchronous copy would violate the ordering guarantee because the
+  // copy start is after an already committed asynchronous copy while its copy
+  // done is before the committed copy.
+  bool ViolatesOrdering(int64_t start_time, int64_t end_time) const;
+
+ private:
+  // We use this data structure for keys into the map that has a custom
+  // comparator for the ordering guarantees.
+  struct Interval {
+    int64_t start_time;
+    int64_t end_time;
+
+    // We allow multiple prefetches that have one or both of the same start and
+    // end times. std::map considers two values as equal if neither are less
+    // than the other.  Using this comparator, we can ensure that the only
+    // intervals that evaluate to be equal are those with the same start and end
+    // times or those with intervals that violate the FIFO order.
+    bool operator<(const Interval& other) const {
+      return (start_time < other.start_time && end_time <= other.end_time) ||
+             (start_time <= other.start_time && end_time < other.end_time);
+    }
+  };
+  // Stores asynchronous copies in a tree set respecting the pipelining order.
+  std::map<Interval, std::set<AsynchronousCopy>> ranges_;
+};
+
+// Helper class to enforce asynchronous copy resources by keeping track of
+// available copy bandwidth and elapsed times of overlapped operations. It
+// maintains a list of initial resources that correspond to the elapsed times of
+// overlapped operations. As asynchronous copies are added, the available
+// resource is subtracted to keep track of the current state.
+class AsynchronousCopyResource {
+ public:
+  // A specification of needed asynchronous copy resources.
+  struct ResourceSpec {
+    int64_t start_time;
+    int64_t end_time;
+    float resource;
+  };
+
+  AsynchronousCopyResource() = default;
+
+  // The constructor needs the initial resources.
+  explicit AsynchronousCopyResource(absl::Span<const float> initial_resources)
+      : initial_resources_(initial_resources.begin(), initial_resources.end()),
+        delay_(initial_resources.size(), 0) {}
+
+  // Adds the given asynchronous copy and updates the current resources. CHECK
+  // fails if there aren't enough resources to satisfy this copy (the caller
+  // should use HasEnoughResource first to ensure there is enough resource).
+  void AddCopy(const AsynchronousCopy& copy);
+
+  // Removes the given copy and frees the resource.
+  void RemoveCopy(const AsynchronousCopy& copy);
+
+  // Returns true if a copy with the given start and end times and resource can
+  // be satisfied.
+  bool HasEnoughResource(int64_t start_time, int64_t end_time, float resource);
+
+  // Returns true if a set of copy specifications can be satisfied in the
+  // order specified.
+  bool HasEnoughResourceMultiCheck(const std::vector<ResourceSpec>& specs);
+
+  // This is only used for debugging and testing purposes, it returns the
+  // currently available resource at each logical time.
+  std::vector<float> GetCurrentResources() const {
+    std::vector<float> current_resources(initial_resources_.begin(),
+                                         initial_resources_.end());
+    for (int i = 0; i < current_resources.size(); ++i) {
+      current_resources[i] -= std::min(current_resources[i], delay_[i]);
+    }
+    return current_resources;
+  }
+
+  // A useful debugging tool for printing several pieces of information about
+  // AsynchronousCopyResource.
+  std::string Dump(
+      int64_t start_time, int64_t end_time,
+      MemorySpaceAssignment::MemorySpace memory_space_filter) const;
+
+ private:
+  // Internal helper method to implement adding/removing/checking resources.
+  // ConsumeResource() may modify delay_. If delay_change_map is not null,
+  // for any change to delay_[i], {i, delay_[i]} will be added to
+  // delay_change_map, allowing callers to undo any modifications.
+  bool ConsumeResource(
+      int64_t start_time, int64_t end_time, float resource,
+      absl::flat_hash_map<int64_t, float>* delay_change_map = nullptr,
+      float resource_to_free = 0.0);
+
+  // Same as the public RemoveCopy except it works on the async_copies_
+  // iterator. Assumes copy_it points to the last copy for its start time;
+  // otherwise the public RemoveCopy method is supposed to temporarily remove
+  // these later copies that share the same start time before removing the
+  // requested copy.
+  void RemoveCopy(std::list<AsynchronousCopy>::iterator& copy_it);
+
+  // We maintain a linked list of asynchronous copies sorted by the start times.
+  // This allows us to efficiently find the copy that starts right after another
+  // one because adding a copy might push a copy further into the future.
+  std::list<AsynchronousCopy> async_copies_;
+// To make the lookups into async_copies_ more efficient, we also maintain a
+// binary tree that is indexed by the start time, containing iterators into
+// async_copies_.
+// TODO(b/210891274): Use btree_map after build issue in Windows is resolved.
+#if defined(__GNUC__) || defined(__clang__)
+  absl::btree_map<int64_t, std::list<AsynchronousCopy>::iterator>
+      async_copy_time_map_;
+#else
+  std::map<int64_t, std::list<AsynchronousCopy>::iterator> async_copy_time_map_;
+#endif
+  std::vector<float> initial_resources_;
+  std::vector<float> delay_;
+};
+
+// TODO(b/280618622): Refactor this class out of this file.
+//
+// An optimizer for unrolled memory-bound loops. It keeps track of alternate
+// memory capacity and default memory bandwidth to decide the allocations of
+// each tensor within a loop iteration. The assumption is that all of the
+// unrolled loop iterations will use the same allocation decisions, so we can
+// spend more time to optimize this one iteration as optimally as possible.
+//
+// To represent instructions, we keep track of three iterations (previous,
+// current, and next), as well as the header and footer regions that are before
+// and after the loop, respectively.
+//
+// We classify each tensor used in the current iteration as one of the following
+// allocations based on its positions and uses:
+//
+// Temporary Allocations: These are produced by a producer in the current
+// iteration and consumed either in this or the next iteration. For these, we
+// try to give them alternate memory allocations for their entire live range.
+//
+// Case 1: producer and consumer all in the current iteration.
+//                                     p-----c--c
+// Case 2: producer is in the current iter, consumer is in the next iter.
+//                                           p-----c
+//  idx:       |...| 0  1  2  3  4| 0  1  2  3  4| 0  1  2  3  4|...|
+// iter: head  |...|      prev    |    current   |     next     |...| foot
+//
+// Loop Carried Dependences: This is where the last use is at a larger index
+// than the producer. This would require 2X peak buffer consumption because both
+// this and next iteration's buffer is alive at the same time. This case is
+// currently not supported.
+//
+// Case 3: producer is in the current iter, consumer is in the next iter
+//         (consumer idx >= producer idx).
+//                                           p-----------------c
+//  idx:       |...| 0  1  2  3  4| 0  1  2  3  4| 0  1  2  3  4|...|
+// iter: head  |...|      prev    |    current   |     next     |...| foot
+//
+// Pinned Allocations: These are values produced at the header and are used in
+// every iteration at the same indices. For these, we just allocate the buffer
+// for the duration of the loop:
+//
+// Case 4: producer: kHead, consumer: kCurrent
+//         p---------------c--------------c--------------c--------
+//  idx:       |...| 0  1  2  3  4| 0  1  2  3  4| 0  1  2  3  4|...|
+// iter: head  |...|      prev    |    current   |     next     |...| foot
+//
+// Prefetch Allocations: These are values produced at the header and are used in
+// the current (and possibly next) iteration. We will try to prefetch these
+// values into the alternate memory:
+//
+// Case 5: producer: kHead, consumer: kCurrent
+//         p---------------------------------c--------c
+//  idx:       |...| 0  1  2  3  4| 0  1  2  3  4| 0  1  2  3  4|...|
+// iter: head  |...|      prev    |    current   |     next     |...| foot
+class MemoryBoundLoopOptimizer {
+ public:
+  // We represent each tensor used in the current iteration as a LoopValue,
+  // wrapping the relevant information such as its HLO value, indices and
+  // pointers to its use and position sites in different iterations.
+  struct LoopValue {
+    // An enum that encodes the allocation type that is suitable for this
+    // LoopValue. See the comment above on what each of these mean.
+    enum class AllocationType {
+      kTemporary,
+      kLoopCarriedDependence,
+      kPinned,
+      kPrefetch,
+      kUnsupported
+    };
+
+    // ToString methods for logging/debugging.
+    static std::string AllocationTypeToString(AllocationType allocation_type);
+    std::string ToString() const;
+
+    // The HloValues that correspond to this LoopValue.
+    std::vector<const HloValue*> hlo_values;
+    // The position in the header, if any.
+    std::optional<HloPosition> header_position;
+    // The loop index and position in the previous and current iterations.
+    std::vector<std::pair<int64_t, HloPosition>> prev_iteration_positions;
+    std::vector<std::pair<int64_t, HloPosition>> loop_positions;
+    // The loop index and use in the current and next iterations.
+    std::vector<std::pair<int64_t, HloUse>> loop_uses;
+    std::vector<std::pair<int64_t, HloUse>> next_iteration_uses;
+    // The allocation type.
+    AllocationType allocation_type;
+    // Size of this tensor.
+    int64_t size;
+    // The default memory bandwidth savings were we to successfully put this in
+    // the alternate memory using the allocation type, in bytes.
+    float savings;
+    // The savings divided by the size. This is typically 2 for temporary
+    // allocations (skip a write and a read to the default memory). More complex
+    // production/consumption patterns may result in higher or lower values. We
+    // use this value to sort LoopValues so that the algorithm can prioritize
+    // allocating the buffers with the highest savings per byte to the alternate
+    // memory.
+    float savings_per_byte;
+    // The optimized AllocationSequence.
+    MemorySpaceAssignment::AllocationSequence allocations;
+  };
+
+  // Factory method to create and initialize a MemoryBoundLoopOptimizer.
+  static StatusOr<std::unique_ptr<MemoryBoundLoopOptimizer>> Create(
+      int loop_start, int loop_end, uint64_t alternate_memory_size,
+      const MemoryBoundLoopOptimizerOptions& options,
+      const HloLiveRange& hlo_live_range,
+      const HloAliasAnalysis& alias_analysis_,
+      const MemorySpaceAssignmentCostAnalysis& cost_analysis,
+      const BufferValue::SizeFunction& size_function);
+
+  // Optimize the loop. Initialize must be called first.
+  void Optimize();
+
+  // Calculate the steady-state execution time of one loop iteration using the
+  // allocation decisions so far.
+  float CalculateExecutionTime() const;
+
+  // Return the LoopValues.
+  const std::vector<LoopValue>& loop_values() const { return loop_values_; }
+  std::vector<LoopValue>& loop_values() { return loop_values_; }
+
+  // Return the remaining memory vector for each point in time in the loop using
+  // the allocation decisions so far.
+  const std::vector<int64_t>& remaining_memory() const {
+    return remaining_memory_;
+  }
+
+  // The loop start, end, and size accessors.
+  int loop_start() const { return loop_start_; }
+  int loop_end() const { return loop_end_; }
+  int loop_size() const { return loop_size_; }
+
+ private:
+  // Temporary data structures used by the AllocatePrefetch function.
+  struct AllocatePrefetchesContext {
+    // The values that are requested to be prefetched.
+    absl::Span<LoopValue*> values;
+
+    // A list of indices into values array, sorted by the start time of the
+    // first use.
+    std::vector<int> value_indices;
+
+    // Default memory remaining bandwidths assuming all prefetches succeeded.
+    std::vector<float> bandwidth_idle_times;
+
+    // Additional memory used while performing prefetching.
+    std::vector<int64_t> additional_memory_used;
+  };
+
+  MemoryBoundLoopOptimizer(
+      int loop_start, int loop_end, uint64_t alternate_memory_size,
+      const MemoryBoundLoopOptimizerOptions& options,
+      const HloLiveRange& hlo_live_range,
+      const HloAliasAnalysis& alias_analysis_,
+      const MemorySpaceAssignmentCostAnalysis& cost_analysis,
+      const BufferValue::SizeFunction& size_function);
+
+  // Initializes the data structures used by the optimizer.
+  Status Initialize();
+
+  // Given an HloBuffer object, determines if this buffer represents a LoopValue
+  // that can be optimized by the optimizer, and if so it adds a LoopValue to
+  // the back of loop_values_ that represents the HloBuffer. Otherwise, no new
+  // LoopValue is added to loop_values_.
+  void MaybeCreateLoopValue(const HloBuffer& buffer,
+                            const HloComputation* loop_computation);
+
+  // Sort LoopValues by savings_per_byte.
+  void SortLoopValues();
+
+  // After allocation finishes, we fix up by creating Allocation objects to any
+  // LoopValues that didn't get alternate memory allocations.
+  void PostProcess();
+
+  // Allocate LoopValues by dispatching to the correct Allocate method.
+  void AllocateLoopValues();
+
+  // Allocate and reserve memory between the given indices.
+  bool AllocateBetween(int64_t begin_idx, int64_t end_idx, int64_t size);
+
+  // Perform allocation type kTemporary. Return true if successful.
+  bool AllocateTemporary(LoopValue& value);
+
+  // Perform allocation type kPinned. Return true if successful.
+  bool AllocatePinned(LoopValue& value);
+
+  // Perform allocation type kPrefetch. Unlike the other Allocate methods, this
+  // performs allocation of multiple LoopValues in order to consider the effect
+  // of remaining bandwidth assuming the other prefetches were successful.
+  // Return true if successful.
+  bool AllocatePrefetches(absl::Span<LoopValue*> values);
+
+  // Allocate one prefetch for the loop value index that corresponds to
+  // context.context.values. Returns true if successful.
+  bool AllocatePrefetch(int value_index, AllocatePrefetchesContext& context);
+
+  // Keeps track of successful allocation of all uses and positions of this
+  // LoopValue.
+  void AddAllLoopPositionsAndUses(LoopValue& value,
+                                  bool allocate_next_iteration_uses);
+
+  // Returns the default memory bandwidth idle time at the index.
+  float GetBandwidthIdleTime(int idx) const;
+
+  // Returns the default memory bandwidth idle time at the index assuming the
+  // given uses and positions got alternate memory allocations.
+  float GetBandwidthIdleTime(
+      int idx,
+      const absl::flat_hash_map<const HloInstruction*,
+                                std::vector<std::pair<int64_t, ShapeIndex>>>&
+          additional_uses_in_alternate_mem,
+      const absl::flat_hash_map<const HloInstruction*, std::vector<ShapeIndex>>&
+          additional_positions_in_alternate_mem) const;
+
+  // Returns the instruction elapsed at the index.
+  float GetInstructionElapsed(int idx) const;
+
+  int loop_start_;
+  int loop_end_;
+  int loop_size_;
+  uint64_t alternate_memory_size_;
+  MemoryBoundLoopOptimizerOptions options_;
+  const HloLiveRange& hlo_live_range_;
+  const HloAliasAnalysis& alias_analysis_;
+  const MemorySpaceAssignmentCostAnalysis& cost_analysis_;
+  BufferValue::SizeFunction size_function_;
+
+  absl::flat_hash_map<const HloInstruction*, int64_t> instructions_in_loop_;
+  absl::flat_hash_map<const HloInstruction*, int64_t>
+      instructions_in_prev_iteration_;
+  absl::flat_hash_map<const HloInstruction*, int64_t>
+      instructions_in_next_iteration_;
+  std::vector<LoopValue> loop_values_;
+  std::vector<int64_t> remaining_memory_;
+  absl::flat_hash_map<const HloInstruction*,
+                      std::vector<std::pair<int64_t, ShapeIndex>>>
+      uses_in_alternate_mem_;
+  absl::flat_hash_map<const HloInstruction*, std::vector<ShapeIndex>>
+      positions_in_alternate_mem_;
+};
+
+// This class inherits from GlobalDecreasingSizeBestFitHeap with a notion of
+// maximum size.
+class AlternateMemoryBestFitHeap
+    : public GlobalDecreasingSizeBestFitHeap<HloValue> {
+ public:
+  using MemorySpace = MemorySpaceAssignment::MemorySpace;
+  using AllocationValue = MemorySpaceAssignment::AllocationValue;
+  using HloPositionOrUse = std::variant<HloPosition, HloUse>;
+
+  AlternateMemoryBestFitHeap(
+      MemorySpaceAssignment::AllocationSequence* allocations,
+      const Options& options, const HloAliasAnalysis& alias_analysis,
+      const HloLiveRange& hlo_live_range);
+
+  // Allocates a buffer in preferred memory with whole program lifetime and
+  // enables prefetching prefetch_candidate from default memory across program
+  // boundaries.
+  void AllocateCrossProgramPrefetchBuffer(
+      HloModule* module, const BufferInterval& prefetch_candidate);
+
+  HeapSimulator::Result<HloValue> Finish() override;
+
+ protected:
+  // Given a buffer interval, returns the colocated intervals. Unlike the
+  // similar GlobalDecreasingSizeBestFitHeap::GetTransitiveColocations, it
+  // returns the colocated intervals sorted by scheduled time.
+  std::vector<const BufferInterval*> GetSortedColocatedIntervals(
+      const BufferInterval& interval) const;
+
+  // Given a BufferInterval, creates AllocationValue objects and corresponding
+  // AllocationSequences and appends them into allocation_sequence_list_.
+  void CreateAllocationValues(
+      const BufferInterval& buffer_interval,
+      std::vector<AllocationValue>& allocation_values) const;
+
+  // Given colocated intervals, populates allocation_values with the
+  // corresponding AllocationValue objects.
+  virtual void CreateAllocationValuesFromColocatedIntervals(
+      absl::Span<const AlternateMemoryBestFitHeap::BufferInterval* const>
+          colocated_intervals,
+      std::vector<MemorySpaceAssignment::AllocationValue>& allocation_values);
+
+  // Go through all the uses in the AllocationValues and find the aliasing
+  // positions.
+  void FindAliases(std::vector<AllocationValue>* allocation_values) const;
+
+  MemorySpaceAssignment::AllocationSequence* allocations() {
+    return allocations_;
+  }
+  const Options& options() const { return options_; }
+  const HloAliasAnalysis& alias_analysis() { return alias_analysis_; }
+  const HloLiveRange& hlo_live_range() { return hlo_live_range_; }
+
+ private:
+  // We inherit AllocationBlock struct to attach the Allocation information to
+  // make importing repacked offsets easier.
+  struct RepackAllocationBlock
+      : MemorySpaceAssignmentRepacker::AllocationBlock {
+    MemorySpaceAssignment::Allocation* allocation;
+  };
+
+  // A data structure we use to associate Allocation objects that are aliased
+  // and must get the same offset.
+  struct AliasedOffset {
+    int64_t offset;
+    absl::flat_hash_set<const MemorySpaceAssignment::Allocation*> allocations;
+  };
+
+  // An allocation request for a use segment. A use segment is the time segment
+  // between the definition and the first use, and the time segment between the
+  // uses of a buffer. For example, the time between the definition and Use1, is
+  // the first segment, and the time between Use1 and Use2 is the second segment
+  // and so on:
+  //
+  //        +------+----------+-------+
+  //       /        \          \       \
+  //      /          v          v       v
+  //    Def         Use1       Use2    Use3
+  //     <----------> <--------> <----->
+  //        Segment    Segment   Segment
+  //
+  // start_time and end_time are the start and end logical times of the segment.
+  // use_times is a sorted sequence of the times of all uses.
+  // latest_prefetch_time is the latest time we can schedule the CopyDone for a
+  // prefetch.
+  // If allow_no_copy_alternate_mem_allocation is false, an eviction is forced.
+  // If earliest_prefetch_time is set, prefetches cannot start before this
+  // value.
+  struct AllocationRequest {
+    int64_t start_time;
+    int64_t end_time;
+    int64_t latest_prefetch_time;
+    int64_t size;
+    bool prefer_no_copy_alternate_mem_allocation;
+    bool allow_no_copy_alternate_mem_allocation;
+    bool allow_prefetch;
+    std::optional<int64_t> earliest_prefetch_time;
+    std::optional<int64_t> preferred_prefetch_time;
+    AliasedOffset* preferred_offset;
+    const MemorySpaceAssignment::AllocationValue::Use* use;
+    MemorySpaceAssignment::AllocationValue* allocation_value;
+    absl::Span<const int64_t> all_use_times;
+  };
+
+  // This struct contains mandatory memory assignments at a given time. E.g., an
+  // input's required memory assignment time would correspond to the definition
+  // time of the parameter instruction, and an output's time would correspond to
+  // the time of last use.
+  struct RequiredMemoryAssignment {
+    MemorySpaceAssignment::MemorySpace memory_space;
+    int64_t time;
+    AliasedOffset* offset;
+
+    bool equals_ignoring_time(const RequiredMemoryAssignment& other) const {
+      return memory_space == other.memory_space && offset == other.offset;
+    }
+
+    bool operator==(const RequiredMemoryAssignment& other) const {
+      return memory_space == other.memory_space && time == other.time &&
+             offset == other.offset;
+    }
+
+    bool operator!=(const RequiredMemoryAssignment& other) const {
+      return !(*this == other);
+    }
+  };
+
+  // A struct that contains a pointer to loop-optimized allocation along with
+  // essential data about the loop itself.
+  struct LoopOptimizedAllocationInfo {
+    // The use_idx is the instruction index of the use within the loop.
+    int64_t use_index;
+    // The number of instructions in one iteration of the loop. We use use_index
+    // and loop_size to calculate when exactly to schedule a prefetch
+    // instruction.
+    int64_t loop_size;
+    // A pointer into an Allocation in loop_optimized_allocations_.
+    const MemorySpaceAssignment::Allocation* loop_optimized_allocation;
+  };
+
+  // A context object that is used to share state amongst the methods that
+  // implement Prefetch(). Prefetch tries to find both a sliced solution and an
+  // unsliced solution at the same time. We store both in this structure.
+  struct PrefetchContext {
+    // Prefetching is designed to operate on a SlicedBufferInterval that is
+    // backed by a standard BufferInterval, even if the number of slices == 1.
+    // WorkingIntervals is used to store a SlicedBufferInterval and its backing
+    // BufferInterval.
+    struct WorkingIntervals {
+      BufferInterval full;
+      // sliced is a unique_ptr because it won't necessarily be initialized
+      // when the WorkingBufferIntervals are created, and there is no way to
+      // create an empty SlicedBufferInterval.
+      std::unique_ptr<SlicedBufferInterval> sliced;
+    };
+
+    struct SlicedSolution {
+      // When we talk about a slice, we think of spatial slices, where each
+      // slice is allocated at different times. The following example shows
+      // 3 slices that are used to form a contiguous buffer from [p0, p3]
+      //
+      //   space
+      //    ^
+      // p3 |       +-----------+
+      //    |       |    s2     |
+      // p2 |   +---+-----------+
+      //    |   |      s1       |
+      // p1 |   +-------+-------+
+      //    |           |  s0   |
+      // p0 |           +-------+
+      //    +---|---|---|---|---|----> time
+      //        t0  t1  t2  t3  t4
+      std::vector<MemorySpaceAssignment::SliceDecision>
+          slice_decisions_sorted_by_start_time;
+
+      // In order to support colocated buffer calculations, we need to add a
+      // BufferInterval-Chunk pair to pending_chunks_, such that:
+      // - The duration of the BufferInterval is non-zero.
+      // - All slices have been allocated by the start of the BufferInterval.
+      // - The BufferInterval ends at the end time for all slices.
+      // - The Chunk covers the space allocated for all slices.
+      //
+      // In order to meet that requirement,
+      // we create BufferInterval-Chunk pairs from
+      // slice_decisions_sorted_by_start_time that meet those requirement but do
+      // not cause any memory to be allocated in more than one Chunk at a time.
+      // The result is stored in slices_for_pending_chunks.
+      //
+      // The illustration below demonstrates how we would construct such
+      // BufferInterval-Chunk pairs from the
+      // slice_decisions_sorted_by_start_time example above.
+      //
+      //   space
+      //    ^
+      // p3 |       +---+---+---+
+      //    |       |c2 |       |
+      // p2 |   +---+---+       |
+      //    |   |  c0   |   c2  |
+      // p1 |   +-------+       |
+      //    |           |       |
+      // p0 |           +-------+
+      //    +---|---|---|---|---|----> time
+      //        t0  t1  t2  t3  t4
+      std::vector<std::pair<BufferInterval, Chunk>> slices_for_pending_chunks;
+
+      // The prefetch_picker_debug_string will only be set with the appropriate
+      // VLOG level.
+      std::string prefetch_picker_debug_string;
+    };
+
+    struct UnslicedSolution {
+      Chunk chunk_candidate;    // The chunk chosen for the solution.
+      float prefetch_resource;  // The amount of required prefetch resource.
+      // The prefetch_picker_debug_string will only be set with the appropriate
+      // VLOG level.
+      std::string prefetch_picker_debug_string;
+    };
+
+    WorkingIntervals& GetMutableWorkingIntervals(bool for_sliced_solution) {
+      if (for_sliced_solution) {
+        return sliced_solution_intervals;
+      }
+      return unsliced_solution_intervals;
+    }
+
+    const WorkingIntervals& GetWorkingIntervals(
+        bool for_sliced_solution) const {
+      if (for_sliced_solution) {
+        return sliced_solution_intervals;
+      }
+      return unsliced_solution_intervals;
+    }
+
+    // Parameters to Prefetch().
+    const AllocationRequest* request;
+    MemorySpaceAssignment::Allocation* prev_allocation_in_default_mem;
+
+    // Intermediate calculations common to both the sliced and unsliced
+    // solutions.
+    int64_t prefetch_start_time = -1;
+    int64_t prefetch_end_time = -1;
+    const Shape* full_shape;
+    int64_t extra_async_copy_limit = 0;
+    // As a compilation time optimization, store the prefetch start time where
+    // we have first seen out of memory. There is no point of exploring prefetch
+    // start times earlier than this point.
+    std::optional<int64_t> out_of_mem_start = std::nullopt;
+
+    // Data structures used to compute and store the sliced solution.
+    std::optional<MemorySpaceAssignment::SliceProposalCollection>
+        slice_proposal_collection = std::nullopt;
+    WorkingIntervals sliced_solution_intervals;
+    std::optional<SlicedSolution> sliced_solution;
+
+    // Data structures used to compute and store the unsliced solution.
+    WorkingIntervals unsliced_solution_intervals;
+    std::optional<UnslicedSolution> unsliced_solution;
+  };
+
+  // Result of an allocation, prefetch, eviction etc. request.  The result is
+  // either kSuccess or a bitwise OR of one or more failures. The values are
+  // unique powers of two. To check if a result contains a particular failure,
+  // use the result_is method. To add a new failure to a result, use the
+  // result_mark method.
+  enum class Result {
+    // Successful allocation.
+    kSuccess = 0,
+    // Allocation failed because we ran out of alternate memory.
+    kFailOutOfMemory = 1,
+    // A no-copy allocation couldn't be performed because the previous
+    // allocation wasn't in the alternate memory space.
+    kFailPrevAllocationNotInAlternateMem = 2,
+    // A no-copy allocation couldn't be performed because the live range was too
+    // long.
+    kFailLiveRangeTooLong = 4,
+    // A prefetching couldn't be performed because the live range was too short.
+    kFailLiveRangeTooShort = 8,
+    // Ran out of outstanding asynchronous copy limit either during prefetching
+    // or eviction.
+    kFailOutOfAsyncCopies = 16,
+    // A prefetching couldn't be performed because the asynchronous copy
+    // resource was violated.
+    kFailViolatesAsyncCopyResource = 32,
+    // An allocation failure happened that requires uncommitting all the pending
+    // allocations. Usually this is due to a situation requiring an eviction but
+    // the eviction couldn't be performed.
+    kFailRequiresUncommit = 64,
+    // For prefetching, indicates that all slices have the same start time, in
+    // which case, we fallback to an unsliced solution.
+    kAllSlicesHaveTheSameStartTime = 128
+  };
+
+  // Return true if the result belongs to a failure.
+  static bool result_is(Result result, Result failure) {
+    return static_cast<int>(result) & static_cast<int>(failure);
+  }
+
+  // Mark (bitwise OR) a failure to the result.
+  static Result result_mark(Result failure, Result& result) {
+    result = static_cast<Result>(static_cast<int>(result) |
+                                 static_cast<int>(failure));
+    return result;
+  }
+
+  // Return true if the result is a failure that requires us to uncommit pending
+  // chunks.
+  static bool result_requires_uncommit(Result result) {
+    return result_is(result, Result::kFailRequiresUncommit);
+  }
+
+  // Return true if the result is a failure either due to running out of
+  // outstanding asynchronous copies or due to violating asynchronous copy
+  // ordering.
+  static bool result_failed_because_of_async_copy(Result result) {
+    return result_is(result, Result::kFailOutOfAsyncCopies) ||
+           result_is(result, Result::kFailViolatesAsyncCopyResource);
+  }
+
+  // For the given loop with the start and end index and loop size, run the
+  // MemoryBoundLoopOptimizer and record its outputs into
+  // optimized_allocations_map_.
+  Status OptimizeMemoryBoundLoop(int loop_start_idx, int loop_end_idx,
+                                 int loop_size);
+
+  // Identify memory-bound loops in the graph and call OptimizeMemoryBoundLoop
+  // for the found loops.
+  void IdentifyAndOptimizeMemoryBoundLoops();
+
+  // Allocates buffers for instructions that need reserved scoped allocations in
+  // the alternate memory space.
+  void AllocateReservedScopedAllocations();
+
+  // Returns the AliasedOffset object associated with the allocation.
+  AliasedOffset* GetAliasedOffset(
+      const MemorySpaceAssignment::Allocation& allocation);
+
+  // If aliased_offset is non-null, this method adds the allocation to
+  // aliased_offset. Otherwise, it creates a new AliasedOffset object and adds
+  // the allocation to this new AliasedOffset.
+  void CreateOrAddToAliasedOffset(
+      const MemorySpaceAssignment::Allocation& allocation,
+      AliasedOffset* aliased_offset);
+
+  // Given an allocation sequence, returns the live allocation at time with a
+  // preference towards allocations in alternate memory. Returns nullptr if no
+  // allocation is alive at that time.
+  static MemorySpaceAssignment::Allocation* GetLiveAllocationAt(
+      const MemorySpaceAssignment::AllocationSequence& allocations,
+      int64_t time);
+
+  // Returns true if the use is allowed in the alternate memory.
+  bool IsUseAllowedInAlternateMemory(const AllocationValue& value,
+                                     const HloUse& use) const;
+
+  // Finds allocations for allocation values generated from colocated intervals.
+  // All of the allocation values have a must-alias relationship with each
+  // other. Returns either kSuccess if all of the sites could be placed in the
+  // alternate memory or a bitwise OR of failure reasons why they couldn't
+  Result AllocateAllocationValues(
+      absl::Span<AllocationValue> allocation_values);
+
+  // Finds an allocation for an allocation request for a segment (see the
+  // documentation for AllocationRequest above how a segment is defined).
+  //
+  // It performs three things in the following order:
+  //  1- Allocate the allocation request entirely in the alternate memory, if
+  //     there is enough space and if the prefetch interval picker allows.
+  //  2- If (1) was unsuccessful, and the only allocation for
+  //     this buffer was in the alternate memory, we try to perform a prefetch.
+  //  3- If (1) was unsuccessful, prefetch the buffer into the alternate memory,
+  //     if there is enough space and if the prefetch interval picker allows.
+  //
+  // If an eviction (2) was requested and was unsuccessful, this method returns
+  // Result::kFailRequiresUncommit. This means we could not find a suitable
+  // allocation, so all previous allocations for this buffer must be removed and
+  // allocated in the default memory. Otherwise, this method may return
+  // Result::kSuccess if the buffer could be placed in alternate memory or some
+  // other Result with an OR of reasons why the buffer couldn't be placed in
+  // alternate memory.
+  Result AllocateSegment(const AllocationRequest& request);
+
+  // Try allocating in alternate memory without any copies.
+  Result AllocateInAlternateMemoryNoCopy(const AllocationRequest& request);
+
+  // Try evicting to default memory space.
+  Result Evict(const AllocationRequest& request);
+
+  // Returns the time a copy done of a prefetch should be scheduled.
+  int64_t FindPrefetchEndTime(const AllocationRequest& request,
+                              int64_t earliest_prefetch_time) const;
+
+  // Try prefetching to alternate memory space.
+  Result Prefetch(
+      const AllocationRequest& request,
+      MemorySpaceAssignment::Allocation& prev_allocation_in_default_mem);
+
+  // Helper methods used to implement Prefetch().
+  //
+  // Generates a SliceProposal in context, if options dictate and one can be
+  // constructed.
+  void GenerateSliceProposal(PrefetchContext& context) const;
+  // Calls GenerateSliceProposal to potentially create a SliceProposal, and
+  // sets up WorkingIntervals for a sliced and unsliced solution. Updates
+  // context.
+  void SetupPrefetchWorkingIntervalsAndSliceProposal(
+      PrefetchContext& context) const;
+  // Initializes the PrefetchIntervalPicker and associated data structures in
+  // context.
+  Result InitializePrefetchIntervalPicker(PrefetchContext& context);
+  // As a compile time optimization, try a prefetch allocation that is as late
+  // as possible. If this is not able to find a solution, none of the
+  // earlier tries will succeed either.
+  Result EnsureSomeSpatialPrefetchFitExists(PrefetchContext& context) const;
+  // Check if for the specified type of solution, using the parameters in
+  // context. If we find a solution, it will be stored in context.
+  Result CheckPrefetchFit(bool for_sliced_solution, PrefetchContext& context);
+  // Given a specified number of slices, start times, and end times, pick times
+  // to start each slice.
+  std::vector<int64_t> PickSliceStartTimes(int64_t num_slices,
+                                           int64_t prefetch_start_time,
+                                           int64_t prefetch_end_time) const;
+  // Creates a debugging string describing the timing of the prefetch solution
+  // we are currently attempting (as dictated by for_sliced_solution and
+  // context).
+  std::string AlternateMemoryAllocationAttemptToString(
+      bool for_sliced_solution, const PrefetchContext& context) const;
+
+  // Find the best possible chunk candidate, where it has the longest possible
+  // availability if no preferred offset is given, or at the preferred_offset if
+  // it is given.
+  std::optional<Chunk> FindBestChunkCandidate(
+      const AllocationRequest& request, const AliasedOffset* preferred_offset,
+      BufferInterval* alternate_mem_interval) const;
+  // The same as FindBestChunkCandidate() but allocates the request in slices.
+  // The ith returned chunk should be allocated at slice time i.
+  std::vector<Chunk> FindBestChunkCandidates(
+      const AllocationRequest& request, const AliasedOffset* preferred_offset,
+      SlicedBufferInterval* alternate_mem_interval) const;
+
+  // Returns the required assignment at a particular time, if available.
+  std::optional<RequiredMemoryAssignment> RequiredMemoryAssignmentAt(
+      const HloValue* buffer, int64_t time) const;
+
+  // Searches for aliases in the use for a required assignment, and returns it
+  // if found.
+  std::optional<RequiredMemoryAssignment> AliasedRequiredAssignmentForUse(
+      const AllocationValue::Use& use) const;
+
+  // Goes through the colocated intervals and adds any required assignment.
+  void AddRequiredAssignmentsForColocatedIntervals(
+      absl::Span<const AlternateMemoryBestFitHeap::BufferInterval* const>
+          colocated_intervals);
+
+  // Propagates aliased required assignment for a given position.
+  void AddAliasedRequiredAssignment(
+      const HloInstruction* instruction, ShapeIndex index,
+      const MemorySpaceAssignment::Allocation* aliased_allocation);
+
+  // This sets a required assignment. CHECK fails if there is a conflicting
+  // required assignment at the same time.
+  void AddRequiredAssignment(const HloValue* value,
+                             const HloInstruction* instruction,
+                             MemorySpace memory_space, int64_t time,
+                             AliasedOffset* offset = nullptr,
+                             bool add_to_pending = true);
+  void AddRequiredAssignment(const HloInstruction* instruction,
+                             ShapeIndex index, MemorySpace memory_space,
+                             AliasedOffset* offset = nullptr,
+                             bool add_to_pending = true);
+  void AddRequiredAssignment(const HloPosition& position,
+                             MemorySpace memory_space,
+                             AliasedOffset* offset = nullptr,
+                             bool add_to_pending = true);
+  void AddRequiredAssignment(const HloUse& use, MemorySpace memory_space,
+                             AliasedOffset* offset = nullptr,
+                             bool add_to_pending = true);
+
+  // Adds input and outputs as required assignments.
+  void AddInputAndOutputRequiredAssignments();
+
+  // Returns a list of "linked" allocations in the alternate memory. Linked
+  // allocations all share a common allocation site (a use or position) with
+  // each other. This can be used to determine if a group of linked allocations
+  // are considered efficient or not.
+  std::vector<std::vector<const MemorySpaceAssignment::Allocation*>>
+  GetLinkedAllocationsInAlternateMemory(
+      absl::Span<const AllocationValue> allocation_values) const;
+
+  // Returns allocation sites (use or position) that are allocated in the
+  // alternate memory, but is considered inefficient.  These arise in the
+  // context of in-place operation like dynamic-update-slice.  We will typically
+  // have an allocation that has the DUS as a use, and another allocation that
+  // has the DUS as a defining position. These two allocation will be part of
+  // the same linked allocation group.
+  //
+  // One reason why an allocation site could be inefficient is because the
+  // amount of data that is asynchronously copied (prefetch and eviction) is
+  // much larger than the amount of data that is used by the HLOs. If we find
+  // inefficient allocation sites, we can require these sites default memory
+  // allocations and allocate them again.
+  std::vector<HloPositionOrUse> GetInefficientAllocationSites(
+      absl::Span<const AllocationValue> allocation_values) const;
+
+  // Returns true if the colocated intervals in the argument are in a parameter
+  // or root instruction of the entry computation and are reserved by the user
+  // to be in the alternate memory space.
+  bool AreIntervalsReservedInAlternateMemory(
+      absl::Span<const BufferInterval* const> colocated_intervals) const;
+
+  // Since the allocations are recorded to the AllocationSequence, we don't
+  // maintain result_ in GlobalDecreasingSizeBestFitHeap. Override AddToChunkMap
+  // to avoid unnecessarily adding the chunk to the chunk map.
+  //
+  // Sliced prefetching requires that we override this method because we
+  // associate more than one chunk with a buffer (i.e., 1 chunk per slice),
+  // which would cause the original implementation of this method to CHECK fail.
+  void AddToChunkMap(const HloValue* buffer, Chunk chunk) override {}
+
+  // Returns true if the addition of num_additional_copies asynchronous copies
+  // in the given time interval would violate the maximum number of asynchronous
+  // copies. An extra  async copy limit can be provided to increase the limit of
+  // asynchronous copies for this instance.
+  bool ViolatesMaximumOutstandingAsyncCopies(
+      int64_t start_time, int64_t end_time, bool is_prefetch,
+      int64_t extra_async_copy_limit = 0,
+      int64_t num_additional_copies = 1) const;
+
+  // Exports the allocations for repacking and puts them into the vector in the
+  // parameter.
+  void ExportAllocationsForRepacking(
+      std::vector<MemorySpaceAssignmentRepacker::AllocationBlock*>&
+          allocations);
+
+  // Update reserved scoped allocation size for instructions when their
+  // operand/output has been allocated in alternate memory by invoking
+  // reserved_scoped_memory_fn
+  void UpdateReservedScopedAllocationSize();
+
+  // Imports repacked allocations and updates the internal data structures
+  // consistent with the new packing.
+  void ImportRepackedAllocations();
+  // Helper functions to implement ImportRepackedAllocations.
+  void ImportRepackedNonSlicedAllocation(RepackAllocationBlock& block);
+  void ImportRepackedSlicedAllocation(RepackAllocationBlock& block);
+
+  // Adds an asynchronous copy to allocations.
+  void AddAsyncCopy(
+      MemorySpaceAssignment::Allocation& prev_allocation,
+      MemorySpace memory_space, std::optional<Chunk> chunk, int64_t start_time,
+      int64_t end_time, int64_t copy_done_schedule_before_time,
+      MemorySpaceAssignment::AllocationSequence* allocations,
+      AliasedOffset* aliased_offset, float resource,
+      std::optional<int> cross_program_prefetch_index = std::nullopt);
+
+  // For prefetching, adds a SlicedCopyAllocation to allocations. Also updates
+  // asynchronous copy data structures, prefetch_interval_tree_, and aliasing
+  // data structures
+  void AddAsyncSlicesForPrefetch(
+      const MemorySpaceAssignment::Allocation& prev_allocation,
+      MemorySpaceAssignment::AllocationSequence* allocations,
+      AliasedOffset* aliased_offset,
+      const std::vector<MemorySpaceAssignment::SliceDecision>&
+          slice_decisions_sorted_by_start_time,
+      int64_t prefetch_end_time, int64_t allocation_end_time);
+
+  // This method is used for committing the chunk candidate but adding it to
+  // pending_chunks_ so that we can "uncommit" them in case we need to roll back
+  // this allocation sequence.
+  void AddToPendingChunks(const BufferInterval& buffer_interval,
+                          const Chunk& chunk);
+  // If we need to remove the allocations for this allocation sequence, this
+  // removes pending chunks and asynchronous copies in the respective pending
+  // buffers from the interval trees. If an allocation request returns
+  // kFailRequiresUncommit, this method must be called.
+  void UncommitPendingChunks(absl::Span<AllocationValue> allocation_values);
+
+  // Finalizes the allocations where they can no longer be uncommitted.
+  void FinalizeAllocations(absl::Span<AllocationValue> allocation_values);
+
+  // Clears all pending chunks and asynchronous copies.
+  void ClearPendingChunks();
+
+  // Append buffer and allocation infos for debugging and dump it into a file,
+  // if enabled.
+  void AppendBufferInfoDebugString(const BufferInterval& interval,
+                                   std::string* debug_str) const;
+  void AppendScopedAllocationBufferInfoDebugString(
+      const HloInstruction* instruction, int64_t time, int64_t size,
+      std::string& debug_str) const;
+  void AppendAllocationInfoDebugString(
+      const MemorySpaceAssignment::Allocation& allocation,
+      std::string& debug_str) const;
+  void DumpDebugStringsIfEnabled() const;
+
+  // Returns the available heap size in the alternate memory.
+  int64_t available_heap_size() const {
+    return options_.max_size_in_bytes - reserved_in_bytes_;
+  }
+
+  // Returns the earliest time in the [start_time, end_time] range that a new
+  // allocation with the given size would fit in the alternate memory. If it
+  // doesn't fit, it returns nullopt.
+  std::optional<int> FindEarliestTimeToSatisfyPeakMemory(int start_time,
+                                                         int end_time,
+                                                         int64_t size) const;
+
+  // Creates and returns a RepackAllocationBlock.
+  static RepackAllocationBlock MakeRepackAllocationBlock(
+      int64_t start_time, int64_t end_time, int64_t size,
+      int64_t initial_offset, int64_t id,
+      MemorySpaceAssignment::Allocation* allocation) {
+    RepackAllocationBlock allocation_block;
+    allocation_block.start_time = start_time;
+    allocation_block.end_time = end_time;
+    allocation_block.size = size;
+    allocation_block.offset = -1;
+    allocation_block.initial_offset = initial_offset;
+    allocation_block.id = id;
+    allocation_block.colocations = {};
+    allocation_block.allocation = allocation;
+    return allocation_block;
+  }
+
+  // Returns a vector of instructions that have the same fingerprint as this
+  // instruction.
+  const std::vector<const HloInstruction*>* GetRepeatedInstructionList(
+      const HloInstruction* instruction) const;
+
+  MemorySpaceAssignment::AllocationSequence* allocations_;
+  const Options& options_;
+  const HloAliasAnalysis& alias_analysis_;
+  const HloLiveRange& hlo_live_range_;
+  std::unique_ptr<CallGraph> call_graph_;
+  // We use a interval tree to keep track of the number of outstanding
+  // prefetches and evictions.
+  BufferIntervalTree prefetch_interval_tree_;
+  BufferIntervalTree eviction_interval_tree_;
+  AsynchronousCopyOrdering async_copy_ordering_;
+  AsynchronousCopyResource prefetch_async_copy_resource_;
+  AsynchronousCopyResource eviction_async_copy_resource_;
+  // A list of RepackAllocationBlock objects that mirrors allocation sequences,
+  // used for repacking. We use a list here because we need pointer stability
+  // for aliased allocations.
+  std::list<RepackAllocationBlock> repack_allocation_blocks_;
+  int64_t num_repacks_ = 0;
+  std::vector<std::pair<BufferInterval, Chunk>> pending_chunks_;
+  std::vector<AsynchronousCopy> pending_async_copies_;
+  std::vector<std::pair<const HloValue*, RequiredMemoryAssignment>>
+      pending_required_assignments_;
+  // A cache to keep the peak memory usage at each point in the graph. We use
+  // this to see if the proposed allocation in the alternate memory would fit
+  // ignoring fragmentation, and if not, we can skip the more expensive lookup
+  // in the BufferIntervalTree, which also considers fragmentation.
+  std::vector<int64_t> peak_memory_usage_;
+  // The data structure that contains AliasedOffset objects and Allocation to
+  // AliasedOffset map for efficient lookup.
+  std::list<AliasedOffset> aliased_offsets_;
+  absl::flat_hash_map<const MemorySpaceAssignment::Allocation*, AliasedOffset*>
+      aliased_offset_map_;
+  // This map contains required memory assignments for HloValues (e.g., input
+  // and outputs).
+  absl::flat_hash_map<const HloValue*, std::vector<RequiredMemoryAssignment>>
+      required_assignments_;
+  // Number of bytes reserved in alternate memory space.
+  int64_t reserved_in_bytes_ = 0;
+  // A rough measure of the memory pressure of the model, in bytes. Note that
+  // this is pressure for memory capacity (and not accessed bytes), and for
+  // alternate memory (not default memory).
+  int64_t memory_pressure_ = 0;
+  int64_t next_async_copy_id_ = 0;
+  // Fingerprint cache.
+  absl::flat_hash_map<const HloInstruction*, std::string> fingerprint_map_;
+  // Vector of repeated instructions (that have the same fingerprint) indexed by
+  // fingerprint.
+  absl::flat_hash_map<std::string, std::vector<const HloInstruction*>>
+      repeated_inst_map_;
+
+  // Loop-optimized allocations found by MemoryBoundLoopOptimizer. These
+  // allocation objects describe the allocations for one iteration of the loop,
+  // so we translate them into the program-level Allocation objects in
+  // allocations_.
+  std::vector<MemorySpaceAssignment::AllocationSequence>
+      loop_optimized_allocations_;
+  // A map to look up the loop-optimized allocation info by use.
+  absl::flat_hash_map<HloUse, LoopOptimizedAllocationInfo>
+      loop_optimized_allocations_map_;
+  // A map to look the operands of each instruction that are assigned in
+  // alternate memory.
+  absl::flat_hash_map<const HloInstruction*,
+                      absl::flat_hash_set<std::pair<int, ShapeIndex>>>
+      operands_in_alternate_memory_map_;
+  // A map to look the outputs of each instruction that are assigned in
+  // alternate memory.
+  absl::flat_hash_map<const HloInstruction*, absl::flat_hash_set<ShapeIndex>>
+      outputs_in_alternate_memory_map_;
+  // Debug strings.
+  std::string buffer_info_str_;
+  std::string allocation_info_str_;
+  std::string instruction_schedule_str_;
+};
+}  // namespace memory_space_assignment
+}  // namespace xla
+
+#endif  // XLA_SERVICE_MEMORY_SPACE_ASSIGNMENT_MEMORY_SPACE_ASSIGNMENT_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/memory_space_assignment/memory_space_assignment.pb.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/memory_space_assignment/memory_space_assignment.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..7d4d597a213719076e19ba910ccac3ef46a49144
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/memory_space_assignment/memory_space_assignment.pb.h
@@ -0,0 +1,590 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: xla/service/memory_space_assignment/memory_space_assignment.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_xla_2fservice_2fmemory_5fspace_5fassignment_2fmemory_5fspace_5fassignment_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_xla_2fservice_2fmemory_5fspace_5fassignment_2fmemory_5fspace_5fassignment_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3021000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3021009 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_xla_2fservice_2fmemory_5fspace_5fassignment_2fmemory_5fspace_5fassignment_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_xla_2fservice_2fmemory_5fspace_5fassignment_2fmemory_5fspace_5fassignment_2eproto {
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_xla_2fservice_2fmemory_5fspace_5fassignment_2fmemory_5fspace_5fassignment_2eproto;
+namespace xla {
+namespace memory_space_assignment {
+class MemoryBoundLoopOptimizerOptions;
+struct MemoryBoundLoopOptimizerOptionsDefaultTypeInternal;
+extern MemoryBoundLoopOptimizerOptionsDefaultTypeInternal _MemoryBoundLoopOptimizerOptions_default_instance_;
+class SlicedPrefetchOptions;
+struct SlicedPrefetchOptionsDefaultTypeInternal;
+extern SlicedPrefetchOptionsDefaultTypeInternal _SlicedPrefetchOptions_default_instance_;
+}  // namespace memory_space_assignment
+}  // namespace xla
+PROTOBUF_NAMESPACE_OPEN
+template<> ::xla::memory_space_assignment::MemoryBoundLoopOptimizerOptions* Arena::CreateMaybeMessage<::xla::memory_space_assignment::MemoryBoundLoopOptimizerOptions>(Arena*);
+template<> ::xla::memory_space_assignment::SlicedPrefetchOptions* Arena::CreateMaybeMessage<::xla::memory_space_assignment::SlicedPrefetchOptions>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace xla {
+namespace memory_space_assignment {
+
+// ===================================================================
+
+class SlicedPrefetchOptions final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.memory_space_assignment.SlicedPrefetchOptions) */ {
+ public:
+  inline SlicedPrefetchOptions() : SlicedPrefetchOptions(nullptr) {}
+  ~SlicedPrefetchOptions() override;
+  explicit PROTOBUF_CONSTEXPR SlicedPrefetchOptions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SlicedPrefetchOptions(const SlicedPrefetchOptions& from);
+  SlicedPrefetchOptions(SlicedPrefetchOptions&& from) noexcept
+    : SlicedPrefetchOptions() {
+    *this = ::std::move(from);
+  }
+
+  inline SlicedPrefetchOptions& operator=(const SlicedPrefetchOptions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SlicedPrefetchOptions& operator=(SlicedPrefetchOptions&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SlicedPrefetchOptions& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SlicedPrefetchOptions* internal_default_instance() {
+    return reinterpret_cast<const SlicedPrefetchOptions*>(
+               &_SlicedPrefetchOptions_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(SlicedPrefetchOptions& a, SlicedPrefetchOptions& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SlicedPrefetchOptions* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SlicedPrefetchOptions* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SlicedPrefetchOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SlicedPrefetchOptions>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SlicedPrefetchOptions& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const SlicedPrefetchOptions& from) {
+    SlicedPrefetchOptions::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SlicedPrefetchOptions* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "xla.memory_space_assignment.SlicedPrefetchOptions";
+  }
+  protected:
+  explicit SlicedPrefetchOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kMinBytesFieldNumber = 2,
+    kMaxSlicesFieldNumber = 1,
+    kFailOnNonAlignmentBoundarySliceProposalFieldNumber = 3,
+  };
+  // uint64 min_bytes = 2;
+  void clear_min_bytes();
+  uint64_t min_bytes() const;
+  void set_min_bytes(uint64_t value);
+  private:
+  uint64_t _internal_min_bytes() const;
+  void _internal_set_min_bytes(uint64_t value);
+  public:
+
+  // uint32 max_slices = 1;
+  void clear_max_slices();
+  uint32_t max_slices() const;
+  void set_max_slices(uint32_t value);
+  private:
+  uint32_t _internal_max_slices() const;
+  void _internal_set_max_slices(uint32_t value);
+  public:
+
+  // bool fail_on_non_alignment_boundary_slice_proposal = 3;
+  void clear_fail_on_non_alignment_boundary_slice_proposal();
+  bool fail_on_non_alignment_boundary_slice_proposal() const;
+  void set_fail_on_non_alignment_boundary_slice_proposal(bool value);
+  private:
+  bool _internal_fail_on_non_alignment_boundary_slice_proposal() const;
+  void _internal_set_fail_on_non_alignment_boundary_slice_proposal(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:xla.memory_space_assignment.SlicedPrefetchOptions)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    uint64_t min_bytes_;
+    uint32_t max_slices_;
+    bool fail_on_non_alignment_boundary_slice_proposal_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_xla_2fservice_2fmemory_5fspace_5fassignment_2fmemory_5fspace_5fassignment_2eproto;
+};
+// -------------------------------------------------------------------
+
+class MemoryBoundLoopOptimizerOptions final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.memory_space_assignment.MemoryBoundLoopOptimizerOptions) */ {
+ public:
+  inline MemoryBoundLoopOptimizerOptions() : MemoryBoundLoopOptimizerOptions(nullptr) {}
+  ~MemoryBoundLoopOptimizerOptions() override;
+  explicit PROTOBUF_CONSTEXPR MemoryBoundLoopOptimizerOptions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  MemoryBoundLoopOptimizerOptions(const MemoryBoundLoopOptimizerOptions& from);
+  MemoryBoundLoopOptimizerOptions(MemoryBoundLoopOptimizerOptions&& from) noexcept
+    : MemoryBoundLoopOptimizerOptions() {
+    *this = ::std::move(from);
+  }
+
+  inline MemoryBoundLoopOptimizerOptions& operator=(const MemoryBoundLoopOptimizerOptions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline MemoryBoundLoopOptimizerOptions& operator=(MemoryBoundLoopOptimizerOptions&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const MemoryBoundLoopOptimizerOptions& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const MemoryBoundLoopOptimizerOptions* internal_default_instance() {
+    return reinterpret_cast<const MemoryBoundLoopOptimizerOptions*>(
+               &_MemoryBoundLoopOptimizerOptions_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(MemoryBoundLoopOptimizerOptions& a, MemoryBoundLoopOptimizerOptions& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(MemoryBoundLoopOptimizerOptions* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(MemoryBoundLoopOptimizerOptions* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  MemoryBoundLoopOptimizerOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<MemoryBoundLoopOptimizerOptions>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const MemoryBoundLoopOptimizerOptions& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const MemoryBoundLoopOptimizerOptions& from) {
+    MemoryBoundLoopOptimizerOptions::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(MemoryBoundLoopOptimizerOptions* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "xla.memory_space_assignment.MemoryBoundLoopOptimizerOptions";
+  }
+  protected:
+  explicit MemoryBoundLoopOptimizerOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDesiredCopyRatioFieldNumber = 2,
+    kEnabledFieldNumber = 1,
+    kAllowUnsatisfiedFullyPipelinedPrefetchFieldNumber = 3,
+  };
+  // optional float desired_copy_ratio = 2;
+  bool has_desired_copy_ratio() const;
+  private:
+  bool _internal_has_desired_copy_ratio() const;
+  public:
+  void clear_desired_copy_ratio();
+  float desired_copy_ratio() const;
+  void set_desired_copy_ratio(float value);
+  private:
+  float _internal_desired_copy_ratio() const;
+  void _internal_set_desired_copy_ratio(float value);
+  public:
+
+  // optional bool enabled = 1;
+  bool has_enabled() const;
+  private:
+  bool _internal_has_enabled() const;
+  public:
+  void clear_enabled();
+  bool enabled() const;
+  void set_enabled(bool value);
+  private:
+  bool _internal_enabled() const;
+  void _internal_set_enabled(bool value);
+  public:
+
+  // optional bool allow_unsatisfied_fully_pipelined_prefetch = 3;
+  bool has_allow_unsatisfied_fully_pipelined_prefetch() const;
+  private:
+  bool _internal_has_allow_unsatisfied_fully_pipelined_prefetch() const;
+  public:
+  void clear_allow_unsatisfied_fully_pipelined_prefetch();
+  bool allow_unsatisfied_fully_pipelined_prefetch() const;
+  void set_allow_unsatisfied_fully_pipelined_prefetch(bool value);
+  private:
+  bool _internal_allow_unsatisfied_fully_pipelined_prefetch() const;
+  void _internal_set_allow_unsatisfied_fully_pipelined_prefetch(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:xla.memory_space_assignment.MemoryBoundLoopOptimizerOptions)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    float desired_copy_ratio_;
+    bool enabled_;
+    bool allow_unsatisfied_fully_pipelined_prefetch_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_xla_2fservice_2fmemory_5fspace_5fassignment_2fmemory_5fspace_5fassignment_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// SlicedPrefetchOptions
+
+// uint32 max_slices = 1;
+inline void SlicedPrefetchOptions::clear_max_slices() {
+  _impl_.max_slices_ = 0u;
+}
+inline uint32_t SlicedPrefetchOptions::_internal_max_slices() const {
+  return _impl_.max_slices_;
+}
+inline uint32_t SlicedPrefetchOptions::max_slices() const {
+  // @@protoc_insertion_point(field_get:xla.memory_space_assignment.SlicedPrefetchOptions.max_slices)
+  return _internal_max_slices();
+}
+inline void SlicedPrefetchOptions::_internal_set_max_slices(uint32_t value) {
+  
+  _impl_.max_slices_ = value;
+}
+inline void SlicedPrefetchOptions::set_max_slices(uint32_t value) {
+  _internal_set_max_slices(value);
+  // @@protoc_insertion_point(field_set:xla.memory_space_assignment.SlicedPrefetchOptions.max_slices)
+}
+
+// uint64 min_bytes = 2;
+inline void SlicedPrefetchOptions::clear_min_bytes() {
+  _impl_.min_bytes_ = uint64_t{0u};
+}
+inline uint64_t SlicedPrefetchOptions::_internal_min_bytes() const {
+  return _impl_.min_bytes_;
+}
+inline uint64_t SlicedPrefetchOptions::min_bytes() const {
+  // @@protoc_insertion_point(field_get:xla.memory_space_assignment.SlicedPrefetchOptions.min_bytes)
+  return _internal_min_bytes();
+}
+inline void SlicedPrefetchOptions::_internal_set_min_bytes(uint64_t value) {
+  
+  _impl_.min_bytes_ = value;
+}
+inline void SlicedPrefetchOptions::set_min_bytes(uint64_t value) {
+  _internal_set_min_bytes(value);
+  // @@protoc_insertion_point(field_set:xla.memory_space_assignment.SlicedPrefetchOptions.min_bytes)
+}
+
+// bool fail_on_non_alignment_boundary_slice_proposal = 3;
+inline void SlicedPrefetchOptions::clear_fail_on_non_alignment_boundary_slice_proposal() {
+  _impl_.fail_on_non_alignment_boundary_slice_proposal_ = false;
+}
+inline bool SlicedPrefetchOptions::_internal_fail_on_non_alignment_boundary_slice_proposal() const {
+  return _impl_.fail_on_non_alignment_boundary_slice_proposal_;
+}
+inline bool SlicedPrefetchOptions::fail_on_non_alignment_boundary_slice_proposal() const {
+  // @@protoc_insertion_point(field_get:xla.memory_space_assignment.SlicedPrefetchOptions.fail_on_non_alignment_boundary_slice_proposal)
+  return _internal_fail_on_non_alignment_boundary_slice_proposal();
+}
+inline void SlicedPrefetchOptions::_internal_set_fail_on_non_alignment_boundary_slice_proposal(bool value) {
+  
+  _impl_.fail_on_non_alignment_boundary_slice_proposal_ = value;
+}
+inline void SlicedPrefetchOptions::set_fail_on_non_alignment_boundary_slice_proposal(bool value) {
+  _internal_set_fail_on_non_alignment_boundary_slice_proposal(value);
+  // @@protoc_insertion_point(field_set:xla.memory_space_assignment.SlicedPrefetchOptions.fail_on_non_alignment_boundary_slice_proposal)
+}
+
+// -------------------------------------------------------------------
+
+// MemoryBoundLoopOptimizerOptions
+
+// optional bool enabled = 1;
+inline bool MemoryBoundLoopOptimizerOptions::_internal_has_enabled() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool MemoryBoundLoopOptimizerOptions::has_enabled() const {
+  return _internal_has_enabled();
+}
+inline void MemoryBoundLoopOptimizerOptions::clear_enabled() {
+  _impl_.enabled_ = false;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline bool MemoryBoundLoopOptimizerOptions::_internal_enabled() const {
+  return _impl_.enabled_;
+}
+inline bool MemoryBoundLoopOptimizerOptions::enabled() const {
+  // @@protoc_insertion_point(field_get:xla.memory_space_assignment.MemoryBoundLoopOptimizerOptions.enabled)
+  return _internal_enabled();
+}
+inline void MemoryBoundLoopOptimizerOptions::_internal_set_enabled(bool value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.enabled_ = value;
+}
+inline void MemoryBoundLoopOptimizerOptions::set_enabled(bool value) {
+  _internal_set_enabled(value);
+  // @@protoc_insertion_point(field_set:xla.memory_space_assignment.MemoryBoundLoopOptimizerOptions.enabled)
+}
+
+// optional float desired_copy_ratio = 2;
+inline bool MemoryBoundLoopOptimizerOptions::_internal_has_desired_copy_ratio() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool MemoryBoundLoopOptimizerOptions::has_desired_copy_ratio() const {
+  return _internal_has_desired_copy_ratio();
+}
+inline void MemoryBoundLoopOptimizerOptions::clear_desired_copy_ratio() {
+  _impl_.desired_copy_ratio_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline float MemoryBoundLoopOptimizerOptions::_internal_desired_copy_ratio() const {
+  return _impl_.desired_copy_ratio_;
+}
+inline float MemoryBoundLoopOptimizerOptions::desired_copy_ratio() const {
+  // @@protoc_insertion_point(field_get:xla.memory_space_assignment.MemoryBoundLoopOptimizerOptions.desired_copy_ratio)
+  return _internal_desired_copy_ratio();
+}
+inline void MemoryBoundLoopOptimizerOptions::_internal_set_desired_copy_ratio(float value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.desired_copy_ratio_ = value;
+}
+inline void MemoryBoundLoopOptimizerOptions::set_desired_copy_ratio(float value) {
+  _internal_set_desired_copy_ratio(value);
+  // @@protoc_insertion_point(field_set:xla.memory_space_assignment.MemoryBoundLoopOptimizerOptions.desired_copy_ratio)
+}
+
+// optional bool allow_unsatisfied_fully_pipelined_prefetch = 3;
+inline bool MemoryBoundLoopOptimizerOptions::_internal_has_allow_unsatisfied_fully_pipelined_prefetch() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool MemoryBoundLoopOptimizerOptions::has_allow_unsatisfied_fully_pipelined_prefetch() const {
+  return _internal_has_allow_unsatisfied_fully_pipelined_prefetch();
+}
+inline void MemoryBoundLoopOptimizerOptions::clear_allow_unsatisfied_fully_pipelined_prefetch() {
+  _impl_.allow_unsatisfied_fully_pipelined_prefetch_ = false;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline bool MemoryBoundLoopOptimizerOptions::_internal_allow_unsatisfied_fully_pipelined_prefetch() const {
+  return _impl_.allow_unsatisfied_fully_pipelined_prefetch_;
+}
+inline bool MemoryBoundLoopOptimizerOptions::allow_unsatisfied_fully_pipelined_prefetch() const {
+  // @@protoc_insertion_point(field_get:xla.memory_space_assignment.MemoryBoundLoopOptimizerOptions.allow_unsatisfied_fully_pipelined_prefetch)
+  return _internal_allow_unsatisfied_fully_pipelined_prefetch();
+}
+inline void MemoryBoundLoopOptimizerOptions::_internal_set_allow_unsatisfied_fully_pipelined_prefetch(bool value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.allow_unsatisfied_fully_pipelined_prefetch_ = value;
+}
+inline void MemoryBoundLoopOptimizerOptions::set_allow_unsatisfied_fully_pipelined_prefetch(bool value) {
+  _internal_set_allow_unsatisfied_fully_pipelined_prefetch(value);
+  // @@protoc_insertion_point(field_set:xla.memory_space_assignment.MemoryBoundLoopOptimizerOptions.allow_unsatisfied_fully_pipelined_prefetch)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace memory_space_assignment
+}  // namespace xla
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_xla_2fservice_2fmemory_5fspace_5fassignment_2fmemory_5fspace_5fassignment_2eproto
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/memory_space_assignment/repacking.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/memory_space_assignment/repacking.h
new file mode 100644
index 0000000000000000000000000000000000000000..0379fc794832303147b4532219711141f4b1a603
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/memory_space_assignment/repacking.h
@@ -0,0 +1,165 @@
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_MEMORY_SPACE_ASSIGNMENT_REPACKING_H_
+#define XLA_SERVICE_MEMORY_SPACE_ASSIGNMENT_REPACKING_H_
+
+#include <cstdint>
+#include <optional>
+#include <string>
+#include <tuple>
+#include <vector>
+
+#include "absl/algorithm/container.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_join.h"
+#include "absl/types/span.h"
+#include "xla/statusor.h"
+#include "xla/types.h"
+
+namespace xla {
+namespace memory_space_assignment {
+
+// An interface to define allocation repacking algorithms.
+class MemorySpaceAssignmentRepacker {
+ public:
+  MemorySpaceAssignmentRepacker(int64_t max_size, int64_t alignment)
+      : max_size_(max_size), alignment_(alignment) {}
+  virtual ~MemorySpaceAssignmentRepacker() = default;
+
+  // Data about a slice in a sliced allocation.
+  struct Slice {
+    int64_t size;
+    int64_t offset;
+    int64_t start_time;
+
+    std::string ToString() const {
+      return absl::StrCat("{ size: ", size, ", offset: ", offset,
+                          ", start_time: ", start_time, " }");
+    }
+
+    std::tuple<int64_t, int64_t, int64_t> ToTuple() const {
+      return std::make_tuple(size, offset, start_time);
+    }
+
+    bool operator==(const Slice& rhs) const {
+      return ToTuple() == rhs.ToTuple();
+    }
+  };
+
+  // Slice data about a sliced allocation.
+  struct SlicedAllocationData {
+    std::vector<Slice> slices_sorted_by_offset;
+
+    std::vector<int64_t> SizesSortedByOffset() const {
+      std::vector<int64_t> sizes_sorted_by_offset;
+      sizes_sorted_by_offset.reserve(slices_sorted_by_offset.size());
+      absl::c_for_each(slices_sorted_by_offset,
+                       [&sizes_sorted_by_offset](const Slice& slice) {
+                         sizes_sorted_by_offset.push_back(slice.size);
+                       });
+      return sizes_sorted_by_offset;
+    }
+
+    std::vector<int64_t> SortedStartTimes() const {
+      std::vector<int64_t> sorted_start_times;
+      sorted_start_times.reserve(slices_sorted_by_offset.size());
+      absl::c_for_each(slices_sorted_by_offset,
+                       [&sorted_start_times](const Slice& slice) {
+                         sorted_start_times.push_back(slice.start_time);
+                       });
+      absl::c_sort(sorted_start_times);
+      return sorted_start_times;
+    }
+
+    std::string ToString() const {
+      return absl::StrCat(
+          "{ slices_sorted_by_offset: [ ",
+          absl::StrJoin(slices_sorted_by_offset, ", ",
+                        [](std::string* out, const Slice& slice) {
+                          absl::StrAppend(out, slice.ToString());
+                        }),
+          " ] }");
+    }
+
+    bool operator==(const SlicedAllocationData& rhs) const {
+      return slices_sorted_by_offset == rhs.slices_sorted_by_offset;
+    }
+  };
+
+  // A contiguous block of allocation consisting of start and end (logical)
+  // times, size, and the initial offset. After repacking, if the repacking was
+  // successful and the allocations were modified, the offset field holds the
+  // new offset. To support aliased allocations, AllocationBlock also includes a
+  // vector of AllocationBlock pointers, called colocations. All AllocationBlock
+  // objects within the colocations must get the same offset. The id should be
+  // unique and is used to ensure determinism for comparison tie-breaker.
+  //
+  // Each AllocationBlock can be treated as an allocation that requires size
+  // space from start_time to end_time. However, some allocations are really
+  // composed of slices. In such cases, the repacker can utilize
+  // the information in the original_slice_data field to achieve an even more
+  // efficient repacking.
+  struct AllocationBlock {
+    int64_t start_time;
+    int64_t end_time;
+    int64_t size;
+    int64_t offset;
+    int64_t initial_offset;
+    int64_t id;
+    std::vector<AllocationBlock*> colocations;
+
+    // Optional data structures that are used to improve repacking, when an
+    // allocation is sliced, e.g., from a sliced prefetch.
+    std::optional<SlicedAllocationData> original_slice_data;
+    std::optional<SlicedAllocationData> repacked_slice_data;
+
+    std::string ToString() const {
+      std::string original_slicing_str;
+      if (original_slice_data.has_value()) {
+        original_slicing_str = absl::StrCat("; original_slice_data: ",
+                                            original_slice_data->ToString());
+      }
+      std::string repacked_slicing_str;
+      if (repacked_slice_data.has_value()) {
+        repacked_slicing_str = absl::StrCat("; repacked_slice_data: ",
+                                            repacked_slice_data->ToString());
+      }
+      return absl::StrCat("[", start_time, ", ", end_time, "]; size: ", size,
+                          "; offset: ", offset,
+                          "; initial offset: ", initial_offset,
+                          "; # colocations: ", colocations.size(),
+                          original_slicing_str, repacked_slicing_str);
+    }
+
+    // This is required by BufferIntervalCompare as a tie breaker. Use a unique
+    // and deterministic id.
+    bool operator<(const AllocationBlock& other) const { return id < other.id; }
+  };
+
+  // Repack the AllocationBlocks provided in the parameter. Returns true if
+  // allocations have been modified and false if not. Returns a non-ok status if
+  // there was an error.
+  virtual StatusOr<bool> Repack(absl::Span<AllocationBlock*> allocations) = 0;
+
+ protected:
+  int64_t max_size_;
+  int64_t alignment_;
+};
+
+}  // namespace memory_space_assignment
+}  // namespace xla
+
+#endif  // XLA_SERVICE_MEMORY_SPACE_ASSIGNMENT_REPACKING_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/memory_space_assignment/tuning_utils.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/memory_space_assignment/tuning_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..749b4445e4be9afbd187115e3ee16711e4155b39
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/memory_space_assignment/tuning_utils.h
@@ -0,0 +1,38 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_MEMORY_SPACE_ASSIGNMENT_TUNING_UTILS_H_
+#define XLA_SERVICE_MEMORY_SPACE_ASSIGNMENT_TUNING_UTILS_H_
+
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/service/heap_simulator.h"
+
+namespace xla {
+
+namespace memory_space_assignment {
+
+using BufferInterval =
+    GlobalDecreasingSizeBestFitHeap<HloValue>::BufferInterval;
+
+// This function converts sorted_buffer_intervals to order-customized buffer
+// intervals respecting a given memory space assignment autotuning config.
+void CustomizeSortedBufferInterval(
+    std::optional<std::vector<uint64_t>> memory_space_assignment_config,
+    std::vector<BufferInterval>& sorted_buffer_intervals);
+
+}  // namespace memory_space_assignment
+}  // namespace xla
+
+#endif  // XLA_SERVICE_MEMORY_SPACE_ASSIGNMENT_TUNING_UTILS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/memory_space_assignment/utils.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/memory_space_assignment/utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..c2d76208a28e188c222031fd2e15031aaef9f392
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/memory_space_assignment/utils.h
@@ -0,0 +1,40 @@
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_MEMORY_SPACE_ASSIGNMENT_UTILS_H_
+#define XLA_SERVICE_MEMORY_SPACE_ASSIGNMENT_UTILS_H_
+
+#include "xla/service/heap_simulator.h"
+
+namespace xla {
+namespace memory_space_assignment {
+
+// Encapsulates common utility methods for memory space assignment.
+class MemorySpaceAssignmentUtils {
+ public:
+  // Returns true if this buffer is allowed to be placed in the alternate
+  // memory.
+  static bool IsIntervalAllowedInAlternateMemory(
+      const GlobalDecreasingSizeBestFitHeap<HloValue>::BufferInterval&
+          interval);
+
+  // Returns true if the HloValue is allowed to be placed in alternate memory.
+  static bool IsValueAllowedInAlternateMemory(const HloValue* value);
+};
+
+}  // namespace memory_space_assignment
+}  // namespace xla
+
+#endif  // XLA_SERVICE_MEMORY_SPACE_ASSIGNMENT_UTILS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/spmd/collective_permute_motion.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/spmd/collective_permute_motion.h
new file mode 100644
index 0000000000000000000000000000000000000000..8b35b90b90a257d0017381a0d802fe44900b7cc9
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/spmd/collective_permute_motion.h
@@ -0,0 +1,41 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_SPMD_COLLECTIVE_PERMUTE_MOTION_H_
+#define XLA_SERVICE_SPMD_COLLECTIVE_PERMUTE_MOTION_H_
+
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/service/hlo_pass_interface.h"
+
+namespace xla {
+
+// This pass moves collective permutes at the end of a loop to the beginning,
+// which makes overlapping possible for megascale decomposed ops.
+class CollectivePermuteMotion : public HloModulePass {
+ public:
+  CollectivePermuteMotion() = default;
+  absl::string_view name() const override {
+    return "collective-permute-motion";
+  }
+
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+};
+
+}  // namespace xla
+
+#endif  // XLA_SERVICE_SPMD_COLLECTIVE_PERMUTE_MOTION_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/spmd/convolution_handler.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/spmd/convolution_handler.h
new file mode 100644
index 0000000000000000000000000000000000000000..617dbb8aeac6c03552417e78672970a95bade0a6
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/spmd/convolution_handler.h
@@ -0,0 +1,43 @@
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_SPMD_CONVOLUTION_HANDLER_H_
+#define XLA_SERVICE_SPMD_CONVOLUTION_HANDLER_H_
+
+#include "xla/hlo/ir/hlo_computation.h"
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/hlo/ir/hlo_sharding.h"
+#include "xla/service/dot_as_convolution_util.h"
+#include "xla/service/spmd/spmd_partitioner.h"
+
+namespace xla {
+namespace spmd {
+
+// Partition convolution.
+StatusOr<HloInstruction*> PartitionConvolution(
+    PartitionedHlo lhs, PartitionedHlo rhs, const Shape& output_base_shape,
+    const HloSharding& output_sharding, const DotConvDimsMapping& dims_mapping,
+    absl::FunctionRef<StatusOr<HloInstruction*>(HloInstruction*,
+                                                HloInstruction*, SpmdBuilder*,
+                                                const Window& conv_window)>
+        create_sharded_conv,
+    const Window& conv_window, HloInstruction* original_hlo,
+    int64_t num_partitions, const SpmdPartitionerOptions& options,
+    HloInstruction* partition_id, HloModule* module, SpmdBuilder* b);
+
+}  // namespace spmd
+}  // namespace xla
+
+#endif  // XLA_SERVICE_SPMD_CONVOLUTION_HANDLER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/spmd/custom_call_handler.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/spmd/custom_call_handler.h
new file mode 100644
index 0000000000000000000000000000000000000000..93c777626301c1bcc003b696d9387ca351615476
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/spmd/custom_call_handler.h
@@ -0,0 +1,35 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_SPMD_CUSTOM_CALL_HANDLER_H_
+#define XLA_SERVICE_SPMD_CUSTOM_CALL_HANDLER_H_
+
+#include <memory>
+
+#include "xla/hlo/ir/hlo_instruction.h"
+
+namespace xla {
+namespace spmd {
+
+// Creators of custom ops defined by the partitioner itself.
+
+// Creates a custom op that rotates data along `dim` with the given amount.
+std::unique_ptr<HloInstruction> CreateCustomCallSPMDInternal_RotateRight(
+    HloInstruction* input, int64_t dim, int64_t amount);
+
+}  // namespace spmd
+}  // namespace xla
+
+#endif  // XLA_SERVICE_SPMD_CUSTOM_CALL_HANDLER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/spmd/spmd_partitioner.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/spmd/spmd_partitioner.h
new file mode 100644
index 0000000000000000000000000000000000000000..26d7a5e6b43cbf33ed79abacd5c86af737dd9f1c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/spmd/spmd_partitioner.h
@@ -0,0 +1,670 @@
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_SPMD_SPMD_PARTITIONER_H_
+#define XLA_SERVICE_SPMD_SPMD_PARTITIONER_H_
+
+#include <functional>
+#include <memory>
+#include <optional>
+#include <string>
+#include <tuple>
+#include <vector>
+
+#include "absl/container/flat_hash_map.h"
+#include "absl/container/flat_hash_set.h"
+#include "absl/container/node_hash_map.h"
+#include "absl/functional/function_ref.h"
+#include "absl/strings/string_view.h"
+#include "xla/hlo/ir/dfs_hlo_visitor_with_default.h"
+#include "xla/hlo/ir/hlo_computation.h"
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/hlo/ir/hlo_opcode.h"
+#include "xla/hlo/ir/hlo_sharding.h"
+#include "xla/service/call_graph.h"
+#include "xla/service/custom_call_sharding_helper.h"
+#include "xla/service/hlo_pass_interface.h"
+#include "xla/xla_data.pb.h"
+
+namespace xla {
+namespace spmd {
+
+struct SpmdPartitionerOptions {
+  // Always exchange halo on LHS for all convolutions. If false, backprop filter
+  // convolution exchanges halo on RHS.
+  bool conv_halo_exchange_always_on_lhs = true;
+
+  // The number of instructions to be reported for the highest memory profile
+  // instructions.
+  int64_t report_instruction_count = 5;
+
+  // The minimum size in MiB of an einsum operand to be considered using
+  // windowed implementation in an HLO loop.
+  int64_t threshold_for_windowed_einsum_mib = 256;
+
+  // Whether unroll windowed einsum loop by degree of two.
+  bool unroll_windowed_einsum = false;
+
+  // Whether doing bidirectional collective permute in windowed einsum loop.
+  bool bidirectional_windowed_einsum = false;
+
+  // Whether the entry computations' signature could change after partitioning.
+  bool allow_module_signature_change = false;
+
+  // Whether to use cached all-gather to avoid repeatedly replicate a tiled
+  // tensor. If it is set to false, the result tends to be more
+  // memory-efficient, and the compiler can use the ScheduleAwareAllGatherCSE
+  // pass to CSE some all-gathers which are relatively close to each other.
+  bool cache_all_gather = true;
+
+  // When making a compromise between windowed einsum speed and memory usage
+  // prefer the former if true.
+  bool choose_faster_windowed_einsum_over_mem = false;
+
+  // Whether doing bidirectional communication when decomposing independent
+  // all-gathers.
+  bool bidirectional_decomposed_all_gather = false;
+
+  // Whether to skip checking the numbers and shardings of windowed einsum's
+  // users.
+  bool skip_checking_windowed_einsum_users = false;
+};
+
+// Class to wrap the computation builder to capture information during SPMD
+// transformation.
+class SpmdBuilder : public HloComputation::Builder {
+ public:
+  SpmdBuilder(const std::string& name, HloInstruction* hlo)
+      : HloComputation::Builder(name) {
+    visiting_hlo_ = hlo;
+  }
+
+  HloInstruction* AddInstruction(
+      std::unique_ptr<HloInstruction> instruction) override;
+
+  const std::vector<HloInstruction*>& derived_instructions(
+      HloInstruction* hlo) {
+    return instructions_.at(hlo);
+  }
+
+  void set_visiting_hlo(HloInstruction* hlo) {
+    visiting_hlo_ = hlo;
+    instructions_[hlo];
+  }
+
+  HloInstruction* visiting_hlo() const { return visiting_hlo_; }
+
+  // Wrapper of queries to broadcast_dims_.
+  std::optional<const absl::flat_hash_set<int64_t>*> BroadcastDimsForCreatedHlo(
+      const HloInstruction* hlo) {
+    auto it = broadcast_dims_.find(hlo);
+    if (it == broadcast_dims_.end()) {
+      return std::nullopt;
+    }
+    return &it->second;
+  }
+
+ private:
+  // Currently visiting instruction.
+  HloInstruction* visiting_hlo_;
+
+  // Map from the currently visiting (old) instruction to new instructions
+  // created during SPMD partitioning.
+  HloInstructionMap<std::vector<HloInstruction*>> instructions_;
+
+  // Maps from each created instruction to a set of dimensions that are from
+  // broadcasts or elementwise ops over broadcasts. This means elements along
+  // these dimensions have the same value.
+  absl::flat_hash_map<const HloInstruction*, absl::flat_hash_set<int64_t>>
+      broadcast_dims_;
+};
+
+// A set of functions that create the cross-partition collective ops.
+struct SPMDCollectiveOpsCreator {
+  // Function used to create a partition ID HLO.
+  std::function<HloInstruction*(SpmdBuilder*)> create_partition_id;
+
+  // Function used to create a cross-partition all-reduce HLO.
+  std::function<HloInstruction*(
+      SpmdBuilder*, HloInstruction* operand, HloComputation* reduction,
+      const std::vector<std::vector<int64_t>>& partition_subgroups,
+      int64_t channel_id)>
+      create_cross_partition_all_reduce;
+
+  // Function used to create a cross-partition collective-permute HLO.
+  std::function<HloInstruction*(
+      SpmdBuilder*, HloInstruction* operand,
+      std::vector<std::pair<int64_t, int64_t>>& src_dst_pairs,
+      int64_t next_channel_id)>
+      create_cross_partition_collective_permute;
+
+  // Function used to create a cross-partition all-to-all HLO.
+  std::function<HloInstruction*(
+      SpmdBuilder*, absl::Span<HloInstruction* const> operands,
+      const std::vector<std::vector<int64_t>>& partition_subgroups,
+      int64_t channel_id, std::optional<int64_t> split_dimension)>
+      create_cross_partition_all_to_all;
+
+  // Function used to create a cross-partition all-gather HLO. This is optional:
+  // if it is nullptr, the partitioner will use all-reduce instead.
+  std::function<HloInstruction*(
+      SpmdBuilder*, HloInstruction* operand, const Shape& ag_shape,
+      const std::vector<std::vector<int64_t>>& partition_subgroups,
+      int64_t channel_id, int64_t all_gather_dimension)>
+      create_cross_partition_all_gather;
+};
+
+// Create a default SPMDCollectiveOpsCreator.
+SPMDCollectiveOpsCreator GetDefaultCollectiveOpsCreator(int64_t num_partitions,
+                                                        int64_t num_replicas);
+
+// Logger to report memory usage during SPMD partitioning.
+class SpmdLogger {
+ public:
+  SpmdLogger(int64_t report_instruction_count, bool disabled)
+      : report_instruction_count_(report_instruction_count),
+        disabled_(disabled) {}
+  static std::string ReportBeforePartition(const HloModule& module,
+                                           int64_t report_instruction_count);
+  static std::string ReportAfterPartition(const HloModule& module,
+                                          int64_t report_instruction_count);
+
+  // Registers the logging for the groups of instructions created to transform
+  // the given hlo.
+  void RegisterLogEntry(HloInstruction* hlo,
+                        const std::vector<HloInstruction*>& group);
+
+  std::string MakeReport();
+
+ private:
+  template <typename F>
+  static std::string ReportMemoryUsage(const HloModule& module, const F& filter,
+                                       int64_t report_instruction_count);
+
+  // A vector of logging messages (one for each original HLO instruction), where
+  // the first integer of the pair represents the size of the HBM used.
+  std::vector<std::pair<int64_t, std::string>> entries_;
+
+  int64_t report_instruction_count_;
+
+  // Note that we allow creating a *disabled* logger when logging is not
+  // enabled, in which case it is supposed to avoid doing any potentially
+  // expensive work. The logger is still created in this case and passed to the
+  // users to help avoid changing current call sites.
+  const bool disabled_;
+};
+
+class SpmdPartitioningVisitor;
+
+class SpmdPartitioner : public HloModulePass {
+ public:
+  SpmdPartitioner(int64_t num_partitions, int64_t num_replicas,
+                  SpmdPartitionerOptions options);
+  SpmdPartitioner(int64_t num_partitions, int64_t num_replicas,
+                  SpmdPartitionerOptions options,
+                  SPMDCollectiveOpsCreator collective_ops_creator)
+      : num_partitions_(num_partitions),
+        num_replicas_(num_replicas),
+        options_(std::move(options)),
+        collective_ops_creator_(std::move(collective_ops_creator)) {}
+  absl::string_view name() const override { return "spmd-partitioning"; }
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+
+  // Transforms the given computation with SPMD instructions, replacing it with
+  // a new computation.
+  StatusOr<bool> PartitionComputation(HloComputation* computation,
+                                      const HloSharding& root_sharding,
+                                      int64_t* next_channel_id,
+                                      SpmdLogger* logger,
+                                      const CallGraph& call_graph);
+
+  // Creates all-gather(s) based on HloSharding. Can be overridden to customize.
+  // The default uses a single all-gather even if there are multiple sharded
+  // dimensions, and adds potential reshapes and transposes to achieve that.
+  // If it returns false, the partitioner will fall back to all-reduce.
+  // `selected_dims` specifies the dimensions along which the all-gather happens
+  // in the tiled sharding, which allows potentially creating a subgroup
+  // all-gather.
+  virtual HloInstruction* AllGatherShards(
+      SpmdBuilder* b, HloInstruction* operand, const HloSharding& sharding,
+      int64_t* next_channel_id, absl::Span<const int64_t> selected_dims,
+      const SPMDCollectiveOpsCreator& collectives_creator);
+
+  // Creates all-reduce(s) across devices along selected_dims in sharding. Can
+  // be overridden to customize.
+  virtual HloInstruction* AllReduceAlongShardingDims(
+      SpmdBuilder* b, HloInstruction* operand, const HloSharding& sharding,
+      int64_t* next_channel_id, absl::Span<const int64_t> selected_dims,
+      const SPMDCollectiveOpsCreator& collectives_creator,
+      HloComputation* reduction);
+
+  const SpmdPartitionerOptions& options() { return options_; }
+
+ protected:
+  virtual std::unique_ptr<SpmdPartitioningVisitor> CreateVisitor(
+      HloComputation* computation, int64_t num_partitions, int64_t num_replicas,
+      const SPMDCollectiveOpsCreator& collective_ops_creator,
+      int64_t* next_channel_id, SpmdLogger* logger,
+      SpmdPartitionerOptions options, const CallGraph& call_graph);
+
+  // This is the internal implementation for AllGatherShards(), returns a pair
+  // of hlo instructions whose first element is the result of the all-gather
+  // shard(which might not be the all-gather itself and it could go through
+  // some other formatting instructions), and the second element is the
+  // all-gather being generated or nullptr is no all-gather is generated.
+  std::pair<HloInstruction*, HloInstruction*> AllGatherShardsInternal(
+      SpmdBuilder* b, HloInstruction* operand, const HloSharding& sharding,
+      int64_t* next_channel_id, absl::Span<const int64_t> selected_dims,
+      const SPMDCollectiveOpsCreator& collectives_creator, bool per_dim_ag);
+
+  HloInstruction* AllReduceAlongShardingDimsInternal(
+      SpmdBuilder* b, HloInstruction* operand, const HloSharding& sharding,
+      int64_t* next_channel_id, absl::Span<const int64_t> selected_dims,
+      const SPMDCollectiveOpsCreator& collectives_creator,
+      HloComputation* reduction, bool per_dim_ar);
+
+  // Verifies that the sharding of instructions in the module are valid, and
+  // also fill in missing sharding information.
+  virtual Status PreprocessSharding(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads);
+
+  // Returns if the given side-effecting instruction is allowed to have
+  // replicated sharding.
+  virtual bool CanSideEffectingHaveReplicatedSharding(
+      const HloInstruction* hlo) {
+    if (hlo->opcode() == HloOpcode::kCustomCall) {
+      if (auto* partitioner =
+              GetCustomCallPartitioner(hlo->custom_call_target())) {
+        return partitioner->CanSideEffectingHaveReplicatedSharding();
+      }
+    }
+    return hlo->opcode() == HloOpcode::kInfeed ||
+           hlo->opcode() == HloOpcode::kOutfeed;
+  }
+
+  // Preprocesses the graph to simplify some communication patterns. E.g., merge
+  // pad->slice into a single pad with potentially negative padding to avoid
+  // multiple halo exchanges.
+  Status PreprocessHlos(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads);
+
+  const int64_t num_partitions_;
+  const int64_t num_replicas_;
+
+  SpmdPartitionerOptions options_;
+  SPMDCollectiveOpsCreator collective_ops_creator_;
+  std::vector<std::vector<int64_t>> device_groups_;
+};
+
+// Class describes partition state of the data represented by an HLO created
+// during SPMD partitioning pass.
+//
+// Data on some devices may include padding region, if the base (full) shape
+// could not be evenly partitioned.
+class PartitionedHlo {
+ public:
+  // Return value for ReshardAsWindowedInput which describes the resharded HLO,
+  // the window for the user on the shard, and if necessary, the dynamic slice
+  // offsets to be applied to the output of the op being sharded.
+  struct WindowedInputShardReturnValue {
+    HloInstruction* sharded_input;
+    Window shard_window;
+    std::optional<std::vector<HloInstruction*>> dynamic_slice_index_on_output;
+  };
+  // A cache for resharding each partitioned HLO.
+  struct ReshardCache {
+    struct PerHloCache {
+      absl::flat_hash_map<HloSharding, PartitionedHlo> reshard_cache;
+      std::vector<
+          std::tuple<HloSharding, Window, WindowedInputShardReturnValue>>
+          window_reshard_cache;
+    };
+    // Use absl::node_hash_map for pointer stability.
+    absl::node_hash_map<HloInstruction*, PerHloCache> per_hlo_cache;
+    // Caches for nested partitioning of grouped sharding. Each string key
+    // represents a unique way of grouping devices.
+    absl::flat_hash_map<std::string, std::unique_ptr<ReshardCache>>
+        groupd_caches;
+  };
+  struct PartitioningState {
+    SpmdBuilder* b;
+    HloModule* module;
+    int64_t num_replicas;
+    HloInstruction* partition_id;
+    SPMDCollectiveOpsCreator collective_ops_creator;
+    int64_t* next_channel_id;
+    ReshardCache* reshard_cache;
+    SpmdPartitioner* partitioner;
+  };
+  PartitionedHlo(HloInstruction* hlo, Shape base_shape, PartitioningState state)
+      : hlo_(hlo), base_shape_(base_shape), state_(std::move(state)) {
+    CHECK(hlo->has_sharding())
+        << "PartitionedHlo is missing sharding:" << hlo->ToString();
+  }
+
+  PartitionedHlo CloneWithNewHlo(HloInstruction* hlo) const {
+    PartitionedHlo new_phlo = *this;
+    new_phlo.hlo_ = hlo;
+    if (!hlo->has_sharding() && hlo_->has_sharding()) {
+      hlo->copy_sharding(hlo_);
+    }
+    return new_phlo;
+  }
+
+  // Reshards the current SPMD instruction to a new sharding with optional
+  // specified pad value used during resharding. Could only modify the reshard
+  // cache.
+  PartitionedHlo Reshard(const HloSharding& target,
+                         std::optional<Literal> pad_value = std::nullopt);
+
+  // Pads the garbage area of the output with the provided value. Normally,
+  // unevenly partitioned dimensions are padded on the right, but this function
+  // allows specifying left-padded dimensions, which can be used during the
+  // handling of kReverse, etc.
+  PartitionedHlo PadWithValue(
+      HloInstruction* pad_value,
+      absl::Span<const int64_t> left_padded_dims = {},
+      absl::Span<const int64_t> skipped_dims = {}) const;
+
+  // Same as PadWithValue but does not create a new PartitionedHlo.
+  HloInstruction* PadWithValueHlo(
+      HloInstruction* pad_value,
+      absl::Span<const int64_t> left_padded_dims = {},
+      absl::Span<const int64_t> skipped_dims = {}) const;
+
+  PartitionedHlo PadWithZero(absl::Span<const int64_t> left_padded_dims = {},
+                             absl::Span<const int64_t> skipped_dims = {}) const;
+
+  // Returns the SPMD instruction.
+  HloInstruction* hlo() const { return hlo_; }
+
+  // Returns the sharding of the SPMD instruction.
+  const HloSharding& sharding() const { return hlo_->sharding(); }
+
+  // Returns the rank of the SPMD instruction.
+  const int64_t rank() const { return base_shape_.rank(); }
+
+  // Original full shape of the data.
+  const Shape& base_shape() const { return base_shape_; }
+
+  int64_t NewChannel() const { return (*state_.next_channel_id)++; }
+
+  // Reshards the HLO to a usable partitioned input for a windowed user. Could
+  // only modify the reshard cache.
+  std::optional<WindowedInputShardReturnValue> ReshardAsWindowedInput(
+      const Window& window, const HloSharding& target,
+      HloInstruction* pad_value, bool mask_invalid_region = true,
+      bool force_mask_in_compact = false);
+
+  const PartitioningState& state() const { return state_; }
+
+  // Helper function to replicate the data on all devices. Could only modify
+  // the reshard cache.
+  PartitionedHlo Replicate();
+
+  // Helper function to replicate the data for partitions along the given dims.
+  HloInstruction* ReplicatePartial(absl::Span<const int64_t> dims);
+
+  // Set state of the partitoned HLO.
+  void set_state(PartitioningState state) { state_ = std::move(state); }
+
+ private:
+  // Same as Reshard except that it does not explicitly modify the reshard
+  // cache, although it would indirectly modify by calling Replicate().
+  PartitionedHlo ReshardNoCache(const HloSharding& target,
+                                std::optional<Literal> pad_value = std::nullopt,
+                                bool allow_full_replication = true);
+
+  // Helper function to broadcast data from a single device to all devices.
+  PartitionedHlo Broadcast() const;
+
+  // Try to perform complicated reshard handling by splitting a big reshard into
+  // multiple reshards using that can be handled directly.
+  std::optional<PartitionedHlo> TryComplexReshardHandling(
+      const HloSharding& target);
+
+  // Helper function to reshard the tensor using AllToAll (instead of the
+  // default of Replicate followed by Slice).
+  PartitionedHlo ReshardWithAllToAll(
+      const HloSharding& target,
+      absl::Span<const std::pair<int64_t, int64_t>> source_target_dims) const;
+
+  // Helper function to reshard the tensor using CollectivePermute.
+  PartitionedHlo ReshardWithCollectivePermute(const HloSharding& target) const;
+
+  // Helper function to reshard to partial replicate using AllGather.
+  std::optional<PartitionedHlo> ReshardToPartialReplicateWithAllGather(
+      const HloSharding& target);
+
+  // Helper function to reshard from partial replicate using DynamicSlice.
+  std::optional<PartitionedHlo> ReshardFromPartialReplicateWithDynamicSlice(
+      const HloSharding& target);
+
+  // Helper function to reshard from partial replicate using AllToAll.
+  std::optional<PartitionedHlo> ReshardPartialReplicateWithAllToAll(
+      const HloSharding& target);
+
+  // SPMD instruction.
+  HloInstruction* hlo_;
+
+  // The original shape of the data before SPMD transformation is applied.
+  Shape base_shape_;
+
+  PartitioningState state_;
+};
+
+struct DotConvDimsMapping {
+  // The dimension numbers for the operands and output corresponding to a
+  // logical dimension (e.g., batch, contracting, non-contracting). If an
+  // operand or the output doesn't have the logical dimension, it is set to
+  // -1.
+  struct DimsMapping {
+    int64_t lhs;
+    int64_t rhs;
+    int64_t output;
+    // input mapped to index in input_spatial_dimensions().
+    int64_t spatial;
+  };
+  std::vector<DimsMapping> batch_dims;
+  std::vector<DimsMapping> contracting_dims;
+  std::vector<DimsMapping> lhs_non_contracting_dims;
+  std::vector<DimsMapping> rhs_non_contracting_dims;
+  std::vector<DimsMapping> conv_spatial_dims;
+};
+
+class SpmdPartitioningVisitor : public DfsHloVisitorWithDefault {
+ public:
+  SpmdPartitioningVisitor(
+      HloComputation* computation, int64_t num_partitions, int64_t num_replicas,
+      const SPMDCollectiveOpsCreator& collective_ops_creator,
+      int64_t* next_channel_id, SpmdLogger* logger,
+      SpmdPartitionerOptions options, SpmdPartitioner* partitioner,
+      const CallGraph& call_graph);
+
+  Status DefaultAction(HloInstruction* hlo) override;
+  Status HandleAllReduce(HloInstruction* hlo) override;
+  Status HandleBroadcast(HloInstruction* hlo) override;
+  Status HandleConstant(HloInstruction* hlo) override;
+  Status HandleCustomCall(HloInstruction* hlo) override;
+  Status HandleDot(HloInstruction* hlo) override;
+  Status HandleDynamicSlice(HloInstruction* hlo) override;
+  Status HandleDynamicUpdateSlice(HloInstruction* hlo) override;
+  Status HandleFft(HloInstruction* hlo) override;
+  Status HandleGather(HloInstruction* hlo) override;
+  Status HandleGetTupleElement(HloInstruction* hlo) override;
+  Status HandleInfeed(HloInstruction* hlo) override;
+  Status HandleOptimizationBarrier(HloInstruction* hlo) override;
+  Status HandleOutfeed(HloInstruction* hlo) override;
+  Status HandlePad(HloInstruction* hlo) override;
+  Status HandleParameter(HloInstruction* hlo) override;
+  Status HandleReduce(HloInstruction* hlo) override;
+  Status HandleReverse(HloInstruction* hlo) override;
+  Status HandleWhile(HloInstruction* hlo) override;
+  Status HandleConditional(HloInstruction* hlo) override;
+  Status HandleReduceWindow(HloInstruction* hlo) override;
+  Status HandleSelectAndScatter(HloInstruction* hlo) override;
+  Status HandleTuple(HloInstruction* hlo) override;
+  Status HandleRng(HloInstruction* hlo) override;
+  Status HandleConvolution(HloInstruction* hlo) override;
+  Status HandleConcatenate(HloInstruction* hlo) override;
+  Status HandleScatter(HloInstruction* hlo) override;
+  Status HandleSlice(HloInstruction* hlo) override;
+  Status HandleSort(HloInstruction* hlo) override;
+  Status HandleTranspose(HloInstruction* hlo) override;
+  Status HandleReshape(HloInstruction* hlo) override;
+  Status HandleIota(HloInstruction* hlo) override;
+  Status HandlePartitionId(HloInstruction* hlo) override;
+
+  // Implementation of dot partitioning given DotGeneralDimsMapping.
+  Status HandleDotHelper(HloInstruction* hlo,
+                         const DotConvDimsMapping& dims_mapping,
+                         absl::FunctionRef<StatusOr<HloInstruction*>(
+                             HloInstruction*, HloInstruction*, SpmdBuilder*,
+                             const Window& conv_window)>
+                             create_sharded_dot);
+
+  // Common handle for elementwise HLOs.
+  Status HandleElementwise(HloInstruction* hlo);
+
+  // Common handle for HLOs that runs on a single device.
+  Status HandleSingleDevice(const HloInstruction* hlo);
+
+  // CustomCall handlers per call target.
+  Status HandleCustomCallTopK(HloInstruction* hlo);
+  // Convenient custom ops defined by the partitioner itself.
+  Status HandleCustomCallSPMDInternal_RotateRight(HloInstruction* hlo);
+
+  // Returns the PartitionedHlo that corresponds to the original hlo.
+  PartitionedHlo& GetPartitionedHlo(const HloInstruction* hlo) {
+    CHECK_EQ(partitioned_instructions_.count(hlo), 1);
+    return partitioned_instructions_.find(hlo)->second;
+  }
+
+  // Sets the PartitionedHlo for the original hlo.
+  void SetPartitionedHlo(const HloInstruction* hlo,
+                         const PartitionedHlo& partitioned_hlo) {
+    CHECK_EQ(partitioned_instructions_.count(hlo), 0);
+    partitioned_instructions_.emplace(hlo, partitioned_hlo);
+    changed_ = true;
+  }
+
+  // Convenient wrapper that creates PartitionedHlo from the result of the func
+  // and maps it to the given original hlo.
+  void SetPartitionedHlo(const HloInstruction* hlo,
+                         absl::FunctionRef<HloInstruction*()> func) {
+    HloInstruction* new_hlo = func();
+    new_hlo->set_sharding(hlo->sharding());
+    SetPartitionedHlo(
+        hlo, PartitionedHlo(new_hlo, hlo->shape(), MakePartitioningState()));
+    changed_ = true;
+  }
+
+  int64_t NewChannel() { return (*next_channel_id_)++; }
+
+  PartitionedHlo::PartitioningState MakePartitioningState();
+
+  SpmdBuilder* builder() { return &b_; }
+
+  virtual StatusOr<bool> DoPartition(HloComputation* computation,
+                                     const HloSharding& root_sharding,
+                                     const SpmdPartitionerOptions& options);
+
+  virtual double GetComputationTimeInMilliSec(HloInstruction* hlo) {
+    return 0.0;
+  }
+
+  virtual double GetCommunicationTimeInMilliSec(
+      int64_t bytes, absl::Span<const ReplicaGroup> device_groups) {
+    return 0.0;
+  }
+
+  virtual int GetCommunicationMultiplier(
+      absl::Span<const ReplicaGroup> device_groups) {
+    return 1;
+  }
+
+  std::vector<ReplicaGroup> CreateReplicaGroups(
+      std::vector<std::vector<int64_t>>& groups);
+
+  const CallGraph& call_graph() { return call_graph_; }
+
+  // Information about a loop created for windowed dot-general. Used when
+  // DoCodeMotionForWindowedDotGeneralLoops() executes after the visitor
+  // finishes traversing the graph.
+  struct WindowedDotGeneralLoop {
+    HloInstruction* while_loop;
+    int64_t windowed_operand;
+    bool windowed_in_contracting_dims;
+    bool windowed_in_batch_dims;
+    bool operands_sharded_at_contracting_dims;
+    int64_t num_partitions;
+    std::vector<ReplicaGroup> loop_replica_groups;
+  };
+
+ protected:
+  Status Preprocess(HloInstruction* hlo) override;
+  Status Postprocess(HloInstruction* hlo) override;
+
+  // Performs code motion for windowed dot-general loops in
+  // windowed_dot_general_loops_. Invoked after the visitor finishes traversing
+  // the graph.
+  Status DoCodeMotionForWindowedDotGeneralLoops(
+      HloComputation* computation, const SpmdPartitionerOptions& options);
+
+  bool changed_;
+  HloModule* module_;
+  int64_t num_partitions_;
+  int64_t num_replicas_;
+
+  SPMDCollectiveOpsCreator collective_ops_creator_;
+
+  // Tracks the next channel id to use for cross-partition all-reduce.
+  int64_t* next_channel_id_;
+  SpmdBuilder b_;
+
+  std::vector<WindowedDotGeneralLoop> windowed_dot_general_loops_;
+
+  HloInstruction* partition_id_;
+
+ private:
+  PartitionedHlo::ReshardCache reshard_cache_;
+
+  // Mapping from the instruction in the original computation to the new SPMD
+  // partitioned instruction.
+  ConstHloInstructionMap<PartitionedHlo> partitioned_instructions_;
+
+  HloInstruction* visiting_hlo_;
+  SpmdLogger* logger_;
+  const SpmdPartitionerOptions options_;
+  SpmdPartitioner* partitioner_;
+  std::vector<HloSharding> visiting_hlo_operand_shardings_;
+  std::optional<HloSharding> visiting_hlo_sharding_;
+  std::optional<int64_t> visiting_num_partitions_;
+  std::optional<SPMDCollectiveOpsCreator> visiting_collective_ops_creator_;
+  std::optional<HloInstruction*> visiting_partition_id_;
+  std::vector<PartitionedHlo::PartitioningState> visiting_state_;
+  std::vector<std::vector<int64_t>> device_groups_;
+  const CallGraph& call_graph_;
+};
+
+}  // namespace spmd
+}  // namespace xla
+#endif  // XLA_SERVICE_SPMD_SPMD_PARTITIONER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/spmd/spmd_partitioner_util.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/spmd/spmd_partitioner_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..0bb05c96577394322d134e169da15751ab1e5f4c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/spmd/spmd_partitioner_util.h
@@ -0,0 +1,568 @@
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_SPMD_SPMD_PARTITIONER_UTIL_H_
+#define XLA_SERVICE_SPMD_SPMD_PARTITIONER_UTIL_H_
+
+#include <limits>
+#include <memory>
+#include <optional>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "xla/hlo/ir/hlo_casting_utils.h"
+#include "xla/hlo/ir/hlo_computation.h"
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/hlo/ir/hlo_sharding.h"
+#include "xla/hlo/utils/hlo_sharding_util.h"
+#include "xla/literal_util.h"
+#include "xla/service/spmd/spmd_partitioner.h"
+#include "xla/shape_util.h"
+#include "xla/xla_data.pb.h"
+
+namespace xla {
+namespace spmd {
+
+template <typename T>
+using IsCompOrCompBuilder =
+    typename std::enable_if_t<std::is_same<HloComputation, T>::value ||
+                              std::is_same<HloComputation::Builder, T>::value ||
+                              std::is_same<SpmdBuilder, T>::value>;
+
+struct GatherScatterParallelDimSharding {
+  HloSharding indices_sharding;
+  HloSharding operand_sharding;
+};
+
+// Returns true if the given sharding contains any replicated sharding.
+bool HasReplicatedSharding(const HloSharding& sharding);
+
+// Base for creating constants.
+template <typename T, typename = IsCompOrCompBuilder<T>>
+HloInstruction* CreateConstantBase(const Shape& shape, Literal value, T* b,
+                                   Literal (*literal_creator)(Literal,
+                                                              PrimitiveType)) {
+  if (shape.IsTuple()) {
+    std::vector<HloInstruction*> elements;
+    for (int64_t i = 0; i < ShapeUtil::TupleElementCount(shape); ++i) {
+      elements.push_back(
+          CreateConstantBase(ShapeUtil::GetTupleElementShape(shape, i),
+                             value.Clone(), b, literal_creator));
+    }
+    return b->AddInstruction(HloInstruction::CreateTuple(elements));
+  }
+
+  if (shape.IsToken()) {
+    return b->AddInstruction(HloInstruction::CreateToken());
+  }
+  auto c = b->AddInstruction(HloInstruction::CreateConstant(
+      literal_creator(std::move(value), shape.element_type())));
+  if (shape.rank() == 0) {
+    return c;
+  }
+  return b->AddInstruction(HloInstruction::CreateBroadcast(shape, c, {}));
+}
+
+// Creates constant value instructions of the given shape. The literal must be a
+// scalar shape and is broadcast to the given shape.
+template <typename T, typename = IsCompOrCompBuilder<T>>
+HloInstruction* CreateConstant(const Shape& shape, Literal value, T* b) {
+  auto identity = [](Literal value, PrimitiveType primitive_type) {
+    CHECK(ShapeUtil::IsScalarWithElementType(value.shape(), primitive_type));
+    return value;
+  };
+  return CreateConstantBase(shape, std::move(value), b, identity);
+}
+
+// Creates zero value instructions of the given shape.
+template <typename T, typename = IsCompOrCompBuilder<T>>
+HloInstruction* CreateZero(const Shape& shape, T* b) {
+  auto zero = [](Literal /*unused*/, PrimitiveType primitive_type) {
+    return LiteralUtil::Zero(primitive_type);
+  };
+  return CreateConstantBase(shape, /*unused*/ Literal(), b, zero);
+}
+
+// Creates one value instructions of the given shape.
+template <typename T, typename = IsCompOrCompBuilder<T>>
+HloInstruction* CreateOne(const Shape& shape, T* b) {
+  auto one = [](Literal /*unused*/, PrimitiveType primitive_type) {
+    return LiteralUtil::One(primitive_type);
+  };
+  return CreateConstantBase(shape, /*unused*/ Literal(), b, one);
+}
+
+template <typename NativeT, typename T, typename = IsCompOrCompBuilder<T>>
+HloInstruction* CreateR0WithType(PrimitiveType type, NativeT value, T* b) {
+  auto literal = LiteralUtil::CreateR0(value)
+                     .ConvertToShape(ShapeUtil::MakeShape(type, {}))
+                     .value();
+  return b->AddInstruction(HloInstruction::CreateConstant(std::move(literal)));
+}
+
+template <typename T, typename = IsCompOrCompBuilder<T>>
+inline HloInstruction* CreateFirstWithType(PrimitiveType type, T* b) {
+  if (type == F32) {
+    auto float_pad_value = std::numeric_limits<float>::quiet_NaN();
+    return CreateR0WithType(type, -float_pad_value, b);
+  }
+  auto literal = LiteralUtil::MinValue(type);
+  return b->AddInstruction(HloInstruction::CreateConstant(std::move(literal)));
+}
+
+template <typename T, typename = IsCompOrCompBuilder<T>>
+inline HloInstruction* CreateLastWithType(PrimitiveType type, T* b) {
+  if (type == F32) {
+    auto float_pad_value = std::numeric_limits<float>::quiet_NaN();
+    return CreateR0WithType(type, float_pad_value, b);
+  }
+  auto literal = LiteralUtil::MaxValue(type);
+  return b->AddInstruction(HloInstruction::CreateConstant(std::move(literal)));
+}
+
+// Create a binary add computation of the given type and add to the module.
+HloComputation* MakeBinaryAdd(PrimitiveType type, HloModule* module);
+
+// Returns true if the shape can be evenly partitioned for the given sharding.
+// All tile sharded dimensions should be evenly divisible and there should be no
+// single-device sharding. Replicate sharding is considered even partition.
+bool EvenlyPartitions(const Shape& shape, const HloSharding& sharding);
+
+// Returns the shard shape of the given shape when it is partitioned for the
+// target sharding.
+Shape MakePartitionedShape(const Shape& shape, const HloSharding& sharding);
+
+// Similar to ShapeUtil::ByteSizeOf(), but does not check it has dense layout
+// since this can be before layout assignment.
+int64_t ShapeSizeInBytes(const Shape& shape);
+
+// Creates a table lookup HLO using the ordinal as the offset.
+template <typename NativeT>
+HloInstruction* TableLookup(absl::Span<const NativeT> table, PrimitiveType type,
+                            HloInstruction* ordinal, SpmdBuilder* b) {
+  HloInstruction* table_hlo = b->AddInstruction(
+      HloInstruction::CreateConstant(LiteralUtil::CreateR1<NativeT>(table)));
+  HloInstruction* value = b->AddInstruction(HloInstruction::CreateDynamicSlice(
+      ShapeUtil::MakeShape(type, {1}), table_hlo, {ordinal}, {1}));
+  return b->AddInstruction(
+      HloInstruction::CreateReshape(ShapeUtil::MakeShape(type, {}), value));
+}
+
+// Returns the shard shape for a partition without padding due to uneven
+// sharding.
+Shape MakeNonPaddedShapeForGivenPartition(const Shape& shape,
+                                          const HloSharding& sharding,
+                                          int64_t partition_id);
+
+// Generates the HLO instructions that represent the dimension offsets on any
+// device. The size of the returned vector is the rank of the given shape.
+// If `dims` is non-empty, the generated offsets will only be non-zero for those
+// dimensions.
+std::vector<HloInstruction*> MakePartitionOffsets(
+    const Shape& shape, const HloSharding& sharding,
+    HloInstruction* partition_id, SpmdBuilder* b,
+    absl::Span<const int64_t> dims = {});
+
+// Returns the offsets of the partition in the tile assignment.
+std::vector<HloInstruction*> MakeTiledPartitionOrdinals(
+    const HloSharding& sharding, HloInstruction* partition_id, SpmdBuilder* b);
+
+// Pads hlo to the desired shape using high padding. Either a builder or a
+// computation needs to be supplied, but not both.
+template <typename T, typename = IsCompOrCompBuilder<T>>
+HloInstruction* PadToShape(HloInstruction* hlo, const Shape& padded_shape, T* b,
+                           std::optional<Literal> value = std::nullopt) {
+  if (ShapeUtil::Compatible(hlo->shape(), padded_shape)) {
+    return hlo;
+  }
+  PaddingConfig padding_config;
+  for (int64_t i = 0; i < padded_shape.rank(); ++i) {
+    auto padding_config_dim = padding_config.add_dimensions();
+    padding_config_dim->set_edge_padding_low(0);
+    padding_config_dim->set_interior_padding(0);
+    padding_config_dim->set_edge_padding_high(padded_shape.dimensions(i) -
+                                              hlo->shape().dimensions(i));
+  }
+  const Shape padding_shape =
+      ShapeUtil::MakeScalarShape(hlo->shape().element_type());
+  HloInstruction* padding =
+      value.has_value() ? CreateConstant(padding_shape, std::move(*value), b)
+                        : CreateZero(padding_shape, b);
+  return b->AddInstruction(
+      HloInstruction::CreatePad(padded_shape, hlo, padding, padding_config));
+}
+
+// Returns the padded shape when combining all partitions.
+Shape GetPaddedShapeForUnevenPartitioning(const Shape& base_shape,
+                                          const HloSharding& sharding);
+
+// Pads the HLO (with base shape) for uneven tiled partition to make it evenly
+// partitionable.
+template <typename T, typename = IsCompOrCompBuilder<T>>
+HloInstruction* PadBaseShapeBeforeUnevenTiledSharding(
+    HloInstruction* hlo, const HloSharding& sharding, T* b,
+    std::optional<Literal> value = std::nullopt) {
+  auto padded_base_shape =
+      GetPaddedShapeForUnevenPartitioning(hlo->shape(), sharding);
+  if (ShapeUtil::Compatible(padded_base_shape, hlo->shape())) {
+    return hlo;
+  }
+  return PadToShape(hlo, padded_base_shape, b, std::move(value));
+}
+
+// Returns the index of the unique tile dimension. Returns std::nullopt if the
+// given sharding is not tiled or tiled along multiple dimensions.
+std::optional<int64_t> UniqueTiledDim(const HloSharding& sharding);
+
+// Utilities for symbolic offset calculation and halo exchange.
+class OffsetCalculation;
+
+// Represents a calculation over integers:
+//   (shard_ordinal * multiplier + offset) / divisor
+class MultiplyAddDivideOffsetCalculation {
+ public:
+  MultiplyAddDivideOffsetCalculation()
+      : multiplier_(0), offset_(0), divisor_(1) {}
+  MultiplyAddDivideOffsetCalculation(int64_t multiplier, int64_t offset,
+                                     int64_t divisor);
+
+  OffsetCalculation operator-(
+      const MultiplyAddDivideOffsetCalculation& other) const;
+  OffsetCalculation operator+(
+      const MultiplyAddDivideOffsetCalculation& other) const;
+
+  bool operator==(const MultiplyAddDivideOffsetCalculation& other) const {
+    return multiplier_ == other.multiplier_ && offset_ == other.offset_ &&
+           divisor_ == other.divisor_;
+  }
+
+  bool IsConstant() const { return multiplier_ == 0; }
+  void Simplify();
+  int64_t Calculate(int64_t shard_ordinal) const;
+  HloInstruction* Calculate(HloInstruction* shard_ordinal,
+                            SpmdBuilder* b) const;
+
+  // Returns the maximum result for shard ordinals in the range
+  // [start_ordinal, limit_ordinal).
+  int64_t MaxInRange(int64_t start_ordinal, int64_t limit_ordinal) const;
+
+ private:
+  int64_t multiplier_;
+  int64_t offset_;
+  int64_t divisor_;
+};
+
+// Represents a calculation over integers based on results of other calculations
+// defined by an opcode. If the opcode is kCopy, it simply wraps an
+// MultiplyAddDivideOffsetCalculation.
+class OffsetCalculation {
+ public:
+  OffsetCalculation() : opcode_(HloOpcode::kCopy), copy_from_() {}
+  explicit OffsetCalculation(
+      const MultiplyAddDivideOffsetCalculation& copy_from)
+      : opcode_(HloOpcode::kCopy), copy_from_(copy_from) {}
+  OffsetCalculation(const OffsetCalculation& copy_from) { *this = copy_from; }
+  OffsetCalculation(HloOpcode opcode,
+                    const MultiplyAddDivideOffsetCalculation& lhs,
+                    const MultiplyAddDivideOffsetCalculation& rhs)
+      : opcode_(opcode),
+        lhs_(std::make_unique<OffsetCalculation>(lhs)),
+        rhs_(std::make_unique<OffsetCalculation>(rhs)) {}
+  OffsetCalculation(HloOpcode opcode, const OffsetCalculation& lhs,
+                    const OffsetCalculation& rhs)
+      : opcode_(opcode),
+        lhs_(std::make_unique<OffsetCalculation>(lhs)),
+        rhs_(std::make_unique<OffsetCalculation>(rhs)) {}
+
+  OffsetCalculation& operator=(const OffsetCalculation& other);
+
+  // Returns whether the calculation returns the same value for all shards. This
+  // is conservative and could return false even if it is actually constant.
+  bool IsConstant() const;
+
+  OffsetCalculation operator-(const OffsetCalculation& other) const;
+  OffsetCalculation operator+(const OffsetCalculation& other) const;
+  bool operator==(const OffsetCalculation& other) const;
+  int64_t Calculate(int64_t shard_ordinal) const;
+  HloInstruction* Calculate(HloInstruction* shard_ordinal,
+                            SpmdBuilder* b) const;
+
+  // Returns the maximum result for shard ordinals in the range
+  // [start_ordinal, limit_ordinal).
+  int64_t MaxInRange(int64_t start_ordinal, int64_t limit_ordinal) const;
+
+ private:
+  HloOpcode opcode_;
+  std::unique_ptr<OffsetCalculation> lhs_;
+  std::unique_ptr<OffsetCalculation> rhs_;
+  MultiplyAddDivideOffsetCalculation copy_from_;
+};
+
+// Performs halo exchange on the given dimension based on the provided
+// left/right halo size functions. Returns nullopt if the halo is beyond the
+// direct neighbor of the shard.
+std::optional<HloInstruction*> ExchangeHalo(
+    HloInstruction* hlo, const OffsetCalculation& left_halo_size_function,
+    const OffsetCalculation& right_halo_size_function, int64_t dim,
+    const HloSharding& target,
+    const SPMDCollectiveOpsCreator& collective_ops_creator,
+    int64_t* next_channel_id, SpmdBuilder* b);
+
+// Exchange halo on all dimensions of the HLO. Returns nullopt if any one of the
+// dimensions fails to exchange halo (halo is beyond the neighbor shard).
+std::optional<HloInstruction*> ExchangeHalo(
+    HloInstruction* hlo,
+    std::vector<OffsetCalculation> left_halo_size_functions,
+    std::vector<OffsetCalculation> right_halo_size_functions,
+    const HloSharding& target,
+    const SPMDCollectiveOpsCreator& collective_ops_creator,
+    int64_t* next_channel_id, SpmdBuilder* b);
+
+// A compact version of halo exchange, which generates fewer collective permutes
+// when the halo ranges are far from the current shard while the final result
+// size is small. It tries to reuse the same collective permute to do as many
+// disjoint communications as possible. It also includes data masking. pad_value
+// can be nullptr, which means the value in padding regions doesn't matter.
+HloInstruction* ExchangeHaloCompact(
+    HloInstruction* hlo, const Shape& base_shape,
+    const OffsetCalculation& left_halo_size_function,
+    const OffsetCalculation& right_halo_size_function,
+    HloInstruction* pad_value, int64_t dim, const HloSharding& sharding,
+    HloInstruction* shard_ordinal,
+    const SPMDCollectiveOpsCreator& collective_ops_creator,
+    int64_t* next_channel_id, SpmdBuilder* b);
+
+// Exchanges halos and performs pad/dynamic-slice on the concatenated data such
+// that the result starts with the first needed element on each shard. It also
+// masks off invalid data due to padding.
+// Arguments:
+//  hlo: the HLO op before halo exchange
+//  explicit_left_padding_on_full_shape: the amount of left padding to be added
+//   explicitly by this function on the base shape before partitioning. Without
+//   base dilation, this is usually set to the window's padding_low so that the
+//   sharded op do not need to add padding_low on the window; however, with base
+//   dilation, this could only be set to a custom size.
+//  padded_full_shape_size: the size of the padded full shape on the given
+//   dimension, which includes explicit_left_padding_on_full_shape and required
+//   right padding to make the shape evenly shardable.
+//  shard_size_with_halo: the shard size on the dimension after halo exchange.
+//   If different shards have different sizes, use the maximum size.
+//  offset_on_padded_shape: the offset HLO (S32) that represents the start of
+//   each shard on the padded full shape.
+//  pad_value: the padding value used on the full shape.
+//  force_mask_in_compact: If true, masking is always applied if it uses
+//   ExchangeHaloCompact. An example is that certain cases in pad can skip
+//   masking in non-compact halo exchange, but not in compact ones.
+std::optional<HloInstruction*> ExchangeHaloAndGetValidData(
+    HloInstruction* hlo, const Shape& base_shape,
+    const OffsetCalculation& left_halo_size_function,
+    const OffsetCalculation& right_halo_size_function,
+    int64_t explicit_left_padding_on_full_shape, int64_t padded_full_shape_size,
+    int64_t shard_size_with_halo, int64_t dim, const HloSharding& target,
+    HloInstruction* offset_on_padded_shape, HloInstruction* pad_value,
+    HloInstruction* partition_ordinal,
+    const SPMDCollectiveOpsCreator& collective_ops_creator,
+    int64_t* next_channel_id, SpmdBuilder* b, bool mask_invalid_region = true,
+    bool force_mask_in_compact = false);
+
+// Uses halo exchange to change from right-padding to left-padding for uneven
+// tiled sharding on the given dimensions. Tiled sharding always pads uneven
+// partitioned data on the right, but we need to swap it to the left for
+// kReverse or kConvolution with window reversal.
+HloInstruction* HaloExchangeToPadOnLeft(PartitionedHlo& original,
+                                        absl::Span<const int64_t> dims);
+
+// Check if the computation is GT comparison and safe for NaNs.
+bool IsNanSafeGt(HloComputation* computation);
+
+// Return k in TopK when input value is parttioned in the sort dimension.
+std::optional<int64_t> GetKValueInTopKWhenPartitionSortDim(HloInstruction* hlo);
+
+// Slices the first k elements at slice dimension.
+HloInstruction* SliceFirstK(HloInstruction* hlo, SpmdBuilder* builder,
+                            int64_t slice_dim, int64_t k);
+
+// Check if a dimension is sharded.
+int64_t ShardCountAtDim(const HloSharding& sharding, int64_t dim);
+
+// Returns the list of source-target pairs of dimensions to swap during
+// resharding via all-to-all. Reshard can be done by swapping each pair at a
+// time.
+std::optional<std::vector<std::pair<int64_t, int64_t>>>
+GetReshardAllToAllSourceTargetDims(const HloSharding& source,
+                                   const HloSharding& target);
+
+// Returns whether the resharding can be done via collective-permute.
+bool CanReshardWithCollectivePermute(const HloSharding& source,
+                                     const HloSharding& target);
+
+// Returns a new GroupedSharding that has the same group definition of
+// `reference`.
+hlo_sharding_util::GroupedSharding AlignGroupsWith(
+    hlo_sharding_util::GroupedSharding grouped_sharding,
+    const hlo_sharding_util::GroupedSharding& reference,
+    bool ignore_group_order = false);
+
+// Align device groups between the two shardings. Equivalent in calling
+// GroupShardingOnDims on the two sharding AlignGroupsWith and then
+// UngroupSharding
+HloSharding AlignShardingOnDims(const HloSharding& sharding,
+                                absl::Span<const int64_t> sharding_dims,
+                                const HloSharding& reference,
+                                absl::Span<const int64_t> reference_dims);
+
+// AlignShardingOnDims only if it doesn't change the sharding when ungrouped.
+std::optional<hlo_sharding_util::GroupedSharding> AlignGroupsWithIfCompatible(
+    hlo_sharding_util::GroupedSharding grouped_sharding,
+    const hlo_sharding_util::GroupedSharding& reference);
+
+// Returns the per-group base shape, i.e., before applying the in-group
+// sharding.
+Shape GetPerGroupBaseShape(
+    const hlo_sharding_util::GroupedSharding& grouped_sharding,
+    const Shape& original_base_shape);
+
+// Returns the partition id within a group.
+HloInstruction* GetInGroupPartitionId(
+    HloInstruction* partition_id,
+    const std::vector<std::vector<int64_t>>& device_groups, SpmdBuilder* b);
+
+// Creates the nested partitioner state for in-group partitioning.
+PartitionedHlo::PartitioningState CreatePerGroupPartitioningState(
+    const PartitionedHlo::PartitioningState& state,
+    const std::vector<std::vector<int64_t>>& device_groups, SpmdBuilder* b);
+
+// Partially shards a replicated HLO into groups along the group dimensions, and
+// within each group data is still replicated.
+HloInstruction* PerGroupSliceFromReplicated(
+    HloInstruction* replicated, HloInstruction* partition_id,
+    const std::vector<std::vector<int64_t>>& device_groups,
+    absl::Span<const int64_t> group_dims,
+    absl::Span<const int64_t> group_dim_sizes, SpmdBuilder* b);
+
+// Pad the shape from partial replicate shape for `dst_sharding`.
+// If dst_sharding needs more padding and per_shard_size increased in
+// dst_sharding, halo exchange on the right side is needed.
+std::optional<HloInstruction*> PadFromPartialReplicateShape(
+    HloInstruction* hlo, const Shape& base_shape,
+    const HloSharding& src_sharding, const HloSharding& dst_sharding,
+    const std::vector<int64_t>& expand_tile_dims,
+    const SPMDCollectiveOpsCreator& collective_ops_creator,
+    int64_t* next_channel_id, HloInstruction* partition_id, SpmdBuilder* b);
+
+// Get the compatible sharding from a partial replicate sharding to a desired
+// target tiled sharding.
+// Compatible means replicate sharding can transform to the target tile
+// dimensions by dynamic slice.
+// For example, if partial_sharding is
+// {devices=[1,2,2]0,1,2,3 last_tile_dim_replicate}
+// Target sharding is {devices=[2,2]0,1,2,3}, the returned compatible sharding
+// will be sharding={devices=[2,2]0,2,1,3}.
+// If patial replicate sharding is not partial replicate or can't reshard to
+// target_tile_dims by dynamic slice, return std::nullopt.
+// If target_sharding is already compatible, returns it.
+std::optional<HloSharding> PartialReplicateReshardCompatibleSharding(
+    const HloSharding& partial_sharding, const HloSharding& target_sharding);
+
+// Do left halo exchange if all-reduce directly from tile sharding to partial
+// replicate sharding will remove useful data from the source.
+std::optional<HloInstruction*> TileToPartialReplicateHaloExchange(
+    HloInstruction* hlo, const Shape& base_shape,
+    const HloSharding& src_sharding, const HloSharding& dst_sharding,
+    const std::vector<int64_t>& replicate_dims,
+    const SPMDCollectiveOpsCreator& collective_ops_creator,
+    int64_t* next_channel_id, HloInstruction* partition_id, SpmdBuilder* b);
+
+// Finds a list of dimensions that can be grouped on such that it will have the
+// specified device groups. Group order and dimension order are ignored.
+std::optional<std::vector<int64_t>> FindMatchingPartitionedDimsForGrouping(
+    const HloSharding& sharding,
+    const std::vector<std::vector<int64_t>>& device_groups);
+
+// Create a sharding that matches the provided source sharding on the
+// specified dimensions. 'target_dims' and 'source_dims' represent the
+// dimensions for which the sharding should match in their respective shape.
+// If some devices from the source sharding are left over (because not all the
+// devices are allocated to 'source_dims' dimensions) then partial replication
+// is employed to make sure the number of devices for the two sharding match.
+HloSharding CreateMatchingShardingOnDims(const Shape& target_shape,
+                                         const HloSharding& source_sharding,
+                                         absl::Span<const int64_t> target_dims,
+                                         absl::Span<const int64_t> source_dims);
+
+// Returns if the sharding across operand and indices of a gather/scatter is
+// across parallel dimensions and matches what SPMD partitioner supports.
+std::optional<GatherScatterParallelDimSharding>
+GatherScatterOperandsShardedAcrossParallelDims(
+    const HloInstruction& operand, const HloInstruction& indices,
+    const hlo_sharding_util::GatherScatterParallelDims& parallel_dims);
+
+// Pattern rewrite preprocessing utilities.
+
+// Returns rotate_amount if the concat(lhs, rhs) is equivalent to rotating the
+// elements along the concat dimension to the right by rotate_amount, where the
+// input of rotation is the shard operand of lhs and rhs. Returns -1 if the
+// pattern is not found.
+int64_t FindRotateRightPattern(const HloInstruction* concat,
+                               const HloInstruction* lhs,
+                               const HloInstruction* rhs);
+
+// Describes the pad with wrap pattern.
+struct PadWithWrapPattern {
+  int64_t lhs_slice_start;
+  int64_t rhs_slice_start;
+  std::vector<const HloInstruction*> lhs_modifiers;
+  std::vector<const HloInstruction*> rhs_modifiers;
+};
+
+// Returns the `PadWithWrapPattern` if the concat(lhs,mid,rhs) is equivalent to
+// padding mid with wrapping (i.e., padding mid with slices of itself). Return
+// std::nullopt if the pattern is not found.
+std::optional<PadWithWrapPattern> FindPadWithWrapPattern(
+    const HloInstruction* concat, const HloInstruction* lhs,
+    const HloInstruction* mid, const HloInstruction* rhs);
+
+// Reshards data for a slice to be happening on such data with the passed
+// parameters.
+std::optional<PartitionedHlo::WindowedInputShardReturnValue>
+ReshardDataForSlicing(absl::Span<const int64_t> strides,
+                      absl::Span<const int64_t> starts,
+                      absl::Span<const int64_t> limits,
+                      PartitionedHlo to_reshard,
+                      const HloSharding& target_sharding, SpmdBuilder* b);
+
+// Performs slicing of data based on the windowed sharding passed as input.
+HloInstruction* SliceDataFromWindowReshard(
+    const PartitionedHlo::WindowedInputShardReturnValue& reshard_operand,
+    absl::Span<const int64_t> strides, const Shape& base_shape,
+    const HloSharding& target_sharding, SpmdBuilder* b);
+
+// Reshards data for a pad to be happening on such data with the passed
+// parameters.
+std::optional<PartitionedHlo::WindowedInputShardReturnValue> ReshardDataForPad(
+    HloInstruction* pad_value, PaddingConfig pc, PartitionedHlo to_reshard,
+    const HloSharding& target_sharding, SpmdBuilder* b);
+
+// Performs padding of data based on the windowed sharding passed as input.
+HloInstruction* PadDataFromWindowReshard(
+    const PartitionedHlo::WindowedInputShardReturnValue& reshard_operand,
+    HloInstruction* pad_value, SpmdBuilder* b);
+
+}  // namespace spmd
+}  // namespace xla
+
+#endif  // XLA_SERVICE_SPMD_SPMD_PARTITIONER_UTIL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/spmd/stateful_rng_spmd_partitioner.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/spmd/stateful_rng_spmd_partitioner.h
new file mode 100644
index 0000000000000000000000000000000000000000..76ef60a3c3178a689a07c40299a28364a88e616f
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/spmd/stateful_rng_spmd_partitioner.h
@@ -0,0 +1,80 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_SPMD_STATEFUL_RNG_SPMD_PARTITIONER_H_
+#define XLA_SERVICE_SPMD_STATEFUL_RNG_SPMD_PARTITIONER_H_
+
+#include <utility>
+
+#include "xla/hlo/ir/hlo_computation.h"
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/service/hlo_pass_interface.h"
+#include "xla/service/spmd/spmd_partitioner.h"
+
+namespace xla {
+namespace spmd {
+
+class StatefulRngSpmdPartitioningVisitor
+    : public spmd::SpmdPartitioningVisitor {
+ public:
+  StatefulRngSpmdPartitioningVisitor(
+      HloComputation* computation, int64_t num_partitions, int64_t num_replicas,
+      const spmd::SPMDCollectiveOpsCreator& collective_ops_creator,
+      int64_t* next_channel_id, spmd::SpmdLogger* logger,
+      spmd::SpmdPartitionerOptions options, spmd::SpmdPartitioner* partitioner,
+      const CallGraph& call_graph)
+      : spmd::SpmdPartitioningVisitor(computation, num_partitions, num_replicas,
+                                      collective_ops_creator, next_channel_id,
+                                      logger, std::move(options), partitioner,
+                                      call_graph) {}
+  Status HandleRngGetAndUpdateState(HloInstruction* hlo) override;
+};
+
+class StatefulRngSpmdPartitioner : public spmd::SpmdPartitioner {
+ public:
+  StatefulRngSpmdPartitioner(int64_t num_partitions, int64_t num_replicas)
+      : spmd::SpmdPartitioner(num_partitions, num_replicas,
+                              GetSpmdPartitionerOptions()) {}
+
+ protected:
+  std::unique_ptr<spmd::SpmdPartitioningVisitor> CreateVisitor(
+      HloComputation* computation, int64_t num_partitions, int64_t num_replicas,
+      const spmd::SPMDCollectiveOpsCreator& collective_ops_creator,
+      int64_t* next_channel_id, spmd::SpmdLogger* logger,
+      spmd::SpmdPartitionerOptions options,
+      const CallGraph& call_graph) override;
+
+  Status PreprocessSharding(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+  bool CanSideEffectingHaveReplicatedSharding(
+      const HloInstruction* hlo) override;
+
+ private:
+  static spmd::SpmdPartitionerOptions GetSpmdPartitionerOptions() {
+    spmd::SpmdPartitionerOptions options;
+    options.allow_module_signature_change = true;
+    // Setting windowed einsum threshold to be large to disable it for GPU by
+    // default.
+    options.threshold_for_windowed_einsum_mib = 100000;
+    return options;
+  }
+};
+
+}  // namespace spmd
+}  // namespace xla
+
+#endif  // XLA_SERVICE_SPMD_STATEFUL_RNG_SPMD_PARTITIONER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/allocator_stats.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/allocator_stats.h
new file mode 100644
index 0000000000000000000000000000000000000000..d073d08cb92d5b327e77c7d609cae5a7554740ff
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/allocator_stats.h
@@ -0,0 +1,63 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_STREAM_EXECUTOR_ALLOCATOR_STATS_H_
+#define XLA_STREAM_EXECUTOR_ALLOCATOR_STATS_H_
+
+#include <string>
+
+#include "absl/types/optional.h"
+#include "xla/stream_executor/platform/port.h"
+
+namespace stream_executor {
+
+// Runtime statistics collected by an allocator. Exactly the same as
+// tsl::AllocatorStats, but independently defined to preserve the mutual
+// independence of StreamExecutor and TensorFlow.
+struct AllocatorStats {
+  int64_t num_allocs;          // Number of allocations.
+  int64_t bytes_in_use;        // Number of bytes in use.
+  int64_t peak_bytes_in_use;   // The peak bytes in use.
+  int64_t largest_alloc_size;  // The largest single allocation seen.
+
+  // The upper limit of bytes of user allocatable device memory, if such a limit
+  // is known.
+  std::optional<int64_t> bytes_limit;
+
+  // Stack related memory usage.
+  int64_t bytes_reserved;  // Number of bytes reserved on the stack.
+  int64_t
+      peak_bytes_reserved;  // The peak number of bytes reserved on the stack.
+  // The upper limit on the number bytes of reservable memory on the stack,
+  // if such a limit is known.
+  std::optional<int64_t> bytes_reservable_limit;
+
+  int64_t largest_free_block_bytes;  // Largest free block's size in heap.
+
+  AllocatorStats()
+      : num_allocs(0),
+        bytes_in_use(0),
+        peak_bytes_in_use(0),
+        largest_alloc_size(0),
+        bytes_reserved(0),
+        peak_bytes_reserved(0),
+        largest_free_block_bytes(0) {}
+
+  std::string DebugString() const;
+};
+
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_ALLOCATOR_STATS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/blas.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/blas.h
new file mode 100644
index 0000000000000000000000000000000000000000..a85ea3b460d6ed659dbabc4a533a570df30ad218
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/blas.h
@@ -0,0 +1,696 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// Exposes the family of BLAS routines as pre-canned high performance calls for
+// use in conjunction with the StreamExecutor abstraction.
+//
+// Note that this interface is optionally supported by platforms.
+//
+// This abstraction makes it simple to entrain BLAS operations on GPU data into
+// a Stream -- users typically will not use this API directly, but will use the
+// Stream builder methods to entrain these operations "under the hood". For
+// example:
+//
+//  DeviceMemory<float> x = stream_exec->AllocateArray<float>(1024);
+//  DeviceMemory<float> y = stream_exec->AllocateArray<float>(1024);
+//  // ... populate x and y ...
+//  Stream stream{stream_exec};
+//  stream
+//    .Init()
+//    .ThenBlasAxpy(1024, 5.5, x, 1, &y, 1);
+//  TF_CHECK_OK(stream.BlockHostUntilDone());
+//
+// By using stream operations in this manner the user can easily intermix custom
+// kernel launches (via StreamExecutor::ThenLaunch()) with these pre-canned BLAS
+// routines.
+
+#ifndef XLA_STREAM_EXECUTOR_BLAS_H_
+#define XLA_STREAM_EXECUTOR_BLAS_H_
+
+#include <complex>
+#include <limits>
+#include <ostream>
+#include <string>
+#include <vector>
+
+#include "absl/types/span.h"
+#include "xla/stream_executor/data_type.h"
+#include "xla/stream_executor/device_memory.h"
+#include "xla/stream_executor/numeric_options.h"
+#include "xla/stream_executor/platform/port.h"
+#include "tsl/platform/statusor.h"
+#include "tsl/protobuf/dnn.pb.h"
+
+namespace Eigen {
+struct half;
+}  // namespace Eigen
+
+namespace stream_executor {
+
+class Stream;
+class ScratchAllocator;
+
+template <typename ElemT>
+class DeviceMemory;
+
+template <typename ElemT>
+class HostOrDeviceScalar;
+
+template <typename T>
+using DeviceMemorySlice = absl::Span<DeviceMemory<T> *const>;
+
+namespace blas {
+
+// Specifies whether the input matrix will be transposed or
+// transposed+conjugated before any BLAS operations.
+enum class Transpose { kNoTranspose, kTranspose, kConjugateTranspose };
+
+// Returns a name for t.
+std::string TransposeString(Transpose t);
+
+// Specifies whether the upper or lower triangular part of a
+// symmetric/Hermitian matrix is used.
+enum class UpperLower { kUpper, kLower };
+
+// Returns a name for ul.
+std::string UpperLowerString(UpperLower ul);
+
+// Specifies whether a matrix is unit triangular.
+enum class Diagonal { kUnit, kNonUnit };
+
+// Returns a name for d.
+std::string DiagonalString(Diagonal d);
+
+// Specifies whether a Hermitian matrix appears on the left or right in
+// operation.
+enum class Side { kLeft, kRight };
+
+// Returns a name for s.
+std::string SideString(Side s);
+
+// Type with which intermediate computations of a blas routine are performed.
+//
+// Some blas calls can perform computations with a type that's different than
+// the type of their inputs/outputs.  This lets you e.g. multiply two matrices
+// of int8s using float32s to store the matmul's intermediate values.
+enum class ComputationType {
+  kF16,  // 16-bit floating-point
+  kF32,  // 32-bit floating-point
+  kF64,  // 64-bit floating-point
+  kI32,  // 32-bit integer
+  // The below values use float32 for accumulation, but allow the inputs and
+  // outputs to be downcast to a lower precision:
+  kF16AsF32,   // Allow downcast to F16 precision.
+  kBF16AsF32,  // Allow downcast to BF16 precision.
+  kTF32AsF32,  // Allow downcast to TF32 precision.
+};
+
+// Converts a ComputationType to a string.
+std::string ComputationTypeString(ComputationType ty);
+
+std::ostream &operator<<(std::ostream &os, ComputationType ty);
+
+using dnn::DataType;
+using dnn::ToDataType;
+
+// Converts a ComputationType to a string.
+std::string DataTypeString(DataType ty);
+
+std::ostream &operator<<(std::ostream &os, DataType ty);
+
+// Opaque identifier for an "algorithm" used by a blas routine.  This functions
+// as a hint to the blas library.
+typedef int64_t AlgorithmType;
+constexpr AlgorithmType kDefaultAlgorithm = -1;
+constexpr AlgorithmType kDefaultBlasGemm = -2;
+constexpr AlgorithmType kDefaultBlasGemv = -3;
+constexpr AlgorithmType kNoAlgorithm = -4;
+constexpr AlgorithmType kRuntimeAutotuning = -5;
+
+// blas uses -1 to represent the default algorithm. This happens to match up
+// with the CUBLAS_GEMM_DFALT constant, so cuda_blas.cc is using static_cast
+// to convert from AlgorithmType to cublasGemmAlgo_t, and uses a static_assert
+// to ensure that this assumption does not break.
+// If another blas implementation uses a different value for the default
+// algorithm, then it needs to convert kDefaultGemmAlgo to that value
+// (e.g. via a function called ToWhateverGemmAlgo).
+constexpr AlgorithmType kDefaultGemmAlgo = -1;
+
+// Describes the result of a performance experiment, usually timing the speed of
+// a particular AlgorithmType.
+//
+// If the call we were benchmarking failed (a common occurrence; not all
+// algorithms are valid for all calls), is_valid() will be false.
+class ProfileResult {
+ public:
+  bool is_valid() const { return is_valid_; }
+  void set_is_valid(bool val) { is_valid_ = val; }
+  AlgorithmType algorithm() const { return algorithm_; }
+  void set_algorithm(AlgorithmType val) { algorithm_ = val; }
+  float elapsed_time_in_ms() const { return elapsed_time_in_ms_; }
+  void set_elapsed_time_in_ms(float val) { elapsed_time_in_ms_ = val; }
+
+ private:
+  bool is_valid_ = false;
+  AlgorithmType algorithm_ = kDefaultAlgorithm;
+  float elapsed_time_in_ms_ = std::numeric_limits<float>::max();
+};
+
+class AlgorithmConfig {
+ public:
+  AlgorithmConfig() : algorithm_(kDefaultAlgorithm) {}
+  explicit AlgorithmConfig(AlgorithmType algorithm) : algorithm_(algorithm) {}
+  AlgorithmType algorithm() const { return algorithm_; }
+  void set_algorithm(AlgorithmType val) { algorithm_ = val; }
+  bool operator==(const AlgorithmConfig &other) const {
+    return this->algorithm_ == other.algorithm_;
+  }
+  bool operator!=(const AlgorithmConfig &other) const {
+    return !(*this == other);
+  }
+  std::string ToString() const;
+
+ private:
+  AlgorithmType algorithm_;
+};
+
+// Opaque identifier specifying the precision to use in gemm calls.
+typedef int64_t ComputePrecision;
+constexpr ComputePrecision kDefaultComputePrecision = 0;
+
+// BLAS support interface -- this can be derived from a GPU executor when the
+// underlying platform has an BLAS library implementation available. See
+// StreamExecutor::AsBlas().
+//
+// Thread-hostile: CUDA associates a CUDA-context with a particular thread in
+// the system. Any operation that a user attempts to perform by enqueueing BLAS
+// operations on a thread not-associated with the CUDA-context has unknown
+// behavior at the current time; see b/13176597
+class BlasSupport {
+ public:
+  virtual ~BlasSupport() {}
+
+  // Performs a BLAS y <- ax+y operation.
+  virtual bool DoBlasAxpy(Stream *stream, uint64_t elem_count, float alpha,
+                          const DeviceMemory<float> &x, int incx,
+                          DeviceMemory<float> *y, int incy) = 0;
+  virtual bool DoBlasAxpy(Stream *stream, uint64_t elem_count, double alpha,
+                          const DeviceMemory<double> &x, int incx,
+                          DeviceMemory<double> *y, int incy) = 0;
+  virtual bool DoBlasAxpy(Stream *stream, uint64_t elem_count,
+                          std::complex<float> alpha,
+                          const DeviceMemory<std::complex<float>> &x, int incx,
+                          DeviceMemory<std::complex<float>> *y, int incy) = 0;
+  virtual bool DoBlasAxpy(Stream *stream, uint64_t elem_count,
+                          std::complex<double> alpha,
+                          const DeviceMemory<std::complex<double>> &x, int incx,
+                          DeviceMemory<std::complex<double>> *y, int incy) = 0;
+
+  // Copies vector to another vector: y <- x.
+  virtual bool DoBlasCopy(Stream *stream, uint64_t elem_count,
+                          const DeviceMemory<float> &x, int incx,
+                          DeviceMemory<float> *y, int incy) = 0;
+  virtual bool DoBlasCopy(Stream *stream, uint64_t elem_count,
+                          const DeviceMemory<double> &x, int incx,
+                          DeviceMemory<double> *y, int incy) = 0;
+  virtual bool DoBlasCopy(Stream *stream, uint64_t elem_count,
+                          const DeviceMemory<std::complex<float>> &x, int incx,
+                          DeviceMemory<std::complex<float>> *y, int incy) = 0;
+  virtual bool DoBlasCopy(Stream *stream, uint64_t elem_count,
+                          const DeviceMemory<std::complex<double>> &x, int incx,
+                          DeviceMemory<std::complex<double>> *y, int incy) = 0;
+
+  // Computes the product of a vector by a scalar: x <- a*x.
+  virtual bool DoBlasScal(Stream *stream, uint64_t elem_count, float alpha,
+                          DeviceMemory<float> *x, int incx) = 0;
+  virtual bool DoBlasScal(Stream *stream, uint64_t elem_count, double alpha,
+                          DeviceMemory<double> *x, int incx) = 0;
+  virtual bool DoBlasScal(Stream *stream, uint64_t elem_count, float alpha,
+                          DeviceMemory<std::complex<float>> *x, int incx) = 0;
+  virtual bool DoBlasScal(Stream *stream, uint64_t elem_count, double alpha,
+                          DeviceMemory<std::complex<double>> *x, int incx) = 0;
+  virtual bool DoBlasScal(Stream *stream, uint64_t elem_count,
+                          std::complex<float> alpha,
+                          DeviceMemory<std::complex<float>> *x, int incx) = 0;
+  virtual bool DoBlasScal(Stream *stream, uint64_t elem_count,
+                          std::complex<double> alpha,
+                          DeviceMemory<std::complex<double>> *x, int incx) = 0;
+
+  // Computes a matrix-vector product using a general matrix.
+  //
+  //     y <- alpha * a * x + beta * y,
+  // or
+  //     y <- alpha * a' * x + beta * y,
+  // or
+  //     y <- alpha * conj(a') * x + beta * y,
+  //
+  // alpha and beta are scalars; a is an m-by-n general matrix; x is a vector
+  // with n(trans==kNoTranspose)/m(otherwise) elements;
+  // y is a vector with m(trans==kNoTranspose)/n(otherwise) elements.
+  virtual bool DoBlasGemv(Stream *stream, blas::Transpose trans, uint64_t m,
+                          uint64_t n, float alpha, const DeviceMemory<float> &a,
+                          int lda, const DeviceMemory<float> &x, int incx,
+                          float beta, DeviceMemory<float> *y, int incy) = 0;
+  virtual bool DoBlasGemv(Stream *stream, blas::Transpose trans, uint64_t m,
+                          uint64_t n, double alpha,
+                          const DeviceMemory<double> &a, int lda,
+                          const DeviceMemory<double> &x, int incx, double beta,
+                          DeviceMemory<double> *y, int incy) = 0;
+  virtual bool DoBlasGemv(Stream *stream, blas::Transpose trans, uint64_t m,
+                          uint64_t n, std::complex<float> alpha,
+                          const DeviceMemory<std::complex<float>> &a, int lda,
+                          const DeviceMemory<std::complex<float>> &x, int incx,
+                          std::complex<float> beta,
+                          DeviceMemory<std::complex<float>> *y, int incy) = 0;
+  virtual bool DoBlasGemv(Stream *stream, blas::Transpose trans, uint64_t m,
+                          uint64_t n, std::complex<double> alpha,
+                          const DeviceMemory<std::complex<double>> &a, int lda,
+                          const DeviceMemory<std::complex<double>> &x, int incx,
+                          std::complex<double> beta,
+                          DeviceMemory<std::complex<double>> *y, int incy) = 0;
+
+  // Computes a matrix-vector product using a symmetric band matrix.
+  //
+  //     y <- alpha * a * x + beta * y,
+  //
+  // alpha and beta are scalars; a is an n-by-n symmetric band matrix, with k
+  // super-diagonals; x and y are n-element vectors.
+  virtual bool DoBlasSbmv(Stream *stream, blas::UpperLower uplo, uint64_t n,
+                          uint64_t k, float alpha, const DeviceMemory<float> &a,
+                          int lda, const DeviceMemory<float> &x, int incx,
+                          float beta, DeviceMemory<float> *y, int incy) = 0;
+  virtual bool DoBlasSbmv(Stream *stream, blas::UpperLower uplo, uint64_t n,
+                          uint64_t k, double alpha,
+                          const DeviceMemory<double> &a, int lda,
+                          const DeviceMemory<double> &x, int incx, double beta,
+                          DeviceMemory<double> *y, int incy) = 0;
+
+  // Computes a matrix-matrix product with general matrices:
+  //
+  //     c <- alpha * op(a) * op(b) + beta * c,
+  //
+  // op(X) is one of op(X) = X, or op(X) = X', or op(X) = conj(X'); alpha and
+  // beta are scalars; a, b, and c are matrices; op(a) is an m-by-k matrix;
+  // op(b) is a k-by-n matrix; c is an m-by-n matrix.
+  //
+  // Note: The half interface uses float precision internally; the version
+  // that uses half precision internally is not yet supported. There is no
+  // batched version of the half-precision interface.
+  //
+  // Alpha/beta type matches `dtype`, unless `dtype` is `Eigen::half`, in that
+  // case the expected alpha/beta type is `float`.
+  virtual tsl::Status DoBlasGemm(Stream *stream, blas::Transpose transa,
+                                 blas::Transpose transb, uint64_t m, uint64 n,
+                                 uint64_t k, DataType dtype, const void *alpha,
+                                 const DeviceMemoryBase &a, int lda,
+                                 const DeviceMemoryBase &b, int ldb,
+                                 const void *beta, DeviceMemoryBase *c, int ldc,
+                                 const NumericOptions &numeric_options) = 0;
+
+  // Gets a list of supported algorithms for DoBlasGemmWithAlgorithm.
+  virtual bool GetBlasGemmAlgorithms(
+      Stream *stream, std::vector<AlgorithmType> *out_algorithms) = 0;
+
+  // Like DoBlasGemm, but accepts an algorithm and an compute type.
+  //
+  // The compute type lets you say (e.g.) that the inputs and outputs are
+  // Eigen::halfs, but you want the internal computations to be done with
+  // float32 precision.
+  //
+  // If output_profile_result is not null, a failure here does not put the
+  // stream in a failure state.  Instead, success/failure is indicated by
+  // output_profile_result->is_valid().  This lets you use this function for
+  // choosing the best algorithm among many (some of which may fail) without
+  // creating a new Stream for each attempt.
+  virtual tsl::Status DoBlasGemmWithAlgorithm(
+      Stream *stream, blas::Transpose transa, blas::Transpose transb,
+      uint64_t m, uint64_t n, uint64 k, const void *alpha,
+      const DeviceMemoryBase &a, DataType type_a, int lda,
+      const DeviceMemoryBase &b, DataType type_b, int ldb, const void *beta,
+      DeviceMemoryBase *c, DataType type_c, int ldc,
+      ComputationType computation_type, AlgorithmType algorithm,
+      const NumericOptions &numeric_options,
+      ProfileResult *output_profile_result) = 0;
+
+  virtual tsl::Status DoBlasGemmStridedBatchedWithAlgorithm(
+      Stream *stream, blas::Transpose transa, blas::Transpose transb,
+      uint64_t m, uint64_t n, uint64 k, const void *alpha,
+      const DeviceMemoryBase &a, DataType type_a, int lda, int64_t stride_a,
+      const DeviceMemoryBase &b, DataType type_b, int ldb, int64_t stride_b,
+      const void *beta, DeviceMemoryBase *c, DataType type_c, int ldc,
+      int64_t stride_c, int batch_count, ComputationType computation_type,
+      AlgorithmType algorithm, const NumericOptions &numeric_options,
+      ProfileResult *output_profile_result) = 0;
+
+  // Computes a batch of matrix-matrix product with general matrices.
+  // This is a batched version of DoBlasGemm.
+  // The batched GEMM computes matrix product for each input/output in a, b,
+  // and c, which contain batch_count DeviceMemory objects.
+  virtual bool DoBlasGemmBatched(Stream *stream, blas::Transpose transa,
+                                 blas::Transpose transb, uint64_t m, uint64_t n,
+                                 uint64 k, float alpha,
+                                 DeviceMemorySlice<Eigen::half> a, int lda,
+                                 DeviceMemorySlice<Eigen::half> b, int ldb,
+                                 float beta, DeviceMemorySlice<Eigen::half> c,
+                                 int ldc, int batch_count,
+                                 const NumericOptions &numeric_options,
+                                 ScratchAllocator *scratch_allocator) = 0;
+  virtual bool DoBlasGemmBatched(Stream *stream, blas::Transpose transa,
+                                 blas::Transpose transb, uint64_t m, uint64_t n,
+                                 uint64 k, float alpha,
+                                 DeviceMemorySlice<Eigen::bfloat16> a, int lda,
+                                 DeviceMemorySlice<Eigen::bfloat16> b, int ldb,
+                                 float beta,
+                                 DeviceMemorySlice<Eigen::bfloat16> c, int ldc,
+                                 int batch_count,
+                                 const NumericOptions &numeric_options,
+                                 ScratchAllocator *scratch_allocator) = 0;
+  virtual bool DoBlasGemmBatched(Stream *stream, blas::Transpose transa,
+                                 blas::Transpose transb, uint64_t m, uint64_t n,
+                                 uint64 k, float alpha,
+                                 DeviceMemorySlice<float> a, int lda,
+                                 DeviceMemorySlice<float> b, int ldb,
+                                 float beta, DeviceMemorySlice<float> c,
+                                 int ldc, int batch_count,
+                                 const NumericOptions &numeric_options,
+                                 ScratchAllocator *scratch_allocator) = 0;
+  virtual bool DoBlasGemmBatched(Stream *stream, blas::Transpose transa,
+                                 blas::Transpose transb, uint64_t m, uint64_t n,
+                                 uint64 k, double alpha,
+                                 DeviceMemorySlice<double> a, int lda,
+                                 DeviceMemorySlice<double> b, int ldb,
+                                 double beta, DeviceMemorySlice<double> c,
+                                 int ldc, int batch_count,
+                                 const NumericOptions &numeric_options,
+                                 ScratchAllocator *scratch_allocator) = 0;
+  virtual bool DoBlasGemmBatched(
+      Stream *stream, blas::Transpose transa, blas::Transpose transb,
+      uint64_t m, uint64_t n, uint64 k, std::complex<float> alpha,
+      DeviceMemorySlice<std::complex<float>> a, int lda,
+      DeviceMemorySlice<std::complex<float>> b, int ldb,
+      std::complex<float> beta, DeviceMemorySlice<std::complex<float>> c,
+      int ldc, int batch_count, const NumericOptions &numeric_options,
+      ScratchAllocator *scratch_allocator) = 0;
+  virtual bool DoBlasGemmBatched(
+      Stream *stream, blas::Transpose transa, blas::Transpose transb,
+      uint64_t m, uint64_t n, uint64 k, std::complex<double> alpha,
+      DeviceMemorySlice<std::complex<double>> a, int lda,
+      DeviceMemorySlice<std::complex<double>> b, int ldb,
+      std::complex<double> beta, DeviceMemorySlice<std::complex<double>> c,
+      int ldc, int batch_count, const NumericOptions &numeric_options,
+      ScratchAllocator *scratch_allocator) = 0;
+
+  // Batched gemm with strides instead of pointer arrays.
+  virtual tsl::Status DoBlasGemmStridedBatched(
+      Stream *stream, blas::Transpose transa, blas::Transpose transb,
+      uint64_t m, uint64_t n, uint64 k, DataType dtype, const void *alpha,
+      const DeviceMemoryBase &a, int lda, int64_t stride_a,
+      const DeviceMemoryBase &b, int ldb, int64_t stride_b, const void *beta,
+      DeviceMemoryBase *c, int ldc, int64_t stride_c, int batch_count,
+      const NumericOptions &numeric_options) = 0;
+
+  // Solves a triangular matrix equation.
+  //
+  //     op(a) * x = alpha * b,
+  // or
+  //     x * op(a) = alpha * b
+  //
+  // alpha is a scalar; x and b are m-by-n matrices; a is a unit, or non-unit,
+  // upper or lower triangular matrix; op(a) is one of op(a) = a, or op(a) = a',
+  // or op(a) = conj(a').
+  virtual bool DoBlasTrsm(Stream *stream, blas::Side side,
+                          blas::UpperLower uplo, blas::Transpose transa,
+                          blas::Diagonal diag, uint64_t m, uint64 n,
+                          float alpha, const DeviceMemory<float> &a, int lda,
+                          DeviceMemory<float> *b, int ldb) = 0;
+  virtual bool DoBlasTrsm(Stream *stream, blas::Side side,
+                          blas::UpperLower uplo, blas::Transpose transa,
+                          blas::Diagonal diag, uint64_t m, uint64 n,
+                          double alpha, const DeviceMemory<double> &a, int lda,
+                          DeviceMemory<double> *b, int ldb) = 0;
+  virtual bool DoBlasTrsm(Stream *stream, blas::Side side,
+                          blas::UpperLower uplo, blas::Transpose transa,
+                          blas::Diagonal diag, uint64_t m, uint64 n,
+                          std::complex<float> alpha,
+                          const DeviceMemory<std::complex<float>> &a, int lda,
+                          DeviceMemory<std::complex<float>> *b, int ldb) = 0;
+  virtual bool DoBlasTrsm(Stream *stream, blas::Side side,
+                          blas::UpperLower uplo, blas::Transpose transa,
+                          blas::Diagonal diag, uint64_t m, uint64 n,
+                          std::complex<double> alpha,
+                          const DeviceMemory<std::complex<double>> &a, int lda,
+                          DeviceMemory<std::complex<double>> *b, int ldb) = 0;
+
+  // Same as DoBlasTrsm, but operates over a list of a's and b's.  The lists
+  // `as` and `bs` must have the same length.
+  virtual bool DoBlasTrsmBatched(Stream *stream, blas::Side side,
+                                 blas::UpperLower uplo, blas::Transpose transa,
+                                 blas::Diagonal diag, uint64_t m, uint64 n,
+                                 float alpha, const DeviceMemory<float *> &as,
+                                 int lda, DeviceMemory<float *> *bs, int ldb,
+                                 int batch_count) = 0;
+  virtual bool DoBlasTrsmBatched(Stream *stream, blas::Side side,
+                                 blas::UpperLower uplo, blas::Transpose transa,
+                                 blas::Diagonal diag, uint64_t m, uint64 n,
+                                 double alpha, const DeviceMemory<double *> &as,
+                                 int lda, DeviceMemory<double *> *bs, int ldb,
+                                 int batch_count) = 0;
+  virtual bool DoBlasTrsmBatched(Stream *stream, blas::Side side,
+                                 blas::UpperLower uplo, blas::Transpose transa,
+                                 blas::Diagonal diag, uint64_t m, uint64 n,
+                                 std::complex<float> alpha,
+                                 const DeviceMemory<std::complex<float> *> &as,
+                                 int lda,
+                                 DeviceMemory<std::complex<float> *> *bs,
+                                 int ldb, int batch_count) = 0;
+  virtual bool DoBlasTrsmBatched(Stream *stream, blas::Side side,
+                                 blas::UpperLower uplo, blas::Transpose transa,
+                                 blas::Diagonal diag, uint64_t m, uint64 n,
+                                 std::complex<double> alpha,
+                                 const DeviceMemory<std::complex<double> *> &as,
+                                 int lda,
+                                 DeviceMemory<std::complex<double> *> *bs,
+                                 int ldb, int batch_count) = 0;
+
+  virtual tsl::Status GetVersion(std::string *version) = 0;
+
+ protected:
+  BlasSupport() {}
+
+ private:
+  BlasSupport(const BlasSupport &) = delete;
+  void operator=(const BlasSupport &) = delete;
+};
+
+// Macro used to quickly declare overrides for abstract virtuals in the
+// BlasSupport base class.
+#define TENSORFLOW_STREAM_EXECUTOR_GPU_BLAS_SUPPORT_OVERRIDES                  \
+  bool DoBlasAxpy(Stream *stream, uint64_t elem_count, float alpha,            \
+                  const DeviceMemory<float> &x, int incx,                      \
+                  DeviceMemory<float> *y, int incy) override;                  \
+  bool DoBlasAxpy(Stream *stream, uint64_t elem_count, double alpha,           \
+                  const DeviceMemory<double> &x, int incx,                     \
+                  DeviceMemory<double> *y, int incy) override;                 \
+  bool DoBlasAxpy(Stream *stream, uint64_t elem_count,                         \
+                  std::complex<float> alpha,                                   \
+                  const DeviceMemory<std::complex<float>> &x, int incx,        \
+                  DeviceMemory<std::complex<float>> *y, int incy) override;    \
+  bool DoBlasAxpy(Stream *stream, uint64_t elem_count,                         \
+                  std::complex<double> alpha,                                  \
+                  const DeviceMemory<std::complex<double>> &x, int incx,       \
+                  DeviceMemory<std::complex<double>> *y, int incy) override;   \
+  bool DoBlasCopy(Stream *stream, uint64_t elem_count,                         \
+                  const DeviceMemory<float> &x, int incx,                      \
+                  DeviceMemory<float> *y, int incy) override;                  \
+  bool DoBlasCopy(Stream *stream, uint64_t elem_count,                         \
+                  const DeviceMemory<double> &x, int incx,                     \
+                  DeviceMemory<double> *y, int incy) override;                 \
+  bool DoBlasCopy(Stream *stream, uint64_t elem_count,                         \
+                  const DeviceMemory<std::complex<float>> &x, int incx,        \
+                  DeviceMemory<std::complex<float>> *y, int incy) override;    \
+  bool DoBlasCopy(Stream *stream, uint64_t elem_count,                         \
+                  const DeviceMemory<std::complex<double>> &x, int incx,       \
+                  DeviceMemory<std::complex<double>> *y, int incy) override;   \
+  bool DoBlasScal(Stream *stream, uint64_t elem_count, float alpha,            \
+                  DeviceMemory<float> *x, int incx) override;                  \
+  bool DoBlasScal(Stream *stream, uint64_t elem_count, double alpha,           \
+                  DeviceMemory<double> *x, int incx) override;                 \
+  bool DoBlasScal(Stream *stream, uint64_t elem_count, float alpha,            \
+                  DeviceMemory<std::complex<float>> *x, int incx) override;    \
+  bool DoBlasScal(Stream *stream, uint64_t elem_count, double alpha,           \
+                  DeviceMemory<std::complex<double>> *x, int incx) override;   \
+  bool DoBlasScal(Stream *stream, uint64_t elem_count,                         \
+                  std::complex<float> alpha,                                   \
+                  DeviceMemory<std::complex<float>> *x, int incx) override;    \
+  bool DoBlasScal(Stream *stream, uint64_t elem_count,                         \
+                  std::complex<double> alpha,                                  \
+                  DeviceMemory<std::complex<double>> *x, int incx) override;   \
+  bool DoBlasGemv(Stream *stream, blas::Transpose trans, uint64_t m, uint64 n, \
+                  float alpha, const DeviceMemory<float> &a, int lda,          \
+                  const DeviceMemory<float> &x, int incx, float beta,          \
+                  DeviceMemory<float> *y, int incy) override;                  \
+  bool DoBlasGemv(Stream *stream, blas::Transpose trans, uint64_t m, uint64 n, \
+                  double alpha, const DeviceMemory<double> &a, int lda,        \
+                  const DeviceMemory<double> &x, int incx, double beta,        \
+                  DeviceMemory<double> *y, int incy) override;                 \
+  bool DoBlasGemv(Stream *stream, blas::Transpose trans, uint64_t m, uint64 n, \
+                  std::complex<float> alpha,                                   \
+                  const DeviceMemory<std::complex<float>> &a, int lda,         \
+                  const DeviceMemory<std::complex<float>> &x, int incx,        \
+                  std::complex<float> beta,                                    \
+                  DeviceMemory<std::complex<float>> *y, int incy) override;    \
+  bool DoBlasGemv(Stream *stream, blas::Transpose trans, uint64_t m, uint64 n, \
+                  std::complex<double> alpha,                                  \
+                  const DeviceMemory<std::complex<double>> &a, int lda,        \
+                  const DeviceMemory<std::complex<double>> &x, int incx,       \
+                  std::complex<double> beta,                                   \
+                  DeviceMemory<std::complex<double>> *y, int incy) override;   \
+  bool DoBlasSbmv(Stream *stream, blas::UpperLower uplo, uint64_t n, uint64 k, \
+                  float alpha, const DeviceMemory<float> &a, int lda,          \
+                  const DeviceMemory<float> &x, int incx, float beta,          \
+                  DeviceMemory<float> *y, int incy) override;                  \
+  bool DoBlasSbmv(Stream *stream, blas::UpperLower uplo, uint64_t n, uint64 k, \
+                  double alpha, const DeviceMemory<double> &a, int lda,        \
+                  const DeviceMemory<double> &x, int incx, double beta,        \
+                  DeviceMemory<double> *y, int incy) override;                 \
+  tsl::Status DoBlasGemm(                                                      \
+      Stream *stream, blas::Transpose transa, blas::Transpose transb,          \
+      uint64_t m, uint64 n, uint64 k, blas::DataType dtype, const void *alpha, \
+      const DeviceMemoryBase &a, int lda, const DeviceMemoryBase &b, int ldb,  \
+      const void *beta, DeviceMemoryBase *c, int ldc,                          \
+      const NumericOptions &numeric_options) override;                         \
+  bool GetBlasGemmAlgorithms(Stream *stream,                                   \
+                             std::vector<blas::AlgorithmType> *out_algorithms) \
+      override;                                                                \
+  tsl::Status DoBlasGemmWithAlgorithm(                                         \
+      Stream *stream, blas::Transpose transa, blas::Transpose transb,          \
+      uint64_t m, uint64 n, uint64 k, const void *alpha,                       \
+      const DeviceMemoryBase &a, blas::DataType type_a, int lda,               \
+      const DeviceMemoryBase &b, blas::DataType type_b, int ldb,               \
+      const void *beta, DeviceMemoryBase *c, blas::DataType type_c, int ldc,   \
+      blas::ComputationType computation_type, blas::AlgorithmType algorithm,   \
+      const NumericOptions &numeric_options,                                   \
+      blas::ProfileResult *output_profile_result) override;                    \
+  bool DoBlasGemmBatched(                                                      \
+      Stream *stream, blas::Transpose transa, blas::Transpose transb,          \
+      uint64_t m, uint64 n, uint64 k, float alpha,                             \
+      DeviceMemorySlice<Eigen::half> a, int lda,                               \
+      DeviceMemorySlice<Eigen::half> b, int ldb, float beta,                   \
+      DeviceMemorySlice<Eigen::half> c, int ldc, int batch_count,              \
+      const NumericOptions &numeric_options,                                   \
+      ScratchAllocator *scratch_allocator) override;                           \
+  bool DoBlasGemmBatched(                                                      \
+      Stream *stream, blas::Transpose transa, blas::Transpose transb,          \
+      uint64_t m, uint64 n, uint64 k, float alpha,                             \
+      DeviceMemorySlice<Eigen::bfloat16> a, int lda,                           \
+      DeviceMemorySlice<Eigen::bfloat16> b, int ldb, float beta,               \
+      DeviceMemorySlice<Eigen::bfloat16> c, int ldc, int batch_count,          \
+      const NumericOptions &numeric_options,                                   \
+      ScratchAllocator *scratch_allocator) override;                           \
+  bool DoBlasGemmBatched(                                                      \
+      Stream *stream, blas::Transpose transa, blas::Transpose transb,          \
+      uint64_t m, uint64 n, uint64 k, float alpha, DeviceMemorySlice<float> a, \
+      int lda, DeviceMemorySlice<float> b, int ldb, float beta,                \
+      DeviceMemorySlice<float> c, int ldc, int batch_count,                    \
+      const NumericOptions &numeric_options,                                   \
+      ScratchAllocator *scratch_allocator) override;                           \
+  bool DoBlasGemmBatched(                                                      \
+      Stream *stream, blas::Transpose transa, blas::Transpose transb,          \
+      uint64_t m, uint64 n, uint64 k, double alpha,                            \
+      DeviceMemorySlice<double> a, int lda, DeviceMemorySlice<double> b,       \
+      int ldb, double beta, DeviceMemorySlice<double> c, int ldc,              \
+      int batch_count, const NumericOptions &numeric_options,                  \
+      ScratchAllocator *scratch_allocator) override;                           \
+  bool DoBlasGemmBatched(                                                      \
+      Stream *stream, blas::Transpose transa, blas::Transpose transb,          \
+      uint64_t m, uint64 n, uint64 k, std::complex<float> alpha,               \
+      DeviceMemorySlice<std::complex<float>> a, int lda,                       \
+      DeviceMemorySlice<std::complex<float>> b, int ldb,                       \
+      std::complex<float> beta, DeviceMemorySlice<std::complex<float>> c,      \
+      int ldc, int batch_count, const NumericOptions &numeric_options,         \
+      ScratchAllocator *scratch_allocator) override;                           \
+  bool DoBlasGemmBatched(                                                      \
+      Stream *stream, blas::Transpose transa, blas::Transpose transb,          \
+      uint64_t m, uint64 n, uint64 k, std::complex<double> alpha,              \
+      DeviceMemorySlice<std::complex<double>> a, int lda,                      \
+      DeviceMemorySlice<std::complex<double>> b, int ldb,                      \
+      std::complex<double> beta, DeviceMemorySlice<std::complex<double>> c,    \
+      int ldc, int batch_count, const NumericOptions &numeric_options,         \
+      ScratchAllocator *scratch_allocator) override;                           \
+  tsl::Status DoBlasGemmStridedBatched(                                        \
+      Stream *stream, blas::Transpose transa, blas::Transpose transb,          \
+      uint64_t m, uint64 n, uint64 k, blas::DataType dtype, const void *alpha, \
+      const DeviceMemoryBase &a, int lda, int64_t stride_a,                    \
+      const DeviceMemoryBase &b, int ldb, int64_t stride_b, const void *beta,  \
+      DeviceMemoryBase *c, int ldc, int64_t stride_c, int batch_count,         \
+      const NumericOptions &numeric_options) override;                         \
+  tsl::Status DoBlasGemmStridedBatchedWithAlgorithm(                           \
+      Stream *stream, blas::Transpose transa, blas::Transpose transb,          \
+      uint64_t m, uint64 n, uint64 k, const void *alpha,                       \
+      const DeviceMemoryBase &a, blas::DataType type_a, int lda,               \
+      int64_t stride_a, const DeviceMemoryBase &b, blas::DataType type_b,      \
+      int ldb, int64_t stride_b, const void *beta, DeviceMemoryBase *c,        \
+      blas::DataType type_c, int ldc, int64_t stride_c, int batch_count,       \
+      blas::ComputationType computation_type, blas::AlgorithmType algorithm,   \
+      const NumericOptions &numeric_options,                                   \
+      blas::ProfileResult *output_profile_result) override;                    \
+  bool DoBlasTrsm(Stream *stream, blas::Side side, blas::UpperLower uplo,      \
+                  blas::Transpose transa, blas::Diagonal diag, uint64_t m,     \
+                  uint64_t n, float alpha, const DeviceMemory<float> &a,       \
+                  int lda, DeviceMemory<float> *b, int ldb) override;          \
+  bool DoBlasTrsm(Stream *stream, blas::Side side, blas::UpperLower uplo,      \
+                  blas::Transpose transa, blas::Diagonal diag, uint64_t m,     \
+                  uint64_t n, double alpha, const DeviceMemory<double> &a,     \
+                  int lda, DeviceMemory<double> *b, int ldb) override;         \
+  bool DoBlasTrsm(Stream *stream, blas::Side side, blas::UpperLower uplo,      \
+                  blas::Transpose transa, blas::Diagonal diag, uint64_t m,     \
+                  uint64_t n, std::complex<float> alpha,                       \
+                  const DeviceMemory<std::complex<float>> &a, int lda,         \
+                  DeviceMemory<std::complex<float>> *b, int ldb) override;     \
+  bool DoBlasTrsm(Stream *stream, blas::Side side, blas::UpperLower uplo,      \
+                  blas::Transpose transa, blas::Diagonal diag, uint64_t m,     \
+                  uint64_t n, std::complex<double> alpha,                      \
+                  const DeviceMemory<std::complex<double>> &a, int lda,        \
+                  DeviceMemory<std::complex<double>> *b, int ldb) override;    \
+  bool DoBlasTrsmBatched(                                                      \
+      Stream *stream, blas::Side side, blas::UpperLower uplo,                  \
+      blas::Transpose transa, blas::Diagonal diag, uint64_t m, uint64 n,       \
+      float alpha, const DeviceMemory<float *> &as, int lda,                   \
+      DeviceMemory<float *> *bs, int ldb, int batch_count) override;           \
+  bool DoBlasTrsmBatched(                                                      \
+      Stream *stream, blas::Side side, blas::UpperLower uplo,                  \
+      blas::Transpose transa, blas::Diagonal diag, uint64_t m, uint64 n,       \
+      double alpha, const DeviceMemory<double *> &as, int lda,                 \
+      DeviceMemory<double *> *bs, int ldb, int batch_count) override;          \
+  bool DoBlasTrsmBatched(Stream *stream, blas::Side side,                      \
+                         blas::UpperLower uplo, blas::Transpose transa,        \
+                         blas::Diagonal diag, uint64_t m, uint64 n,            \
+                         std::complex<float> alpha,                            \
+                         const DeviceMemory<std::complex<float> *> &as,        \
+                         int lda, DeviceMemory<std::complex<float> *> *bs,     \
+                         int ldb, int batch_count) override;                   \
+  bool DoBlasTrsmBatched(Stream *stream, blas::Side side,                      \
+                         blas::UpperLower uplo, blas::Transpose transa,        \
+                         blas::Diagonal diag, uint64_t m, uint64 n,            \
+                         std::complex<double> alpha,                           \
+                         const DeviceMemory<std::complex<double> *> &as,       \
+                         int lda, DeviceMemory<std::complex<double> *> *bs,    \
+                         int ldb, int batch_count) override;                   \
+  tsl::Status GetVersion(std::string *version) override;
+
+}  // namespace blas
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_BLAS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/command_buffer.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/command_buffer.h
new file mode 100644
index 0000000000000000000000000000000000000000..2587872d27e5438ff733391d47a4f3aec43db17f
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/command_buffer.h
@@ -0,0 +1,163 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_STREAM_EXECUTOR_COMMAND_BUFFER_H_
+#define XLA_STREAM_EXECUTOR_COMMAND_BUFFER_H_
+
+#include <cstdint>
+#include <memory>
+#include <tuple>
+
+#include "absl/functional/any_invocable.h"
+#include "xla/stream_executor/kernel.h"
+#include "xla/stream_executor/launch_dim.h"
+#include "tsl/platform/errors.h"
+#include "tsl/platform/status.h"
+#include "tsl/platform/statusor.h"
+
+namespace stream_executor {
+
+class Stream;
+class StreamExecutor;
+
+namespace internal {
+class CommandBufferInterface;
+}
+
+//===----------------------------------------------------------------------===//
+// CommandBuffer
+//===----------------------------------------------------------------------===//
+
+// Command buffer represent a "bundle of work items" for StreamExecutor device
+// that can be submitted with one API call, e.g. command buffer might have
+// multiple device kernels and synchronization barriers between them. Command
+// buffers allow to amortize the cost of launching "work" on device by building
+// it on the host ahead of time without expensive interaction with underlying
+// device.
+class CommandBuffer {
+ public:
+  // Command buffer state:
+  //
+  //   (1) kCreate:    a new command buffer under construction
+  //   (2) kUpdate:    updating a previously finalized command buffer
+  //   (3) kFinalized: command buffer ready for execution
+  //
+  // Supported state transitions:
+  //
+  //   (1) Finalize: (kCreate|kUpdate) -> kFinalized
+  //   (2) Update:   kFinalized -> kUpdate
+  //
+  enum class State { kCreate, kUpdate, kFinalized };
+
+  // Command buffers have two modes of execution:
+  //
+  //   (1) kPrimary: command buffer can be submitted for execution via
+  //                 StreamExecutor APIs
+  //   (2) kNested:  command buffer can be executed only within a primary
+  //                 command buffer
+  //
+  enum class Mode { kPrimary, kNested };
+
+  //===--------------------------------------------------------------------===//
+  // Command buffer constructors
+  //===--------------------------------------------------------------------===//
+
+  // Creates a new empty command buffer on the given executor.
+  static tsl::StatusOr<CommandBuffer> Create(StreamExecutor* executor,
+                                             Mode mode = Mode::kPrimary);
+
+  // Creates a new command buffer on the given executor by tracing `function`
+  // invocation. All StreamExecutor operations on a Stream argument will be
+  // recorded into the command buffer. Returned command buffer is finalized, and
+  // can't be updated.
+  //
+  // Command buffer tracing should be used only when it is impossible to use
+  // explicit construction APIs, e.g. when calling external libraries.
+  static tsl::StatusOr<CommandBuffer> Trace(
+      StreamExecutor* executor,
+      absl::AnyInvocable<tsl::Status(Stream*)> function,
+      Mode mode = Mode::kPrimary);
+
+  //===--------------------------------------------------------------------===//
+  // Command buffer API
+  //===--------------------------------------------------------------------===//
+
+  // Adds a kernel launch command to the command buffer.
+  tsl::Status Launch(const ThreadDim& threads, const BlockDim& blocks,
+                     const KernelBase& kernel, const KernelArgsArrayBase& args);
+
+  // Adds a device-to-device memory copy to the command buffer.
+  tsl::Status MemcpyDeviceToDevice(DeviceMemoryBase* dst,
+                                   const DeviceMemoryBase& src, uint64_t size);
+
+  // Finalizes command buffer and makes it executable. Once command buffer is
+  // finalized no commands can be added to it.
+  tsl::Status Finalize();
+
+  // Begins command buffer update. Command buffer update should be finalized
+  // before it can be executed.
+  tsl::Status Update();
+
+  // Type-safe wrapper for launching typed kernels. Notice that the order of
+  // arguments is different do disambiguate from the regular launch API.
+  template <typename... Params, typename... Args>
+  tsl::Status Launch(const TypedKernel<Params...>& kernel,
+                     const ThreadDim& threads, const BlockDim& blocks,
+                     Args... args);
+
+  // Returns command buffer execution mode.
+  Mode mode() const;
+
+  internal::CommandBufferInterface* implementation() {
+    return implementation_.get();
+  }
+
+  const internal::CommandBufferInterface* implementation() const {
+    return implementation_.get();
+  }
+
+  CommandBuffer(CommandBuffer&&) = default;
+  CommandBuffer& operator=(CommandBuffer&&) = default;
+
+ private:
+  explicit CommandBuffer(
+      std::unique_ptr<internal::CommandBufferInterface> implementation);
+
+  std::unique_ptr<internal::CommandBufferInterface> implementation_;
+
+  CommandBuffer(const CommandBuffer&) = delete;
+  void operator=(const CommandBuffer&) = delete;
+};
+
+//===----------------------------------------------------------------------===//
+// CommandBuffer templates implementation below
+//===----------------------------------------------------------------------===//
+
+template <typename... Params, typename... Args>
+inline tsl::Status CommandBuffer::Launch(const TypedKernel<Params...>& kernel,
+                                         const ThreadDim& threads,
+                                         const BlockDim& blocks, Args... args) {
+  KernelInvocationChecker<std::tuple<Params...>,
+                          std::tuple<Args...>>::CheckAllStaticAssert();
+
+  KernelArgsArray<sizeof...(args)> kernel_args;
+  kernel.PackParams(&kernel_args, args...);
+  TF_RETURN_IF_ERROR(Launch(threads, blocks, kernel, kernel_args));
+  return tsl::OkStatus();
+}
+
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_COMMAND_BUFFER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/cuda/cuda_activation.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/cuda/cuda_activation.h
new file mode 100644
index 0000000000000000000000000000000000000000..bcdc8f5e178efec265331e3c3d551f09f231b8e4
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/cuda/cuda_activation.h
@@ -0,0 +1,39 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// This file contains APIs that assume a StreamExecutor is backed by CUDA.
+// It reaches into the CUDA implementation to activate an underlying CUDA
+// context.
+//
+// Having this file separate from cuda/cuda_executor.h means that dependent
+// code does not also have to depend on cuda.h.
+
+#ifndef XLA_STREAM_EXECUTOR_CUDA_CUDA_ACTIVATION_H_
+#define XLA_STREAM_EXECUTOR_CUDA_CUDA_ACTIVATION_H_
+
+#include "xla/stream_executor/gpu/gpu_activation.h"
+
+namespace stream_executor {
+
+class StreamExecutor;
+
+namespace cuda {
+
+using ScopedActivateExecutorContext = gpu::ScopedActivateExecutorContext;
+
+}  // namespace cuda
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_CUDA_CUDA_ACTIVATION_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.h
new file mode 100644
index 0000000000000000000000000000000000000000..a23fb616181e4261f4879604d59dfa81b9783118
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.h
@@ -0,0 +1,131 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// CUDA-specific support for BLAS functionality -- this wraps the cuBLAS library
+// capabilities, and is only included into CUDA implementation code -- it will
+// not introduce cuda headers into other code.
+
+#ifndef XLA_STREAM_EXECUTOR_CUDA_CUDA_BLAS_H_
+#define XLA_STREAM_EXECUTOR_CUDA_CUDA_BLAS_H_
+
+#include "absl/base/thread_annotations.h"
+#include "absl/synchronization/mutex.h"
+#include "third_party/gpus/cuda/include/cublas_v2.h"
+#include "xla/stream_executor/blas.h"
+#include "xla/stream_executor/cuda/cuda_blas_lt.h"
+#include "xla/stream_executor/platform/port.h"
+#include "xla/stream_executor/plugin_registry.h"
+
+namespace stream_executor {
+
+class Stream;
+
+namespace gpu {
+class GpuExecutor;
+}  // namespace gpu
+
+namespace cuda {
+
+// BLAS plugin for CUDA platform via cuBLAS library.
+//
+// This satisfies the platform-agnostic BlasSupport interface.
+//
+// Note that the cuBLAS handle that this encapsulates is implicitly tied to the
+// context (and, as a result, the device) that the parent GpuExecutor is tied
+// to. This simply happens as an artifact of creating the cuBLAS handle when a
+// CUDA context is active.
+//
+// Thread-safe post-initialization.
+class CUDABlas : public blas::BlasSupport {
+ public:
+  explicit CUDABlas(gpu::GpuExecutor *parent);
+
+  // Allocates a cuBLAS handle.
+  bool Init();
+
+  // Releases the cuBLAS handle, if present.
+  ~CUDABlas() override;
+
+  TENSORFLOW_STREAM_EXECUTOR_GPU_BLAS_SUPPORT_OVERRIDES
+
+  BlasLt &blas_lt() { return blas_lt_; }
+
+ private:
+  // Tells cuBLAS to enqueue the BLAS operation onto a particular Stream.
+  //
+  // cuBLAS is stateful, and only be associated with one stream (in order to
+  // enqueue dispatch) at a given time. As a result, this generally must be
+  // invoked before calling into cuBLAS.
+  bool SetStream(Stream *stream) ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+
+  // Returns the underlying CUDA stream.
+  cudaStream_t CUDAStream(Stream *stream);
+
+  // A helper function that calls the real cuBLAS function together with error
+  // handling.
+  //
+  // cublas_func:        cuBLAS function pointer.
+  // cublas_name:        cuBLAS function name.
+  // stream:             Stream to enqueue the BLAS operation onto.
+  // pointer_mode_host:  Indicate if the pointer to a scalar value is from host
+  //                     (true) or device (false).
+  // args:               Arguments of cuBLAS function.
+  template <typename FuncT, typename... Args>
+  tsl::Status DoBlasInternalImpl(FuncT cublas_func, Stream *stream,
+                                 bool pointer_mode_host, cublasMath_t math_type,
+                                 Args... args);
+
+  // Convenience functions that call DoBlasInternalImpl with err_on_failure=true
+  // and math_type=CUBLAS_DEFAULT_MATH.
+  template <typename FuncT, typename... Args>
+  bool DoBlasInternal(FuncT cublas_func, Stream *stream, bool pointer_mode_host,
+                      Args... args) {
+    return DoBlasInternalImpl(cublas_func, stream, pointer_mode_host,
+                              CUBLAS_DEFAULT_MATH, args...)
+        .ok();
+  }
+
+  // A helper function to implement DoBlasGemmBatched interfaces for generic
+  // types.
+  template <typename T, typename Scalar, typename FuncT>
+  tsl::Status DoBlasGemmBatchedInternal(
+      FuncT cublas_func, Stream *stream, blas::Transpose transa,
+      blas::Transpose transb, uint64_t m, uint64 n, uint64 k, Scalar alpha,
+      const DeviceMemorySlice<T> &a_array, int lda,
+      const DeviceMemorySlice<T> &b_array, int ldb, Scalar beta,
+      const DeviceMemorySlice<T> &c_array, int ldc, int batch_count,
+      const NumericOptions &numeric_options,
+      ScratchAllocator *scratch_allocator);
+
+  // Guards the cuBLAS handle for this device.
+  absl::Mutex mu_;
+
+  // GpuExecutor which instantiated this CUDABlas.
+  // Immutable post-initialization.
+  gpu::GpuExecutor *parent_;
+
+  // cuBLAS library handle on the device.
+  cublasHandle_t blas_ ABSL_GUARDED_BY(mu_);
+
+  BlasLt blas_lt_;
+
+  CUDABlas(const CUDABlas &) = delete;
+  void operator=(const CUDABlas &) = delete;
+};
+
+}  // namespace cuda
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_CUDA_CUDA_BLAS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/cuda/cuda_blas_lt.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/cuda/cuda_blas_lt.h
new file mode 100644
index 0000000000000000000000000000000000000000..44e11206925f8baea84ca7ca54e6c3acaf8c58e8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/cuda/cuda_blas_lt.h
@@ -0,0 +1,250 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_STREAM_EXECUTOR_CUDA_CUDA_BLAS_LT_H_
+#define XLA_STREAM_EXECUTOR_CUDA_CUDA_BLAS_LT_H_
+
+#include <algorithm>
+#include <memory>
+#include <optional>
+#include <string>
+#include <vector>
+
+#include "third_party/gpus/cuda/include/cublasLt.h"
+#include "third_party/gpus/cuda/include/cublas_v2.h"
+#include "third_party/gpus/cuda/include/cuda.h"
+#include "xla/stream_executor/blas.h"
+#include "xla/stream_executor/cuda/cuda_blas_utils.h"
+#include "xla/stream_executor/device_memory.h"
+#include "xla/stream_executor/host_or_device_scalar.h"
+#include "tsl/platform/status.h"
+
+namespace stream_executor {
+namespace gpu {
+class GpuExecutor;
+}  // namespace gpu
+
+namespace cuda {
+
+class BlasLt {
+  template <typename T>
+  using Owned =
+      std::unique_ptr<std::remove_pointer_t<T>, cublasStatus_t (*)(T)>;
+
+ public:
+  class MatrixLayout {
+   public:
+    enum class Order { kRowMajor, kColumnMajor };
+
+    // If `leading_dim_stride` is not specified, it defaults to:
+    //  - `num_cols` if `order == kRowMajor`,
+    //  - `num_rows` if `order == kColumnMajor`.
+    // If `batch_stride` is not specified, it defaults to `num_rows * num_cols`
+    // if `batch_size > 1`, otherwise `0`.
+    static tsl::StatusOr<MatrixLayout> Create(
+        blas::DataType type, size_t num_rows, size_t num_cols, Order order,
+        size_t batch_size = 1,
+        std::optional<int64_t> leading_dim_stride = std::nullopt,
+        std::optional<int64_t> batch_stride = std::nullopt);
+
+    cudaDataType_t type() const;
+
+    cublasLtMatrixLayout_t get() const { return handle_.get(); }
+
+   private:
+    explicit MatrixLayout(cublasLtMatrixLayout_t handle)
+        : handle_(handle, cublasLtMatrixLayoutDestroy) {}
+
+    Owned<cublasLtMatrixLayout_t> handle_;
+  };
+
+  enum class Epilogue {
+    kDefault = 1,                   // No special postprocessing
+    kReLU = 2,                      // Apply point-wise ReLU function
+    kBias = 4,                      // Add broadcasted bias vector
+    kBiasThenReLU = kBias | kReLU,  // Apply bias and then ReLU transform
+    kGELU = 32,                // Apply GELU point-wise transform to the results
+    kGELUWithAux = 32 | 1024,  // Apply GELU with auxiliary output.
+    kBiasThenGELU = kBias | kGELU,  // Apply bias and then approximate GELU.
+    kBiasThenGELUWithAux = kBiasThenGELU | 1024,
+  };
+
+  // Describes the location of pointers for the scaling factors alpha and beta.
+  enum class PointerMode {
+    kHost,
+    kDevice,
+  };
+
+  class MatmulDesc {
+   public:
+    static tsl::StatusOr<MatmulDesc> Create(
+        blas::ComputationType compute_type, blas::DataType scale_type,
+        blas::Transpose trans_a = blas::Transpose::kNoTranspose,
+        blas::Transpose trans_b = blas::Transpose::kNoTranspose,
+        Epilogue epilogue = Epilogue::kDefault,
+        PointerMode pointer_mode = PointerMode::kHost);
+
+    cublasComputeType_t compute_type() const;
+    cudaDataType_t scale_type() const;
+    cublasLtPointerMode_t pointer_mode() const;
+
+    cublasLtMatmulDesc_t get() const { return handle_.get(); }
+
+   private:
+    explicit MatmulDesc(cublasLtMatmulDesc_t handle)
+        : handle_(handle, cublasLtMatmulDescDestroy) {}
+
+    Owned<cublasLtMatmulDesc_t> handle_;
+  };
+
+  // TODO(cjfj): Add consistency checks for types, shapes, etc.?
+  struct MatmulPlan {
+    MatmulDesc op_desc;
+    MatrixLayout a_desc;
+    MatrixLayout b_desc;
+    MatrixLayout c_desc;
+    MatrixLayout d_desc;
+  };
+
+  class MatmulPreference {
+   public:
+    static tsl::StatusOr<MatmulPreference> Create(size_t max_workspace_size);
+
+    cublasLtMatmulPreference_t get() const { return handle_.get(); }
+
+   private:
+    explicit MatmulPreference(cublasLtMatmulPreference_t handle)
+        : handle_(handle, cublasLtMatmulPreferenceDestroy) {}
+
+    Owned<cublasLtMatmulPreference_t> handle_;
+  };
+
+  struct MatmulAlgorithm {
+    cublasLtMatmulAlgo_t algo;
+    size_t workspace_size;
+  };
+
+  explicit BlasLt(gpu::GpuExecutor* parent)
+      : parent_(parent), blas_lt_(nullptr, cublasLtDestroy) {}
+
+  tsl::Status Init();
+
+  // Returns a list of supported algorithms for DoMatmul. The algorithms are
+  // returned in the order of increasing estimated compute time according to an
+  // internal heuristic.
+  tsl::StatusOr<std::vector<MatmulAlgorithm>> GetMatmulAlgorithms(
+      const MatmulPlan& plan, const MatmulPreference& preference,
+      size_t max_algorithm_count = 128);
+
+  template <typename A, typename B, typename C, typename D, typename Scale>
+  tsl::Status DoMatmul(Stream* stream, const MatmulPlan& plan,
+                       const HostOrDeviceScalar<Scale>& alpha,
+                       const DeviceMemory<A>& a, const DeviceMemory<B>& b,
+                       const HostOrDeviceScalar<Scale>& beta,
+                       const DeviceMemory<C>& c, DeviceMemory<D>& d,
+                       const MatmulAlgorithm& algorithm,
+                       ScratchAllocator& scratch_allocator,
+                       const DeviceMemory<C>& bias = {},
+                       const DeviceMemoryBase& aux = DeviceMemory<uint8_t>{},
+                       const DeviceMemory<Scale>& a_scale = {},
+                       const DeviceMemory<Scale>& b_scale = {},
+                       const DeviceMemory<Scale>& c_scale = {},
+                       const DeviceMemory<Scale>& d_scale = {},
+                       const DeviceMemory<Scale>& d_amax = {},
+                       blas::ProfileResult* profile_result = nullptr) {
+    if (AsCudaDataType(blas::ToDataType<Scale>::value) !=
+        plan.op_desc.scale_type()) {
+      return tsl::errors::InvalidArgument("mismatched scale types");
+    }
+
+    bool expect_scale_factor_on_device =
+        (plan.op_desc.pointer_mode() == CUBLASLT_POINTER_MODE_DEVICE);
+
+    if (alpha.on_device() != expect_scale_factor_on_device) {
+      return tsl::errors::InvalidArgument("wrong location for alpha");
+    }
+
+    if (beta.on_device() != expect_scale_factor_on_device) {
+      return tsl::errors::InvalidArgument("wrong location for beta");
+    }
+
+    if (AsCudaDataType(blas::ToDataType<A>::value) != plan.a_desc.type()) {
+      return tsl::errors::InvalidArgument("mismatched A matrix types");
+    }
+
+    if (AsCudaDataType(blas::ToDataType<B>::value) != plan.b_desc.type()) {
+      return tsl::errors::InvalidArgument("mismatched B matrix types");
+    }
+
+    if (AsCudaDataType(blas::ToDataType<C>::value) != plan.c_desc.type()) {
+      return tsl::errors::InvalidArgument("mismatched C matrix types");
+    }
+
+    if (AsCudaDataType(blas::ToDataType<D>::value) != plan.d_desc.type()) {
+      return tsl::errors::InvalidArgument("mismatched D matrix types");
+    }
+
+    return DoMatmul(stream, plan, alpha.opaque(), a, b, beta.opaque(), c, d,
+                    algorithm, scratch_allocator, bias, aux, a_scale, b_scale,
+                    c_scale, d_scale, d_amax, profile_result);
+  }
+
+  template <typename A, typename B, typename C, typename D, typename Scale>
+  tsl::Status DoMatmul(Stream* stream, const MatmulPlan& plan,
+                       const HostOrDeviceScalar<Scale>& alpha,
+                       const DeviceMemory<A>& a, const DeviceMemory<B>& b,
+                       const HostOrDeviceScalar<Scale>& beta,
+                       const DeviceMemory<C>& c, DeviceMemory<D>& d,
+                       const MatmulAlgorithm& algorithm,
+                       ScratchAllocator& scratch_allocator,
+                       const DeviceMemory<C>& bias = {},
+                       const DeviceMemoryBase& aux = DeviceMemory<uint8_t>{},
+                       blas::ProfileResult* profile_result = nullptr) {
+    return DoMatmul(stream, plan, alpha, a, b, beta, c, d, algorithm,
+                    scratch_allocator, bias, aux, {}, {}, {}, {}, {},
+                    profile_result);
+  }
+
+ private:
+  tsl::Status DoMatmul(Stream* stream, const MatmulPlan& plan,
+                       const void* alpha, DeviceMemoryBase a,
+                       DeviceMemoryBase b, const void* beta, DeviceMemoryBase c,
+                       DeviceMemoryBase d, const MatmulAlgorithm& algorithm,
+                       ScratchAllocator& scratch_allocator,
+                       DeviceMemoryBase bias, DeviceMemoryBase aux,
+                       DeviceMemoryBase a_scale, DeviceMemoryBase b_scale,
+                       DeviceMemoryBase c_scale, DeviceMemoryBase d_scale,
+                       DeviceMemoryBase d_amax,
+                       blas::ProfileResult* profile_result);
+
+  gpu::GpuExecutor* parent_;
+
+  absl::Mutex mu_;
+  Owned<cublasLtHandle_t> blas_lt_ ABSL_GUARDED_BY(mu_);
+};
+
+// Returns `BlasLt` implementation for a stream if available, or `nullptr`.
+BlasLt* GetBlasLt(Stream* stream);
+
+}  // namespace cuda
+
+namespace gpu {
+using BlasLt = ::stream_executor::cuda::BlasLt;
+inline BlasLt* GetBlasLt(Stream* stream) { return cuda::GetBlasLt(stream); }
+}  // namespace gpu
+
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_CUDA_CUDA_BLAS_LT_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/cuda/cuda_blas_utils.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/cuda/cuda_blas_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..2e8789b1f1bcde7d87cf5ace2356a9f08d58e109
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/cuda/cuda_blas_utils.h
@@ -0,0 +1,41 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_STREAM_EXECUTOR_CUDA_CUDA_BLAS_UTILS_H_
+#define XLA_STREAM_EXECUTOR_CUDA_CUDA_BLAS_UTILS_H_
+
+#include <string>
+
+#include "third_party/gpus/cuda/include/cublas_v2.h"
+#include "xla/stream_executor/blas.h"
+#include "tsl/platform/errors.h"
+#include "tsl/platform/status.h"
+
+#define SE_CUBLAS_RETURN_IF_ERROR(expr) \
+  TF_RETURN_IF_ERROR(::stream_executor::cuda::ToStatus(expr, #expr))
+
+namespace stream_executor {
+namespace cuda {
+
+const char* ToString(cublasStatus_t status);
+tsl::Status ToStatus(cublasStatus_t status, const char* prefix = "cublasLt");
+cudaDataType_t AsCudaDataType(blas::DataType type);
+cublasComputeType_t AsCublasComputeType(blas::ComputationType type);
+cublasOperation_t AsCublasOperation(blas::Transpose trans);
+
+}  // namespace cuda
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_CUDA_CUDA_BLAS_UTILS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/cuda/cuda_diagnostics.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/cuda/cuda_diagnostics.h
new file mode 100644
index 0000000000000000000000000000000000000000..46d1a001051c658bdca8efeec990b2b51c177b48
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/cuda/cuda_diagnostics.h
@@ -0,0 +1,41 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_STREAM_EXECUTOR_CUDA_CUDA_DIAGNOSTICS_H_
+#define XLA_STREAM_EXECUTOR_CUDA_CUDA_DIAGNOSTICS_H_
+
+#include "xla/stream_executor/gpu/gpu_diagnostics.h"
+
+namespace stream_executor {
+namespace cuda {
+
+// e.g. DriverVersion{346, 3, 4}
+using DriverVersion = gpu::DriverVersion;
+
+// Converts a parsed driver version to string form.
+std::string DriverVersionToString(DriverVersion version);
+
+// Converts a parsed driver version or status value to natural string form.
+std::string DriverVersionStatusToString(tsl::StatusOr<DriverVersion> version);
+
+// Converts a string of a form like "331.79" to a DriverVersion{331, 79}.
+tsl::StatusOr<DriverVersion> StringToDriverVersion(const std::string& value);
+
+using Diagnostician = gpu::Diagnostician;
+
+}  // namespace cuda
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_CUDA_CUDA_DIAGNOSTICS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.h
new file mode 100644
index 0000000000000000000000000000000000000000..1157093b53bedcd891ab9301de6ae48228b3fd7a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.h
@@ -0,0 +1,777 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// The CUDA-specific DNN library support, implementing the general DnnSupport
+// interface.
+
+#ifndef XLA_STREAM_EXECUTOR_CUDA_CUDA_DNN_H_
+#define XLA_STREAM_EXECUTOR_CUDA_CUDA_DNN_H_
+
+#include <cstdint>
+#include <optional>
+#include <string>
+#include <vector>
+
+#include "absl/base/thread_annotations.h"
+#include "absl/types/span.h"
+#include "xla/stream_executor/cuda/cuda_activation.h"
+#include "xla/stream_executor/dnn.h"
+#include "xla/stream_executor/plugin_registry.h"
+#include "xla/stream_executor/temporary_device_memory.h"
+#include "tsl/platform/status.h"
+
+namespace stream_executor {
+namespace gpu {
+
+class GpuExecutor;
+class CudnnRnnDescriptor;
+class CudnnRnnSequenceTensorDescriptor;
+class CudnnRnnStateTensorDescriptor;
+class CudnnCtcLossDescriptor;
+
+using BatchDescriptorSlice = absl::Span<const dnn::BatchDescriptor>;
+
+template <typename T>
+using DeviceMemorySlice = absl::Span<const DeviceMemory<T>* const>;
+
+// cudnn-library based DNN support. For details on overridden interface
+// functions, see dnn.h.
+class CudnnSupport : public dnn::DnnSupport {
+ public:
+  explicit CudnnSupport(GpuExecutor* parent);
+
+  tsl::Status Init() override;
+  tsl::StatusOr<stream_executor::dnn::VersionInfo> GetVersion() override;
+
+  tsl::StatusOr<std::unique_ptr<dnn::RnnDescriptor>> createRnnDescriptor(
+      int num_layers, int hidden_size, int input_size, int cell_size,
+      int batch_size, dnn::RnnInputMode input_mode,
+      dnn::RnnDirectionMode direction_mode, dnn::RnnMode rnn_mode,
+      dnn::DataType data_type, const dnn::AlgorithmConfig& algorithm_config,
+      const NumericOptions& numeric_options, float dropout, uint64_t seed,
+      ScratchAllocator* state_allocator, bool use_padded_io) override;
+
+  tsl::StatusOr<std::unique_ptr<dnn::RnnSequenceTensorDescriptor>>
+  createRnnSequenceTensorDescriptor(int max_seq_length, int batch_size,
+                                    int data_size,
+                                    dnn::DataType data_type) override;
+
+  tsl::StatusOr<std::unique_ptr<dnn::RnnSequenceTensorDescriptor>>
+  createRnnSequenceTensorDescriptor(int max_seq_length, int batch_size,
+                                    int data_size,
+                                    const absl::Span<const int>& seq_lengths,
+                                    bool time_major,
+                                    dnn::DataType data_type) override;
+
+  tsl::StatusOr<std::unique_ptr<dnn::RnnStateTensorDescriptor>>
+  createRnnStateTensorDescriptor(int num_layer, int batch_size, int data_size,
+                                 dnn::DataType data_type) override;
+
+  bool DoRnnForward(Stream* stream, const dnn::RnnDescriptor& rnn_desc,
+                    const dnn::RnnSequenceTensorDescriptor& input_desc,
+                    const DeviceMemory<Eigen::half>& input_data,
+                    const DeviceMemory<int>& seq_lengths_data,
+                    const dnn::RnnStateTensorDescriptor& input_h_desc,
+                    const DeviceMemory<Eigen::half>& input_h_data,
+                    const dnn::RnnStateTensorDescriptor& input_c_desc,
+                    const DeviceMemory<Eigen::half>& input_c_data,
+                    const DeviceMemory<Eigen::half>& params,
+                    const dnn::RnnSequenceTensorDescriptor& output_desc,
+                    DeviceMemory<Eigen::half>* output_data,
+                    const dnn::RnnStateTensorDescriptor& output_h_desc,
+                    DeviceMemory<Eigen::half>* output_h_data,
+                    const dnn::RnnStateTensorDescriptor& output_c_desc,
+                    DeviceMemory<Eigen::half>* output_c_data, bool is_training,
+                    ScratchAllocator* reserve_space_allocator,
+                    ScratchAllocator* workspace_allocator,
+                    dnn::ProfileResult* output_profile_result) override;
+
+  bool DoRnnForward(Stream* stream, const dnn::RnnDescriptor& rnn_desc,
+                    const dnn::RnnSequenceTensorDescriptor& input_desc,
+                    const DeviceMemory<float>& input_data,
+                    const DeviceMemory<int>& seq_lengths_data,
+                    const dnn::RnnStateTensorDescriptor& input_h_desc,
+                    const DeviceMemory<float>& input_h_data,
+                    const dnn::RnnStateTensorDescriptor& input_c_desc,
+                    const DeviceMemory<float>& input_c_data,
+                    const DeviceMemory<float>& params,
+                    const dnn::RnnSequenceTensorDescriptor& output_desc,
+                    DeviceMemory<float>* output_data,
+                    const dnn::RnnStateTensorDescriptor& output_h_desc,
+                    DeviceMemory<float>* output_h_data,
+                    const dnn::RnnStateTensorDescriptor& output_c_desc,
+                    DeviceMemory<float>* output_c_data, bool is_training,
+                    ScratchAllocator* reserve_space_allocator,
+                    ScratchAllocator* workspace_allocator,
+                    dnn::ProfileResult* output_profile_result) override;
+
+  bool DoRnnForward(Stream* stream, const dnn::RnnDescriptor& rnn_desc,
+                    const dnn::RnnSequenceTensorDescriptor& input_desc,
+                    const DeviceMemory<double>& input_data,
+                    const DeviceMemory<int>& seq_lengths_data,
+                    const dnn::RnnStateTensorDescriptor& input_h_desc,
+                    const DeviceMemory<double>& input_h_data,
+                    const dnn::RnnStateTensorDescriptor& input_c_desc,
+                    const DeviceMemory<double>& input_c_data,
+                    const DeviceMemory<double>& params,
+                    const dnn::RnnSequenceTensorDescriptor& output_desc,
+                    DeviceMemory<double>* output_data,
+                    const dnn::RnnStateTensorDescriptor& output_h_desc,
+                    DeviceMemory<double>* output_h_data,
+                    const dnn::RnnStateTensorDescriptor& output_c_desc,
+                    DeviceMemory<double>* output_c_data, bool is_training,
+                    ScratchAllocator* reserve_space_allocator,
+                    ScratchAllocator* workspace_allocator,
+                    dnn::ProfileResult* output_profile_result) override;
+
+  bool DoRnnBackward(Stream* stream, const dnn::RnnDescriptor& rnn_desc,
+                     const dnn::RnnSequenceTensorDescriptor& input_desc,
+                     const DeviceMemory<Eigen::half>& input_data,
+                     const DeviceMemory<int>& seq_lengths_data,
+                     const dnn::RnnStateTensorDescriptor& input_h_desc,
+                     const DeviceMemory<Eigen::half>& input_h_data,
+                     const dnn::RnnStateTensorDescriptor& input_c_desc,
+                     const DeviceMemory<Eigen::half>& input_c_data,
+                     const DeviceMemory<Eigen::half>& params,
+                     const dnn::RnnSequenceTensorDescriptor& output_desc,
+                     const DeviceMemory<Eigen::half>& output_data,
+                     const dnn::RnnStateTensorDescriptor& output_h_desc,
+                     const DeviceMemory<Eigen::half>& output_h_data,
+                     const dnn::RnnStateTensorDescriptor& output_c_desc,
+                     const DeviceMemory<Eigen::half>& output_c_data,
+                     const DeviceMemory<Eigen::half>& output_backprop_data,
+                     const DeviceMemory<Eigen::half>& output_h_backprop_data,
+                     const DeviceMemory<Eigen::half>& output_c_backprop_data,
+                     DeviceMemory<Eigen::half>* input_backprop_data,
+                     DeviceMemory<Eigen::half>* input_h_backprop_data,
+                     DeviceMemory<Eigen::half>* input_c_backprop_data,
+                     DeviceMemory<Eigen::half>* params_backprop_data,
+                     DeviceMemory<uint8_t>* reserve_space_data,
+                     ScratchAllocator* workspace_allocator,
+                     dnn::ProfileResult* output_profile_result) override;
+
+  bool DoRnnBackward(Stream* stream, const dnn::RnnDescriptor& rnn_desc,
+                     const dnn::RnnSequenceTensorDescriptor& input_desc,
+                     const DeviceMemory<float>& input_data,
+                     const DeviceMemory<int>& seq_lengths_data,
+                     const dnn::RnnStateTensorDescriptor& input_h_desc,
+                     const DeviceMemory<float>& input_h_data,
+                     const dnn::RnnStateTensorDescriptor& input_c_desc,
+                     const DeviceMemory<float>& input_c_data,
+                     const DeviceMemory<float>& params,
+                     const dnn::RnnSequenceTensorDescriptor& output_desc,
+                     const DeviceMemory<float>& output_data,
+                     const dnn::RnnStateTensorDescriptor& output_h_desc,
+                     const DeviceMemory<float>& output_h_data,
+                     const dnn::RnnStateTensorDescriptor& output_c_desc,
+                     const DeviceMemory<float>& output_c_data,
+                     const DeviceMemory<float>& output_backprop_data,
+                     const DeviceMemory<float>& output_h_backprop_data,
+                     const DeviceMemory<float>& output_c_backprop_data,
+                     DeviceMemory<float>* input_backprop_data,
+                     DeviceMemory<float>* input_h_backprop_data,
+                     DeviceMemory<float>* input_c_backprop_data,
+                     DeviceMemory<float>* params_backprop_data,
+                     DeviceMemory<uint8_t>* reserve_space_data,
+                     ScratchAllocator* workspace_allocator,
+                     dnn::ProfileResult* output_profile_result) override;
+
+  bool DoRnnBackward(Stream* stream, const dnn::RnnDescriptor& rnn_desc,
+                     const dnn::RnnSequenceTensorDescriptor& input_desc,
+                     const DeviceMemory<double>& input_data,
+                     const DeviceMemory<int>& seq_lengths_data,
+                     const dnn::RnnStateTensorDescriptor& input_h_desc,
+                     const DeviceMemory<double>& input_h_data,
+                     const dnn::RnnStateTensorDescriptor& input_c_desc,
+                     const DeviceMemory<double>& input_c_data,
+                     const DeviceMemory<double>& params,
+                     const dnn::RnnSequenceTensorDescriptor& output_desc,
+                     const DeviceMemory<double>& output_data,
+                     const dnn::RnnStateTensorDescriptor& output_h_desc,
+                     const DeviceMemory<double>& output_h_data,
+                     const dnn::RnnStateTensorDescriptor& output_c_desc,
+                     const DeviceMemory<double>& output_c_data,
+                     const DeviceMemory<double>& output_backprop_data,
+                     const DeviceMemory<double>& output_h_backprop_data,
+                     const DeviceMemory<double>& output_c_backprop_data,
+                     DeviceMemory<double>* input_backprop_data,
+                     DeviceMemory<double>* input_h_backprop_data,
+                     DeviceMemory<double>* input_c_backprop_data,
+                     DeviceMemory<double>* params_backprop_data,
+                     DeviceMemory<uint8_t>* reserve_space_data,
+                     ScratchAllocator* workspace_allocator,
+                     dnn::ProfileResult* output_profile_result) override;
+
+  tsl::Status GetConvolveRunners(
+      bool use_cudnn_frontend, dnn::ConvolutionKind kind,
+      dnn::DataType input_type, dnn::DataType output_type, Stream* stream,
+      const dnn::BatchDescriptor& input_descriptor, DeviceMemoryBase input_data,
+      const dnn::FilterDescriptor& filter_descriptor,
+      DeviceMemoryBase filter_data,
+      const dnn::BatchDescriptor& output_descriptor,
+      DeviceMemoryBase output_data,
+      const dnn::ConvolutionDescriptor& convolution_descriptor,
+      bool use_fallback, ScratchAllocator* scratch_allocator,
+      const NumericOptions& numeric_options,
+      std::vector<std::unique_ptr<const dnn::ConvRunner>>* out_exec_plans)
+      override;
+
+  tsl::StatusOr<std::unique_ptr<const dnn::ConvRunner>> ConvolveRunnerFromDesc(
+      Stream* stream, const dnn::AlgorithmDesc& algorithm_desc,
+      dnn::ConvolutionKind kind, dnn::DataType input_type,
+      dnn::DataType output_type, const dnn::BatchDescriptor& input_descriptor,
+      const dnn::FilterDescriptor& filter_descriptor,
+      const dnn::BatchDescriptor& output_descriptor,
+      const dnn::ConvolutionDescriptor& convolution_descriptor) override;
+
+  tsl::Status GetGraphConvolveRunners(
+      dnn::ConvolutionKind kind, dnn::DataType input_type,
+      dnn::DataType output_type, Stream* stream,
+      const dnn::BatchDescriptor& input_descriptor,
+      const dnn::FilterDescriptor& filter_descriptor,
+      const dnn::BatchDescriptor& output_descriptor,
+      const dnn::ConvolutionDescriptor& convolution_descriptor,
+      bool use_fallback, const NumericOptions& numeric_options,
+      std::vector<std::unique_ptr<const dnn::GraphConvRunner>>* out_exec_plans,
+      std::string serialized_graph) override;
+
+  tsl::StatusOr<std::unique_ptr<const dnn::GraphConvRunner>>
+  GraphConvolveRunnerFromDesc(
+      Stream* stream, const dnn::AlgorithmDesc& algorithm_desc,
+      dnn::ConvolutionKind kind, dnn::DataType input_type,
+      dnn::DataType output_type, const dnn::BatchDescriptor& input_descriptor,
+      const dnn::FilterDescriptor& filter_descriptor,
+      const dnn::BatchDescriptor& output_descriptor,
+      const dnn::ConvolutionDescriptor& convolution_descriptor,
+      std::string serialized_graph) override;
+
+  tsl::Status GetFusedConvolveRunners(
+      bool use_cudnn_frontend, dnn::ConvolutionKind kind,
+      dnn::DataType input_type, dnn::DataType bias_type,
+      dnn::DataType output_type, double conv_scale, double side_input_scale,
+      double leakyrelu_alpha, Stream* stream,
+      const dnn::BatchDescriptor& input_descriptor,
+      const dnn::FilterDescriptor& filter_descriptor,
+      const dnn::BatchDescriptor& bias_descriptor,
+      const dnn::BatchDescriptor& output_descriptor,
+      const dnn::ConvolutionDescriptor& convolution_descriptor,
+      bool use_fallback, dnn::ActivationMode activation_mode,
+      const NumericOptions& numeric_options,
+      std::vector<std::unique_ptr<const dnn::FusedConvRunner>>* out_exec_plans)
+      override;
+
+  tsl::Status GetFusedMatmulRunners(
+      bool use_cudnn_frontend, dnn::DataType input_type,
+      dnn::DataType bias_type, dnn::DataType output_type, Stream* stream,
+      bool trans_a, bool trans_b, uint64_t m, uint64_t n, uint64_t k,
+      int64_t lda, int64_t ldb, int64_t ldc,
+      dnn::ActivationMode activation_mode, bool use_fallback,
+      const NumericOptions& numeric_options,
+      std::vector<std::unique_ptr<const dnn::FusedMatmulRunner>>*
+          out_exec_plans) override;
+
+  tsl::StatusOr<std::unique_ptr<const dnn::FusedConvRunner>>
+  FusedConvolveRunnerFromDesc(
+      Stream* stream, const dnn::AlgorithmDesc& algorithm_desc,
+      dnn::ConvolutionKind kind, dnn::DataType input_type,
+      dnn::DataType bias_type, dnn::DataType output_type, double conv_scale,
+      double side_input_scale, double leakyrelu_alpha,
+      const dnn::BatchDescriptor& input_descriptor,
+      const dnn::FilterDescriptor& filter_descriptor,
+      const dnn::BatchDescriptor& bias_descriptor,
+      const dnn::BatchDescriptor& output_descriptor,
+      const dnn::ConvolutionDescriptor& convolution_descriptor,
+      dnn::ActivationMode activation_mode) override;
+
+  tsl::StatusOr<std::unique_ptr<const dnn::FusedMHARunner>>
+  FusedMHARunnerFromDesc(
+      Stream* stream, const dnn::AlgorithmDesc& algorithm_desc,
+      dnn::FusedMHAKind kind,
+      const dnn::MatmulTensorDescriptor& bmm1_lhs_descriptor,
+      const dnn::MatmulTensorDescriptor& bmm1_rhs_descriptor,
+      const dnn::MatmulTensorDescriptor& bmm2_rhs_descriptor,
+      const dnn::MatmulTensorDescriptor& intermediate_bmm2_lhs_descriptor,
+      const dnn::TensorDescriptor& output_descriptor,
+      std::optional<dnn::TensorDescriptor> activation_descriptor,
+      std::optional<dnn::TensorDescriptor> mask_descriptor,
+      std::optional<dnn::TensorDescriptor> bias_descriptor, double scale,
+      std::optional<double> dropout_rate, std::optional<int64_t> seed) override;
+
+  tsl::StatusOr<std::unique_ptr<const dnn::FusedMHABackwardRunner>>
+  FusedMHABackwardRunnerFromDesc(
+      Stream* stream, const dnn::AlgorithmDesc& algorithm_desc,
+      dnn::FusedMHAKind kind,
+      const dnn::MatmulTensorDescriptor& bmm1_grad_gemm1_rhs_descriptor,
+      const dnn::MatmulTensorDescriptor& bmm1_grad_gemm2_rhs_descriptor,
+      const dnn::MatmulTensorDescriptor& bmm2_grad_gemm1_lhs_descriptor,
+      const dnn::MatmulTensorDescriptor& bmm2_grad_gemm2_rhs_descriptor,
+      const dnn::MatmulTensorDescriptor& d_output_descriptor,
+      const dnn::TensorDescriptor& d_bmm1_lhs_descriptor,
+      const dnn::TensorDescriptor& d_bmm1_rhs_descriptor,
+      const dnn::TensorDescriptor& d_bmm2_rhs_descriptor,
+      const dnn::TensorDescriptor& d_s_descriptor,
+      std::optional<dnn::TensorDescriptor> mask_descriptor,
+      std::optional<dnn::TensorDescriptor> d_bias_descriptor, double scale,
+      std::optional<double> dropout_rate, std::optional<int64_t> seed) override;
+  bool GetRnnAlgorithms(
+      std::vector<dnn::AlgorithmDesc>* out_algorithms) override;
+
+  bool DoBatchNormalizationForward(
+      Stream* stream, const DeviceMemory<float>& x,
+      const DeviceMemory<float>& scale, const DeviceMemory<float>& offset,
+      const DeviceMemory<float>& estimated_mean,
+      const DeviceMemory<float>& estimated_var_iance,
+      const DeviceMemory<float>& side_input, const dnn::BatchDescriptor& x_desc,
+      const dnn::BatchDescriptor& scale_offset_desc, const double epsilon,
+      const double exponential_average_factor,
+      dnn::ActivationMode activation_mode, DeviceMemory<float>* y,
+      DeviceMemory<float>* batch_mean, DeviceMemory<float>* batch_var,
+      DeviceMemory<float>* saved_mean, DeviceMemory<float>* saved_inv_var,
+      bool is_training, ScratchAllocator* reserve_space_allocator,
+      ScratchAllocator* workspace_allocator) override;
+
+  bool DoBatchNormalizationForward(
+      Stream* stream, const DeviceMemory<Eigen::half>& x,
+      const DeviceMemory<float>& scale, const DeviceMemory<float>& offset,
+      const DeviceMemory<float>& estimated_mean,
+      const DeviceMemory<float>& estimated_variance,
+      const DeviceMemory<Eigen::half>& side_input,
+      const dnn::BatchDescriptor& x_desc,
+      const dnn::BatchDescriptor& scale_offset_desc, const double epsilon,
+      const double exponential_average_factor,
+      dnn::ActivationMode activation_mode, DeviceMemory<Eigen::half>* y,
+      DeviceMemory<float>* batch_mean, DeviceMemory<float>* batch_var,
+      DeviceMemory<float>* saved_mean, DeviceMemory<float>* saved_inv_var,
+      bool is_training, ScratchAllocator* reserve_space_allocator,
+      ScratchAllocator* workspace_allocator) override;
+
+  bool DoBatchNormalizationForward(
+      Stream* stream, const DeviceMemory<Eigen::bfloat16>& x,
+      const DeviceMemory<float>& scale, const DeviceMemory<float>& offset,
+      const DeviceMemory<float>& estimated_mean,
+      const DeviceMemory<float>& estimated_variance,
+      const DeviceMemory<Eigen::bfloat16>& side_input,
+      const dnn::BatchDescriptor& x_desc,
+      const dnn::BatchDescriptor& scale_offset_desc, const double epsilon,
+      const double exponential_average_factor,
+      dnn::ActivationMode activation_mode, DeviceMemory<Eigen::bfloat16>* y,
+      DeviceMemory<float>* batch_mean, DeviceMemory<float>* batch_var,
+      DeviceMemory<float>* saved_mean, DeviceMemory<float>* saved_inv_var,
+      bool is_training, ScratchAllocator* reserve_space_allocator,
+      ScratchAllocator* workspace_allocator) override;
+
+  bool DoBatchNormalizationBackward(
+      Stream* stream, const DeviceMemory<float>& y_backprop,
+      const DeviceMemory<float>& x, const DeviceMemory<float>& scale,
+      const DeviceMemory<float>& offset, const DeviceMemory<float>& mean,
+      const DeviceMemory<float>& inv_var, const DeviceMemory<float>& y,
+      const dnn::BatchDescriptor& x_desc,
+      const dnn::BatchDescriptor& scale_offset_desc, const double epsilon,
+      dnn::ActivationMode activation_mode, DeviceMemory<float>* x_backprop,
+      DeviceMemory<float>* scale_backprop, DeviceMemory<float>* offset_backprop,
+      DeviceMemory<float>* side_input_backprop,
+      DeviceMemory<uint8_t>* reserve_space_data,
+      ScratchAllocator* workspace_allocator) override;
+
+  bool DoBatchNormalizationBackward(
+      Stream* stream, const DeviceMemory<Eigen::half>& y_backprop,
+      const DeviceMemory<Eigen::half>& x, const DeviceMemory<float>& scale,
+      const DeviceMemory<float>& offset, const DeviceMemory<float>& mean,
+      const DeviceMemory<float>& inv_var, const DeviceMemory<Eigen::half>& y,
+      const dnn::BatchDescriptor& x_desc,
+      const dnn::BatchDescriptor& scale_offset_desc, const double epsilon,
+      dnn::ActivationMode activation_mode,
+      DeviceMemory<Eigen::half>* x_backprop,
+      DeviceMemory<float>* scale_backprop, DeviceMemory<float>* offset_backprop,
+      DeviceMemory<Eigen::half>* side_input_backprop,
+      DeviceMemory<uint8_t>* reserve_space_data,
+      ScratchAllocator* workspace_allocator) override;
+
+  bool DoBatchNormalizationBackward(
+      Stream* stream, const DeviceMemory<Eigen::bfloat16>& y_backprop,
+      const DeviceMemory<Eigen::bfloat16>& x, const DeviceMemory<float>& scale,
+      const DeviceMemory<float>& offset, const DeviceMemory<float>& mean,
+      const DeviceMemory<float>& inv_var,
+      const DeviceMemory<Eigen::bfloat16>& y,
+      const dnn::BatchDescriptor& x_desc,
+      const dnn::BatchDescriptor& scale_offset_desc, const double epsilon,
+      dnn::ActivationMode activation_mode,
+      DeviceMemory<Eigen::bfloat16>* x_backprop,
+      DeviceMemory<float>* scale_backprop, DeviceMemory<float>* offset_backprop,
+      DeviceMemory<Eigen::bfloat16>* side_input_backprop,
+      DeviceMemory<uint8_t>* reserve_space_data,
+      ScratchAllocator* workspace_allocator) override;
+
+  tsl::Status DoConvolve(
+      dnn::ConvolutionKind kind, dnn::DataType element_type,
+      dnn::DataType output_type, Stream* stream,
+      const dnn::BatchDescriptor& input_descriptor, DeviceMemoryBase input_data,
+      const dnn::FilterDescriptor& filter_descriptor,
+      DeviceMemoryBase filter_data,
+      const dnn::BatchDescriptor& output_descriptor,
+      DeviceMemoryBase output_data,
+      const dnn::ConvolutionDescriptor& convolution_descriptor,
+      dnn::AlgorithmDesc algorithm_desc, DeviceMemory<uint8_t> scratch_memory,
+      dnn::ProfileResult* output_profile_result) override;
+
+  tsl::Status DoFusedConvolve(
+      Stream* stream, dnn::DataType input_type, dnn::DataType side_input_type,
+      dnn::DataType bias_type, dnn::DataType output_type,
+      const dnn::BatchDescriptor& conv_input_descriptor,
+      DeviceMemoryBase conv_input_data, double conv_input_scale,
+      const dnn::FilterDescriptor& filter_descriptor,
+      DeviceMemoryBase filter_data,
+      const dnn::ConvolutionDescriptor& convolution_descriptor,
+      DeviceMemoryBase side_input_data, double side_input_scale,
+      const dnn::BatchDescriptor& bias_descriptor, DeviceMemoryBase biases,
+      dnn::ActivationMode activation_mode,
+      const dnn::BatchDescriptor& output_descriptor,
+      DeviceMemoryBase output_data, ScratchAllocator* scratch_allocator,
+      const dnn::AlgorithmConfig& algorithm_config,
+      dnn::ProfileResult* output_profile_result) override;
+
+  tsl::Status CudnnReorderConvolutionFilterAndBias(
+      Stream* stream, const dnn::FilterDescriptor& filter_descriptor,
+      const DeviceMemory<int8_t>& filter_input,
+      DeviceMemory<int8_t>* filter_output,
+      std::optional<const DeviceMemory<float>> bias_input,
+      std::optional<DeviceMemory<float>> bias_output) override;
+
+  bool DoConvolveQuantized(
+      Stream* stream, const dnn::BatchDescriptor& input_descriptor,
+      const DeviceMemory<float>& input_data,
+      const dnn::FilterDescriptor& filter_descriptor,
+      const DeviceMemory<int8_t>& filter_coefficients,
+      const DeviceMemory<float>& coefficient_scales,
+      const dnn::ConvolutionDescriptor& convolution_descriptor,
+      const dnn::BatchDescriptor& output_descriptor,
+      DeviceMemory<float>* output_data) override {
+    LOG(ERROR) << "DoConvolveQuantized not supported by cuDNN";
+    return false;
+  }
+
+  bool DoConvolveQuantized(
+      Stream* stream, const dnn::BatchDescriptor& input_descriptor,
+      const DeviceMemory<float>& input_data,
+      const dnn::FilterDescriptor& filter_descriptor,
+      const DeviceMemory<int16>& filter_coefficients,
+      const DeviceMemory<float>& coefficient_scales,
+      const dnn::ConvolutionDescriptor& convolution_descriptor,
+      const dnn::BatchDescriptor& output_descriptor,
+      DeviceMemory<float>* output_data) override {
+    LOG(ERROR) << "DoConvolveQuantized not supported by cuDNN";
+    return false;
+  }
+
+  bool DoSeparableConvolve(
+      Stream* stream, const dnn::BatchDescriptor& batch_descriptor,
+      const DeviceMemory<float>& input_data,
+      const dnn::FilterDescriptor& filter_descriptor, int depth_multiplier,
+      const DeviceMemory<float>& first_weights,
+      const DeviceMemory<float>& second_weights,
+      const dnn::ConvolutionDescriptor& convolution_descriptor,
+      const dnn::BatchDescriptor& output_descriptor,
+      DeviceMemory<float>* output_data) override {
+    LOG(ERROR) << "separable convolution not supported by CUDNN";
+    return false;
+  }
+
+  bool DoMatMul(Stream* stream, const DeviceMemory<float>& input_data,
+                const DeviceMemory<float>& weights,
+                const dnn::BatchDescriptor& input_dimensions,
+                const dnn::BatchDescriptor& output_dimensions,
+                DeviceMemory<float>* output_data) override;
+
+  bool DoMatMulQuantized(Stream* stream, const DeviceMemory<float>& input_data,
+                         const DeviceMemory<int8_t>& quantized_weights,
+                         const DeviceMemory<float>& weight_scales,
+                         const dnn::BatchDescriptor& input_dimensions,
+                         const dnn::BatchDescriptor& output_dimensions,
+                         DeviceMemory<float>* output_data) override {
+    LOG(ERROR) << "DNN MatMulQuantized not supported by CUDNN";
+    return false;
+  }
+
+  bool DoMatMulQuantized(Stream* stream, const DeviceMemory<float>& input_data,
+                         const DeviceMemory<int16>& quantized_weights,
+                         const DeviceMemory<float>& weight_scales,
+                         const dnn::BatchDescriptor& input_dimensions,
+                         const dnn::BatchDescriptor& output_dimensions,
+                         DeviceMemory<float>* output_data) override {
+    LOG(ERROR) << "DNN MatMulQuantized not supported by CUDNN";
+    return false;
+  }
+
+  bool DoBiasAdd(Stream* stream, const DeviceMemory<float>& input_data,
+                 const DeviceMemory<float>& biases,
+                 const dnn::BatchDescriptor& dimensions,
+                 DeviceMemory<float>* output_data) override;
+
+  bool DoActivate(Stream* stream, dnn::ActivationMode activation_mode,
+                  const dnn::BatchDescriptor& dimensions,
+                  const DeviceMemory<float>& input_data,
+                  DeviceMemory<float>* output_data, uint64_t options) override;
+
+  tsl::Status DoPoolForward(dnn::DataType element_type, Stream* stream,
+                            const dnn::PoolingDescriptor& pooling_dimensions,
+                            const dnn::BatchDescriptor& input_dimensions,
+                            DeviceMemoryBase input_data,
+                            const dnn::BatchDescriptor& output_dimensions,
+                            DeviceMemoryBase output_data,
+                            ScratchAllocator* workspace_allocator) override;
+
+  tsl::Status DoPoolForward(dnn::DataType element_type, Stream* stream,
+                            const dnn::PoolingDescriptor& pooling_dimensions,
+                            const NumericOptions& numeric_options,
+                            const dnn::BatchDescriptor& input_dimensions,
+                            DeviceMemoryBase input_data,
+                            const dnn::BatchDescriptor& output_dimensions,
+                            DeviceMemoryBase output_data,
+                            ScratchAllocator* workspace_allocator) override;
+
+  tsl::Status DoPoolBackward(dnn::DataType element_type, Stream* stream,
+                             const dnn::PoolingDescriptor& pooling_dimensions,
+                             const dnn::BatchDescriptor& input_dimensions,
+                             DeviceMemoryBase input_data,
+                             const dnn::BatchDescriptor& output_dimensions,
+                             DeviceMemoryBase output_data,
+                             DeviceMemoryBase input_diff_data,
+                             DeviceMemoryBase output_diff_data,
+                             ScratchAllocator* workspace_allocator) override;
+
+  tsl::Status DoPoolBackward(dnn::DataType element_type, Stream* stream,
+                             const dnn::PoolingDescriptor& pooling_dimensions,
+                             const NumericOptions& numeric_options,
+                             const dnn::BatchDescriptor& input_dimensions,
+                             DeviceMemoryBase input_data,
+                             const dnn::BatchDescriptor& output_dimensions,
+                             DeviceMemoryBase output_data,
+                             DeviceMemoryBase input_diff_data,
+                             DeviceMemoryBase output_diff_data,
+                             ScratchAllocator* workspace_allocator) override;
+
+  bool DoNormalizeWithDimensions(
+      Stream* stream, const dnn::NormalizeDescriptor& normalize_descriptor,
+      const dnn::BatchDescriptor& dimensions,
+      const DeviceMemory<float>& input_data,
+      DeviceMemory<float>* output_data) override;
+
+  bool DoNormalizeBackwardWithDimensions(
+      Stream* stream, const dnn::NormalizeDescriptor& normalize_descriptor,
+      const dnn::BatchDescriptor& dimensions,
+      const DeviceMemory<float>& raw_data,
+      const DeviceMemory<float>& normalized_data,
+      const DeviceMemory<float>& normalized_variable_gradient,
+      DeviceMemory<float>* raw_variable_gradient,
+      ScratchAllocator* workspace_allocator) override;
+
+  bool DoDepthConcatenate(Stream* stream, BatchDescriptorSlice input_dimensions,
+                          DeviceMemorySlice<float> input_data,
+                          DeviceMemory<float>* output_data) override;
+
+  bool DoElementwiseOperate(Stream* stream, dnn::ElementwiseOperation operation,
+                            BatchDescriptorSlice input_dimensions,
+                            DeviceMemorySlice<float> input_data,
+                            const dnn::BatchDescriptor& output_dimensions,
+                            DeviceMemory<float>* output_data) override;
+
+  bool DoXYPad(Stream* stream, const dnn::BatchDescriptor& dimensions,
+               const DeviceMemory<float>& input_data, int64_t left_pad,
+               int64_t right_pad, int64_t top_pad, int64_t bottom_pad,
+               DeviceMemory<float>* output_data) override;
+
+  bool DoXYSlice(Stream* stream, const dnn::BatchDescriptor& dimensions,
+                 const DeviceMemory<float>& input_data, int64_t left_trim,
+                 int64_t right_trim, int64_t top_trim, int64_t bottom_trim,
+                 DeviceMemory<float>* output_data) override;
+
+  bool DoMemcpyD2HQuantized(Stream* stream,
+                            const DeviceMemory<float>& device_unquantized_src,
+                            dnn::QuantizedActivationMode mode, void* host_dst,
+                            int64_t size) override;
+
+  bool DoMemcpyH2DQuantized(
+      Stream* stream, const void* host_src, int64_t size,
+      dnn::QuantizedActivationMode mode,
+      DeviceMemory<float>* device_unquantized_dst) override;
+
+  // Derives an output batch descriptor from an input batch and convolution
+  // descriptors.
+  bool DeriveOutputBatchDescriptor(
+      const dnn::BatchDescriptor& batch_descriptor,
+      const dnn::FilterDescriptor& filter_descriptor,
+      const dnn::ConvolutionDescriptor& convolution_descriptor,
+      dnn::BatchDescriptor* output_batch_descriptor);
+
+  tsl::Status DoCtcLoss(Stream* stream, dnn::DataType element_type,
+                        const dnn::RnnStateTensorDescriptor& probs_desc,
+                        const DeviceMemoryBase probs_data,
+                        absl::Span<const int> labels_data,
+                        absl::Span<const int> labels_lengths_data,
+                        absl::Span<const int> input_lengths_data,
+                        DeviceMemoryBase costs_data,
+                        const dnn::RnnStateTensorDescriptor& grads_desc,
+                        DeviceMemoryBase grads_data,
+                        DeviceMemory<uint8_t> scratch_memory,
+                        int ctc_loss_algo_id) override;
+
+  bool DoTransformTensor(Stream* stream, const dnn::BatchDescriptor& input_desc,
+                         dnn::DataType input_type,
+                         const DeviceMemoryBase& input_data,
+                         const dnn::BatchDescriptor& output_desc,
+                         dnn::DataType output_type, float scale,
+                         DeviceMemoryBase* output_data) override;
+
+  void NotifyStreamDestroyed(Stream* stream) override;
+
+ private:
+  GpuExecutor* parent_;  // Parent executor object. Not owned.
+
+  // Provides access to the cuDNN handle.
+  std::unique_ptr<class CudnnAccess> cudnn_;
+
+  bool GetConvolveAlgorithms(CudaComputeCapability cuda_compute_capability,
+                             dnn::DataType input_type,
+                             const NumericOptions& numeric_options,
+                             std::vector<dnn::AlgorithmDesc>* out_algorithms);
+
+  bool GetConvolveBackwardDataAlgorithms(
+      CudaComputeCapability cuda_compute_capability, dnn::DataType input_type,
+      const NumericOptions& numeric_options,
+      std::vector<dnn::AlgorithmDesc>* out_algorithms);
+
+  bool GetConvolveBackwardFilterAlgorithms(
+      CudaComputeCapability cuda_compute_capability, dnn::DataType input_type,
+      const NumericOptions& numeric_options,
+      std::vector<dnn::AlgorithmDesc>* out_algorithms);
+
+  template <class T, class U>
+  tsl::Status DoBatchNormalizationForwardImpl(
+      Stream* stream, dnn::DataType input_data_type,
+      dnn::DataType scale_data_type, const DeviceMemory<T>& x,
+      const DeviceMemory<U>& scale, const DeviceMemory<U>& offset,
+      const DeviceMemory<U>& estimated_mean,
+      const DeviceMemory<U>& estimated_variance,
+      const DeviceMemory<T>& side_input, const dnn::BatchDescriptor& x_desc,
+      const dnn::BatchDescriptor& scale_offset_desc, const double epsilon,
+      const double exponential_average_factor,
+      dnn::ActivationMode activation_mode, DeviceMemory<T>* y,
+      DeviceMemory<U>* batch_mean, DeviceMemory<U>* batch_var,
+      DeviceMemory<U>* saved_mean, DeviceMemory<U>* saved_inv_var,
+      bool is_training, ScratchAllocator* reserve_space_allocator,
+      ScratchAllocator* workspace_allocator);
+
+  template <class T, class U>
+  tsl::Status DoBatchNormalizationBackwardImpl(
+      Stream* stream, int cudnn_input_type, int cudnn_scale_type,
+      const DeviceMemory<T>& y_backprop, const DeviceMemory<T>& x,
+      const DeviceMemory<U>& scale, const DeviceMemory<U>& offset,
+      const DeviceMemory<U>& mean, const DeviceMemory<U>& inv_var,
+      const DeviceMemory<T>& y, const dnn::BatchDescriptor& x_desc,
+      const dnn::BatchDescriptor& scale_offset_desc, const double epsilon,
+      dnn::ActivationMode activation_mode, DeviceMemory<T>* x_backprop,
+      DeviceMemory<U>* scale_backprop, DeviceMemory<U>* offset_backprop,
+      DeviceMemory<T>* side_input_backprop,
+      DeviceMemory<uint8_t>* reserve_space_data,
+      ScratchAllocator* workspace_allocator);
+
+  template <class T>
+  tsl::Status DoRnnForwardImpl(
+      Stream* stream, const CudnnRnnDescriptor& rnn_desc,
+      const CudnnRnnSequenceTensorDescriptor& input_desc,
+      const DeviceMemory<T>& input_data,
+      const DeviceMemory<int>& seq_lengths_data,
+      const CudnnRnnStateTensorDescriptor& input_h_desc,
+      const DeviceMemory<T>& input_h_data,
+      const CudnnRnnStateTensorDescriptor& input_c_desc,
+      const DeviceMemory<T>& input_c_data, const DeviceMemory<T>& params,
+      const CudnnRnnSequenceTensorDescriptor& output_desc,
+      DeviceMemory<T>* output_data,
+      const CudnnRnnStateTensorDescriptor& output_h_desc,
+      DeviceMemory<T>* output_h_data,
+      const CudnnRnnStateTensorDescriptor& output_c_desc,
+      DeviceMemory<T>* output_c_data, bool is_training,
+      ScratchAllocator* reserve_space_allocator,
+      ScratchAllocator* workspace_allocator,
+      dnn::ProfileResult* output_profile_result);
+
+  template <class T>
+  tsl::Status DoRnnBackwardImpl(
+      Stream* stream, const CudnnRnnDescriptor& rnn_desc,
+      const CudnnRnnSequenceTensorDescriptor& input_desc,
+      const DeviceMemory<T>& input_data,
+      const DeviceMemory<int>& seq_lengths_data,
+      const CudnnRnnStateTensorDescriptor& input_h_desc,
+      const DeviceMemory<T>& input_h_data,
+      const CudnnRnnStateTensorDescriptor& input_c_desc,
+      const DeviceMemory<T>& input_c_data, const DeviceMemory<T>& params,
+      const CudnnRnnSequenceTensorDescriptor& output_desc,
+      const DeviceMemory<T>& output_data,
+      const CudnnRnnStateTensorDescriptor& output_h_desc,
+      const DeviceMemory<T>& output_h_data,
+      const CudnnRnnStateTensorDescriptor& output_c_desc,
+      const DeviceMemory<T>& output_c_data,
+      const DeviceMemory<T>& output_backprop_data,
+      const DeviceMemory<T>& output_h_backprop_data,
+      const DeviceMemory<T>& output_c_backprop_data,
+      DeviceMemory<T>* input_backprop_data,
+      DeviceMemory<T>* input_h_backprop_data,
+      DeviceMemory<T>* input_c_backprop_data,
+      DeviceMemory<T>* params_backprop_data,
+      DeviceMemory<uint8_t>* reserve_space_data,
+      ScratchAllocator* workspace_allocator,
+      dnn::ProfileResult* output_profile_result);
+
+  tsl::Status DoCtcLossImpl(
+      Stream* stream, const CudnnRnnStateTensorDescriptor& probs_desc,
+      const DeviceMemoryBase probs_data, absl::Span<const int> labels_data,
+      absl::Span<const int> labels_lengths_data,
+      absl::Span<const int> input_lengths_data, DeviceMemoryBase costs_data,
+      const CudnnRnnStateTensorDescriptor& grads_desc,
+      DeviceMemoryBase grads_data, const CudnnCtcLossDescriptor& ctc_loss_desc,
+      DeviceMemory<uint8_t> scratch_memory, int ctc_loss_algo_id);
+
+ private:
+  tsl::Status DoPrepareForConvolution(
+      dnn::ConvolutionKind kind, dnn::DataType element_type, Stream* stream,
+      const dnn::BatchDescriptor& input_descriptor, DeviceMemoryBase input_data,
+      const dnn::FilterDescriptor& filter_descriptor,
+      DeviceMemoryBase filter_data,
+      const dnn::BatchDescriptor& output_descriptor,
+      DeviceMemoryBase output_data,
+      const dnn::ConvolutionDescriptor& convolution_descriptor,
+      const dnn::AlgorithmConfig& algorithm_config,
+      ScratchAllocator* scratch_allocator, dnn::AlgorithmDesc* algorithm_desc,
+      DeviceMemory<uint8_t>* scratch_memory) override;
+
+  tsl::Status DoPrepareForCtcLoss(
+      Stream* stream, dnn::DataType element_type,
+      const dnn::RnnStateTensorDescriptor& probs_desc,
+      const dnn::RnnStateTensorDescriptor& grads_desc,
+      absl::Span<const int> labels_data,
+      absl::Span<const int> labels_lengths_data,
+      absl::Span<const int> input_lengths_data,
+      const NumericOptions& numeric_options,
+      ScratchAllocator* scratch_allocator,
+      DeviceMemory<uint8_t>* scratch_memory, int* ctc_loss_algo_id) override;
+
+  CudnnSupport(const CudnnSupport&) = delete;
+  void operator=(const CudnnSupport&) = delete;
+};
+
+}  // namespace gpu
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_CUDA_CUDA_DNN_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/cuda/cuda_driver.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/cuda/cuda_driver.h
new file mode 100644
index 0000000000000000000000000000000000000000..7f3314fbff585c8868badeedc7ae478dd5ffadcf
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/cuda/cuda_driver.h
@@ -0,0 +1,165 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// CUDA userspace driver library wrapper functionality.
+
+#ifndef XLA_STREAM_EXECUTOR_CUDA_CUDA_DRIVER_H_
+#define XLA_STREAM_EXECUTOR_CUDA_CUDA_DRIVER_H_
+
+#include "absl/container/node_hash_map.h"
+#include "absl/memory/memory.h"
+#include "absl/strings/str_cat.h"
+#include "absl/synchronization/mutex.h"
+#include "xla/stream_executor/gpu/gpu_driver.h"
+
+namespace stream_executor {
+namespace gpu {
+// Formats CUresult to output prettified values into a log stream.
+static std::string ToString(CUresult result) {
+  const char* error_name;
+  if (cuGetErrorName(result, &error_name)) {
+    return absl::StrCat("UNKNOWN ERROR (", static_cast<int>(result), ")");
+  }
+  const char* error_string;
+  if (cuGetErrorString(result, &error_string)) {
+    return error_name;
+  }
+  return absl::StrCat(error_name, ": ", error_string);
+}
+
+// CUDAContext wraps a cuda CUcontext handle, and includes a unique id. The
+// unique id is positive, and ids are not repeated within the process.
+class GpuContext {
+ public:
+  GpuContext(CUcontext context, int64_t id) : context_(context), id_(id) {}
+
+  CUcontext context() const { return context_; }
+  int64_t id() const { return id_; }
+
+  // Disallow copying and moving.
+  GpuContext(GpuContext&&) = delete;
+  GpuContext(const GpuContext&) = delete;
+  GpuContext& operator=(GpuContext&&) = delete;
+  GpuContext& operator=(const GpuContext&) = delete;
+
+ private:
+  CUcontext const context_;
+  const int64_t id_;
+};
+
+// Manages the singleton map of contexts that we've created, mapping
+// from the CUcontext to the GpuContext* that we pass around internally.
+// This also manages assignment of unique ids to GpuContexts, to allow
+// for fast comparison of a context against the current context.
+//
+// CUDA-runtime-created contexts are avoided, if triple angle
+// brace launches are required, by using the scoped activations in
+// gpu/gpu_activation.h.
+class CreatedContexts {
+ public:
+  // Returns whether context is a member of the live set.
+  static bool Has(CUcontext context) {
+    absl::ReaderMutexLock lock(&mu_);
+    return Live()->find(context) != Live()->end();
+  }
+
+  // Adds context to the live set, or returns it if it's already present.
+  static GpuContext* Add(CUcontext context, int device_ordinal) {
+    CHECK(context != nullptr);
+    absl::MutexLock lock(&mu_);
+
+    auto insert_result = Live()->insert(std::make_pair(context, nullptr));
+    auto it = insert_result.first;
+    if (insert_result.second) {
+      // context was not present in the map.  Add it.
+      it->second = std::make_unique<GpuContext>(context, next_id_++);
+      (*LiveOrdinal())[device_ordinal].push_back(context);
+    }
+    return it->second.get();
+  }
+
+  // Removes context from the live set.
+  static void Remove(CUcontext context) {
+    CHECK(context != nullptr);
+    absl::MutexLock lock(&mu_);
+    auto it = Live()->find(context);
+    CHECK(it != Live()->end()) << context;
+    Live()->erase(it);
+    for (auto p : (*LiveOrdinal())) {
+      auto it2 = std::find(p.second.begin(), p.second.end(), context);
+      if (it2 != p.second.end()) {
+        p.second.erase(it2, it2++);
+        if (p.second.empty()) {
+          LiveOrdinal()->erase(p.first);
+        }
+        break;
+      }
+    }
+  }
+
+  // Return the context associated to that ptr.
+  static CUcontext GetAnyContext(void* ptr) {
+    absl::ReaderMutexLock lock(&mu_);
+    int device_ordinal;
+    CUresult result = cuPointerGetAttribute(static_cast<void*>(&device_ordinal),
+                                            CU_POINTER_ATTRIBUTE_DEVICE_ORDINAL,
+                                            reinterpret_cast<CUdeviceptr>(ptr));
+    if (result != CUDA_SUCCESS) {
+      LOG(FATAL) << "Not able to get the device_ordinal for ptr: " << ptr
+                 << ". Error: " << ToString(result);
+    }
+    CHECK_EQ(LiveOrdinal()->count(device_ordinal), 1);
+    CHECK(!LiveOrdinal()->at(device_ordinal).empty())
+        << "Need at least one context.";
+    return LiveOrdinal()->at(device_ordinal)[0];
+  }
+
+ private:
+  // Returns the live map singleton.
+  static absl::node_hash_map<CUcontext, std::unique_ptr<GpuContext>>* Live() {
+    static auto singleton =
+        new absl::node_hash_map<CUcontext, std::unique_ptr<GpuContext>>;
+    return singleton;
+  }
+  static absl::node_hash_map<int, std::vector<CUcontext>>* LiveOrdinal() {
+    static auto singleton =
+        new absl::node_hash_map<int, std::vector<CUcontext>>;
+    return singleton;
+  }
+
+  // Lock that guards access-to/mutation-of the live set.
+  static absl::Mutex mu_;
+  static int64_t next_id_;
+};
+}  // namespace gpu
+
+namespace cuda {
+
+using MemorySpace = gpu::MemorySpace;
+
+using CUDADriver = gpu::GpuDriver;
+
+using ScopedActivateContext = gpu::ScopedActivateContext;
+
+using CudaContext = gpu::GpuContext;
+
+// Returns the current context set in CUDA. This is done by calling the cuda
+// driver (e.g., this value is not our cached view of the current context).
+CUcontext CurrentContextOrDie();
+
+}  // namespace cuda
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_CUDA_CUDA_DRIVER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/cuda/cuda_event.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/cuda/cuda_event.h
new file mode 100644
index 0000000000000000000000000000000000000000..b4aa70392a46ccf05fa70eb4fae2363794f80283
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/cuda/cuda_event.h
@@ -0,0 +1,29 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_STREAM_EXECUTOR_CUDA_CUDA_EVENT_H_
+#define XLA_STREAM_EXECUTOR_CUDA_CUDA_EVENT_H_
+
+#include "xla/stream_executor/gpu/gpu_event.h"
+
+namespace stream_executor {
+namespace cuda {
+
+using CUDAEvent = gpu::GpuEvent;
+
+}  // namespace cuda
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_CUDA_CUDA_EVENT_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.h
new file mode 100644
index 0000000000000000000000000000000000000000..e5ce88163e4bbca8b3018474da4b561020a3a54a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.h
@@ -0,0 +1,141 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// CUDA-specific support for FFT functionality -- this wraps the cuFFT library
+// capabilities, and is only included into CUDA implementation code -- it will
+// not introduce cuda headers into other code.
+
+#ifndef XLA_STREAM_EXECUTOR_CUDA_CUDA_FFT_H_
+#define XLA_STREAM_EXECUTOR_CUDA_CUDA_FFT_H_
+
+#include <cstdint>
+
+#include "third_party/gpus/cuda/include/cufft.h"
+#include "xla/stream_executor/fft.h"
+#include "xla/stream_executor/platform/port.h"
+#include "xla/stream_executor/plugin_registry.h"
+#include "xla/stream_executor/scratch_allocator.h"
+
+namespace stream_executor {
+
+class Stream;
+
+namespace gpu {
+
+class GpuExecutor;
+
+// CUDAFftPlan uses deferred initialization. Only a single call of
+// Initialize() is allowed to properly create cufft plan and set member
+// variable is_initialized_ to true. Newly added interface that uses member
+// variables should first check is_initialized_ to make sure that the values of
+// member variables are valid.
+class CUDAFftPlan : public fft::Plan {
+ public:
+  CUDAFftPlan()
+      : parent_(nullptr),
+        plan_(-1),
+        fft_type_(fft::Type::kInvalid),
+        scratch_(nullptr),
+        scratch_size_bytes_(0),
+        is_initialized_(false),
+        scratch_allocator_(nullptr) {}
+  ~CUDAFftPlan() override;
+
+  // Get FFT direction in cuFFT based on FFT type.
+  int GetFftDirection() const;
+  cufftHandle GetPlan() const {
+    if (IsInitialized()) {
+      return plan_;
+    } else {
+      LOG(FATAL) << "Try to get cufftHandle value before initialization.";
+    }
+  }
+
+  // Initialize function for batched plan
+  tsl::Status Initialize(GpuExecutor* parent, Stream* stream, int rank,
+                         uint64_t* elem_count, uint64_t* input_embed,
+                         uint64_t input_stride, uint64 input_distance,
+                         uint64_t* output_embed, uint64_t output_stride,
+                         uint64_t output_distance, fft::Type type,
+                         int batch_count, ScratchAllocator* scratch_allocator);
+
+  // Initialize function for 1d,2d, and 3d plan
+  tsl::Status Initialize(GpuExecutor* parent, Stream* stream, int rank,
+                         uint64_t* elem_count, fft::Type type,
+                         ScratchAllocator* scratch_allocator);
+
+  tsl::Status UpdateScratchAllocator(Stream* stream,
+                                     ScratchAllocator* scratch_allocator);
+
+  ScratchAllocator* GetScratchAllocator() const { return scratch_allocator_; }
+
+ protected:
+  bool IsInitialized() const { return is_initialized_; }
+
+ private:
+  GpuExecutor* parent_;
+  cufftHandle plan_;
+  fft::Type fft_type_;
+  DeviceMemory<uint8_t> scratch_;
+  size_t scratch_size_bytes_;
+  bool is_initialized_;
+  ScratchAllocator* scratch_allocator_;
+};
+
+// FFT support for CUDA platform via cuFFT library.
+//
+// This satisfies the platform-agnostic FftSupport interface.
+//
+// Note that the cuFFT handle that this encapsulates is implicitly tied to the
+// context (and, as a result, the device) that the parent GpuExecutor is tied
+// to. This simply happens as an artifact of creating the cuFFT handle when a
+// CUDA context is active.
+//
+// Thread-safe. The CUDA context associated with all operations is the CUDA
+// context of parent_, so all context is explicit.
+class CUDAFft : public fft::FftSupport {
+ public:
+  explicit CUDAFft(GpuExecutor* parent) : parent_(parent) {}
+  ~CUDAFft() override {}
+
+  TENSORFLOW_STREAM_EXECUTOR_GPU_FFT_SUPPORT_OVERRIDES
+
+ private:
+  GpuExecutor* parent_;
+
+  // Two helper functions that execute dynload::cufftExec?2?.
+
+  // This is for complex to complex FFT, when the direction is required.
+  template <typename FuncT, typename InputT, typename OutputT>
+  bool DoFftWithDirectionInternal(Stream *stream, fft::Plan *plan,
+                                  FuncT cufft_exec,
+                                  const DeviceMemory<InputT> &input,
+                                  DeviceMemory<OutputT> *output);
+
+  // This is for complex to real or real to complex FFT, when the direction
+  // is implied.
+  template <typename FuncT, typename InputT, typename OutputT>
+  bool DoFftInternal(Stream *stream, fft::Plan *plan, FuncT cufft_exec,
+                     const DeviceMemory<InputT> &input,
+                     DeviceMemory<OutputT> *output);
+
+  CUDAFft(const CUDAFft&) = delete;
+  void operator=(const CUDAFft&) = delete;
+};
+
+}  // namespace gpu
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_CUDA_CUDA_FFT_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/cuda/cuda_helpers.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/cuda/cuda_helpers.h
new file mode 100644
index 0000000000000000000000000000000000000000..5ff0ed0d2af5db9c360bd69f12d7b8e07ef8b679
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/cuda/cuda_helpers.h
@@ -0,0 +1,25 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// Common helper functions used for dealing with CUDA API datatypes.
+//
+// These are typically placed here for use by multiple source components (for
+// example, BLAS and executor components).
+#ifndef XLA_STREAM_EXECUTOR_CUDA_CUDA_HELPERS_H_
+#define XLA_STREAM_EXECUTOR_CUDA_CUDA_HELPERS_H_
+
+#include "xla/stream_executor/gpu/gpu_helpers.h"
+
+#endif  // XLA_STREAM_EXECUTOR_CUDA_CUDA_HELPERS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/cuda/cuda_kernel.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/cuda/cuda_kernel.h
new file mode 100644
index 0000000000000000000000000000000000000000..7077ee952ec9e2f270816070a29895cc93f2236b
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/cuda/cuda_kernel.h
@@ -0,0 +1,35 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// The CUDA implementation of the StreamExecutorInterface functionality.
+// CUDA inclusions are ideally confined to this implementation file.
+//
+// The notions from the StreamExecutor basically correspond to the CUDA streams
+// programming model provided by the libcuda.so driver APIs, so we don't have
+// to do much more than wrap the calls to the libraries appropriately.
+#ifndef XLA_STREAM_EXECUTOR_CUDA_CUDA_KERNEL_H_
+#define XLA_STREAM_EXECUTOR_CUDA_CUDA_KERNEL_H_
+
+#include "xla/stream_executor/gpu/gpu_kernel.h"
+
+namespace stream_executor {
+namespace cuda {
+
+using CUDAKernel = gpu::GpuKernel;
+
+}  // namespace cuda
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_CUDA_CUDA_KERNEL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/cuda/cuda_platform_id.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/cuda/cuda_platform_id.h
new file mode 100644
index 0000000000000000000000000000000000000000..83af581d6f209492a5ec45ac7e646e0496481d33
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/cuda/cuda_platform_id.h
@@ -0,0 +1,34 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_STREAM_EXECUTOR_CUDA_CUDA_PLATFORM_ID_H_
+#define XLA_STREAM_EXECUTOR_CUDA_CUDA_PLATFORM_ID_H_
+
+#include "xla/stream_executor/platform.h"
+
+namespace stream_executor {
+namespace cuda {
+
+// Opaque and unique identifier for the cuda platform.
+// This is needed so that plugins can refer to/identify this platform without
+// instantiating a CudaPlatform object.
+// This is broken out here to avoid a circular dependency between CudaPlatform
+// and CudaExecutor.
+extern const Platform::Id kCudaPlatformId;
+
+}  // namespace cuda
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_CUDA_CUDA_PLATFORM_ID_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/cuda/cuda_stream.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/cuda/cuda_stream.h
new file mode 100644
index 0000000000000000000000000000000000000000..a99fe6d5eecb85dea24c4e594216aead4af5ffa6
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/cuda/cuda_stream.h
@@ -0,0 +1,36 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// Defines the GpuStream type - the CUDA-specific implementation of the generic
+// StreamExecutor Stream interface.
+
+#ifndef XLA_STREAM_EXECUTOR_CUDA_CUDA_STREAM_H_
+#define XLA_STREAM_EXECUTOR_CUDA_CUDA_STREAM_H_
+
+#include "xla/stream_executor/gpu/gpu_stream.h"
+
+namespace stream_executor {
+namespace cuda {
+
+using CUDAStream = gpu::GpuStream;
+
+inline CUDAStream* AsCUDAStream(Stream* stream) {
+  return gpu::AsGpuStream(stream);
+}
+
+}  // namespace cuda
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_CUDA_CUDA_STREAM_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/data_type.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/data_type.h
new file mode 100644
index 0000000000000000000000000000000000000000..c0f900d4794e4d2c89741c97dd3e80c2b0fc2330
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/data_type.h
@@ -0,0 +1,95 @@
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_STREAM_EXECUTOR_DATA_TYPE_H_
+#define XLA_STREAM_EXECUTOR_DATA_TYPE_H_
+
+#include <complex>
+#include <cstdint>
+
+#include "tsl/platform/float8.h"
+#include "tsl/protobuf/dnn.pb.h"
+
+namespace Eigen {
+struct bfloat16;
+struct half;
+}  // namespace Eigen
+
+namespace stream_executor {
+namespace dnn {
+
+// A helper class to convert C/C++ types to the proper enums.
+template <typename T>
+struct ToDataType;
+
+// Note: If you add a new specialization below, make sure to add the
+// corresponding definition in stream_executor/dnn.cc.
+template <>
+struct ToDataType<tsl::float8_e4m3fn> {
+  static constexpr DataType value = DataType::kF8E4M3FN;
+};
+template <>
+struct ToDataType<tsl::float8_e5m2> {
+  static constexpr DataType value = DataType::kF8E5M2;
+};
+template <>
+struct ToDataType<tsl::float8_e4m3fnuz> {
+  static constexpr DataType value = DataType::kF8E4M3FNUZ;
+};
+template <>
+struct ToDataType<tsl::float8_e5m2fnuz> {
+  static constexpr DataType value = DataType::kF8E5M2FNUZ;
+};
+template <>
+struct ToDataType<float> {
+  static constexpr DataType value = DataType::kFloat;
+};
+template <>
+struct ToDataType<double> {
+  static constexpr DataType value = DataType::kDouble;
+};
+template <>
+struct ToDataType<Eigen::half> {
+  static constexpr DataType value = DataType::kHalf;
+};
+template <>
+struct ToDataType<Eigen::bfloat16> {
+  static constexpr DataType value = DataType::kBF16;
+};
+template <>
+struct ToDataType<int8_t> {
+  static constexpr DataType value = DataType::kInt8;
+};
+template <>
+struct ToDataType<int32_t> {
+  static constexpr DataType value = DataType::kInt32;
+};
+template <>
+struct ToDataType<int64_t> {
+  static constexpr DataType value = DataType::kInt64;
+};
+template <>
+struct ToDataType<std::complex<float>> {
+  static constexpr DataType value = DataType::kComplexFloat;
+};
+template <>
+struct ToDataType<std::complex<double>> {
+  static constexpr DataType value = DataType::kComplexDouble;
+};
+
+}  // namespace dnn
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_DATA_TYPE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/device_description.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/device_description.h
new file mode 100644
index 0000000000000000000000000000000000000000..84653c070ec56f1599213d778e43f227b48207a9
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/device_description.h
@@ -0,0 +1,549 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// Describes the underlying platform for a StreamExecutor; e.g. OpenCL or CUDA
+// device and platform properties. Also contains convenience functions for
+// checking/calculating launch dimensionality based on device properties.
+
+#ifndef XLA_STREAM_EXECUTOR_DEVICE_DESCRIPTION_H_
+#define XLA_STREAM_EXECUTOR_DEVICE_DESCRIPTION_H_
+
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <utility>
+#include <variant>
+#include <vector>
+
+#include "absl/algorithm/container.h"
+#include "absl/strings/str_join.h"
+#include "absl/strings/str_split.h"
+#include "absl/strings/string_view.h"
+#include "xla/stream_executor/device_description.pb.h"
+#include "xla/stream_executor/launch_dim.h"
+#include "xla/stream_executor/platform/port.h"
+
+namespace stream_executor {
+namespace internal {
+class DeviceDescriptionBuilder;
+}  // namespace internal
+
+// CUDA compute capability, as reported by the device description.
+struct CudaComputeCapability {
+  int major = 0;
+  int minor = 0;
+
+  // MSVC does not like "PASCAL" symbol.
+  enum CudaComputeCapabilities {
+    PASCAL_ = 6,
+    VOLTA = 7,
+    AMPERE = 8,
+    HOPPER = 9
+  };
+
+  CudaComputeCapability() = default;
+  CudaComputeCapability(int major, int minor) {
+    this->major = major;
+    this->minor = minor;
+  }
+
+  explicit CudaComputeCapability(const CudaComputeCapabilityProto &proto) {
+    this->major = proto.major();
+    this->minor = proto.minor();
+  }
+
+  bool IsAtLeast(int other_major, int other_minor = 0) const {
+    return !(*this < CudaComputeCapability{other_major, other_minor});
+  }
+
+  bool operator<(const CudaComputeCapability &other) const {
+    return ToPair() < other.ToPair();
+  }
+
+  bool operator==(const CudaComputeCapability &other) const {
+    return ToPair() == other.ToPair();
+  }
+
+  bool operator!=(const CudaComputeCapability &other) const {
+    return !(*this == other);
+  }
+
+  // Maximum resident blocks per multiprocessor, values taken from
+  // https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#compute-capabilities.
+  int GetMaxResidentBlocksPerSM() const {
+    if (IsAtLeast(8, 6)) {
+      return 16;
+    } else if (IsAtLeast(8)) {
+      return 32;
+    } else if (IsAtLeast(7, 5)) {
+      return 16;
+    }
+    return 32;
+  }
+
+  // Maximum resident warps per multiprocessor, values taken from
+  // https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#compute-capabilities.
+  int GetMaxResidentWarpsPerSM() const {
+    if (IsAtLeast(8, 6)) {
+      return 48;
+    } else if (IsAtLeast(8)) {
+      return 64;
+    } else if (IsAtLeast(7, 5)) {
+      return 32;
+    }
+    return 64;
+  }
+
+  std::string ToString() const { return absl::StrCat(major, ".", minor); }
+
+  std::pair<int, int> ToPair() const { return std::make_pair(major, minor); }
+
+  CudaComputeCapabilityProto ToProto() const {
+    CudaComputeCapabilityProto proto;
+    proto.set_major(major);
+    proto.set_minor(minor);
+    return proto;
+  }
+};
+
+// ROCm compute capability, as reported by the device description.
+class RocmComputeCapability {
+ public:
+  // gcn_arch_name example --  gfx90a:sramecc+:xnack-
+  // gfx_version is the "gfx90a" part of the gcn_arch_name
+  explicit RocmComputeCapability(const std::string &gcn_arch_name)
+      : gcn_arch_name_(gcn_arch_name) {}
+
+  explicit RocmComputeCapability(const RocmComputeCapabilityProto &proto)
+      : gcn_arch_name_(proto.gcn_arch_name()) {}
+
+  RocmComputeCapability() = default;
+  ~RocmComputeCapability() = default;
+
+  std::string gcn_arch_name() const { return gcn_arch_name_; }
+
+  std::string gfx_version() const {
+    std::vector<std::string> tokens = absl::StrSplit(gcn_arch_name_, ':');
+    return tokens[0];
+  }
+
+  bool is_supported_gfx_version() const {
+    return absl::c_count(kSupportedGfxVersions, gfx_version()) != 0;
+  }
+
+  std::string supported_gfx_versions_str() const {
+    return absl::StrJoin(kSupportedGfxVersions, ", ");
+  }
+
+  bool has_nhwc_layout_support() const {
+    static constexpr absl::string_view kList[] = {"gfx908", "gfx90a"};
+    return absl::c_count(kList, gfx_version()) != 0;
+  }
+
+  bool has_bf16_dtype_support() const {
+    static constexpr absl::string_view kList[] = {"gfx908", "gfx90a"};
+    return absl::c_count(kList, gfx_version()) != 0;
+  }
+
+  bool has_fast_fp16_support() const {
+    static constexpr absl::string_view kList[] = {"gfx906", "gfx908", "gfx90a",
+                                                  "gfx1030"};
+    return absl::c_count(kList, gfx_version()) != 0;
+  }
+
+  bool has_mfma_instr_support() const {
+    static constexpr absl::string_view kList[] = {"gfx908", "gfx90a"};
+    return absl::c_count(kList, gfx_version()) != 0;
+  }
+
+  bool has_fp16_atomics_support() const {
+    // TODO(rocm): Check. This should be the same as has_fast_fp16_support().
+    static constexpr absl::string_view kList[] = {"gfx90a"};
+    return absl::c_count(kList, gfx_version()) != 0;
+  }
+
+  RocmComputeCapabilityProto ToProto() const {
+    RocmComputeCapabilityProto proto;
+    proto.set_gcn_arch_name(gcn_arch_name_);
+    return proto;
+  }
+
+  bool operator==(const RocmComputeCapability &other) const {
+    return gcn_arch_name_ == other.gcn_arch_name_;
+  }
+
+ private:
+  std::string gcn_arch_name_ = "gfx000";  // default to invalid arch.
+
+  static constexpr absl::string_view kSupportedGfxVersions[]{
+      "gfx900",  // MI25
+      "gfx906",  // MI50 / MI60
+      "gfx908",  // MI100
+      "gfx90a",  // MI200
+      "gfx1030"  // Navi21
+  };
+};
+
+using GpuComputeCapability =
+    std::variant<CudaComputeCapability, RocmComputeCapability>;
+
+// Data that describes the execution target of the StreamExecutor, in terms of
+// important logical parameters. These include dimensionality limits and
+// physical parameters of interest, such as number of cores present on the
+// device.
+//
+// Thread-safe: immutable post-initialization.
+class DeviceDescription {
+ public:
+  // Returns the platform being run on; this value is primarily intended for
+  // printing, and comes out something like "OpenCL 1.2" or "Compute Capability
+  // 3.5".
+  const std::string &platform_version() const { return platform_version_; }
+
+  // Returns the driver version interfacing with the underlying platform. Vendor
+  // dependent format.
+  const std::string &driver_version() const { return driver_version_; }
+
+  // Return the runtime version, if one is provided by the underlying platform.
+  // Vendor dependent format / usefulness.
+  const std::string &runtime_version() const { return runtime_version_; }
+
+  // Returns the name that the device reports. Vendor dependent.
+  const std::string &name() const { return name_; }
+
+  // Gets a human-readable description of the device, e.g. "nvidia GPU
+  // supporting sm75 with 32GB RAM, 80 SMs, ...".  This is intended to be the
+  // same if and only if two devices are "the same" (e.g. the same make/model of
+  // GPU), though it may not completely succeed at this for all platforms.
+  //
+  // This string is not guaranteed to be stable between versions.  Please DO NOT
+  // rely on it never changing.  (Within one version of the code, it won't
+  // change, don't worry.)
+  const std::string &model_str() const { return model_str_; }
+
+  // Returns the PCI bus identifier for this device, of the form
+  // [domain]:[bus]:[device].[function]
+  const std::string &pci_bus_id() const { return pci_bus_id_; }
+
+  // Returns the NUMA node associated with this device, for use in
+  // determining socket locality. If the NUMA node could not be determined, -1
+  // is returned.
+  int numa_node() const { return numa_node_; }
+
+  // Number of cores (traditional notion of core; i.e. an SM on an NVIDIA device
+  // or an AMD Compute Unit.
+  int core_count() const { return core_count_; }
+
+  // Number of floating point operations one core (SM, compute unit) can execute
+  // in parallel. Corresponds to the number of "CUDA cores" for NVIDIA devices.
+  int fpus_per_core() const { return fpus_per_core_; }
+
+  // Returns the limit on the thread dimensionality values in each of the
+  // respective dimensions. These limits affect what constitutes a legitimate
+  // kernel launch request.
+  const ThreadDim &thread_dim_limit() const { return thread_dim_limit_; }
+
+  // Returns the limit on the block dimensionality values in each of the
+  // respective dimensions. These limits may affect what constitutes a
+  // legitimate kernel launch request.
+  const BlockDim &block_dim_limit() const { return block_dim_limit_; }
+
+  // Returns the limit on the total number of threads that can be launched in a
+  // single block; i.e. the limit on x * y * z dimensions of a ThreadDim.
+  // This limit affects what constitutes a legitimate kernel launch request.
+  const int64_t &threads_per_block_limit() const {
+    return threads_per_block_limit_;
+  }
+
+  // Returns the limit on the total number of threads that can be simultaneously
+  // launched on a given multiprocessor.
+  const int64_t &threads_per_core_limit() const {
+    return threads_per_core_limit_;
+  }
+
+  // Returns the number of threads per warp/wavefront.
+  const int64_t &threads_per_warp() const { return threads_per_warp_; }
+
+  // Returns the limit on the total number of registers per core.
+  const int64_t &registers_per_core_limit() const {
+    return registers_per_core_limit_;
+  }
+
+  // Returns the limit on the total number of registers that can be
+  // simultaneously used by a block.
+  const int64_t &registers_per_block_limit() const {
+    return registers_per_block_limit_;
+  }
+
+  // Returns the number of address bits available to kernel code running on the
+  // platform. This affects things like the maximum allocation size and perhaps
+  // types used in kernel code such as size_t.
+  const int64_t &device_address_bits() const { return device_address_bits_; }
+
+  // Returns the device memory size in bytes.
+  int64_t device_memory_size() const { return device_memory_size_; }
+
+  // Returns the L2 cache size in bytes.
+  int64_t l2_cache_size() const { return l2_cache_size_; }
+
+  // Returns the device's memory bandwidth in bytes/sec.  (This is for
+  // reads/writes to/from the device's own memory, not for transfers between the
+  // host and device.)
+  int64_t memory_bandwidth() const { return memory_bandwidth_; }
+
+  // Returns the device's core clock rate in GHz.
+  float clock_rate_ghz() const { return clock_rate_ghz_; }
+
+  // Returns whether ECC is enabled.
+  bool ecc_enabled() const { return ecc_enabled_; }
+
+  // Returns the device vendor string, e.g., "NVIDIA Corporation", "Advanced
+  // Micro Devices, Inc.", or "GenuineIntel".
+  const std::string &device_vendor() const { return device_vendor_; }
+
+  // Returns the CUDA compute capability if we're running on the CUDA platform.
+  // If a CUDA compute capability is not available, the major version will be
+  // zero.
+  CudaComputeCapability cuda_compute_capability() const;
+
+  // Returns the ROCm compute capability if we're running on the ROCm platform.
+  // If a ROCm compute capability is not available, the default gfx_arch will
+  // be "gfx000" (which is an invalid gfx arch).
+  RocmComputeCapability rocm_compute_capability() const;
+
+  const GpuComputeCapability &gpu_compute_capability() const;
+
+  // Returns the maximum amount of shared memory present on a single core
+  // (i.e. Streaming Multiprocessor on NVIDIA GPUs; Compute Unit for OpenCL
+  // devices). Note that some devices, such as NVIDIA's have a configurable
+  // partitioning between shared memory and L1 cache.
+  int64_t shared_memory_per_core() const { return shared_memory_per_core_; }
+
+  // Returns the maximum amount of static shared memory
+  // available for a single block.
+  int64_t shared_memory_per_block() const { return shared_memory_per_block_; }
+
+  // Returns the maximum amount of shared memory available for a single block
+  // including the dynamically allocated one.
+  int64_t shared_memory_per_block_optin() const {
+    return shared_memory_per_block_optin_;
+  }
+
+  GpuDeviceInfoProto ToGpuProto() const;
+  explicit DeviceDescription(const GpuDeviceInfoProto &proto);
+
+  // For string values that are not available via the underlying platform, this
+  // value will be provided.
+  static const char *kUndefinedString;
+
+ private:
+  friend class internal::DeviceDescriptionBuilder;
+
+  DeviceDescription();
+
+  // For description of the following members, see the corresponding accessor
+  // above.
+  //
+  // N.B. If another field is added, update ToMap() above.
+  std::string device_vendor_;
+  std::string platform_version_;
+  std::string driver_version_;
+  std::string runtime_version_;
+  std::string pci_bus_id_;
+  std::string name_;
+  std::string model_str_;
+
+  ThreadDim thread_dim_limit_;
+  BlockDim block_dim_limit_;
+
+  int64_t threads_per_core_limit_;
+  int64_t threads_per_block_limit_;
+  int64_t threads_per_warp_;
+
+  int64_t registers_per_core_limit_;
+  int64_t registers_per_block_limit_;
+
+  int64_t device_address_bits_;
+  int64_t device_memory_size_;
+  int64_t l2_cache_size_;
+  int64_t memory_bandwidth_;
+
+  // Shared memory limits on a given device.
+  int64_t shared_memory_per_core_;
+  int64_t shared_memory_per_block_;
+  int64_t shared_memory_per_block_optin_;
+
+  float clock_rate_ghz_;
+
+  GpuComputeCapability gpu_compute_capability_;
+
+  int numa_node_;
+  int core_count_;
+  int fpus_per_core_;
+  bool ecc_enabled_;
+};
+
+namespace internal {
+
+// Helper class the builds a device description, given that it has a large
+// number of fields that would be easily confused in constructor form.
+class DeviceDescriptionBuilder {
+ public:
+  DeviceDescriptionBuilder() = default;
+
+  // For descriptions of the following fields, see comments on the corresponding
+  // DeviceDescription::* accessors above.
+
+  void set_gpu_compute_capability(GpuComputeCapability c) {
+    device_description_.gpu_compute_capability_ = c;
+  }
+
+  void set_block_dim_limit_x(int64_t limit) {
+    device_description_.block_dim_limit_.x = limit;
+  }
+
+  void set_block_dim_limit_y(int64_t limit) {
+    device_description_.block_dim_limit_.y = limit;
+  }
+
+  void set_block_dim_limit_z(int64_t limit) {
+    device_description_.block_dim_limit_.z = limit;
+  }
+
+  void set_device_vendor(const std::string &value) {
+    device_description_.device_vendor_ = value;
+  }
+  void set_platform_version(const std::string &value) {
+    device_description_.platform_version_ = value;
+  }
+  void set_driver_version(const std::string &value) {
+    device_description_.driver_version_ = value;
+  }
+  void set_runtime_version(const std::string &value) {
+    device_description_.runtime_version_ = value;
+  }
+  void set_pci_bus_id(const std::string &value) {
+    device_description_.pci_bus_id_ = value;
+  }
+  void set_name(const std::string &value) { device_description_.name_ = value; }
+  void set_model_str(const std::string &value) {
+    device_description_.model_str_ = value;
+  }
+
+  void set_thread_dim_limit(const ThreadDim &value) {
+    device_description_.thread_dim_limit_ = value;
+  }
+  void set_block_dim_limit(const BlockDim &value) {
+    device_description_.block_dim_limit_ = value;
+  }
+
+  void set_threads_per_core_limit(int64_t value) {
+    device_description_.threads_per_core_limit_ = value;
+  }
+  void set_threads_per_block_limit(int64_t value) {
+    device_description_.threads_per_block_limit_ = value;
+  }
+  void set_threads_per_warp(int64_t value) {
+    device_description_.threads_per_warp_ = value;
+  }
+
+  void set_registers_per_core_limit(int64_t value) {
+    device_description_.registers_per_core_limit_ = value;
+  }
+  void set_registers_per_block_limit(int64_t value) {
+    device_description_.registers_per_block_limit_ = value;
+  }
+
+  void set_device_address_bits(int64_t value) {
+    device_description_.device_address_bits_ = value;
+  }
+  void set_device_memory_size(int64_t value) {
+    device_description_.device_memory_size_ = value;
+  }
+  void set_l2_cache_size(int64_t value) {
+    device_description_.l2_cache_size_ = value;
+  }
+  void set_memory_bandwidth(int64_t value) {
+    device_description_.memory_bandwidth_ = value;
+  }
+
+  void set_shared_memory_per_core(int64_t value) {
+    device_description_.shared_memory_per_core_ = value;
+  }
+  void set_shared_memory_per_block(int64_t value) {
+    device_description_.shared_memory_per_block_ = value;
+  }
+  void set_shared_memory_per_block_optin(int64_t value) {
+    device_description_.shared_memory_per_block_optin_ = value;
+  }
+
+  void set_clock_rate_ghz(float value) {
+    device_description_.clock_rate_ghz_ = value;
+  }
+
+  void set_cuda_compute_capability(int major, int minor) {
+    device_description_.gpu_compute_capability_ =
+        CudaComputeCapability{major, minor};
+  }
+
+  void set_rocm_compute_capability(std::string gcn_arch_name) {
+    device_description_.gpu_compute_capability_ =
+        RocmComputeCapability(gcn_arch_name);
+  }
+
+  void set_numa_node(int value) { device_description_.numa_node_ = value; }
+  void set_core_count(int value) { device_description_.core_count_ = value; }
+  void set_fpus_per_core(int value) {
+    device_description_.fpus_per_core_ = value;
+  }
+  void set_ecc_enabled(bool value) { device_description_.ecc_enabled_ = value; }
+
+  // Returns a built DeviceDescription with ownership transferred to the
+  // caller. There are currently no restrictions on which fields must be set in
+  // order to build the descriptor.
+  //
+  // Once the description is built, this builder object should be discarded.
+  std::unique_ptr<DeviceDescription> Build() {
+    return std::make_unique<DeviceDescription>(device_description_);
+  }
+
+  DeviceDescription BuildObject() { return device_description_; }
+
+ private:
+  DeviceDescription device_description_;
+
+  DeviceDescriptionBuilder(const DeviceDescriptionBuilder &) = delete;
+  void operator=(const DeviceDescriptionBuilder &) = delete;
+};
+
+}  // namespace internal
+
+// Returns whether the given thread_dim is acceptable given the limits described
+// in device_description. For detailed reasons for failing the predicate, enable
+// VLOG(2) for this module.
+bool ThreadDimOk(const DeviceDescription &device_description,
+                 const ThreadDim &thread_dim);
+
+// Calculate the number of threads/blocks required to process element_count
+// elements. Note that you can still end up with more threads than
+// element_count due to rounding, so kernels often start with an "is this
+// thread id in the element_count range?" test.
+void CalculateDimensionality(const DeviceDescription &device_description,
+                             int64_t element_count, int64_t *threads_per_block,
+                             int64_t *block_count);
+
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_DEVICE_DESCRIPTION_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/device_description.pb.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/device_description.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..c47979277859a746c7d10c130c8dba9de6ac07e3
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/device_description.pb.h
@@ -0,0 +1,2164 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: xla/stream_executor/device_description.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_xla_2fstream_5fexecutor_2fdevice_5fdescription_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_xla_2fstream_5fexecutor_2fdevice_5fdescription_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3021000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3021009 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+#include "xla/autotune_results.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_xla_2fstream_5fexecutor_2fdevice_5fdescription_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_xla_2fstream_5fexecutor_2fdevice_5fdescription_2eproto {
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_xla_2fstream_5fexecutor_2fdevice_5fdescription_2eproto;
+namespace stream_executor {
+class CudaComputeCapabilityProto;
+struct CudaComputeCapabilityProtoDefaultTypeInternal;
+extern CudaComputeCapabilityProtoDefaultTypeInternal _CudaComputeCapabilityProto_default_instance_;
+class DnnVersionInfoProto;
+struct DnnVersionInfoProtoDefaultTypeInternal;
+extern DnnVersionInfoProtoDefaultTypeInternal _DnnVersionInfoProto_default_instance_;
+class GpuDeviceInfoProto;
+struct GpuDeviceInfoProtoDefaultTypeInternal;
+extern GpuDeviceInfoProtoDefaultTypeInternal _GpuDeviceInfoProto_default_instance_;
+class GpuTargetConfigProto;
+struct GpuTargetConfigProtoDefaultTypeInternal;
+extern GpuTargetConfigProtoDefaultTypeInternal _GpuTargetConfigProto_default_instance_;
+class RocmComputeCapabilityProto;
+struct RocmComputeCapabilityProtoDefaultTypeInternal;
+extern RocmComputeCapabilityProtoDefaultTypeInternal _RocmComputeCapabilityProto_default_instance_;
+}  // namespace stream_executor
+PROTOBUF_NAMESPACE_OPEN
+template<> ::stream_executor::CudaComputeCapabilityProto* Arena::CreateMaybeMessage<::stream_executor::CudaComputeCapabilityProto>(Arena*);
+template<> ::stream_executor::DnnVersionInfoProto* Arena::CreateMaybeMessage<::stream_executor::DnnVersionInfoProto>(Arena*);
+template<> ::stream_executor::GpuDeviceInfoProto* Arena::CreateMaybeMessage<::stream_executor::GpuDeviceInfoProto>(Arena*);
+template<> ::stream_executor::GpuTargetConfigProto* Arena::CreateMaybeMessage<::stream_executor::GpuTargetConfigProto>(Arena*);
+template<> ::stream_executor::RocmComputeCapabilityProto* Arena::CreateMaybeMessage<::stream_executor::RocmComputeCapabilityProto>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace stream_executor {
+
+// ===================================================================
+
+class CudaComputeCapabilityProto final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:stream_executor.CudaComputeCapabilityProto) */ {
+ public:
+  inline CudaComputeCapabilityProto() : CudaComputeCapabilityProto(nullptr) {}
+  ~CudaComputeCapabilityProto() override;
+  explicit PROTOBUF_CONSTEXPR CudaComputeCapabilityProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  CudaComputeCapabilityProto(const CudaComputeCapabilityProto& from);
+  CudaComputeCapabilityProto(CudaComputeCapabilityProto&& from) noexcept
+    : CudaComputeCapabilityProto() {
+    *this = ::std::move(from);
+  }
+
+  inline CudaComputeCapabilityProto& operator=(const CudaComputeCapabilityProto& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline CudaComputeCapabilityProto& operator=(CudaComputeCapabilityProto&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const CudaComputeCapabilityProto& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const CudaComputeCapabilityProto* internal_default_instance() {
+    return reinterpret_cast<const CudaComputeCapabilityProto*>(
+               &_CudaComputeCapabilityProto_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(CudaComputeCapabilityProto& a, CudaComputeCapabilityProto& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(CudaComputeCapabilityProto* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(CudaComputeCapabilityProto* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  CudaComputeCapabilityProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<CudaComputeCapabilityProto>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const CudaComputeCapabilityProto& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const CudaComputeCapabilityProto& from) {
+    CudaComputeCapabilityProto::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(CudaComputeCapabilityProto* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "stream_executor.CudaComputeCapabilityProto";
+  }
+  protected:
+  explicit CudaComputeCapabilityProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kMajorFieldNumber = 1,
+    kMinorFieldNumber = 2,
+  };
+  // int32 major = 1;
+  void clear_major();
+  int32_t major() const;
+  void set_major(int32_t value);
+  private:
+  int32_t _internal_major() const;
+  void _internal_set_major(int32_t value);
+  public:
+
+  // int32 minor = 2;
+  void clear_minor();
+  int32_t minor() const;
+  void set_minor(int32_t value);
+  private:
+  int32_t _internal_minor() const;
+  void _internal_set_minor(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:stream_executor.CudaComputeCapabilityProto)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    int32_t major_;
+    int32_t minor_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_xla_2fstream_5fexecutor_2fdevice_5fdescription_2eproto;
+};
+// -------------------------------------------------------------------
+
+class RocmComputeCapabilityProto final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:stream_executor.RocmComputeCapabilityProto) */ {
+ public:
+  inline RocmComputeCapabilityProto() : RocmComputeCapabilityProto(nullptr) {}
+  ~RocmComputeCapabilityProto() override;
+  explicit PROTOBUF_CONSTEXPR RocmComputeCapabilityProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  RocmComputeCapabilityProto(const RocmComputeCapabilityProto& from);
+  RocmComputeCapabilityProto(RocmComputeCapabilityProto&& from) noexcept
+    : RocmComputeCapabilityProto() {
+    *this = ::std::move(from);
+  }
+
+  inline RocmComputeCapabilityProto& operator=(const RocmComputeCapabilityProto& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline RocmComputeCapabilityProto& operator=(RocmComputeCapabilityProto&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const RocmComputeCapabilityProto& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const RocmComputeCapabilityProto* internal_default_instance() {
+    return reinterpret_cast<const RocmComputeCapabilityProto*>(
+               &_RocmComputeCapabilityProto_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(RocmComputeCapabilityProto& a, RocmComputeCapabilityProto& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(RocmComputeCapabilityProto* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(RocmComputeCapabilityProto* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  RocmComputeCapabilityProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<RocmComputeCapabilityProto>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const RocmComputeCapabilityProto& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const RocmComputeCapabilityProto& from) {
+    RocmComputeCapabilityProto::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(RocmComputeCapabilityProto* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "stream_executor.RocmComputeCapabilityProto";
+  }
+  protected:
+  explicit RocmComputeCapabilityProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kGcnArchNameFieldNumber = 1,
+  };
+  // string gcn_arch_name = 1;
+  void clear_gcn_arch_name();
+  const std::string& gcn_arch_name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_gcn_arch_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_gcn_arch_name();
+  PROTOBUF_NODISCARD std::string* release_gcn_arch_name();
+  void set_allocated_gcn_arch_name(std::string* gcn_arch_name);
+  private:
+  const std::string& _internal_gcn_arch_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_gcn_arch_name(const std::string& value);
+  std::string* _internal_mutable_gcn_arch_name();
+  public:
+
+  // @@protoc_insertion_point(class_scope:stream_executor.RocmComputeCapabilityProto)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr gcn_arch_name_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_xla_2fstream_5fexecutor_2fdevice_5fdescription_2eproto;
+};
+// -------------------------------------------------------------------
+
+class GpuDeviceInfoProto final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:stream_executor.GpuDeviceInfoProto) */ {
+ public:
+  inline GpuDeviceInfoProto() : GpuDeviceInfoProto(nullptr) {}
+  ~GpuDeviceInfoProto() override;
+  explicit PROTOBUF_CONSTEXPR GpuDeviceInfoProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  GpuDeviceInfoProto(const GpuDeviceInfoProto& from);
+  GpuDeviceInfoProto(GpuDeviceInfoProto&& from) noexcept
+    : GpuDeviceInfoProto() {
+    *this = ::std::move(from);
+  }
+
+  inline GpuDeviceInfoProto& operator=(const GpuDeviceInfoProto& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline GpuDeviceInfoProto& operator=(GpuDeviceInfoProto&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const GpuDeviceInfoProto& default_instance() {
+    return *internal_default_instance();
+  }
+  enum ComputeCapabilityCase {
+    kCudaComputeCapability = 16,
+    kRocmComputeCapability = 17,
+    COMPUTE_CAPABILITY_NOT_SET = 0,
+  };
+
+  static inline const GpuDeviceInfoProto* internal_default_instance() {
+    return reinterpret_cast<const GpuDeviceInfoProto*>(
+               &_GpuDeviceInfoProto_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(GpuDeviceInfoProto& a, GpuDeviceInfoProto& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(GpuDeviceInfoProto* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(GpuDeviceInfoProto* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  GpuDeviceInfoProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<GpuDeviceInfoProto>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const GpuDeviceInfoProto& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const GpuDeviceInfoProto& from) {
+    GpuDeviceInfoProto::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(GpuDeviceInfoProto* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "stream_executor.GpuDeviceInfoProto";
+  }
+  protected:
+  explicit GpuDeviceInfoProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kThreadsPerBlockLimitFieldNumber = 1,
+    kThreadsPerWarpFieldNumber = 2,
+    kSharedMemoryPerBlockFieldNumber = 3,
+    kSharedMemoryPerCoreFieldNumber = 4,
+    kThreadsPerCoreLimitFieldNumber = 5,
+    kCoreCountFieldNumber = 6,
+    kFpusPerCoreFieldNumber = 7,
+    kBlockDimLimitXFieldNumber = 8,
+    kBlockDimLimitYFieldNumber = 9,
+    kMemoryBandwidthFieldNumber = 11,
+    kBlockDimLimitZFieldNumber = 10,
+    kClockRateGhzFieldNumber = 13,
+    kL2CacheSizeFieldNumber = 12,
+    kDeviceMemorySizeFieldNumber = 14,
+    kSharedMemoryPerBlockOptinFieldNumber = 15,
+    kCudaComputeCapabilityFieldNumber = 16,
+    kRocmComputeCapabilityFieldNumber = 17,
+  };
+  // int32 threads_per_block_limit = 1;
+  void clear_threads_per_block_limit();
+  int32_t threads_per_block_limit() const;
+  void set_threads_per_block_limit(int32_t value);
+  private:
+  int32_t _internal_threads_per_block_limit() const;
+  void _internal_set_threads_per_block_limit(int32_t value);
+  public:
+
+  // int32 threads_per_warp = 2;
+  void clear_threads_per_warp();
+  int32_t threads_per_warp() const;
+  void set_threads_per_warp(int32_t value);
+  private:
+  int32_t _internal_threads_per_warp() const;
+  void _internal_set_threads_per_warp(int32_t value);
+  public:
+
+  // int32 shared_memory_per_block = 3;
+  void clear_shared_memory_per_block();
+  int32_t shared_memory_per_block() const;
+  void set_shared_memory_per_block(int32_t value);
+  private:
+  int32_t _internal_shared_memory_per_block() const;
+  void _internal_set_shared_memory_per_block(int32_t value);
+  public:
+
+  // int32 shared_memory_per_core = 4;
+  void clear_shared_memory_per_core();
+  int32_t shared_memory_per_core() const;
+  void set_shared_memory_per_core(int32_t value);
+  private:
+  int32_t _internal_shared_memory_per_core() const;
+  void _internal_set_shared_memory_per_core(int32_t value);
+  public:
+
+  // int32 threads_per_core_limit = 5;
+  void clear_threads_per_core_limit();
+  int32_t threads_per_core_limit() const;
+  void set_threads_per_core_limit(int32_t value);
+  private:
+  int32_t _internal_threads_per_core_limit() const;
+  void _internal_set_threads_per_core_limit(int32_t value);
+  public:
+
+  // int32 core_count = 6;
+  void clear_core_count();
+  int32_t core_count() const;
+  void set_core_count(int32_t value);
+  private:
+  int32_t _internal_core_count() const;
+  void _internal_set_core_count(int32_t value);
+  public:
+
+  // int64 fpus_per_core = 7;
+  void clear_fpus_per_core();
+  int64_t fpus_per_core() const;
+  void set_fpus_per_core(int64_t value);
+  private:
+  int64_t _internal_fpus_per_core() const;
+  void _internal_set_fpus_per_core(int64_t value);
+  public:
+
+  // int32 block_dim_limit_x = 8;
+  void clear_block_dim_limit_x();
+  int32_t block_dim_limit_x() const;
+  void set_block_dim_limit_x(int32_t value);
+  private:
+  int32_t _internal_block_dim_limit_x() const;
+  void _internal_set_block_dim_limit_x(int32_t value);
+  public:
+
+  // int32 block_dim_limit_y = 9;
+  void clear_block_dim_limit_y();
+  int32_t block_dim_limit_y() const;
+  void set_block_dim_limit_y(int32_t value);
+  private:
+  int32_t _internal_block_dim_limit_y() const;
+  void _internal_set_block_dim_limit_y(int32_t value);
+  public:
+
+  // int64 memory_bandwidth = 11;
+  void clear_memory_bandwidth();
+  int64_t memory_bandwidth() const;
+  void set_memory_bandwidth(int64_t value);
+  private:
+  int64_t _internal_memory_bandwidth() const;
+  void _internal_set_memory_bandwidth(int64_t value);
+  public:
+
+  // int32 block_dim_limit_z = 10;
+  void clear_block_dim_limit_z();
+  int32_t block_dim_limit_z() const;
+  void set_block_dim_limit_z(int32_t value);
+  private:
+  int32_t _internal_block_dim_limit_z() const;
+  void _internal_set_block_dim_limit_z(int32_t value);
+  public:
+
+  // float clock_rate_ghz = 13;
+  void clear_clock_rate_ghz();
+  float clock_rate_ghz() const;
+  void set_clock_rate_ghz(float value);
+  private:
+  float _internal_clock_rate_ghz() const;
+  void _internal_set_clock_rate_ghz(float value);
+  public:
+
+  // int64 l2_cache_size = 12;
+  void clear_l2_cache_size();
+  int64_t l2_cache_size() const;
+  void set_l2_cache_size(int64_t value);
+  private:
+  int64_t _internal_l2_cache_size() const;
+  void _internal_set_l2_cache_size(int64_t value);
+  public:
+
+  // int64 device_memory_size = 14;
+  void clear_device_memory_size();
+  int64_t device_memory_size() const;
+  void set_device_memory_size(int64_t value);
+  private:
+  int64_t _internal_device_memory_size() const;
+  void _internal_set_device_memory_size(int64_t value);
+  public:
+
+  // int32 shared_memory_per_block_optin = 15;
+  void clear_shared_memory_per_block_optin();
+  int32_t shared_memory_per_block_optin() const;
+  void set_shared_memory_per_block_optin(int32_t value);
+  private:
+  int32_t _internal_shared_memory_per_block_optin() const;
+  void _internal_set_shared_memory_per_block_optin(int32_t value);
+  public:
+
+  // .stream_executor.CudaComputeCapabilityProto cuda_compute_capability = 16;
+  bool has_cuda_compute_capability() const;
+  private:
+  bool _internal_has_cuda_compute_capability() const;
+  public:
+  void clear_cuda_compute_capability();
+  const ::stream_executor::CudaComputeCapabilityProto& cuda_compute_capability() const;
+  PROTOBUF_NODISCARD ::stream_executor::CudaComputeCapabilityProto* release_cuda_compute_capability();
+  ::stream_executor::CudaComputeCapabilityProto* mutable_cuda_compute_capability();
+  void set_allocated_cuda_compute_capability(::stream_executor::CudaComputeCapabilityProto* cuda_compute_capability);
+  private:
+  const ::stream_executor::CudaComputeCapabilityProto& _internal_cuda_compute_capability() const;
+  ::stream_executor::CudaComputeCapabilityProto* _internal_mutable_cuda_compute_capability();
+  public:
+  void unsafe_arena_set_allocated_cuda_compute_capability(
+      ::stream_executor::CudaComputeCapabilityProto* cuda_compute_capability);
+  ::stream_executor::CudaComputeCapabilityProto* unsafe_arena_release_cuda_compute_capability();
+
+  // .stream_executor.RocmComputeCapabilityProto rocm_compute_capability = 17;
+  bool has_rocm_compute_capability() const;
+  private:
+  bool _internal_has_rocm_compute_capability() const;
+  public:
+  void clear_rocm_compute_capability();
+  const ::stream_executor::RocmComputeCapabilityProto& rocm_compute_capability() const;
+  PROTOBUF_NODISCARD ::stream_executor::RocmComputeCapabilityProto* release_rocm_compute_capability();
+  ::stream_executor::RocmComputeCapabilityProto* mutable_rocm_compute_capability();
+  void set_allocated_rocm_compute_capability(::stream_executor::RocmComputeCapabilityProto* rocm_compute_capability);
+  private:
+  const ::stream_executor::RocmComputeCapabilityProto& _internal_rocm_compute_capability() const;
+  ::stream_executor::RocmComputeCapabilityProto* _internal_mutable_rocm_compute_capability();
+  public:
+  void unsafe_arena_set_allocated_rocm_compute_capability(
+      ::stream_executor::RocmComputeCapabilityProto* rocm_compute_capability);
+  ::stream_executor::RocmComputeCapabilityProto* unsafe_arena_release_rocm_compute_capability();
+
+  void clear_compute_capability();
+  ComputeCapabilityCase compute_capability_case() const;
+  // @@protoc_insertion_point(class_scope:stream_executor.GpuDeviceInfoProto)
+ private:
+  class _Internal;
+  void set_has_cuda_compute_capability();
+  void set_has_rocm_compute_capability();
+
+  inline bool has_compute_capability() const;
+  inline void clear_has_compute_capability();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    int32_t threads_per_block_limit_;
+    int32_t threads_per_warp_;
+    int32_t shared_memory_per_block_;
+    int32_t shared_memory_per_core_;
+    int32_t threads_per_core_limit_;
+    int32_t core_count_;
+    int64_t fpus_per_core_;
+    int32_t block_dim_limit_x_;
+    int32_t block_dim_limit_y_;
+    int64_t memory_bandwidth_;
+    int32_t block_dim_limit_z_;
+    float clock_rate_ghz_;
+    int64_t l2_cache_size_;
+    int64_t device_memory_size_;
+    int32_t shared_memory_per_block_optin_;
+    union ComputeCapabilityUnion {
+      constexpr ComputeCapabilityUnion() : _constinit_{} {}
+        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+      ::stream_executor::CudaComputeCapabilityProto* cuda_compute_capability_;
+      ::stream_executor::RocmComputeCapabilityProto* rocm_compute_capability_;
+    } compute_capability_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    uint32_t _oneof_case_[1];
+
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_xla_2fstream_5fexecutor_2fdevice_5fdescription_2eproto;
+};
+// -------------------------------------------------------------------
+
+class DnnVersionInfoProto final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:stream_executor.DnnVersionInfoProto) */ {
+ public:
+  inline DnnVersionInfoProto() : DnnVersionInfoProto(nullptr) {}
+  ~DnnVersionInfoProto() override;
+  explicit PROTOBUF_CONSTEXPR DnnVersionInfoProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DnnVersionInfoProto(const DnnVersionInfoProto& from);
+  DnnVersionInfoProto(DnnVersionInfoProto&& from) noexcept
+    : DnnVersionInfoProto() {
+    *this = ::std::move(from);
+  }
+
+  inline DnnVersionInfoProto& operator=(const DnnVersionInfoProto& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DnnVersionInfoProto& operator=(DnnVersionInfoProto&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const DnnVersionInfoProto& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const DnnVersionInfoProto* internal_default_instance() {
+    return reinterpret_cast<const DnnVersionInfoProto*>(
+               &_DnnVersionInfoProto_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  friend void swap(DnnVersionInfoProto& a, DnnVersionInfoProto& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DnnVersionInfoProto* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(DnnVersionInfoProto* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  DnnVersionInfoProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<DnnVersionInfoProto>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const DnnVersionInfoProto& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const DnnVersionInfoProto& from) {
+    DnnVersionInfoProto::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(DnnVersionInfoProto* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "stream_executor.DnnVersionInfoProto";
+  }
+  protected:
+  explicit DnnVersionInfoProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kMajorFieldNumber = 1,
+    kMinorFieldNumber = 2,
+    kPatchFieldNumber = 3,
+  };
+  // int32 major = 1;
+  void clear_major();
+  int32_t major() const;
+  void set_major(int32_t value);
+  private:
+  int32_t _internal_major() const;
+  void _internal_set_major(int32_t value);
+  public:
+
+  // int32 minor = 2;
+  void clear_minor();
+  int32_t minor() const;
+  void set_minor(int32_t value);
+  private:
+  int32_t _internal_minor() const;
+  void _internal_set_minor(int32_t value);
+  public:
+
+  // int32 patch = 3;
+  void clear_patch();
+  int32_t patch() const;
+  void set_patch(int32_t value);
+  private:
+  int32_t _internal_patch() const;
+  void _internal_set_patch(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:stream_executor.DnnVersionInfoProto)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    int32_t major_;
+    int32_t minor_;
+    int32_t patch_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_xla_2fstream_5fexecutor_2fdevice_5fdescription_2eproto;
+};
+// -------------------------------------------------------------------
+
+class GpuTargetConfigProto final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:stream_executor.GpuTargetConfigProto) */ {
+ public:
+  inline GpuTargetConfigProto() : GpuTargetConfigProto(nullptr) {}
+  ~GpuTargetConfigProto() override;
+  explicit PROTOBUF_CONSTEXPR GpuTargetConfigProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  GpuTargetConfigProto(const GpuTargetConfigProto& from);
+  GpuTargetConfigProto(GpuTargetConfigProto&& from) noexcept
+    : GpuTargetConfigProto() {
+    *this = ::std::move(from);
+  }
+
+  inline GpuTargetConfigProto& operator=(const GpuTargetConfigProto& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline GpuTargetConfigProto& operator=(GpuTargetConfigProto&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const GpuTargetConfigProto& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const GpuTargetConfigProto* internal_default_instance() {
+    return reinterpret_cast<const GpuTargetConfigProto*>(
+               &_GpuTargetConfigProto_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    4;
+
+  friend void swap(GpuTargetConfigProto& a, GpuTargetConfigProto& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(GpuTargetConfigProto* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(GpuTargetConfigProto* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  GpuTargetConfigProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<GpuTargetConfigProto>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const GpuTargetConfigProto& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const GpuTargetConfigProto& from) {
+    GpuTargetConfigProto::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(GpuTargetConfigProto* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "stream_executor.GpuTargetConfigProto";
+  }
+  protected:
+  explicit GpuTargetConfigProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kPlatformNameFieldNumber = 4,
+    kDeviceDescriptionStrFieldNumber = 7,
+    kGpuDeviceInfoFieldNumber = 1,
+    kDnnVersionInfoFieldNumber = 5,
+    kAutotuneResultsFieldNumber = 6,
+  };
+  // string platform_name = 4;
+  void clear_platform_name();
+  const std::string& platform_name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_platform_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_platform_name();
+  PROTOBUF_NODISCARD std::string* release_platform_name();
+  void set_allocated_platform_name(std::string* platform_name);
+  private:
+  const std::string& _internal_platform_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_platform_name(const std::string& value);
+  std::string* _internal_mutable_platform_name();
+  public:
+
+  // string device_description_str = 7;
+  void clear_device_description_str();
+  const std::string& device_description_str() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_device_description_str(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_device_description_str();
+  PROTOBUF_NODISCARD std::string* release_device_description_str();
+  void set_allocated_device_description_str(std::string* device_description_str);
+  private:
+  const std::string& _internal_device_description_str() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_device_description_str(const std::string& value);
+  std::string* _internal_mutable_device_description_str();
+  public:
+
+  // .stream_executor.GpuDeviceInfoProto gpu_device_info = 1;
+  bool has_gpu_device_info() const;
+  private:
+  bool _internal_has_gpu_device_info() const;
+  public:
+  void clear_gpu_device_info();
+  const ::stream_executor::GpuDeviceInfoProto& gpu_device_info() const;
+  PROTOBUF_NODISCARD ::stream_executor::GpuDeviceInfoProto* release_gpu_device_info();
+  ::stream_executor::GpuDeviceInfoProto* mutable_gpu_device_info();
+  void set_allocated_gpu_device_info(::stream_executor::GpuDeviceInfoProto* gpu_device_info);
+  private:
+  const ::stream_executor::GpuDeviceInfoProto& _internal_gpu_device_info() const;
+  ::stream_executor::GpuDeviceInfoProto* _internal_mutable_gpu_device_info();
+  public:
+  void unsafe_arena_set_allocated_gpu_device_info(
+      ::stream_executor::GpuDeviceInfoProto* gpu_device_info);
+  ::stream_executor::GpuDeviceInfoProto* unsafe_arena_release_gpu_device_info();
+
+  // .stream_executor.DnnVersionInfoProto dnn_version_info = 5;
+  bool has_dnn_version_info() const;
+  private:
+  bool _internal_has_dnn_version_info() const;
+  public:
+  void clear_dnn_version_info();
+  const ::stream_executor::DnnVersionInfoProto& dnn_version_info() const;
+  PROTOBUF_NODISCARD ::stream_executor::DnnVersionInfoProto* release_dnn_version_info();
+  ::stream_executor::DnnVersionInfoProto* mutable_dnn_version_info();
+  void set_allocated_dnn_version_info(::stream_executor::DnnVersionInfoProto* dnn_version_info);
+  private:
+  const ::stream_executor::DnnVersionInfoProto& _internal_dnn_version_info() const;
+  ::stream_executor::DnnVersionInfoProto* _internal_mutable_dnn_version_info();
+  public:
+  void unsafe_arena_set_allocated_dnn_version_info(
+      ::stream_executor::DnnVersionInfoProto* dnn_version_info);
+  ::stream_executor::DnnVersionInfoProto* unsafe_arena_release_dnn_version_info();
+
+  // .xla.AutotuneResults autotune_results = 6;
+  bool has_autotune_results() const;
+  private:
+  bool _internal_has_autotune_results() const;
+  public:
+  void clear_autotune_results();
+  const ::xla::AutotuneResults& autotune_results() const;
+  PROTOBUF_NODISCARD ::xla::AutotuneResults* release_autotune_results();
+  ::xla::AutotuneResults* mutable_autotune_results();
+  void set_allocated_autotune_results(::xla::AutotuneResults* autotune_results);
+  private:
+  const ::xla::AutotuneResults& _internal_autotune_results() const;
+  ::xla::AutotuneResults* _internal_mutable_autotune_results();
+  public:
+  void unsafe_arena_set_allocated_autotune_results(
+      ::xla::AutotuneResults* autotune_results);
+  ::xla::AutotuneResults* unsafe_arena_release_autotune_results();
+
+  // @@protoc_insertion_point(class_scope:stream_executor.GpuTargetConfigProto)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr platform_name_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_description_str_;
+    ::stream_executor::GpuDeviceInfoProto* gpu_device_info_;
+    ::stream_executor::DnnVersionInfoProto* dnn_version_info_;
+    ::xla::AutotuneResults* autotune_results_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_xla_2fstream_5fexecutor_2fdevice_5fdescription_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// CudaComputeCapabilityProto
+
+// int32 major = 1;
+inline void CudaComputeCapabilityProto::clear_major() {
+  _impl_.major_ = 0;
+}
+inline int32_t CudaComputeCapabilityProto::_internal_major() const {
+  return _impl_.major_;
+}
+inline int32_t CudaComputeCapabilityProto::major() const {
+  // @@protoc_insertion_point(field_get:stream_executor.CudaComputeCapabilityProto.major)
+  return _internal_major();
+}
+inline void CudaComputeCapabilityProto::_internal_set_major(int32_t value) {
+  
+  _impl_.major_ = value;
+}
+inline void CudaComputeCapabilityProto::set_major(int32_t value) {
+  _internal_set_major(value);
+  // @@protoc_insertion_point(field_set:stream_executor.CudaComputeCapabilityProto.major)
+}
+
+// int32 minor = 2;
+inline void CudaComputeCapabilityProto::clear_minor() {
+  _impl_.minor_ = 0;
+}
+inline int32_t CudaComputeCapabilityProto::_internal_minor() const {
+  return _impl_.minor_;
+}
+inline int32_t CudaComputeCapabilityProto::minor() const {
+  // @@protoc_insertion_point(field_get:stream_executor.CudaComputeCapabilityProto.minor)
+  return _internal_minor();
+}
+inline void CudaComputeCapabilityProto::_internal_set_minor(int32_t value) {
+  
+  _impl_.minor_ = value;
+}
+inline void CudaComputeCapabilityProto::set_minor(int32_t value) {
+  _internal_set_minor(value);
+  // @@protoc_insertion_point(field_set:stream_executor.CudaComputeCapabilityProto.minor)
+}
+
+// -------------------------------------------------------------------
+
+// RocmComputeCapabilityProto
+
+// string gcn_arch_name = 1;
+inline void RocmComputeCapabilityProto::clear_gcn_arch_name() {
+  _impl_.gcn_arch_name_.ClearToEmpty();
+}
+inline const std::string& RocmComputeCapabilityProto::gcn_arch_name() const {
+  // @@protoc_insertion_point(field_get:stream_executor.RocmComputeCapabilityProto.gcn_arch_name)
+  return _internal_gcn_arch_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void RocmComputeCapabilityProto::set_gcn_arch_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.gcn_arch_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:stream_executor.RocmComputeCapabilityProto.gcn_arch_name)
+}
+inline std::string* RocmComputeCapabilityProto::mutable_gcn_arch_name() {
+  std::string* _s = _internal_mutable_gcn_arch_name();
+  // @@protoc_insertion_point(field_mutable:stream_executor.RocmComputeCapabilityProto.gcn_arch_name)
+  return _s;
+}
+inline const std::string& RocmComputeCapabilityProto::_internal_gcn_arch_name() const {
+  return _impl_.gcn_arch_name_.Get();
+}
+inline void RocmComputeCapabilityProto::_internal_set_gcn_arch_name(const std::string& value) {
+  
+  _impl_.gcn_arch_name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* RocmComputeCapabilityProto::_internal_mutable_gcn_arch_name() {
+  
+  return _impl_.gcn_arch_name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* RocmComputeCapabilityProto::release_gcn_arch_name() {
+  // @@protoc_insertion_point(field_release:stream_executor.RocmComputeCapabilityProto.gcn_arch_name)
+  return _impl_.gcn_arch_name_.Release();
+}
+inline void RocmComputeCapabilityProto::set_allocated_gcn_arch_name(std::string* gcn_arch_name) {
+  if (gcn_arch_name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.gcn_arch_name_.SetAllocated(gcn_arch_name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.gcn_arch_name_.IsDefault()) {
+    _impl_.gcn_arch_name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:stream_executor.RocmComputeCapabilityProto.gcn_arch_name)
+}
+
+// -------------------------------------------------------------------
+
+// GpuDeviceInfoProto
+
+// int32 threads_per_block_limit = 1;
+inline void GpuDeviceInfoProto::clear_threads_per_block_limit() {
+  _impl_.threads_per_block_limit_ = 0;
+}
+inline int32_t GpuDeviceInfoProto::_internal_threads_per_block_limit() const {
+  return _impl_.threads_per_block_limit_;
+}
+inline int32_t GpuDeviceInfoProto::threads_per_block_limit() const {
+  // @@protoc_insertion_point(field_get:stream_executor.GpuDeviceInfoProto.threads_per_block_limit)
+  return _internal_threads_per_block_limit();
+}
+inline void GpuDeviceInfoProto::_internal_set_threads_per_block_limit(int32_t value) {
+  
+  _impl_.threads_per_block_limit_ = value;
+}
+inline void GpuDeviceInfoProto::set_threads_per_block_limit(int32_t value) {
+  _internal_set_threads_per_block_limit(value);
+  // @@protoc_insertion_point(field_set:stream_executor.GpuDeviceInfoProto.threads_per_block_limit)
+}
+
+// int32 threads_per_warp = 2;
+inline void GpuDeviceInfoProto::clear_threads_per_warp() {
+  _impl_.threads_per_warp_ = 0;
+}
+inline int32_t GpuDeviceInfoProto::_internal_threads_per_warp() const {
+  return _impl_.threads_per_warp_;
+}
+inline int32_t GpuDeviceInfoProto::threads_per_warp() const {
+  // @@protoc_insertion_point(field_get:stream_executor.GpuDeviceInfoProto.threads_per_warp)
+  return _internal_threads_per_warp();
+}
+inline void GpuDeviceInfoProto::_internal_set_threads_per_warp(int32_t value) {
+  
+  _impl_.threads_per_warp_ = value;
+}
+inline void GpuDeviceInfoProto::set_threads_per_warp(int32_t value) {
+  _internal_set_threads_per_warp(value);
+  // @@protoc_insertion_point(field_set:stream_executor.GpuDeviceInfoProto.threads_per_warp)
+}
+
+// int32 shared_memory_per_block = 3;
+inline void GpuDeviceInfoProto::clear_shared_memory_per_block() {
+  _impl_.shared_memory_per_block_ = 0;
+}
+inline int32_t GpuDeviceInfoProto::_internal_shared_memory_per_block() const {
+  return _impl_.shared_memory_per_block_;
+}
+inline int32_t GpuDeviceInfoProto::shared_memory_per_block() const {
+  // @@protoc_insertion_point(field_get:stream_executor.GpuDeviceInfoProto.shared_memory_per_block)
+  return _internal_shared_memory_per_block();
+}
+inline void GpuDeviceInfoProto::_internal_set_shared_memory_per_block(int32_t value) {
+  
+  _impl_.shared_memory_per_block_ = value;
+}
+inline void GpuDeviceInfoProto::set_shared_memory_per_block(int32_t value) {
+  _internal_set_shared_memory_per_block(value);
+  // @@protoc_insertion_point(field_set:stream_executor.GpuDeviceInfoProto.shared_memory_per_block)
+}
+
+// int32 shared_memory_per_core = 4;
+inline void GpuDeviceInfoProto::clear_shared_memory_per_core() {
+  _impl_.shared_memory_per_core_ = 0;
+}
+inline int32_t GpuDeviceInfoProto::_internal_shared_memory_per_core() const {
+  return _impl_.shared_memory_per_core_;
+}
+inline int32_t GpuDeviceInfoProto::shared_memory_per_core() const {
+  // @@protoc_insertion_point(field_get:stream_executor.GpuDeviceInfoProto.shared_memory_per_core)
+  return _internal_shared_memory_per_core();
+}
+inline void GpuDeviceInfoProto::_internal_set_shared_memory_per_core(int32_t value) {
+  
+  _impl_.shared_memory_per_core_ = value;
+}
+inline void GpuDeviceInfoProto::set_shared_memory_per_core(int32_t value) {
+  _internal_set_shared_memory_per_core(value);
+  // @@protoc_insertion_point(field_set:stream_executor.GpuDeviceInfoProto.shared_memory_per_core)
+}
+
+// int32 threads_per_core_limit = 5;
+inline void GpuDeviceInfoProto::clear_threads_per_core_limit() {
+  _impl_.threads_per_core_limit_ = 0;
+}
+inline int32_t GpuDeviceInfoProto::_internal_threads_per_core_limit() const {
+  return _impl_.threads_per_core_limit_;
+}
+inline int32_t GpuDeviceInfoProto::threads_per_core_limit() const {
+  // @@protoc_insertion_point(field_get:stream_executor.GpuDeviceInfoProto.threads_per_core_limit)
+  return _internal_threads_per_core_limit();
+}
+inline void GpuDeviceInfoProto::_internal_set_threads_per_core_limit(int32_t value) {
+  
+  _impl_.threads_per_core_limit_ = value;
+}
+inline void GpuDeviceInfoProto::set_threads_per_core_limit(int32_t value) {
+  _internal_set_threads_per_core_limit(value);
+  // @@protoc_insertion_point(field_set:stream_executor.GpuDeviceInfoProto.threads_per_core_limit)
+}
+
+// int32 core_count = 6;
+inline void GpuDeviceInfoProto::clear_core_count() {
+  _impl_.core_count_ = 0;
+}
+inline int32_t GpuDeviceInfoProto::_internal_core_count() const {
+  return _impl_.core_count_;
+}
+inline int32_t GpuDeviceInfoProto::core_count() const {
+  // @@protoc_insertion_point(field_get:stream_executor.GpuDeviceInfoProto.core_count)
+  return _internal_core_count();
+}
+inline void GpuDeviceInfoProto::_internal_set_core_count(int32_t value) {
+  
+  _impl_.core_count_ = value;
+}
+inline void GpuDeviceInfoProto::set_core_count(int32_t value) {
+  _internal_set_core_count(value);
+  // @@protoc_insertion_point(field_set:stream_executor.GpuDeviceInfoProto.core_count)
+}
+
+// int64 fpus_per_core = 7;
+inline void GpuDeviceInfoProto::clear_fpus_per_core() {
+  _impl_.fpus_per_core_ = int64_t{0};
+}
+inline int64_t GpuDeviceInfoProto::_internal_fpus_per_core() const {
+  return _impl_.fpus_per_core_;
+}
+inline int64_t GpuDeviceInfoProto::fpus_per_core() const {
+  // @@protoc_insertion_point(field_get:stream_executor.GpuDeviceInfoProto.fpus_per_core)
+  return _internal_fpus_per_core();
+}
+inline void GpuDeviceInfoProto::_internal_set_fpus_per_core(int64_t value) {
+  
+  _impl_.fpus_per_core_ = value;
+}
+inline void GpuDeviceInfoProto::set_fpus_per_core(int64_t value) {
+  _internal_set_fpus_per_core(value);
+  // @@protoc_insertion_point(field_set:stream_executor.GpuDeviceInfoProto.fpus_per_core)
+}
+
+// int32 block_dim_limit_x = 8;
+inline void GpuDeviceInfoProto::clear_block_dim_limit_x() {
+  _impl_.block_dim_limit_x_ = 0;
+}
+inline int32_t GpuDeviceInfoProto::_internal_block_dim_limit_x() const {
+  return _impl_.block_dim_limit_x_;
+}
+inline int32_t GpuDeviceInfoProto::block_dim_limit_x() const {
+  // @@protoc_insertion_point(field_get:stream_executor.GpuDeviceInfoProto.block_dim_limit_x)
+  return _internal_block_dim_limit_x();
+}
+inline void GpuDeviceInfoProto::_internal_set_block_dim_limit_x(int32_t value) {
+  
+  _impl_.block_dim_limit_x_ = value;
+}
+inline void GpuDeviceInfoProto::set_block_dim_limit_x(int32_t value) {
+  _internal_set_block_dim_limit_x(value);
+  // @@protoc_insertion_point(field_set:stream_executor.GpuDeviceInfoProto.block_dim_limit_x)
+}
+
+// int32 block_dim_limit_y = 9;
+inline void GpuDeviceInfoProto::clear_block_dim_limit_y() {
+  _impl_.block_dim_limit_y_ = 0;
+}
+inline int32_t GpuDeviceInfoProto::_internal_block_dim_limit_y() const {
+  return _impl_.block_dim_limit_y_;
+}
+inline int32_t GpuDeviceInfoProto::block_dim_limit_y() const {
+  // @@protoc_insertion_point(field_get:stream_executor.GpuDeviceInfoProto.block_dim_limit_y)
+  return _internal_block_dim_limit_y();
+}
+inline void GpuDeviceInfoProto::_internal_set_block_dim_limit_y(int32_t value) {
+  
+  _impl_.block_dim_limit_y_ = value;
+}
+inline void GpuDeviceInfoProto::set_block_dim_limit_y(int32_t value) {
+  _internal_set_block_dim_limit_y(value);
+  // @@protoc_insertion_point(field_set:stream_executor.GpuDeviceInfoProto.block_dim_limit_y)
+}
+
+// int32 block_dim_limit_z = 10;
+inline void GpuDeviceInfoProto::clear_block_dim_limit_z() {
+  _impl_.block_dim_limit_z_ = 0;
+}
+inline int32_t GpuDeviceInfoProto::_internal_block_dim_limit_z() const {
+  return _impl_.block_dim_limit_z_;
+}
+inline int32_t GpuDeviceInfoProto::block_dim_limit_z() const {
+  // @@protoc_insertion_point(field_get:stream_executor.GpuDeviceInfoProto.block_dim_limit_z)
+  return _internal_block_dim_limit_z();
+}
+inline void GpuDeviceInfoProto::_internal_set_block_dim_limit_z(int32_t value) {
+  
+  _impl_.block_dim_limit_z_ = value;
+}
+inline void GpuDeviceInfoProto::set_block_dim_limit_z(int32_t value) {
+  _internal_set_block_dim_limit_z(value);
+  // @@protoc_insertion_point(field_set:stream_executor.GpuDeviceInfoProto.block_dim_limit_z)
+}
+
+// int64 memory_bandwidth = 11;
+inline void GpuDeviceInfoProto::clear_memory_bandwidth() {
+  _impl_.memory_bandwidth_ = int64_t{0};
+}
+inline int64_t GpuDeviceInfoProto::_internal_memory_bandwidth() const {
+  return _impl_.memory_bandwidth_;
+}
+inline int64_t GpuDeviceInfoProto::memory_bandwidth() const {
+  // @@protoc_insertion_point(field_get:stream_executor.GpuDeviceInfoProto.memory_bandwidth)
+  return _internal_memory_bandwidth();
+}
+inline void GpuDeviceInfoProto::_internal_set_memory_bandwidth(int64_t value) {
+  
+  _impl_.memory_bandwidth_ = value;
+}
+inline void GpuDeviceInfoProto::set_memory_bandwidth(int64_t value) {
+  _internal_set_memory_bandwidth(value);
+  // @@protoc_insertion_point(field_set:stream_executor.GpuDeviceInfoProto.memory_bandwidth)
+}
+
+// int64 l2_cache_size = 12;
+inline void GpuDeviceInfoProto::clear_l2_cache_size() {
+  _impl_.l2_cache_size_ = int64_t{0};
+}
+inline int64_t GpuDeviceInfoProto::_internal_l2_cache_size() const {
+  return _impl_.l2_cache_size_;
+}
+inline int64_t GpuDeviceInfoProto::l2_cache_size() const {
+  // @@protoc_insertion_point(field_get:stream_executor.GpuDeviceInfoProto.l2_cache_size)
+  return _internal_l2_cache_size();
+}
+inline void GpuDeviceInfoProto::_internal_set_l2_cache_size(int64_t value) {
+  
+  _impl_.l2_cache_size_ = value;
+}
+inline void GpuDeviceInfoProto::set_l2_cache_size(int64_t value) {
+  _internal_set_l2_cache_size(value);
+  // @@protoc_insertion_point(field_set:stream_executor.GpuDeviceInfoProto.l2_cache_size)
+}
+
+// float clock_rate_ghz = 13;
+inline void GpuDeviceInfoProto::clear_clock_rate_ghz() {
+  _impl_.clock_rate_ghz_ = 0;
+}
+inline float GpuDeviceInfoProto::_internal_clock_rate_ghz() const {
+  return _impl_.clock_rate_ghz_;
+}
+inline float GpuDeviceInfoProto::clock_rate_ghz() const {
+  // @@protoc_insertion_point(field_get:stream_executor.GpuDeviceInfoProto.clock_rate_ghz)
+  return _internal_clock_rate_ghz();
+}
+inline void GpuDeviceInfoProto::_internal_set_clock_rate_ghz(float value) {
+  
+  _impl_.clock_rate_ghz_ = value;
+}
+inline void GpuDeviceInfoProto::set_clock_rate_ghz(float value) {
+  _internal_set_clock_rate_ghz(value);
+  // @@protoc_insertion_point(field_set:stream_executor.GpuDeviceInfoProto.clock_rate_ghz)
+}
+
+// int64 device_memory_size = 14;
+inline void GpuDeviceInfoProto::clear_device_memory_size() {
+  _impl_.device_memory_size_ = int64_t{0};
+}
+inline int64_t GpuDeviceInfoProto::_internal_device_memory_size() const {
+  return _impl_.device_memory_size_;
+}
+inline int64_t GpuDeviceInfoProto::device_memory_size() const {
+  // @@protoc_insertion_point(field_get:stream_executor.GpuDeviceInfoProto.device_memory_size)
+  return _internal_device_memory_size();
+}
+inline void GpuDeviceInfoProto::_internal_set_device_memory_size(int64_t value) {
+  
+  _impl_.device_memory_size_ = value;
+}
+inline void GpuDeviceInfoProto::set_device_memory_size(int64_t value) {
+  _internal_set_device_memory_size(value);
+  // @@protoc_insertion_point(field_set:stream_executor.GpuDeviceInfoProto.device_memory_size)
+}
+
+// int32 shared_memory_per_block_optin = 15;
+inline void GpuDeviceInfoProto::clear_shared_memory_per_block_optin() {
+  _impl_.shared_memory_per_block_optin_ = 0;
+}
+inline int32_t GpuDeviceInfoProto::_internal_shared_memory_per_block_optin() const {
+  return _impl_.shared_memory_per_block_optin_;
+}
+inline int32_t GpuDeviceInfoProto::shared_memory_per_block_optin() const {
+  // @@protoc_insertion_point(field_get:stream_executor.GpuDeviceInfoProto.shared_memory_per_block_optin)
+  return _internal_shared_memory_per_block_optin();
+}
+inline void GpuDeviceInfoProto::_internal_set_shared_memory_per_block_optin(int32_t value) {
+  
+  _impl_.shared_memory_per_block_optin_ = value;
+}
+inline void GpuDeviceInfoProto::set_shared_memory_per_block_optin(int32_t value) {
+  _internal_set_shared_memory_per_block_optin(value);
+  // @@protoc_insertion_point(field_set:stream_executor.GpuDeviceInfoProto.shared_memory_per_block_optin)
+}
+
+// .stream_executor.CudaComputeCapabilityProto cuda_compute_capability = 16;
+inline bool GpuDeviceInfoProto::_internal_has_cuda_compute_capability() const {
+  return compute_capability_case() == kCudaComputeCapability;
+}
+inline bool GpuDeviceInfoProto::has_cuda_compute_capability() const {
+  return _internal_has_cuda_compute_capability();
+}
+inline void GpuDeviceInfoProto::set_has_cuda_compute_capability() {
+  _impl_._oneof_case_[0] = kCudaComputeCapability;
+}
+inline void GpuDeviceInfoProto::clear_cuda_compute_capability() {
+  if (_internal_has_cuda_compute_capability()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete _impl_.compute_capability_.cuda_compute_capability_;
+    }
+    clear_has_compute_capability();
+  }
+}
+inline ::stream_executor::CudaComputeCapabilityProto* GpuDeviceInfoProto::release_cuda_compute_capability() {
+  // @@protoc_insertion_point(field_release:stream_executor.GpuDeviceInfoProto.cuda_compute_capability)
+  if (_internal_has_cuda_compute_capability()) {
+    clear_has_compute_capability();
+    ::stream_executor::CudaComputeCapabilityProto* temp = _impl_.compute_capability_.cuda_compute_capability_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    _impl_.compute_capability_.cuda_compute_capability_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::stream_executor::CudaComputeCapabilityProto& GpuDeviceInfoProto::_internal_cuda_compute_capability() const {
+  return _internal_has_cuda_compute_capability()
+      ? *_impl_.compute_capability_.cuda_compute_capability_
+      : reinterpret_cast< ::stream_executor::CudaComputeCapabilityProto&>(::stream_executor::_CudaComputeCapabilityProto_default_instance_);
+}
+inline const ::stream_executor::CudaComputeCapabilityProto& GpuDeviceInfoProto::cuda_compute_capability() const {
+  // @@protoc_insertion_point(field_get:stream_executor.GpuDeviceInfoProto.cuda_compute_capability)
+  return _internal_cuda_compute_capability();
+}
+inline ::stream_executor::CudaComputeCapabilityProto* GpuDeviceInfoProto::unsafe_arena_release_cuda_compute_capability() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:stream_executor.GpuDeviceInfoProto.cuda_compute_capability)
+  if (_internal_has_cuda_compute_capability()) {
+    clear_has_compute_capability();
+    ::stream_executor::CudaComputeCapabilityProto* temp = _impl_.compute_capability_.cuda_compute_capability_;
+    _impl_.compute_capability_.cuda_compute_capability_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void GpuDeviceInfoProto::unsafe_arena_set_allocated_cuda_compute_capability(::stream_executor::CudaComputeCapabilityProto* cuda_compute_capability) {
+  clear_compute_capability();
+  if (cuda_compute_capability) {
+    set_has_cuda_compute_capability();
+    _impl_.compute_capability_.cuda_compute_capability_ = cuda_compute_capability;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:stream_executor.GpuDeviceInfoProto.cuda_compute_capability)
+}
+inline ::stream_executor::CudaComputeCapabilityProto* GpuDeviceInfoProto::_internal_mutable_cuda_compute_capability() {
+  if (!_internal_has_cuda_compute_capability()) {
+    clear_compute_capability();
+    set_has_cuda_compute_capability();
+    _impl_.compute_capability_.cuda_compute_capability_ = CreateMaybeMessage< ::stream_executor::CudaComputeCapabilityProto >(GetArenaForAllocation());
+  }
+  return _impl_.compute_capability_.cuda_compute_capability_;
+}
+inline ::stream_executor::CudaComputeCapabilityProto* GpuDeviceInfoProto::mutable_cuda_compute_capability() {
+  ::stream_executor::CudaComputeCapabilityProto* _msg = _internal_mutable_cuda_compute_capability();
+  // @@protoc_insertion_point(field_mutable:stream_executor.GpuDeviceInfoProto.cuda_compute_capability)
+  return _msg;
+}
+
+// .stream_executor.RocmComputeCapabilityProto rocm_compute_capability = 17;
+inline bool GpuDeviceInfoProto::_internal_has_rocm_compute_capability() const {
+  return compute_capability_case() == kRocmComputeCapability;
+}
+inline bool GpuDeviceInfoProto::has_rocm_compute_capability() const {
+  return _internal_has_rocm_compute_capability();
+}
+inline void GpuDeviceInfoProto::set_has_rocm_compute_capability() {
+  _impl_._oneof_case_[0] = kRocmComputeCapability;
+}
+inline void GpuDeviceInfoProto::clear_rocm_compute_capability() {
+  if (_internal_has_rocm_compute_capability()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete _impl_.compute_capability_.rocm_compute_capability_;
+    }
+    clear_has_compute_capability();
+  }
+}
+inline ::stream_executor::RocmComputeCapabilityProto* GpuDeviceInfoProto::release_rocm_compute_capability() {
+  // @@protoc_insertion_point(field_release:stream_executor.GpuDeviceInfoProto.rocm_compute_capability)
+  if (_internal_has_rocm_compute_capability()) {
+    clear_has_compute_capability();
+    ::stream_executor::RocmComputeCapabilityProto* temp = _impl_.compute_capability_.rocm_compute_capability_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    _impl_.compute_capability_.rocm_compute_capability_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::stream_executor::RocmComputeCapabilityProto& GpuDeviceInfoProto::_internal_rocm_compute_capability() const {
+  return _internal_has_rocm_compute_capability()
+      ? *_impl_.compute_capability_.rocm_compute_capability_
+      : reinterpret_cast< ::stream_executor::RocmComputeCapabilityProto&>(::stream_executor::_RocmComputeCapabilityProto_default_instance_);
+}
+inline const ::stream_executor::RocmComputeCapabilityProto& GpuDeviceInfoProto::rocm_compute_capability() const {
+  // @@protoc_insertion_point(field_get:stream_executor.GpuDeviceInfoProto.rocm_compute_capability)
+  return _internal_rocm_compute_capability();
+}
+inline ::stream_executor::RocmComputeCapabilityProto* GpuDeviceInfoProto::unsafe_arena_release_rocm_compute_capability() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:stream_executor.GpuDeviceInfoProto.rocm_compute_capability)
+  if (_internal_has_rocm_compute_capability()) {
+    clear_has_compute_capability();
+    ::stream_executor::RocmComputeCapabilityProto* temp = _impl_.compute_capability_.rocm_compute_capability_;
+    _impl_.compute_capability_.rocm_compute_capability_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void GpuDeviceInfoProto::unsafe_arena_set_allocated_rocm_compute_capability(::stream_executor::RocmComputeCapabilityProto* rocm_compute_capability) {
+  clear_compute_capability();
+  if (rocm_compute_capability) {
+    set_has_rocm_compute_capability();
+    _impl_.compute_capability_.rocm_compute_capability_ = rocm_compute_capability;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:stream_executor.GpuDeviceInfoProto.rocm_compute_capability)
+}
+inline ::stream_executor::RocmComputeCapabilityProto* GpuDeviceInfoProto::_internal_mutable_rocm_compute_capability() {
+  if (!_internal_has_rocm_compute_capability()) {
+    clear_compute_capability();
+    set_has_rocm_compute_capability();
+    _impl_.compute_capability_.rocm_compute_capability_ = CreateMaybeMessage< ::stream_executor::RocmComputeCapabilityProto >(GetArenaForAllocation());
+  }
+  return _impl_.compute_capability_.rocm_compute_capability_;
+}
+inline ::stream_executor::RocmComputeCapabilityProto* GpuDeviceInfoProto::mutable_rocm_compute_capability() {
+  ::stream_executor::RocmComputeCapabilityProto* _msg = _internal_mutable_rocm_compute_capability();
+  // @@protoc_insertion_point(field_mutable:stream_executor.GpuDeviceInfoProto.rocm_compute_capability)
+  return _msg;
+}
+
+inline bool GpuDeviceInfoProto::has_compute_capability() const {
+  return compute_capability_case() != COMPUTE_CAPABILITY_NOT_SET;
+}
+inline void GpuDeviceInfoProto::clear_has_compute_capability() {
+  _impl_._oneof_case_[0] = COMPUTE_CAPABILITY_NOT_SET;
+}
+inline GpuDeviceInfoProto::ComputeCapabilityCase GpuDeviceInfoProto::compute_capability_case() const {
+  return GpuDeviceInfoProto::ComputeCapabilityCase(_impl_._oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// DnnVersionInfoProto
+
+// int32 major = 1;
+inline void DnnVersionInfoProto::clear_major() {
+  _impl_.major_ = 0;
+}
+inline int32_t DnnVersionInfoProto::_internal_major() const {
+  return _impl_.major_;
+}
+inline int32_t DnnVersionInfoProto::major() const {
+  // @@protoc_insertion_point(field_get:stream_executor.DnnVersionInfoProto.major)
+  return _internal_major();
+}
+inline void DnnVersionInfoProto::_internal_set_major(int32_t value) {
+  
+  _impl_.major_ = value;
+}
+inline void DnnVersionInfoProto::set_major(int32_t value) {
+  _internal_set_major(value);
+  // @@protoc_insertion_point(field_set:stream_executor.DnnVersionInfoProto.major)
+}
+
+// int32 minor = 2;
+inline void DnnVersionInfoProto::clear_minor() {
+  _impl_.minor_ = 0;
+}
+inline int32_t DnnVersionInfoProto::_internal_minor() const {
+  return _impl_.minor_;
+}
+inline int32_t DnnVersionInfoProto::minor() const {
+  // @@protoc_insertion_point(field_get:stream_executor.DnnVersionInfoProto.minor)
+  return _internal_minor();
+}
+inline void DnnVersionInfoProto::_internal_set_minor(int32_t value) {
+  
+  _impl_.minor_ = value;
+}
+inline void DnnVersionInfoProto::set_minor(int32_t value) {
+  _internal_set_minor(value);
+  // @@protoc_insertion_point(field_set:stream_executor.DnnVersionInfoProto.minor)
+}
+
+// int32 patch = 3;
+inline void DnnVersionInfoProto::clear_patch() {
+  _impl_.patch_ = 0;
+}
+inline int32_t DnnVersionInfoProto::_internal_patch() const {
+  return _impl_.patch_;
+}
+inline int32_t DnnVersionInfoProto::patch() const {
+  // @@protoc_insertion_point(field_get:stream_executor.DnnVersionInfoProto.patch)
+  return _internal_patch();
+}
+inline void DnnVersionInfoProto::_internal_set_patch(int32_t value) {
+  
+  _impl_.patch_ = value;
+}
+inline void DnnVersionInfoProto::set_patch(int32_t value) {
+  _internal_set_patch(value);
+  // @@protoc_insertion_point(field_set:stream_executor.DnnVersionInfoProto.patch)
+}
+
+// -------------------------------------------------------------------
+
+// GpuTargetConfigProto
+
+// .stream_executor.GpuDeviceInfoProto gpu_device_info = 1;
+inline bool GpuTargetConfigProto::_internal_has_gpu_device_info() const {
+  return this != internal_default_instance() && _impl_.gpu_device_info_ != nullptr;
+}
+inline bool GpuTargetConfigProto::has_gpu_device_info() const {
+  return _internal_has_gpu_device_info();
+}
+inline void GpuTargetConfigProto::clear_gpu_device_info() {
+  if (GetArenaForAllocation() == nullptr && _impl_.gpu_device_info_ != nullptr) {
+    delete _impl_.gpu_device_info_;
+  }
+  _impl_.gpu_device_info_ = nullptr;
+}
+inline const ::stream_executor::GpuDeviceInfoProto& GpuTargetConfigProto::_internal_gpu_device_info() const {
+  const ::stream_executor::GpuDeviceInfoProto* p = _impl_.gpu_device_info_;
+  return p != nullptr ? *p : reinterpret_cast<const ::stream_executor::GpuDeviceInfoProto&>(
+      ::stream_executor::_GpuDeviceInfoProto_default_instance_);
+}
+inline const ::stream_executor::GpuDeviceInfoProto& GpuTargetConfigProto::gpu_device_info() const {
+  // @@protoc_insertion_point(field_get:stream_executor.GpuTargetConfigProto.gpu_device_info)
+  return _internal_gpu_device_info();
+}
+inline void GpuTargetConfigProto::unsafe_arena_set_allocated_gpu_device_info(
+    ::stream_executor::GpuDeviceInfoProto* gpu_device_info) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.gpu_device_info_);
+  }
+  _impl_.gpu_device_info_ = gpu_device_info;
+  if (gpu_device_info) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:stream_executor.GpuTargetConfigProto.gpu_device_info)
+}
+inline ::stream_executor::GpuDeviceInfoProto* GpuTargetConfigProto::release_gpu_device_info() {
+  
+  ::stream_executor::GpuDeviceInfoProto* temp = _impl_.gpu_device_info_;
+  _impl_.gpu_device_info_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::stream_executor::GpuDeviceInfoProto* GpuTargetConfigProto::unsafe_arena_release_gpu_device_info() {
+  // @@protoc_insertion_point(field_release:stream_executor.GpuTargetConfigProto.gpu_device_info)
+  
+  ::stream_executor::GpuDeviceInfoProto* temp = _impl_.gpu_device_info_;
+  _impl_.gpu_device_info_ = nullptr;
+  return temp;
+}
+inline ::stream_executor::GpuDeviceInfoProto* GpuTargetConfigProto::_internal_mutable_gpu_device_info() {
+  
+  if (_impl_.gpu_device_info_ == nullptr) {
+    auto* p = CreateMaybeMessage<::stream_executor::GpuDeviceInfoProto>(GetArenaForAllocation());
+    _impl_.gpu_device_info_ = p;
+  }
+  return _impl_.gpu_device_info_;
+}
+inline ::stream_executor::GpuDeviceInfoProto* GpuTargetConfigProto::mutable_gpu_device_info() {
+  ::stream_executor::GpuDeviceInfoProto* _msg = _internal_mutable_gpu_device_info();
+  // @@protoc_insertion_point(field_mutable:stream_executor.GpuTargetConfigProto.gpu_device_info)
+  return _msg;
+}
+inline void GpuTargetConfigProto::set_allocated_gpu_device_info(::stream_executor::GpuDeviceInfoProto* gpu_device_info) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.gpu_device_info_;
+  }
+  if (gpu_device_info) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(gpu_device_info);
+    if (message_arena != submessage_arena) {
+      gpu_device_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, gpu_device_info, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.gpu_device_info_ = gpu_device_info;
+  // @@protoc_insertion_point(field_set_allocated:stream_executor.GpuTargetConfigProto.gpu_device_info)
+}
+
+// string platform_name = 4;
+inline void GpuTargetConfigProto::clear_platform_name() {
+  _impl_.platform_name_.ClearToEmpty();
+}
+inline const std::string& GpuTargetConfigProto::platform_name() const {
+  // @@protoc_insertion_point(field_get:stream_executor.GpuTargetConfigProto.platform_name)
+  return _internal_platform_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void GpuTargetConfigProto::set_platform_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.platform_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:stream_executor.GpuTargetConfigProto.platform_name)
+}
+inline std::string* GpuTargetConfigProto::mutable_platform_name() {
+  std::string* _s = _internal_mutable_platform_name();
+  // @@protoc_insertion_point(field_mutable:stream_executor.GpuTargetConfigProto.platform_name)
+  return _s;
+}
+inline const std::string& GpuTargetConfigProto::_internal_platform_name() const {
+  return _impl_.platform_name_.Get();
+}
+inline void GpuTargetConfigProto::_internal_set_platform_name(const std::string& value) {
+  
+  _impl_.platform_name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* GpuTargetConfigProto::_internal_mutable_platform_name() {
+  
+  return _impl_.platform_name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* GpuTargetConfigProto::release_platform_name() {
+  // @@protoc_insertion_point(field_release:stream_executor.GpuTargetConfigProto.platform_name)
+  return _impl_.platform_name_.Release();
+}
+inline void GpuTargetConfigProto::set_allocated_platform_name(std::string* platform_name) {
+  if (platform_name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.platform_name_.SetAllocated(platform_name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.platform_name_.IsDefault()) {
+    _impl_.platform_name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:stream_executor.GpuTargetConfigProto.platform_name)
+}
+
+// .stream_executor.DnnVersionInfoProto dnn_version_info = 5;
+inline bool GpuTargetConfigProto::_internal_has_dnn_version_info() const {
+  return this != internal_default_instance() && _impl_.dnn_version_info_ != nullptr;
+}
+inline bool GpuTargetConfigProto::has_dnn_version_info() const {
+  return _internal_has_dnn_version_info();
+}
+inline void GpuTargetConfigProto::clear_dnn_version_info() {
+  if (GetArenaForAllocation() == nullptr && _impl_.dnn_version_info_ != nullptr) {
+    delete _impl_.dnn_version_info_;
+  }
+  _impl_.dnn_version_info_ = nullptr;
+}
+inline const ::stream_executor::DnnVersionInfoProto& GpuTargetConfigProto::_internal_dnn_version_info() const {
+  const ::stream_executor::DnnVersionInfoProto* p = _impl_.dnn_version_info_;
+  return p != nullptr ? *p : reinterpret_cast<const ::stream_executor::DnnVersionInfoProto&>(
+      ::stream_executor::_DnnVersionInfoProto_default_instance_);
+}
+inline const ::stream_executor::DnnVersionInfoProto& GpuTargetConfigProto::dnn_version_info() const {
+  // @@protoc_insertion_point(field_get:stream_executor.GpuTargetConfigProto.dnn_version_info)
+  return _internal_dnn_version_info();
+}
+inline void GpuTargetConfigProto::unsafe_arena_set_allocated_dnn_version_info(
+    ::stream_executor::DnnVersionInfoProto* dnn_version_info) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.dnn_version_info_);
+  }
+  _impl_.dnn_version_info_ = dnn_version_info;
+  if (dnn_version_info) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:stream_executor.GpuTargetConfigProto.dnn_version_info)
+}
+inline ::stream_executor::DnnVersionInfoProto* GpuTargetConfigProto::release_dnn_version_info() {
+  
+  ::stream_executor::DnnVersionInfoProto* temp = _impl_.dnn_version_info_;
+  _impl_.dnn_version_info_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::stream_executor::DnnVersionInfoProto* GpuTargetConfigProto::unsafe_arena_release_dnn_version_info() {
+  // @@protoc_insertion_point(field_release:stream_executor.GpuTargetConfigProto.dnn_version_info)
+  
+  ::stream_executor::DnnVersionInfoProto* temp = _impl_.dnn_version_info_;
+  _impl_.dnn_version_info_ = nullptr;
+  return temp;
+}
+inline ::stream_executor::DnnVersionInfoProto* GpuTargetConfigProto::_internal_mutable_dnn_version_info() {
+  
+  if (_impl_.dnn_version_info_ == nullptr) {
+    auto* p = CreateMaybeMessage<::stream_executor::DnnVersionInfoProto>(GetArenaForAllocation());
+    _impl_.dnn_version_info_ = p;
+  }
+  return _impl_.dnn_version_info_;
+}
+inline ::stream_executor::DnnVersionInfoProto* GpuTargetConfigProto::mutable_dnn_version_info() {
+  ::stream_executor::DnnVersionInfoProto* _msg = _internal_mutable_dnn_version_info();
+  // @@protoc_insertion_point(field_mutable:stream_executor.GpuTargetConfigProto.dnn_version_info)
+  return _msg;
+}
+inline void GpuTargetConfigProto::set_allocated_dnn_version_info(::stream_executor::DnnVersionInfoProto* dnn_version_info) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.dnn_version_info_;
+  }
+  if (dnn_version_info) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(dnn_version_info);
+    if (message_arena != submessage_arena) {
+      dnn_version_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, dnn_version_info, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.dnn_version_info_ = dnn_version_info;
+  // @@protoc_insertion_point(field_set_allocated:stream_executor.GpuTargetConfigProto.dnn_version_info)
+}
+
+// .xla.AutotuneResults autotune_results = 6;
+inline bool GpuTargetConfigProto::_internal_has_autotune_results() const {
+  return this != internal_default_instance() && _impl_.autotune_results_ != nullptr;
+}
+inline bool GpuTargetConfigProto::has_autotune_results() const {
+  return _internal_has_autotune_results();
+}
+inline const ::xla::AutotuneResults& GpuTargetConfigProto::_internal_autotune_results() const {
+  const ::xla::AutotuneResults* p = _impl_.autotune_results_;
+  return p != nullptr ? *p : reinterpret_cast<const ::xla::AutotuneResults&>(
+      ::xla::_AutotuneResults_default_instance_);
+}
+inline const ::xla::AutotuneResults& GpuTargetConfigProto::autotune_results() const {
+  // @@protoc_insertion_point(field_get:stream_executor.GpuTargetConfigProto.autotune_results)
+  return _internal_autotune_results();
+}
+inline void GpuTargetConfigProto::unsafe_arena_set_allocated_autotune_results(
+    ::xla::AutotuneResults* autotune_results) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.autotune_results_);
+  }
+  _impl_.autotune_results_ = autotune_results;
+  if (autotune_results) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:stream_executor.GpuTargetConfigProto.autotune_results)
+}
+inline ::xla::AutotuneResults* GpuTargetConfigProto::release_autotune_results() {
+  
+  ::xla::AutotuneResults* temp = _impl_.autotune_results_;
+  _impl_.autotune_results_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::xla::AutotuneResults* GpuTargetConfigProto::unsafe_arena_release_autotune_results() {
+  // @@protoc_insertion_point(field_release:stream_executor.GpuTargetConfigProto.autotune_results)
+  
+  ::xla::AutotuneResults* temp = _impl_.autotune_results_;
+  _impl_.autotune_results_ = nullptr;
+  return temp;
+}
+inline ::xla::AutotuneResults* GpuTargetConfigProto::_internal_mutable_autotune_results() {
+  
+  if (_impl_.autotune_results_ == nullptr) {
+    auto* p = CreateMaybeMessage<::xla::AutotuneResults>(GetArenaForAllocation());
+    _impl_.autotune_results_ = p;
+  }
+  return _impl_.autotune_results_;
+}
+inline ::xla::AutotuneResults* GpuTargetConfigProto::mutable_autotune_results() {
+  ::xla::AutotuneResults* _msg = _internal_mutable_autotune_results();
+  // @@protoc_insertion_point(field_mutable:stream_executor.GpuTargetConfigProto.autotune_results)
+  return _msg;
+}
+inline void GpuTargetConfigProto::set_allocated_autotune_results(::xla::AutotuneResults* autotune_results) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.autotune_results_);
+  }
+  if (autotune_results) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(autotune_results));
+    if (message_arena != submessage_arena) {
+      autotune_results = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, autotune_results, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.autotune_results_ = autotune_results;
+  // @@protoc_insertion_point(field_set_allocated:stream_executor.GpuTargetConfigProto.autotune_results)
+}
+
+// string device_description_str = 7;
+inline void GpuTargetConfigProto::clear_device_description_str() {
+  _impl_.device_description_str_.ClearToEmpty();
+}
+inline const std::string& GpuTargetConfigProto::device_description_str() const {
+  // @@protoc_insertion_point(field_get:stream_executor.GpuTargetConfigProto.device_description_str)
+  return _internal_device_description_str();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void GpuTargetConfigProto::set_device_description_str(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.device_description_str_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:stream_executor.GpuTargetConfigProto.device_description_str)
+}
+inline std::string* GpuTargetConfigProto::mutable_device_description_str() {
+  std::string* _s = _internal_mutable_device_description_str();
+  // @@protoc_insertion_point(field_mutable:stream_executor.GpuTargetConfigProto.device_description_str)
+  return _s;
+}
+inline const std::string& GpuTargetConfigProto::_internal_device_description_str() const {
+  return _impl_.device_description_str_.Get();
+}
+inline void GpuTargetConfigProto::_internal_set_device_description_str(const std::string& value) {
+  
+  _impl_.device_description_str_.Set(value, GetArenaForAllocation());
+}
+inline std::string* GpuTargetConfigProto::_internal_mutable_device_description_str() {
+  
+  return _impl_.device_description_str_.Mutable(GetArenaForAllocation());
+}
+inline std::string* GpuTargetConfigProto::release_device_description_str() {
+  // @@protoc_insertion_point(field_release:stream_executor.GpuTargetConfigProto.device_description_str)
+  return _impl_.device_description_str_.Release();
+}
+inline void GpuTargetConfigProto::set_allocated_device_description_str(std::string* device_description_str) {
+  if (device_description_str != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.device_description_str_.SetAllocated(device_description_str, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.device_description_str_.IsDefault()) {
+    _impl_.device_description_str_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:stream_executor.GpuTargetConfigProto.device_description_str)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace stream_executor
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_xla_2fstream_5fexecutor_2fdevice_5fdescription_2eproto
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/device_host_allocator.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/device_host_allocator.h
new file mode 100644
index 0000000000000000000000000000000000000000..b724f2e1d2292dc716a2b14502cde3a1f1c2a306
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/device_host_allocator.h
@@ -0,0 +1,86 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_STREAM_EXECUTOR_DEVICE_HOST_ALLOCATOR_H_
+#define XLA_STREAM_EXECUTOR_DEVICE_HOST_ALLOCATOR_H_
+
+#include <vector>
+
+#include "xla/stream_executor/stream_executor.h"
+#include "tsl/framework/allocator.h"
+#include "tsl/platform/macros.h"
+#include "tsl/profiler/lib/traceme.h"
+
+namespace stream_executor {
+// Allocator for pinned CPU RAM that is made known to a StreamExecutor-based
+// device for the purpose of efficient DMA with the device.
+class DeviceHostAllocator : public tsl::SubAllocator {
+ public:
+  // Note: stream_exec cannot be null.
+  explicit DeviceHostAllocator(StreamExecutor* stream_exec, int numa_node,
+                               const std::vector<Visitor>& alloc_visitors,
+                               const std::vector<Visitor>& free_visitors)
+      : SubAllocator(alloc_visitors, free_visitors),
+        stream_exec_(stream_exec),
+        numa_node_(numa_node) {
+    CHECK(stream_exec_ != nullptr);
+  }
+
+  ~DeviceHostAllocator() override = default;
+
+  void* Alloc(size_t alignment, size_t num_bytes,
+              size_t* bytes_received) override {
+    tsl::profiler::TraceMe traceme("DeviceHostAllocator::Alloc");
+
+    void* ptr = nullptr;
+    *bytes_received = num_bytes;
+    if (num_bytes > 0) {
+      ptr = stream_exec_->HostMemoryAllocate(num_bytes);
+      if (ptr == nullptr) {
+        LOG(WARNING) << "could not allocate pinned host memory of size: "
+                     << num_bytes;
+        return ptr;
+      }
+      VisitAlloc(ptr, numa_node_, num_bytes);
+    }
+    return ptr;
+  }
+
+  void Free(void* ptr, size_t num_bytes) override {
+    tsl::profiler::TraceMe traceme("DeviceHostAllocator::Free");
+
+    if (ptr != nullptr) {
+      VisitFree(ptr, numa_node_, num_bytes);
+      stream_exec_->HostMemoryDeallocate(ptr);
+    }
+  }
+
+  bool SupportsCoalescing() const override { return false; }
+
+  tsl::AllocatorMemoryType GetMemoryType() const override {
+    return tsl::AllocatorMemoryType::kHostPinned;
+  }
+
+ private:
+  StreamExecutor* stream_exec_;  // not owned, non-null
+  const int numa_node_;
+
+  DeviceHostAllocator(const DeviceHostAllocator&) = delete;
+  void operator=(const DeviceHostAllocator&) = delete;
+};
+
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_DEVICE_HOST_ALLOCATOR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/device_id_utils.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/device_id_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..76aada1dcfec0af1ad8cd0c1cd976fe611c69abd
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/device_id_utils.h
@@ -0,0 +1,47 @@
+
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_STREAM_EXECUTOR_DEVICE_ID_UTILS_H_
+#define XLA_STREAM_EXECUTOR_DEVICE_ID_UTILS_H_
+
+#include "xla/stream_executor/platform.h"
+#include "xla/stream_executor/stream_executor.h"
+#include "tsl/framework/device_id.h"
+#include "tsl/framework/device_id_manager.h"
+
+namespace stream_executor {
+
+// Utility methods for getting the associated executor given a TfDeviceId
+// or PlatformDeviceId.
+class DeviceIdUtil {
+ public:
+  static tsl::StatusOr<StreamExecutor*> ExecutorForPlatformDeviceId(
+      Platform* device_manager, tsl::PlatformDeviceId platform_device_id) {
+    return device_manager->ExecutorForDevice(platform_device_id.value());
+  }
+  static tsl::StatusOr<StreamExecutor*> ExecutorForTfDeviceId(
+      const tsl::DeviceType& type, Platform* device_manager,
+      tsl::TfDeviceId tf_device_id) {
+    tsl::PlatformDeviceId platform_device_id;
+    TF_RETURN_IF_ERROR(tsl::DeviceIdManager::TfToPlatformDeviceId(
+        type, tf_device_id, &platform_device_id));
+    return ExecutorForPlatformDeviceId(device_manager, platform_device_id);
+  }
+};
+
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_DEVICE_ID_UTILS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/device_mem_allocator.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/device_mem_allocator.h
new file mode 100644
index 0000000000000000000000000000000000000000..fe02b44f5fd5bdc931afa282fc5f413f09e55400
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/device_mem_allocator.h
@@ -0,0 +1,96 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_STREAM_EXECUTOR_DEVICE_MEM_ALLOCATOR_H_
+#define XLA_STREAM_EXECUTOR_DEVICE_MEM_ALLOCATOR_H_
+
+#include <vector>
+
+#include "xla/stream_executor/stream_executor.h"
+#include "tsl/framework/allocator.h"
+#include "tsl/framework/device_id.h"
+#include "tsl/profiler/lib/traceme.h"
+
+namespace stream_executor {
+
+// Suballocator for StreamExecutor-based device memory.
+class DeviceMemAllocator : public tsl::SubAllocator {
+ public:
+  // 'platform_device_id' refers to the ID of the device within
+  // the process and must reference a valid ID in the process.
+  // Note: stream_exec cannot be null.
+  explicit DeviceMemAllocator(StreamExecutor* stream_exec,
+                              tsl::PlatformDeviceId device_id,
+                              bool use_unified_memory,
+                              const std::vector<Visitor>& alloc_visitors,
+                              const std::vector<Visitor>& free_visitors)
+      : SubAllocator(alloc_visitors, free_visitors),
+        stream_exec_(stream_exec),
+        device_id_(device_id),
+        use_unified_memory_(use_unified_memory) {
+    CHECK(stream_exec_ != nullptr);
+  }
+
+  ~DeviceMemAllocator() override = default;
+
+  void* Alloc(size_t alignment, size_t num_bytes,
+              size_t* bytes_received) override {
+    tsl::profiler::TraceMe traceme("DeviceMemAllocator::Alloc");
+
+    void* ptr = nullptr;
+    *bytes_received = num_bytes;
+    if (num_bytes > 0) {
+      if (use_unified_memory_) {
+        ptr = stream_exec_->UnifiedMemoryAllocate(num_bytes);
+      } else {
+        ptr = stream_exec_->AllocateArray<char>(num_bytes).opaque();
+      }
+      VisitAlloc(ptr, device_id_.value(), num_bytes);
+    }
+    return ptr;
+  }
+
+  void Free(void* ptr, size_t num_bytes) override {
+    tsl::profiler::TraceMe traceme("DeviceMemAllocator::Free");
+
+    if (ptr != nullptr) {
+      VisitFree(ptr, device_id_.value(), num_bytes);
+      if (use_unified_memory_) {
+        stream_exec_->UnifiedMemoryDeallocate(ptr);
+      } else {
+        DeviceMemoryBase device_ptr(ptr);
+        stream_exec_->Deallocate(&device_ptr);
+      }
+    }
+  }
+
+  bool SupportsCoalescing() const override { return false; }
+
+  tsl::AllocatorMemoryType GetMemoryType() const override {
+    return tsl::AllocatorMemoryType::kDevice;
+  }
+
+ private:
+  StreamExecutor* stream_exec_;  // not owned, non-null
+  const tsl::PlatformDeviceId device_id_;
+  const bool use_unified_memory_ = false;
+
+  DeviceMemAllocator(const DeviceMemAllocator&) = delete;
+  void operator=(const DeviceMemAllocator&) = delete;
+};
+
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_DEVICE_MEM_ALLOCATOR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/device_memory.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/device_memory.h
new file mode 100644
index 0000000000000000000000000000000000000000..f69fe8148c67a014da76b6c7a3daeb87ec63065e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/device_memory.h
@@ -0,0 +1,202 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// Suite of types that represent device memory allocations. These are
+// allocated by the StreamExecutor interface, which produces values appropriate
+// for the underlying platform (whether it be CUDA or OpenCL).
+//
+// The untyped base class (like a device void*) is DeviceMemoryBase, which can
+// be specialized for a given allocation type (like a device T*) using
+// DeviceMemory<T>.
+
+#ifndef XLA_STREAM_EXECUTOR_DEVICE_MEMORY_H_
+#define XLA_STREAM_EXECUTOR_DEVICE_MEMORY_H_
+
+#include <stddef.h>
+
+#include "xla/stream_executor/platform/port.h"
+
+namespace stream_executor {
+
+class DeviceMemoryAllocator;
+class StreamExecutor;
+
+// void*-analogous device memory allocation. For the typed variation, see
+// DeviceMemory<T>.
+//
+// This is effectively a two-tuple of a pointer and size; however, note that the
+// pointer may not be to the virtual address itself -- in OpenCL the pointer is
+// to a cl_mem handle that describes the device allocation. Therefore,
+// DeviceMemoryBase::opaque does not necessarily produce a pointer that can be
+// referenced directly, so use it with caution.
+//
+// Thread-compatible.
+class DeviceMemoryBase {
+ public:
+  // Default constructor instantiates a null-pointed, zero-sized device memory
+  // region. An opaque pointer may be provided -- see header for details on the
+  // opacity of that pointer.
+  explicit DeviceMemoryBase(void *opaque = nullptr, uint64_t size = 0)
+      : opaque_(opaque), size_(size) {}
+
+  // Returns whether the backing memory is the null pointer.
+  // A `== nullptr` convenience method is also provided.
+  bool is_null() const { return opaque_ == nullptr; }
+  bool operator==(std::nullptr_t other) const { return is_null(); }
+  bool operator!=(std::nullptr_t other) const { return !is_null(); }
+
+  // Provides a partial order between device memory values.
+  //
+  // This operator is provided so that this object can be used as a key in an
+  // ordered map.
+  bool operator<(const DeviceMemoryBase &other) const {
+    return opaque() < other.opaque();
+  }
+
+  // Returns the size, in bytes, for the backing memory.
+  uint64_t size() const { return size_; }
+
+  // Warning: note that the pointer returned is not necessarily directly to
+  // device virtual address space, but is platform-dependent.
+  void *opaque() { return opaque_; }
+  const void *opaque() const { return opaque_; }
+
+  // Returns the payload of this memory region.
+  uint64_t payload() const { return payload_; }
+
+  // Sets payload to given value.
+  void SetPayload(uint64_t payload) { payload_ = payload; }
+
+  // Returns whether the two DeviceMemoryBase segments are identical (both in
+  // their opaque pointer and size).
+  bool IsSameAs(const DeviceMemoryBase &other) const {
+    return opaque() == other.opaque() && size() == other.size();
+  }
+
+ protected:
+  friend class StreamExecutor;
+
+  // Resets the internal values of the opaque pointer and number of bytes in the
+  // memory region, just as in the constructor.
+  void Reset(void *opaque, uint64_t bytes) {
+    opaque_ = opaque;
+    size_ = bytes;
+  }
+
+ private:
+  void *opaque_;  // Platform-dependent value representing allocated memory.
+  uint64_t size_;         // Size in bytes of this allocation.
+  uint64_t payload_ = 0;  // Payload data associated with this allocation.
+};
+
+// Typed wrapper around "void *"-like DeviceMemoryBase.
+//
+// For example, DeviceMemory<int> is a simple wrapper around DeviceMemoryBase
+// that represents one or more integers in Device memory.
+//
+// Thread-compatible.
+template <typename ElemT>
+class DeviceMemory final : public DeviceMemoryBase {
+ public:
+  // Default constructor instantiates a null-pointed, zero-sized memory region.
+  DeviceMemory() : DeviceMemoryBase(nullptr, 0) {}
+  explicit DeviceMemory(std::nullptr_t) : DeviceMemory() {}
+
+  // Typed device memory regions may be constructed from untyped device memory
+  // regions, this effectively amounts to a cast from a void*.
+  explicit DeviceMemory(const DeviceMemoryBase &other)
+      : DeviceMemoryBase(const_cast<DeviceMemoryBase &>(other).opaque(),
+                         other.size()) {
+    SetPayload(other.payload());
+  }
+
+  // Returns the number of elements of type ElemT that constitute this
+  // allocation.
+  uint64_t ElementCount() const { return size() / sizeof(ElemT); }
+
+  // Returns whether this is a single-element allocation.
+  bool IsScalar() const { return ElementCount() == 1; }
+
+  // Create a typed area of DeviceMemory with a given opaque pointer and the
+  // quantity of bytes in the allocation. This function is broken out to
+  // distinguish bytes from an element count.
+  static DeviceMemory<ElemT> MakeFromByteSize(void *opaque, uint64_t bytes) {
+    return DeviceMemory<ElemT>(opaque, bytes);
+  }
+
+  // Resets the DeviceMemory data, in MakeFromByteSize fashion.
+  // This simply clobbers the prior values.
+  void ResetFromByteSize(void *opaque, uint64_t bytes) {
+    // TODO(leary) when NVCC is eliminated we can add this check (and the
+    // logging include it requires).
+    // CHECK_EQ(0, bytes % sizeof(ElemT));
+    DeviceMemoryBase::Reset(opaque, bytes);
+  }
+
+  // ------------------------------------------------------------
+
+ protected:
+  // This constructor is solely used from derived classes; it is made protected
+  // because it accepts a byte-size instead of an element count, which could
+  // potentially be misused given the ElementCount() nature of this interface.
+  //
+  // In order to specify the desire to use byte size instead of element count
+  // explicitly, use MakeFromByteSize.
+  DeviceMemory(void *opaque, uint64_t size) : DeviceMemoryBase(opaque, size) {}
+};
+
+// A class to encapsulate the type and size of a dynamic shared memory
+// buffer. Because the buffer exists solely on the device and is not copyable
+// to the host, memory objects of this type do not maintain buffer pointers
+// on the host.
+template <typename ElemT>
+class SharedDeviceMemory final : public DeviceMemoryBase {
+ public:
+  explicit SharedDeviceMemory(uint64_t elem_count)
+      : DeviceMemoryBase(nullptr, elem_count * kElemSize) {}
+
+  static constexpr size_t kElemSize = sizeof(ElemT);
+
+  // Returns the number of elements of type ElemT that constitute this
+  // allocation.
+  uint64_t ElementCount() const { return size() / kElemSize; }
+
+  // Returns whether this is a single-element allocation.
+  bool IsScalar() const { return ElementCount() == 1; }
+};
+
+// Host-side representation of packed-and-aligned vector datatypes on the device
+// side. Since these can appear in device kernel signatures, we support
+// launching them with these datatypes in launch signatures.
+
+struct Float2 {
+  float x, y;
+};
+
+struct Float4 {
+  Float2 xz, yw;
+};
+
+struct Double2 {
+  double x, y;
+};
+
+static_assert(sizeof(Float2) == 2 * sizeof(float), "Float2 must be packed");
+static_assert(sizeof(Float4) == 4 * sizeof(float), "Float4 must be packed");
+static_assert(sizeof(Double2) == 2 * sizeof(double), "Double2 must be packed");
+
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_DEVICE_MEMORY_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/device_memory_allocator.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/device_memory_allocator.h
new file mode 100644
index 0000000000000000000000000000000000000000..500428b0ed24b5f70b5679535a088ca11820d063
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/device_memory_allocator.h
@@ -0,0 +1,289 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_STREAM_EXECUTOR_DEVICE_MEMORY_ALLOCATOR_H_
+#define XLA_STREAM_EXECUTOR_DEVICE_MEMORY_ALLOCATOR_H_
+
+#include <cstdint>
+#include <map>
+#include <vector>
+
+#include "absl/base/thread_annotations.h"
+#include "absl/synchronization/mutex.h"
+#include "absl/types/span.h"
+#include "xla/stream_executor/device_memory.h"
+#include "xla/stream_executor/platform.h"
+#include "tsl/platform/errors.h"
+#include "tsl/platform/status.h"
+#include "tsl/platform/statusor.h"
+
+namespace stream_executor {
+
+class Stream;
+class DeviceMemoryAllocator;
+
+// Owning pointer for memory on a device.
+//
+// ScopedDeviceMemory is an owning pointer like std::unique_ptr, but it can
+// point to memory that resides on a "device" (e.g. a GPU).  When a
+// ScopedDeviceMemory goes out of scope, it frees the memory it owns.
+//
+// We say that an instance of ScopedDeviceMemory is "active" if it currently
+// owns a (possibly empty) slice of memory on the device.  Moving,
+// Release()'ing, Free()'ing, and other actions can deactivate an active object.
+template <typename ElemT>
+class ScopedDeviceMemory {
+ public:
+  // Default construction initializes the internal state to nullptr.  This
+  // mirrors the std::unique_ptr<> functionality, where default construction
+  // produces a nullptr unique_ptr, which can be assigned later.
+  ScopedDeviceMemory() : device_ordinal_(-1), allocator_(nullptr) {}
+
+  // Construct a ScopedDeviceMemory from a custom allocator.
+  //
+  // Parameters:
+  //  mem: Already-allocated device memory value for this scoped mechanism to
+  //       deallocate. This memory must have been allocated by parent.
+  //  device_ordinal: Device on which the memory was allocated.
+  //  allocator: Allocator used to deallocate memory when this instance goes
+  //             out of scope.
+  ScopedDeviceMemory(DeviceMemoryBase mem, int device_ordinal,
+                     DeviceMemoryAllocator *allocator)
+      : wrapped_(mem), device_ordinal_(device_ordinal), allocator_(allocator) {
+    DCHECK_GE(device_ordinal_, 0);
+  }
+
+  // A helper constructor to generate a scoped device memory given an already
+  // allocated memory and a stream executor.
+  //
+  // Precondition: memory was allocated by the stream executor `parent`.
+  ScopedDeviceMemory(StreamExecutor *parent, DeviceMemoryBase value);
+
+  // Constructor overload that places a literal array into device memory.
+  //
+  // Relies on the allocation function exposed by the stream executor `parent`,
+  // which will be also used for deallocating the memory
+  ScopedDeviceMemory(StreamExecutor *parent,
+                     std::initializer_list<ElemT> values);
+
+  // Moves ownership of the memory from other to the constructed
+  // object.
+  //
+  // Postcondition: other == nullptr.
+  ScopedDeviceMemory(ScopedDeviceMemory &&other)
+      : wrapped_(other.Release()),
+        device_ordinal_(other.device_ordinal_),
+        allocator_(other.allocator_) {}
+
+  // Releases the memory that was provided in the constructor, through the
+  // "parent" StreamExecutor.
+  ~ScopedDeviceMemory() { TF_CHECK_OK(Free()); }
+
+  // Moves ownership of the memory from other to this object.
+  //
+  // Postcondition: other == nullptr.
+  ScopedDeviceMemory &operator=(ScopedDeviceMemory &&other) {
+    TF_CHECK_OK(Free());
+    wrapped_ = other.Release();
+    allocator_ = other.allocator_;
+    device_ordinal_ = other.device_ordinal_;
+    return *this;
+  }
+
+  // Returns the memory that backs this scoped allocation converted to
+  // DeviceMemory<T> apparent type. This is useful for cases where the
+  // DeviceMemory must be passed by const-ref, as the ScopedDeviceMemory doesn't
+  // allow copying, for scoped-object-lifetime reasons.
+  const DeviceMemory<ElemT> &cref() const { return wrapped_; }
+
+  // Returns a pointer to the DeviceMemory<T> apparent type for use in mutable
+  // operations. The value returned should not be used outside the scope of this
+  // ScopedDeviceMemory object's lifetime.
+  DeviceMemory<ElemT> *ptr() { return &wrapped_; }
+  const DeviceMemory<ElemT> *ptr() const { return &wrapped_; }
+
+  // Smart-pointer-like operators for the wrapped DeviceMemory.
+  // This reference must not be used outside the lifetime of this
+  // ScopedDeviceMemory.
+  const DeviceMemory<ElemT> &operator*() const { return cref(); }
+  DeviceMemory<ElemT> *operator->() { return ptr(); }
+  const DeviceMemory<ElemT> *operator->() const { return ptr(); }
+
+  bool is_null() const { return wrapped_.is_null(); }
+  bool operator==(std::nullptr_t other) const { return is_null(); }
+  bool operator!=(std::nullptr_t other) const { return !is_null(); }
+
+  // Analogous to std::unique_ptr::release, releases ownership of the held
+  // memory and transfers it to the caller.
+  //
+  // Postcondition: *this == nullptr
+  DeviceMemory<ElemT> Release() {
+    DeviceMemory<ElemT> tmp = wrapped_;
+    wrapped_ = DeviceMemory<ElemT>{};
+    return tmp;
+  }
+
+  // The returned allocator is nonnull iff this object is active.
+  DeviceMemoryAllocator *allocator() const { return allocator_; }
+
+  int device_ordinal() const { return device_ordinal_; }
+
+  // Frees the existing memory, resets the wrapped memory to null.
+  tsl::Status Free();
+
+ private:
+  DeviceMemory<ElemT> wrapped_;       // Value we wrap with scoped-release.
+  int device_ordinal_;                // Negative one for inactive object.
+  DeviceMemoryAllocator *allocator_;  // Null if this object is inactive.
+
+  ScopedDeviceMemory(const ScopedDeviceMemory &) = delete;
+  void operator=(const ScopedDeviceMemory &) = delete;
+};
+
+// Type alias for compatibility with the previous managed memory implementation.
+using OwningDeviceMemory = ScopedDeviceMemory<uint8_t>;
+
+// Memory allocator interface for the device.
+//
+// Intended usage is through Allocate() functions which return an owning smart
+// pointer.
+class DeviceMemoryAllocator {
+ public:
+  // Parameter platform indicates which platform the allocator allocates memory
+  // on. Must be non-null.
+  explicit DeviceMemoryAllocator(const Platform *platform)
+      : platform_(platform) {}
+  virtual ~DeviceMemoryAllocator() {}
+
+  // Allocates memory on the device.
+  //
+  // If size > 0 and the returned StatusOr is OK, the wrapped OwningDeviceMemory
+  // must not be null.  If size == 0, must return a null OwningDeviceMemory.
+  //
+  // 'retry_on_failure': If false, and the first attempt to allocate the memory
+  // fails, the allocation should return immediately without retrying.  An
+  // example use case is optional scratch spaces where a failure has only
+  // performance impact.
+  virtual tsl::StatusOr<OwningDeviceMemory> Allocate(int device_ordinal,
+                                                     uint64_t size,
+                                                     bool retry_on_failure,
+                                                     int64_t memory_space) = 0;
+
+  // Two-arg version of Allocate(), which sets retry-on-failure to true and
+  // memory_space to default (0).
+  //
+  // (We don't simply use a default argument on the virtual Allocate function
+  // because default args on virtual functions are disallowed by the Google
+  // style guide.)
+  tsl::StatusOr<OwningDeviceMemory> Allocate(int device_ordinal,
+                                             uint64_t size) {
+    return Allocate(device_ordinal, size, /*retry_on_failure=*/true,
+                    /*memory_space=*/0);
+  }
+
+  // Three-arg version of Allocate(), which sets memory_space to default (0).
+  tsl::StatusOr<OwningDeviceMemory> Allocate(int device_ordinal, uint64_t size,
+                                             bool retry_on_failure) {
+    return Allocate(device_ordinal, size, retry_on_failure,
+                    /*memory_space=*/0);
+  }
+
+  // Typed version of the allocation, returning typed memory.
+  template <typename ElemT>
+  tsl::StatusOr<ScopedDeviceMemory<ElemT>> Allocate(
+      int device_ordinal, uint64_t size, bool retry_on_failure = true,
+      int64_t memory_space = 0) {
+    return Allocate(device_ordinal, size, retry_on_failure, memory_space);
+  }
+
+  // Must be a nop for null pointers. Should not be used.
+  //
+  // TODO(cheshire): Add deprecation notice.
+  virtual tsl::Status Deallocate(int device_ordinal, DeviceMemoryBase mem) = 0;
+
+  // Return the platform that the allocator allocates memory on.
+  const Platform *platform() const { return platform_; }
+
+  // Can we call Deallocate() as soon as a computation has been scheduled on
+  // a stream, or do we have to wait for the computation to complete first?
+  virtual bool AllowsAsynchronousDeallocation() const { return false; }
+
+  // Returns a stream pointer on which it is always safe to access memory
+  // allocated by this allocator. It is not necessary to use the returned stream
+  // though, as clients may have additional information letting them safely use
+  // a different stream.
+  virtual tsl::StatusOr<Stream *> GetStream(int device_ordinal) = 0;
+
+ protected:
+  const Platform *platform_;
+};
+
+// Default memory allocator for a platform which uses
+// StreamExecutor::Allocate/Deallocate.
+class StreamExecutorMemoryAllocator : public DeviceMemoryAllocator {
+ public:
+  // Create an allocator supporting a single device, corresponding to the passed
+  // executor.
+  explicit StreamExecutorMemoryAllocator(StreamExecutor *executor);
+
+  // Create an allocator supporting multiple stream executors.
+  //
+  // Precondition: all stream_executors have different device ordinals.
+  StreamExecutorMemoryAllocator(
+      const Platform *platform,
+      absl::Span<StreamExecutor *const> stream_executors);
+
+  tsl::StatusOr<OwningDeviceMemory> Allocate(int device_ordinal, uint64_t size,
+                                             bool retry_on_failure,
+                                             int64_t memory_space) override;
+
+  // Pull in two-arg overload that sets retry_on_failure to true.
+  using DeviceMemoryAllocator::Allocate;
+
+  tsl::Status Deallocate(int device_ordinal, DeviceMemoryBase mem) override;
+
+  bool AllowsAsynchronousDeallocation() const override;
+
+  // Gets-or-creates a stream for a given `device_ordinal` from an appropriate
+  // stream executor.
+  tsl::StatusOr<Stream *> GetStream(int device_ordinal) override;
+
+  // Gets the stream executor for given device ordinal.
+  tsl::StatusOr<StreamExecutor *> GetStreamExecutor(int device_ordinal) const;
+
+ private:
+  // Available stream executors. Each stream executor has a different device
+  // ordinal.
+  std::vector<StreamExecutor *> stream_executors_;
+
+  absl::Mutex mutex_;
+
+  // Cache of streams for GetStream.
+  std::map<int, Stream> streams_ ABSL_GUARDED_BY(mutex_);
+};
+
+template <typename ElemT>
+tsl::Status ScopedDeviceMemory<ElemT>::Free() {
+  if (!wrapped_.is_null()) {
+    CHECK(allocator_ != nullptr) << "Owning pointer in inconsistent state";
+    TF_RETURN_IF_ERROR(allocator_->Deallocate(device_ordinal_, wrapped_));
+  }
+  wrapped_ = DeviceMemory<ElemT>{};
+  return ::tsl::OkStatus();
+}
+
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_DEVICE_MEMORY_ALLOCATOR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/device_options.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/device_options.h
new file mode 100644
index 0000000000000000000000000000000000000000..776fa4220813c4cf159b3b0482885edce0836677
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/device_options.h
@@ -0,0 +1,104 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// Contains device-level options that can be specified at a platform level.
+// Example usage:
+//    auto device_options = DeviceOptions::Default();
+
+#ifndef XLA_STREAM_EXECUTOR_DEVICE_OPTIONS_H_
+#define XLA_STREAM_EXECUTOR_DEVICE_OPTIONS_H_
+
+#include <map>
+#include <string>
+#include <vector>
+
+#include "absl/log/check.h"
+#include "absl/strings/str_join.h"
+
+namespace stream_executor {
+
+// Indicates a set of options for a device's usage, which generally must be
+// provided at StreamExecutor device-initialization time.
+//
+// These are intended to be useful-but-not-mandatorily-supported options for
+// using devices on the underlying platform. Presently, if the option requested
+// is not available on the target platform, a warning will be emitted.
+struct DeviceOptions {
+ public:
+  // When it is observed that more memory has to be allocated for thread stacks,
+  // this flag prevents it from ever being deallocated. Potentially saves
+  // thrashing the thread stack memory allocation, but at the potential cost of
+  // some memory space.
+  static constexpr unsigned kDoNotReclaimStackAllocation = 0x1;
+
+  // The following options refer to synchronization options when
+  // using SynchronizeStream or SynchronizeContext.
+
+  // Synchronize with spinlocks.
+  static constexpr unsigned kScheduleSpin = 0x02;
+  // Synchronize with spinlocks that also call CPU yield instructions.
+  static constexpr unsigned kScheduleYield = 0x04;
+  // Synchronize with a "synchronization primitive" (e.g. mutex).
+  static constexpr unsigned kScheduleBlockingSync = 0x08;
+
+  static constexpr unsigned kMask = 0xf;  // Mask of all available flags.
+
+  // Constructs an or-d together set of device options.
+  explicit DeviceOptions(unsigned flags) : flags_(flags) {
+    CHECK((flags & kMask) == flags);
+  }
+
+  // Factory for the default set of device options.
+  static DeviceOptions Default() { return DeviceOptions(0); }
+
+  unsigned flags() const { return flags_; }
+
+  bool operator==(const DeviceOptions& other) const {
+    return flags_ == other.flags_ &&
+           non_portable_tags == other.non_portable_tags;
+  }
+
+  bool operator!=(const DeviceOptions& other) const {
+    return !(*this == other);
+  }
+
+  std::string ToString() const {
+    std::vector<std::string> flags_on;
+    if (flags_ & kDoNotReclaimStackAllocation) {
+      flags_on.push_back("kDoNotReclaimStackAllocation");
+    }
+    if (flags_ & kScheduleSpin) {
+      flags_on.push_back("kScheduleSpin");
+    }
+    if (flags_ & kScheduleYield) {
+      flags_on.push_back("kScheduleYield");
+    }
+    if (flags_ & kScheduleBlockingSync) {
+      flags_on.push_back("kScheduleBlockingSync");
+    }
+    return flags_on.empty() ? "none" : absl::StrJoin(flags_on, "|");
+  }
+
+  // Platform-specific device options. Expressed as key-value pairs to avoid
+  // DeviceOptions subclass proliferation.
+  std::map<std::string, std::string> non_portable_tags;
+
+ private:
+  unsigned flags_;
+};
+
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_DEVICE_OPTIONS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/dnn.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/dnn.h
new file mode 100644
index 0000000000000000000000000000000000000000..3561a1ffd4f13b21a74a6beabe80f8acf5cf0500
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/dnn.h
@@ -0,0 +1,2603 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// Neural Net operation support for StreamExecutor instances.
+//
+// This is an abstract interface for a platform to optionally support common
+// neural net operations; it accommodates implementations such as the cudnn
+// library operations.
+
+#ifndef XLA_STREAM_EXECUTOR_DNN_H_
+#define XLA_STREAM_EXECUTOR_DNN_H_
+
+#include <cstdint>
+#include <functional>
+#include <limits>
+#include <memory>
+#include <optional>
+#include <ostream>
+#include <string>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include "google/protobuf/wrappers.pb.h"
+#include "absl/types/optional.h"
+#include "absl/types/span.h"
+#include "xla/stream_executor/data_type.h"
+#include "xla/stream_executor/device_description.h"
+#include "xla/stream_executor/device_description.pb.h"
+#include "xla/stream_executor/device_memory.h"
+#include "xla/stream_executor/numeric_options.h"
+#include "xla/stream_executor/platform/port.h"
+#include "tsl/platform/logging.h"
+#include "tsl/platform/status.h"
+#include "tsl/platform/statusor.h"
+#include "tsl/protobuf/dnn.pb.h"
+
+namespace Eigen {
+struct half;
+}  // namespace Eigen
+
+namespace stream_executor {
+
+class HostBuffer;
+class Stream;
+class ScratchAllocator;
+
+namespace dnn {
+
+// Specifies an index to use when accessing specific spatial dimensions.
+enum class DimIndex : int {
+  X = 0,
+  Y = 1,
+  Z = 2,
+};
+
+// Return a reordered dims.
+std::vector<int64_t> ReorderDims(const std::vector<int64_t>& input,
+                                 const DataLayout& from, const DataLayout& to);
+
+// Helper functions to make methods more readable.
+inline int64_t GetDim(absl::Span<const int64_t> data, DimIndex dim) {
+  return data.rbegin()[static_cast<int64_t>(dim)];
+}
+
+inline void SetDim(absl::Span<int64_t> data, DimIndex dim, int64_t value) {
+  data.rbegin()[static_cast<int64_t>(dim)] = value;
+}
+
+inline void SetDim(std::vector<int64_t>* data, DimIndex dim, int64_t value) {
+  return SetDim(absl::MakeSpan(*data), dim, value);
+}
+
+// int64_t is not the same type as tensorflow::protobuf_int64 in open-source.
+// This wrapper function gives an int64_t array slice view of a repeated int64
+// protobuf field.
+//
+// T should be a protobuf RepeatedField.
+template <typename T>
+inline absl::Span<const int64_t> AsInt64Slice(const T& repeated_field) {
+  using data_ty =
+      typename std::remove_reference<decltype(*repeated_field.data())>::type;
+  static_assert(std::is_integral<data_ty>::value &&
+                    std::is_signed<data_ty>::value && sizeof(data_ty) == 8,
+                "repeated_field.data() must return a pointer to a signed "
+                "64-bit integer type.");
+  return absl::Span<const int64_t>(
+      reinterpret_cast<const int64_t*>(repeated_field.data()),
+      repeated_field.size());
+}
+template <typename T>
+inline absl::Span<int64_t> AsInt64Slice(T* repeated_field) {
+  using data_ty =
+      typename std::remove_reference<decltype(*repeated_field->data())>::type;
+  static_assert(std::is_integral<data_ty>::value &&
+                    std::is_signed<data_ty>::value && sizeof(data_ty) == 8,
+                "repeated_field->data() must return a pointer to a signed "
+                "64-bit integer type.");
+  return absl::Span<int64_t>(
+      reinterpret_cast<int64_t*>(repeated_field->mutable_data()),
+      repeated_field->size());
+}
+
+// Returns a string representation of the given data layout.
+std::string DataLayoutString(DataLayout layout);
+
+// Specifies a quantization for activations in a given BatchDescriptor.
+enum class QuantizedActivationMode {
+  k8Bit = 1,
+  k16Bit = 2,
+  k32Bit = 4,
+};
+
+// Specifies the types of a RNN model.
+enum class RnnMode {
+  kRnnRelu = 0,
+  kRnnTanh = 1,
+  kRnnLstm = 2,
+  kRnnGru = 3,
+};
+
+// Specifies the input model and whether there is a linear transformation
+// between the input state and the first layer hidden state.
+enum class RnnInputMode {
+  kRnnLinearSkip = 0,
+  kRnnSkipInput = 1,
+};
+
+// Specifies the number of directions used in a RNN model. When bidirection
+// is used, the input states and output sequence contain data for both
+// directions.
+enum class RnnDirectionMode {
+  kRnnUnidirectional = 0,
+  kRnnBidirectional = 1,
+};
+
+// Relevant to DepthToSpace and SpaceToDepth. This is the write layout when
+// performing depth to space and the read layout when performing space to depth.
+// It's specified with most-major dimension first and most-minor dimension last.
+// In DepthToSpace, the D*M^2 values are read in and then, for DepthHeightWidth,
+// written out to the output patch, by varying first width, then height, then
+// depth. In C array format, it looks like [depth][height][width]. See
+// DepthToSpace comment for more information.
+enum class DepthToSpaceLayout { DepthHeightWidth };
+
+class TensorDescriptor {
+ public:
+  TensorDescriptor() = default;
+  tsl::StatusOr<std::vector<int64_t>> GetPhysicalDimensionsMajorToMinor() const;
+  std::vector<int64_t> GetPhysicalStridesMajorToMinor() const;
+  std::vector<int64_t> GetLogicalStrides() const;
+
+  static TensorDescriptor For(DataType type,
+                              absl::Span<const int64_t> dimensions,
+                              absl::Span<const int64_t> minor_to_major);
+  int ndims() const;
+  std::vector<int64_t> dimensions() const { return dimensions_; }
+  std::vector<int64_t> minor_to_major() const { return minor_to_major_; }
+  DataType type() const { return d_type_; }
+  std::string ToString() const;
+
+ protected:
+  TensorDescriptor(DataType type, std::vector<int64_t> dimensions,
+                   std::vector<int64_t> minor_to_major)
+      : d_type_(type),
+        dimensions_(dimensions),
+        minor_to_major_(minor_to_major) {}
+
+ private:
+  DataType d_type_;
+  std::vector<int64_t> dimensions_;
+  std::vector<int64_t> minor_to_major_;
+};
+
+class MatmulTensorDescriptor {
+ public:
+  MatmulTensorDescriptor() = default;
+  tsl::StatusOr<std::vector<int64_t>> GetNonContractingDims() const;
+  std::vector<int64_t> GetCudnnCompatibleDimensions(
+      bool is_lhs
+      /*if not lhs, then rhs*/) const;
+  std::vector<int64_t> GetCudnnCompatibleStrides(
+      bool is_lhs
+      /*if not lhs, then rhs*/) const;
+  tsl::StatusOr<std::vector<int64_t>> MakeCudnnCompatible(
+      const std::vector<int64_t>&, bool is_lhs) const;
+
+  static MatmulTensorDescriptor For(DataType type,
+                                    absl::Span<const int64_t> dimensions,
+                                    absl::Span<const int64_t> minor_to_major,
+                                    absl::Span<const int64_t> batch_dims,
+                                    absl::Span<const int64_t> contracting_dims);
+  std::vector<int64_t> dimensions() const { return tensor_.dimensions(); }
+  std::vector<int64_t> minor_to_major() const {
+    return tensor_.minor_to_major();
+  }
+  DataType type() const { return tensor_.type(); }
+
+  std::string ToString() const;
+
+ protected:
+  MatmulTensorDescriptor(TensorDescriptor tensor,
+                         std::vector<int64_t> batch_dims,
+                         std::vector<int64_t> contracting_dims)
+      : tensor_(tensor),
+        batch_dimension_numbers_(batch_dims),
+        contracting_dim_(contracting_dims) {}
+
+ private:
+  TensorDescriptor tensor_;
+  std::vector<int64_t> batch_dimension_numbers_;
+  std::vector<int64_t> contracting_dim_;
+};
+
+// Specifies the descriptor for a RNN model.
+//
+// An example use case:
+//   * The user first creates a model through createRnnDescriptor.
+//   * The user queries the size of the underlying opaque parameter buffer.
+//   * The user creates and initializes a parameter buffer of the proper size.
+//   * The user runs forward and backward operations using this RNN descriptor.
+//   * Once a while, user queries maintainable weights and bias regions from
+//       the underlying parameter buffer. They are more likely to be forward
+//       compatible and should used in saving and restoring a model.
+//   * The user releases the RNN descriptor when the model is no longer in use.
+class RnnDescriptor {
+ public:
+  struct ParamsRegion {
+    int64_t offset;
+    int64_t size;
+  };
+  typedef std::vector<ParamsRegion> ParamsRegions;
+  virtual ~RnnDescriptor() = default;
+  virtual int64_t ParamsSizeInBytes() const { return -1; }
+  virtual ParamsRegions ParamsWeightRegions() const { return ParamsRegions(); }
+  virtual ParamsRegions ParamsBiasRegions() const { return ParamsRegions(); }
+};
+
+// Specifies the sequence in a RNN model.
+//
+// The user is responsible for releasing this descriptor when it is no longer
+// in use. The destructor releases the underlying descriptors.
+class RnnSequenceTensorDescriptor {
+ public:
+  virtual ~RnnSequenceTensorDescriptor() = default;
+};
+
+// Specifies either the input and hidden state in a RNN model.
+//
+// The user is responsible for releasing this descriptor when it is no longer
+// in use. The destructor releases the underlying descriptors.
+class RnnStateTensorDescriptor {
+ public:
+  virtual ~RnnStateTensorDescriptor() = default;
+};
+
+// Returns a string representation of the given quantization mode.
+std::string QuantizedActivationModeString(QuantizedActivationMode mode);
+
+// Describes the dimensions that a layer consumes/produces.
+//
+// This is a matrix (height, width), its "depth" (feature_map_count),
+// how many of these matrices are present (count),
+// and the maximum and minimum values expected in the matrix (value_max,
+// value_min).
+// If input is quantized, all values greater
+// than value_max will be clipped to value_max and all values less than
+// value_min will be clipped to value_min.
+// When quantized output is dequantized no value will be greater than
+// value_max or less than value_min.
+//
+// Uses the named argument construction form:
+//
+//  auto input_batch_dimensions =
+//      BatchDescriptor().set_count(42).set_feature_map_count(7)...
+//
+// Details:
+//
+// For a convolutional layer, a single inference takes a 3-dimensional matrix
+// of input and produces a 3-dimensional matrix of output. We call the three
+// dimensions height, width and feature_map_count, where for an image, the
+// height and width correspond to the Y and X pixel indices, respectively, and
+// the feature_map_count corresponds to the RGB dimension of the input data.
+// Then the count indicates how many 3D matrices are being presented to be
+// processed at once; this corresponds to the neural network concept of
+// minibatch size.
+//
+// For a fully connected layer, it's better to put the nodes of the layer in
+// the feature_map_count, and leave the height and weight as degenerate (== 1).
+// Count indicates how many input vectors (degenerate 3D matrices) are to be
+// processed.
+//
+// If unspecified, value_max and value_min default to 0.0.
+// If value_max == value_min the Stream will attempt to derive valid values -
+// for example the output of Relu6 activation will always be in the range
+// [0.0, 6.0].
+//
+// If unspecified, layout defaults to kYXDepthBatch.
+class BatchDescriptor {
+ public:
+  // Creates a "blank" batch descriptor, which should be initialized via the
+  // named argument helpers.
+  BatchDescriptor();
+  explicit BatchDescriptor(int ndims);
+
+  // Clones values from 'other' for initialization.
+  void CloneFrom(const BatchDescriptor& other);
+
+  std::string ToString() const;
+  std::string ToShortString() const;
+
+  // Pre-condition:
+  //   value_max_ == 0
+  //   value_min_ == 0
+  //   quantized_activation_mode_ == QuantizedActivationMode::k8Bit
+  TensorDescriptorProto ToProto(DataType data_type) const;
+
+  // Accessors.
+  int64_t count() const { return tensor_.dimensions(0); }
+  int64_t feature_map_count() const { return tensor_.dimensions(1); }
+  int64_t height() const { return GetDim(spatial_size(), DimIndex::Y); }
+  int64_t width() const { return GetDim(spatial_size(), DimIndex::X); }
+  int64_t spatial_dim(DimIndex dim) const {
+    return GetDim(spatial_size(), dim);
+  }
+  int ndims() const { return spatial_size().size(); }
+  float value_max() const { return value_max_; }
+  float value_min() const { return value_min_; }
+  DataLayout layout() const { return tensor_.data_layout(); }
+  QuantizedActivationMode quantized_activation_mode() const {
+    return quantized_activation_mode_;
+  }
+  // Full dimensions of the underlying data, ordered according to a specific
+  // layout.
+  std::vector<int64_t> full_dims(const DataLayout& layout) const;
+
+  // Full strides of the underlying data, ordered according to a specific
+  // layout.
+  std::vector<int64_t> full_strides(const DataLayout& layout) const;
+
+  // Vectorized dimensions where users can specify the dimension that the number
+  // of dimensions is reported rather than the full number of elements.
+  std::vector<int64_t> vectorized_dims(const DataLayout& layout,
+                                       int vector_size, int vector_dim) const;
+
+  // Vectorized strides correspond to the vectorized_dims.
+  std::vector<int64_t> vectorized_strides(const DataLayout& layout,
+                                          int vector_size,
+                                          int vector_dim) const;
+
+  // Named-argument helpers for avoiding user error during construction.
+  BatchDescriptor& set_count(int64_t value) {
+    tensor_.set_dimensions(0, value);
+    return *this;
+  }
+  BatchDescriptor& set_feature_map_count(int64_t value) {
+    tensor_.set_dimensions(1, value);
+    return *this;
+  }
+  BatchDescriptor& set_height(int64_t value) {
+    SetDim(spatial_size(), DimIndex::Y, value);
+    return *this;
+  }
+  BatchDescriptor& set_width(int64_t value) {
+    SetDim(spatial_size(), DimIndex::X, value);
+    return *this;
+  }
+  BatchDescriptor& set_spatial_dim(DimIndex dim, int64_t value) {
+    SetDim(spatial_size(), dim, value);
+    return *this;
+  }
+  BatchDescriptor& set_value_max(float value) {
+    value_max_ = value;
+    return *this;
+  }
+  BatchDescriptor& set_value_min(float value) {
+    value_min_ = value;
+    return *this;
+  }
+  BatchDescriptor& set_layout(DataLayout layout) {
+    tensor_.set_data_layout(layout);
+    return *this;
+  }
+  BatchDescriptor& set_quantized_activation_mode(
+      QuantizedActivationMode quantized_activation_mode) {
+    quantized_activation_mode_ = quantized_activation_mode;
+    return *this;
+  }
+
+  // Return the number of nodes in a single feature map.
+  int64_t NodesPerFeatureMap() const;
+
+  // Return the number of nodes across all feature maps. Note that this is not
+  // affected by the batch count.
+  int64_t NodesAcrossFeatureMaps() const;
+
+  // Returns the number of elements (e.g. RGB pixel values) required to hold a
+  // given batch descriptor, given a no-padding assumption. Note that this is
+  // affected by the batch count.
+  int64_t ElementCount() const;
+
+  // Return the number of weights required to fully connect a layer with
+  // dimensions given by the 'input' descriptor with a layer with dimensions
+  // given by the 'output' descriptor.
+  static int64_t FullyConnectedWeightCount(const BatchDescriptor& input,
+                                           const BatchDescriptor& output);
+
+  // Return the number of biases required to fully connect to an output layer
+  // with dimensions given the 'output' descriptor.
+  static int64_t FullyConnectedBiasCount(const BatchDescriptor& output);
+
+  // Return a BatchDescriptor for the output of a depth concatenation
+  // with the given input descriptors. The inputs should have the same
+  // dimensions, except possibly for feature_map_count(), though this
+  // function does not verify that.
+  static BatchDescriptor DepthConcatenateOutputDescriptor(
+      absl::Span<const dnn::BatchDescriptor> inputs);
+
+ private:
+  absl::Span<const int64_t> spatial_size() const {
+    return AsInt64Slice(tensor_.dimensions()).subspan(2);
+  }
+
+  absl::Span<int64_t> spatial_size() {
+    return AsInt64Slice(tensor_.mutable_dimensions()).subspan(2);
+  }
+
+  TensorDescriptorProto tensor_;
+  float value_max_;
+  float value_min_;
+  QuantizedActivationMode quantized_activation_mode_;
+};
+
+// Returns a string representation of the given filter layout.
+std::string FilterLayoutString(FilterLayout layout);
+
+// Describes a filter for the convolution. This is the "window" from
+// height-by-width patches of each of the feature maps in the input layer to the
+// cells within the output feature map.
+//
+// Uses the named argument construction form:
+//
+//  FilterDescriptor filter_dimensions;
+//  filter_dimensions
+//    .set_output_feature_map_count(42)
+//    .set_input_feature_map_count(7)
+//    ...
+//
+// Arguments:
+// - output_feature_map_count: number of feature maps in the output layer.
+// - input_feature_map_count: number of feature maps in the input layer (from
+//      which the filter patch is taken).
+// - input_filter_height: "height" number of neurons used in the sliding window
+//      over the input layer.
+// - input_filter_width: "width" number of neurons used in the sliding window
+//      over the input layer.
+//
+// Sometimes names like "filter input height" are referred to by synonymous
+// terminology, such as "kernel y size".
+//
+// If unspecified, layout defaults to kOutputInputYX.
+class FilterDescriptor {
+ public:
+  // By default construction, all dimensions are set to zero, so they should all
+  // be populated by the user via the named-argument helpers below. (See class
+  // comment for details.)
+  FilterDescriptor();
+  explicit FilterDescriptor(int ndims);
+  ~FilterDescriptor();
+
+  // Named-argument helpers for avoiding user error during construction.
+  FilterDescriptor& set_output_feature_map_count(int64_t value) {
+    tensor_.set_dimensions(0, value);
+    return *this;
+  }
+  FilterDescriptor& set_input_feature_map_count(int64_t value) {
+    tensor_.set_dimensions(1, value);
+    return *this;
+  }
+  FilterDescriptor& set_input_filter_height(int64_t value) {
+    SetDim(input_filter_dims(), DimIndex::Y, value);
+    return *this;
+  }
+  FilterDescriptor& set_input_filter_width(int64_t value) {
+    SetDim(input_filter_dims(), DimIndex::X, value);
+    return *this;
+  }
+  FilterDescriptor& set_layout(FilterLayout layout) {
+    tensor_.set_filter_layout(layout);
+    return *this;
+  }
+  FilterDescriptor& set_spatial_dim(DimIndex dim, int64_t value) {
+    SetDim(input_filter_dims(), dim, value);
+    return *this;
+  }
+  int ndims() const { return input_filter_dims().size(); }
+
+  void CloneFrom(const FilterDescriptor& other);
+
+  std::string ToString() const;
+  std::string ToShortString() const;
+  TensorDescriptorProto ToProto(DataType data_type) const;
+
+  // Returns the number of weights required as parameters for a convolution
+  // using this filter descriptor.
+  int64_t ComputeWeightCount() const;
+
+  // Returns the number of biases required as parameters for a convolution
+  // using this filter descriptor.
+  int64_t bias_count() const { return output_feature_map_count(); }
+
+  int64_t output_feature_map_count() const { return tensor_.dimensions(0); }
+  int64_t input_feature_map_count() const { return tensor_.dimensions(1); }
+  int64_t input_filter_height() const {
+    return GetDim(input_filter_dims(), DimIndex::Y);
+  }
+  int64_t input_filter_width() const {
+    return GetDim(input_filter_dims(), DimIndex::X);
+  }
+  int64_t input_filter_dim(DimIndex dim) const {
+    return GetDim(input_filter_dims(), dim);
+  }
+
+  FilterLayout layout() const { return tensor_.filter_layout(); }
+
+  absl::Span<const int64_t> input_filter_dims() const {
+    return AsInt64Slice(tensor_.dimensions()).subspan(2);
+  }
+
+  // Full dimensions of the underlying filter,
+  // ordered according to a specific layout.
+  std::vector<int64_t> full_dims(const FilterLayout& layout) const;
+
+  // Full strides of the underlying filter,
+  // ordered according to a specific layout.
+  std::vector<int64_t> full_strides(const FilterLayout& layout) const;
+
+  // Vectorized dimensions where users can specify the dimension that the number
+  // of dimensions is reported rather than the full number of elements.
+  std::vector<int64_t> vectorized_dims(const FilterLayout& layout,
+                                       int vector_size, int vector_dim) const;
+
+  // Vectorized strides correspond to the vectorized_dims.
+  std::vector<int64_t> vectorized_strides(const FilterLayout& layout,
+                                          int vector_size,
+                                          int vector_dim) const;
+
+ private:
+  absl::Span<int64_t> input_filter_dims() {
+    return AsInt64Slice(tensor_.mutable_dimensions()).subspan(2);
+  }
+
+  TensorDescriptorProto tensor_;
+};
+
+// Describes how padding should be aligned when the total number of pad
+// elements is odd.
+enum class PadAlignment : int64_t {
+  kDefault = 0,        // default padding for the device.
+  kCudnnPadding,       // cuDNN padding - prefer to pad at the start.
+  kTensorFlowPadding,  // TensorFlow padding - prefer to pad at the end.
+};
+
+// Returns a string representation of the given padding alignment.
+std::string PadAlignmentString(PadAlignment alignment);
+
+// Print alignment to str. Needed to use CHECK_EQ between two PadAlignments.
+std::ostream& operator<<(std::ostream& str, dnn::PadAlignment alignment);
+
+// Describes a convolution.
+//
+// Uses the named argument construction form:
+//
+//  ConvolutionDescriptor convolution_dimensions;
+//  convolution_dimensions
+//    .set_vertical_filter_stride(2)
+//    .set_horizontal_filter_stride(2)
+//    ...
+//
+// Arguments:
+// - zero_padding_height: padding of the "y dimension" of the input data. Note
+//    that this is different from the height of the filter.
+// - zero_padding_width: analogous to the height above, but in the "x
+//    dimension".
+// - vertical_filter_stride: the convolution slides a 2-dimensional window of
+//    filter-height-by-filter-width over the input layer -- the center of that
+//    window is moved in the "y dimension" according to this stride value.
+// - horizontal_filter_stride: analogous to the vertical stride above, but in
+//    the "x dimension".
+// - vertical_dilation_rate: there will be (vertical_dilation_rate - 1) skipped
+//   cells between each filter element in the "y dimension".
+// - horizontal_dilation_rate: there will be (horizontal_dilation_rate - 1)
+//   skipped cells between each filter element in the "x dimension".
+// - convolution_not_crosscor: By default (convolution_not_crosscor == false),
+//   we perform cross correlation rather than convolution. With the flag set,
+//   we perform convolution. Convolution and cross correlation are related by
+//   rotating the filter by 180 degrees (or equivalently flipping all spatial
+//   dimensions).
+class ConvolutionDescriptor {
+ public:
+  // By default construction, there is no zero-padding and the filter stride is
+  // 1x1 (centering the filter on every cell in the input layer's
+  // width-by-height area).
+  ConvolutionDescriptor();
+  explicit ConvolutionDescriptor(int ndims);
+  ~ConvolutionDescriptor();
+
+  std::string ToString() const;
+  std::string ToShortString() const;
+  ConvolutionDescriptorProto ToProto() const { return proto_; }
+
+  ConvolutionDescriptor& set_zero_padding_height(int64_t value) {
+    SetDim(padding(), DimIndex::Y, value);
+    return *this;
+  }
+  ConvolutionDescriptor& set_zero_padding_width(int64_t value) {
+    SetDim(padding(), DimIndex::X, value);
+    return *this;
+  }
+  ConvolutionDescriptor& set_zero_padding(DimIndex dim, int64_t value) {
+    SetDim(padding(), dim, value);
+    return *this;
+  }
+  ConvolutionDescriptor& set_vertical_filter_stride(int64_t value) {
+    SetDim(strides(), DimIndex::Y, value);
+    return *this;
+  }
+  ConvolutionDescriptor& set_horizontal_filter_stride(int64_t value) {
+    SetDim(strides(), DimIndex::X, value);
+    return *this;
+  }
+  ConvolutionDescriptor& set_filter_stride(DimIndex dim, int64_t value) {
+    SetDim(strides(), dim, value);
+    return *this;
+  }
+  ConvolutionDescriptor& set_vertical_dilation_rate(int64_t value) {
+    SetDim(dilations(), DimIndex::Y, value);
+    return *this;
+  }
+  ConvolutionDescriptor& set_horizontal_dilation_rate(int64_t value) {
+    SetDim(dilations(), DimIndex::X, value);
+    return *this;
+  }
+  ConvolutionDescriptor& set_dilation_rate(DimIndex dim, int64_t value) {
+    SetDim(dilations(), dim, value);
+    return *this;
+  }
+  ConvolutionDescriptor& set_group_count(int group_count) {
+    proto_.set_group_count(group_count);
+    return *this;
+  }
+  ConvolutionDescriptor& set_convolution_not_crosscorr(bool conv) {
+    proto_.set_convolution_mode(conv ? ConvolutionMode::CONVOLUTION
+                                     : ConvolutionMode::CROSS_CORRELATION);
+    return *this;
+  }
+  ConvolutionDescriptor& set_name(const std::string& name) {
+    proto_.set_name(name);
+    return *this;
+  }
+  int64_t zero_padding_height() const { return GetDim(padding(), DimIndex::Y); }
+  int64_t zero_padding_width() const { return GetDim(padding(), DimIndex::X); }
+  int64_t vertical_filter_stride() const {
+    return GetDim(strides(), DimIndex::Y);
+  }
+  int64_t horizontal_filter_stride() const {
+    return GetDim(strides(), DimIndex::X);
+  }
+  int64_t vertical_dilation_rate() const {
+    return GetDim(dilations(), DimIndex::Y);
+  }
+  int64_t horizontal_dilation_rate() const {
+    return GetDim(dilations(), DimIndex::X);
+  }
+
+  int zero_padding(DimIndex dim) const { return GetDim(padding(), dim); }
+  int filter_stride(DimIndex dim) const { return GetDim(strides(), dim); }
+  int dilation_rate(DimIndex dim) const { return GetDim(dilations(), dim); }
+  // TODO(timshen): remove this function. No users of this class is setting a
+  // non-default pad alignment.
+  PadAlignment pad_alignment() const { return PadAlignment::kDefault; }
+  int group_count() const { return proto_.group_count(); }
+  int ndims() const { return padding().size(); }
+  bool convolution_not_crosscorr() const {
+    return proto_.convolution_mode() == ConvolutionMode::CONVOLUTION;
+  }
+
+  absl::Span<const int64_t> strides() const {
+    return AsInt64Slice(proto_.strides());
+  }
+
+  absl::Span<const int64_t> dilations() const {
+    return AsInt64Slice(proto_.dilations());
+  }
+
+  absl::Span<const int64_t> padding() const {
+    return AsInt64Slice(proto_.paddings());
+  }
+
+  std::string name() const { return proto_.name(); }
+
+ private:
+  absl::Span<int64_t> strides() {
+    return AsInt64Slice(proto_.mutable_strides());
+  }
+
+  absl::Span<int64_t> dilations() {
+    return AsInt64Slice(proto_.mutable_dilations());
+  }
+
+  absl::Span<int64_t> padding() {
+    return AsInt64Slice(proto_.mutable_paddings());
+  }
+
+  ConvolutionDescriptorProto proto_;
+
+  // TODO(leary) cudnn provides these fields, but need to characterize what
+  // their effect is -- they may be boolean rather than integral.
+  // int64_t upscale_input_x;
+  // int64_t upscale_input_y;
+};
+
+// A patch of values in the input can be pooled via either a max or an average
+// operation.
+// Specify int64_t so there's no padding in PoolingDescriptor.
+enum class PoolingMode : int64_t {
+  kMaximum,
+  kAverage,
+};
+
+// Specify the dimension in which to concatenate inputs in space.
+// Specify int64_t so there's no padding in SpaceConcatenateMode.
+enum class SpaceConcatenateMode : int64_t {
+  XDirection,
+  YDirection,
+};
+
+// Returns a short name for the pooling mode, e.g. "Avg".
+std::string ShortPoolingModeString(PoolingMode mode);
+
+// Describes a pooling operation to be enqueued onto a stream via a platform's
+// DnnSupport.
+//
+// TODO(broune): describe how padding works and what happens if the
+// window height/width is not divisible by the vertical/horizontal
+// stride.
+//
+// Arguments:
+//  pooling_mode: pooling operator to use on the input patch
+//  window_height: height of input window
+//  window_width: width of input window
+//  vertical_stride: vertical delta for center of the input patch
+//  horizontal_stride: horizontal delta for center of the input patch
+class PoolingDescriptor {
+ public:
+  PoolingDescriptor();
+  explicit PoolingDescriptor(int ndims);
+
+  PoolingDescriptor& set_pooling_mode(PoolingMode value) {
+    mode_ = value;
+    return *this;
+  }
+  PoolingDescriptor& set_window_height(int64_t value) {
+    SetDim(&window_, DimIndex::Y, value);
+    return *this;
+  }
+  PoolingDescriptor& set_window_width(int64_t value) {
+    SetDim(&window_, DimIndex::X, value);
+    return *this;
+  }
+  PoolingDescriptor& set_window(DimIndex dim, int64_t value) {
+    SetDim(&window_, dim, value);
+    return *this;
+  }
+  PoolingDescriptor& set_vertical_padding(int64_t value) {
+    SetDim(&padding_, DimIndex::Y, value);
+    return *this;
+  }
+  PoolingDescriptor& set_horizontal_padding(int64_t value) {
+    SetDim(&padding_, DimIndex::X, value);
+    return *this;
+  }
+  PoolingDescriptor& set_padding(DimIndex dim, int64_t value) {
+    SetDim(&padding_, dim, value);
+    return *this;
+  }
+  PoolingDescriptor& set_vertical_stride(int64_t value) {
+    SetDim(&strides_, DimIndex::Y, value);
+    return *this;
+  }
+  PoolingDescriptor& set_horizontal_stride(int64_t value) {
+    SetDim(&strides_, DimIndex::X, value);
+    return *this;
+  }
+  PoolingDescriptor& set_stride(DimIndex dim, int64_t value) {
+    SetDim(&strides_, dim, value);
+    return *this;
+  }
+  PoolingDescriptor& set_propagate_nans(bool value) {
+    propagate_nans_ = value;
+    return *this;
+  }
+  PoolingDescriptor& set_name(const std::string& name) {
+    name_ = name;
+    return *this;
+  }
+
+  int ndims() const { return ndims_; }
+  void CloneFrom(const PoolingDescriptor& other);
+
+  std::string ToString() const;
+  std::string ToShortString() const;
+
+  PoolingMode mode() const { return mode_; }
+  int64_t window_height() const { return GetDim(window_, DimIndex::Y); }
+  int64_t window_width() const { return GetDim(window_, DimIndex::X); }
+  int64_t window(DimIndex dim) const { return GetDim(window_, dim); }
+  int64_t vertical_padding() const { return GetDim(padding_, DimIndex::Y); }
+  int64_t horizontal_padding() const { return GetDim(padding_, DimIndex::X); }
+  int64_t padding(DimIndex dim) const { return GetDim(padding_, dim); }
+  int64_t vertical_stride() const { return GetDim(strides_, DimIndex::Y); }
+  int64_t horizontal_stride() const { return GetDim(strides_, DimIndex::X); }
+  int64_t stride(DimIndex dim) const { return GetDim(strides_, dim); }
+  absl::Span<const int64_t> window() const { return window_; }
+  absl::Span<const int64_t> padding() const { return padding_; }
+  absl::Span<const int64_t> strides() const { return strides_; }
+  bool propagate_nans() const { return propagate_nans_; }
+  std::string name() const { return name_; }
+
+ private:
+  PoolingMode mode_;
+  int ndims_;
+  bool propagate_nans_;
+  std::string name_;  // Name as in Tensorflow NodeDef, for debugging purposes.
+
+  // Stored as: ..., y, x.
+  std::vector<int64_t> window_;
+  std::vector<int64_t> padding_;
+  std::vector<int64_t> strides_;
+};
+
+// Collects parameters for DNN algorithms
+class AlgorithmDesc {
+ public:
+  typedef int64_t Index;
+  AlgorithmDesc() : AlgorithmDesc(0, false, std::nullopt) {}
+  explicit AlgorithmDesc(AlgorithmProto proto) : proto_(std::move(proto)) {}
+  AlgorithmDesc(Index algo_id, bool use_tensor_ops)
+      : AlgorithmDesc(algo_id, use_tensor_ops, std::nullopt) {}
+  AlgorithmDesc(Index algo_id, bool use_tensor_ops,
+                std::optional<uint64_t> workspace_size) {
+    proto_.set_is_cudnn_frontend(false);
+    proto_.set_algo_id(algo_id);
+    proto_.set_math_type(use_tensor_ops ? AlgorithmProto::TENSOR_OP_MATH
+                                        : AlgorithmProto::DEFAULT_MATH);
+    if (workspace_size) {
+      proto_.mutable_workspace_size()->set_value(*workspace_size);
+    }
+  }
+  AlgorithmDesc(int64_t engine_id,
+                const std::vector<std::pair<int64_t, int64_t>>& tuning_knobs,
+                std::optional<uint64_t> workspace_size);
+  bool is_cudnn_frontend() const { return proto_.is_cudnn_frontend(); }
+
+  bool tensor_ops_enabled() const {
+    return proto_.math_type() == AlgorithmProto::TENSOR_OP_MATH;
+  }
+  std::optional<uint64_t> workspace_size() const {
+    if (proto_.has_workspace_size()) {
+      return proto_.workspace_size().value();
+    }
+    return std::nullopt;
+  }
+  Index algo_id() const { return proto_.algo_id(); }
+
+  std::vector<std::pair<int64_t, int64_t>> TuningKnobs() const;
+
+  bool operator==(const AlgorithmDesc& other) const;
+
+  uint64_t hash() const;
+
+  AlgorithmProto ToProto() const { return proto_; }
+
+  std::string ToString() const;
+
+ private:
+  AlgorithmProto proto_;
+};
+
+// Describes the result from a perf experiment.
+//
+// Arguments:
+//  algorithm: returns the exact algorithm that was used.
+//  elapsed_time_in_ms: returns the measured elapsed time in milliseconds.
+class ProfileResult {
+ public:
+  bool is_valid() const {
+    return algorithm_.has_value() &&
+           elapsed_time_in_ms() != std::numeric_limits<float>::max();
+  }
+
+  AlgorithmDesc algorithm() const { return *algorithm_; }
+  void set_algorithm(AlgorithmDesc val) { algorithm_ = val; }
+
+  float elapsed_time_in_ms() const { return elapsed_time_in_ms_; }
+  void set_elapsed_time_in_ms(float val) { elapsed_time_in_ms_ = val; }
+
+  size_t scratch_size() const { return scratch_size_; }
+  void set_scratch_size(size_t val) { scratch_size_ = val; }
+
+ private:
+  std::optional<AlgorithmDesc> algorithm_;
+  float elapsed_time_in_ms_ = std::numeric_limits<float>::max();
+  // The scratch size algorithm_ requires. Currently it's only populated by
+  // convolutions.
+  size_t scratch_size_ = 0;
+};
+
+// Backend-specific data shared between repeated launches of the same
+// convolution.
+template <typename Sig>
+class OpRunner;
+
+// An abstract class owning cached state for a particular op/configuration.
+//
+// The primary motivation for this is cuDNN backend ExecutionPlans, which are
+// costly to recreate.
+//
+// All OpRunners must be outlived by their parent Stream.
+template <typename... Args>
+class OpRunner<void(Args...)> {
+ public:
+  virtual ~OpRunner() = default;
+
+  // Get a description of the runner, for uniqueness of autotune entries.
+  //
+  // Since this is used to determine whether runners are equivalent for the
+  // purpose of scoring autotune entries, it shall be unique among runners of
+  // the same op and parameters.
+  virtual std::string ToString() const = 0;
+
+  // Get the number of bytes of scratch space needed for `operator()`.
+  //
+  // If determining the workspace size can fail, runners should precompute and
+  // cache it at construction time.
+  virtual size_t GetWorkspaceSize() const = 0;
+
+  // Convert to an AlgorithmDesc for AoT compilation or autotuning.
+  virtual tsl::StatusOr<AlgorithmDesc> ToAlgorithmDesc() const = 0;
+
+  // Launch the operation, with the signature determined by `Sig`.
+  virtual tsl::Status operator()(Stream*, ProfileResult*,
+                                 DeviceMemoryBase scratch_memory,
+                                 Args... args) const = 0;
+};
+
+using ConvSignature = void(DeviceMemoryBase /* input_data */,
+                           DeviceMemoryBase /* filter_data */,
+                           DeviceMemoryBase /* output_data */);
+using ConvRunner = OpRunner<ConvSignature>;
+
+using GraphConvSignature = void(std::vector<DeviceMemoryBase>);
+using GraphConvRunner = OpRunner<GraphConvSignature>;
+
+using FusedConvSignature = void(DeviceMemoryBase /* input_data */,
+                                DeviceMemoryBase /* filter_data */,
+                                DeviceMemoryBase /* side_input_data */,
+                                DeviceMemoryBase /* bias_data */,
+                                DeviceMemoryBase /* output_data */);
+using FusedConvRunner = OpRunner<FusedConvSignature>;
+
+using FusedMatmulSignature = void(DeviceMemoryBase /* a_data */,
+                                  DeviceMemoryBase /* b_data */,
+                                  DeviceMemoryBase /* bias_data */,
+                                  DeviceMemoryBase /* c_data */);
+using FusedMatmulRunner = OpRunner<FusedMatmulSignature>;
+
+using FusedMHASignature = void(DeviceMemoryBase /*BMM1_inputA_data*/,
+                               DeviceMemoryBase /* BMM1_inputB_data */,
+                               DeviceMemoryBase /* BMM2_inputA_data */,
+                               DeviceMemoryBase /* output_data */,
+                               DeviceMemoryBase /* mask_data */,
+                               DeviceMemoryBase /* bias_data */,
+                               DeviceMemoryBase /* activation_data */);
+using FusedMHARunner = OpRunner<FusedMHASignature>;
+
+using FusedMHABackwardSignature = void(
+    DeviceMemoryBase /* BMM1_GRAD_GEMM1_inputA_data */,
+    DeviceMemoryBase /* BMM1_GRAD_GEMM2_inputB_data */,
+    DeviceMemoryBase /* BMM2_GRAD_GEMM1_inputA_data */,
+    DeviceMemoryBase /* BMM2_GRAD_GEMM2_inputB_data */,
+    DeviceMemoryBase /* d_output_data */,
+    DeviceMemoryBase /* d_BMM1_inputA_data */,
+    DeviceMemoryBase /* d_BMM1_inputB_data */,
+    DeviceMemoryBase /* d_BMM2_inputB_data */, DeviceMemoryBase /* d_s_data */,
+    DeviceMemoryBase /* mask_data */, DeviceMemoryBase /* d_bias_data */);
+using FusedMHABackwardRunner = OpRunner<FusedMHABackwardSignature>;
+
+// Describes the configuration for the algorithms that will used.
+//
+// Arguments:
+//  algorithm: the primary algorithm that should be used.
+//  algorithm_no_scratch: a secondary algorithm that should be used, if the
+//    the allocation for the scratch memory fails.
+//  scrach_size: specify the size of scratch memory in bytes needed for the
+//    algorithm used.
+//
+// On CUDA platform with CUDNN library, algorithm and algorithm_no_scratch
+// would be used. On ROCm platform with MIOpen library, algorithm and
+// scratch_size would be used. The major difference between the two platforms
+// are whether it's possible to get an algorithm without scratch memory. On
+// CUDA + CUDNN it's possible, and algorithm_no_scratch can be used to track
+// such information, whereas on ROCm + MIOpen there is no guarantee to getting
+// one without scratch memory, and scratch_size field is used to track it.
+class AlgorithmConfig {
+ public:
+  AlgorithmConfig() = default;
+  explicit AlgorithmConfig(AlgorithmDesc algorithm) : algorithm_(algorithm) {}
+  AlgorithmConfig(AlgorithmDesc algorithm, size_t scratch_size)
+      : algorithm_(algorithm), scratch_size_(scratch_size) {}
+  AlgorithmConfig(AlgorithmDesc algorithm, AlgorithmDesc algorithm_no_scratch)
+      : algorithm_(algorithm), algorithm_no_scratch_(algorithm_no_scratch) {}
+  AlgorithmConfig(AlgorithmDesc algorithm, size_t scratch_size,
+                  AlgorithmDesc algorithm_no_scratch)
+      : algorithm_(algorithm),
+        algorithm_no_scratch_(algorithm_no_scratch),
+        scratch_size_(scratch_size) {}
+
+  // TODO(ruochengw): After cl/380702564, add support for algorithm configs with
+  // cuDNN Frontend APIs.
+  explicit AlgorithmConfig(const AlgorithmConfigProto& algorithm_config_proto) {
+    const AlgorithmProto& algorithm_proto = algorithm_config_proto.algorithm();
+    algorithm_ = AlgorithmDesc(algorithm_proto);
+    if (algorithm_config_proto.optional_scratch_size_case() !=
+        /*ONEOF_NAME_NOT_SET=*/0) {
+      scratch_size_ = algorithm_config_proto.scratch_size();
+    }
+    if (algorithm_config_proto.optional_algorithm_no_scratch_case() !=
+        /*ONEOF_NAME_NOT_SET=*/0) {
+      const AlgorithmProto& algorithm_no_scratch_proto =
+          algorithm_config_proto.algorithm_no_scratch();
+      algorithm_no_scratch_ = AlgorithmDesc(algorithm_no_scratch_proto);
+    }
+  }
+
+  std::optional<AlgorithmDesc> algorithm() const { return algorithm_; }
+  void set_algorithm(AlgorithmDesc val) { algorithm_ = val; }
+  std::optional<AlgorithmDesc> algorithm_no_scratch() const {
+    return algorithm_no_scratch_;
+  }
+  void set_algorithm_no_scratch(AlgorithmDesc val) {
+    algorithm_no_scratch_ = val;
+  }
+  std::optional<size_t> scratch_size() const { return scratch_size_; }
+  void set_scratch_size(size_t val) { scratch_size_ = val; }
+  bool operator==(const AlgorithmConfig& other) const {
+    return this->algorithm_ == other.algorithm_ &&
+           this->algorithm_no_scratch_ == other.algorithm_no_scratch_ &&
+           this->scratch_size_ == other.scratch_size_;
+  }
+  bool operator!=(const AlgorithmConfig& other) const {
+    return !(*this == other);
+  }
+  std::string ToString() const;
+
+  // TODO(ruochengw): After cl/380702564, add support for algorithm configs with
+  // cuDNN Frontend APIs.
+  AlgorithmConfigProto ToProto() const {
+    AlgorithmConfigProto algorithm_config_proto;
+    if (algorithm_.has_value()) {
+      *algorithm_config_proto.mutable_algorithm() =
+          algorithm_.value().ToProto();
+    }
+    if (algorithm_no_scratch_.has_value()) {
+      *algorithm_config_proto.mutable_algorithm_no_scratch() =
+          algorithm_no_scratch_.value().ToProto();
+    }
+    if (scratch_size_.has_value()) {
+      algorithm_config_proto.set_scratch_size(scratch_size_.value());
+    }
+    return algorithm_config_proto;
+  }
+
+ private:
+  std::optional<AlgorithmDesc> algorithm_;
+  std::optional<AlgorithmDesc> algorithm_no_scratch_;
+  std::optional<size_t> scratch_size_;
+};
+
+// Describes a local response normalization (LRN). LRN is used e.g. in
+// dist_belief.
+//
+// Let V be the vector of feature maps at some (batch, y, x)
+// coordinate. LRN applies independently to each vector V in the
+// input, across all coordinates (batch, y, x), by mapping each V to
+// another vector U of the same size using the formula
+//
+//   U_i = V_i / ((bias + alpha * (sum_j V_j^2)) ^ beta)
+//
+// where the sum is taken over j in the closed range [i - range, i + range].
+//
+// When calculating U_i the j in the sum can extend beyond the bounds
+// of V. If wrap_around is true, then V_j = V_{j mod F} where F is the
+// size of V, which is the number of feature maps. If wrap_around is
+// false, then V_j = 0 for j outside [0, F-1].
+//
+// If segment_size <= F, where F is the number of feature_maps, then
+// segment_size has no effect. Otherwise, each consecutive segment of
+// segment_size entries in V are normalized separately.
+//
+// Not all StreamExecutors allow wrap_around == true or segment_size
+// != 64. Some do not implement normalization at all.
+class NormalizeDescriptor {
+ public:
+  NormalizeDescriptor();
+
+  NormalizeDescriptor& set_bias(float bias) {
+    bias_ = bias;
+    return *this;
+  }
+
+  NormalizeDescriptor& set_range(int32_t range) {
+    range_ = range;
+    return *this;
+  }
+
+  NormalizeDescriptor& set_alpha(float alpha) {
+    alpha_ = alpha;
+    return *this;
+  }
+
+  NormalizeDescriptor& set_beta(float beta) {
+    beta_ = beta;
+    return *this;
+  }
+
+  NormalizeDescriptor& set_wrap_around(bool wrap_around) {
+    wrap_around_ = wrap_around;
+    return *this;
+  }
+
+  NormalizeDescriptor& set_segment_size(int32_t segment_size) {
+    segment_size_ = segment_size;
+    return *this;
+  }
+
+  void CloneFrom(const NormalizeDescriptor& other);
+
+  std::string ToString() const;
+  std::string ToShortString() const;
+
+  float bias() const { return bias_; }
+  int32_t range() const { return range_; }
+  float alpha() const { return alpha_; }
+  float beta() const { return beta_; }
+  bool wrap_around() const { return wrap_around_; }
+  int32_t segment_size() const { return segment_size_; }
+
+ private:
+  float bias_;
+  int32_t range_;
+  float alpha_;
+  float beta_;
+  bool wrap_around_;
+  int32_t segment_size_;
+};
+
+// Returns a string representation of the given activation mode.
+std::string ActivationModeString(ActivationMode mode);
+
+// Describes the operation that DoElementwiseOperation should perform on its
+// inputs.
+enum class ElementwiseOperation { kAdd, kMultiply };
+
+std::string ElementwiseOperationString(ElementwiseOperation op);
+
+// A simple class representing the version of the backing library, to
+// workaround the "too perfect forwarding" issue in gcc6+ compilers.
+// See PR#16309 and issue #18402 for links discussing the issue.
+class VersionInfo {
+ public:
+  explicit VersionInfo(int major = 0, int minor = 0, int patch = 0)
+      : major_(major), minor_(minor), patch_(patch) {}
+  explicit VersionInfo(DnnVersionInfoProto proto)
+      : major_(proto.major()), minor_(proto.minor()), patch_(proto.patch()) {}
+
+  DnnVersionInfoProto ToProto() const {
+    DnnVersionInfoProto proto;
+    proto.set_major(major_);
+    proto.set_minor(minor_);
+    proto.set_patch(patch_);
+    return proto;
+  }
+
+  int major_version() const { return major_; }
+  int minor_version() const { return minor_; }
+  int patch() const { return patch_; }
+
+  std::tuple<int, int, int> as_tuple() const {
+    return std::make_tuple(major_, minor_, patch_);
+  }
+
+  friend bool operator<(const VersionInfo& a, const VersionInfo& b) {
+    return a.as_tuple() < b.as_tuple();
+  }
+  friend bool operator>(const VersionInfo& a, const VersionInfo& b) {
+    return a.as_tuple() > b.as_tuple();
+  }
+  friend bool operator<=(const VersionInfo& a, const VersionInfo& b) {
+    return a.as_tuple() <= b.as_tuple();
+  }
+  friend bool operator>=(const VersionInfo& a, const VersionInfo& b) {
+    return a.as_tuple() >= b.as_tuple();
+  }
+  friend bool operator==(const VersionInfo& a, const VersionInfo& b) {
+    return a.as_tuple() == b.as_tuple();
+  }
+  friend bool operator!=(const VersionInfo& a, const VersionInfo& b) {
+    return a.as_tuple() != b.as_tuple();
+  }
+
+  std::string ToString() const {
+    return absl::StrCat(major_, ".", minor_, ".", patch_);
+  }
+
+ private:
+  int major_;
+  int minor_;
+  int patch_;
+};
+
+// Suite of operations typically used for implementing Deep/Convolutional Neural
+// Nets. Note: A false return value of an operation indicates the
+// implementation is not available.
+//
+// TODO(b/118763918): this class (or rather dispatch table) has several
+// problems:
+// * Some overloads are missing. Ideally we want to have template virtual
+//   functions while the template arguments is a closed set. However, we don't
+//   get that from the language.
+// * The API is a union of cuDNN and another private backend. Only 10% of the
+//   functions are actually implemented by both backends, the rest are
+//   actually backend-specific. The massive interface creates extra mental
+//   burden.
+// * Poor error handling: the API should return tsl::Status objects.
+//
+// PrepareForConvolution is an example for how new APIs should be written.
+class DnnSupport {
+ public:
+  DnnSupport() = default;
+  virtual ~DnnSupport() = default;
+
+  virtual tsl::Status Init() = 0;
+
+  // Gets the version of the backing library, as a VersionInfo object.
+  virtual tsl::StatusOr<VersionInfo> GetVersion() {
+    return tsl::errors::Unimplemented(
+        "DnnSupport::GetVersion not implemented on this platform.");
+  }
+
+  // Performs a single-precision forward batch normalization operation onto
+  // the stream.
+  //
+  // Arguments:
+  //  stream: borrowed pointer to the stream that the batch normalization
+  //    operation should be enqueued onto.
+  //  x: input data.
+  //  scale: scaling parameters.
+  //  offset: offset parameters.
+  //  estimated_mean: population mean estimated during training.
+  //    Used for inference only; empty for training.
+  //  estimated_variance: population variance estimated during training,
+  //    used for inference only; empty for training.
+  //  side_input: optional input that is element-wise added to the output of
+  //    batch normalization.
+  //  x_desc: dimensions of the input data, which is the same as the dimensions
+  //    of the output and side input.
+  //  scale_offset_desc: dimensions of scale and offset.
+  //  epsilon: a small floating point number added to the variance of x.
+  //  activation_mode: activation applied to the result of batch normalization
+  //    (or after adding optional side input)
+  //  y: output data.
+  //  batch_mean: batch mean, to be used to compute the running mean.
+  //  batch_variance: batch variance, to be used to compute
+  //    the running variance.
+  //  reserve_space_1: saved mean, to be reused in the backward gradient
+  //    computation.
+  //  reserve_space_2: saved inv_var (1/sqrt(epsilon + variance), to be reused
+  //    in the backward gradient computation.
+  //  is_training: Set to true for training, false for inference.
+  virtual bool DoBatchNormalizationForward(
+      Stream* stream, const DeviceMemory<float>& x,
+      const DeviceMemory<float>& scale, const DeviceMemory<float>& offset,
+      const DeviceMemory<float>& estimated_mean,
+      const DeviceMemory<float>& estimated_variance,
+      const DeviceMemory<float>& side_input, const dnn::BatchDescriptor& x_desc,
+      const dnn::BatchDescriptor& scale_offset_desc, const double epsilon,
+      const double exponential_average_factor,
+      dnn::ActivationMode activation_mode, DeviceMemory<float>* y,
+      DeviceMemory<float>* batch_mean, DeviceMemory<float>* batch_var,
+      DeviceMemory<float>* reserve_space_1,
+      DeviceMemory<float>* reserve_space_2, bool is_training,
+      ScratchAllocator* reserve_space_allocator,
+      ScratchAllocator* workspace_allocator) {
+    return false;
+  }
+
+  // Performs a half-precision forwards batch normalization operation onto the
+  // stream. See DoBatchNormalizationForward above for argument details.
+  virtual bool DoBatchNormalizationForward(
+      Stream* stream, const DeviceMemory<Eigen::half>& x,
+      const DeviceMemory<float>& scale, const DeviceMemory<float>& offset,
+      const DeviceMemory<float>& estimated_mean,
+      const DeviceMemory<float>& estimated_variance,
+      const DeviceMemory<Eigen::half>& side_input,
+      const dnn::BatchDescriptor& x_desc,
+      const dnn::BatchDescriptor& scale_offset_desc, const double epsilon,
+      const double exponential_average_factor,
+      dnn::ActivationMode activation_mode, DeviceMemory<Eigen::half>* y,
+      DeviceMemory<float>* batch_mean, DeviceMemory<float>* batch_var,
+      DeviceMemory<float>* reserve_space_1,
+      DeviceMemory<float>* reserve_space_2, bool is_training,
+      ScratchAllocator* reserve_space_allocator,
+      ScratchAllocator* workspace_allocator) {
+    return false;
+  }
+
+  // Performs a bfloat16 forward batch normalization operation onto the
+  // stream. See DoBatchNormalizationForward above for argument details.
+  virtual bool DoBatchNormalizationForward(
+      Stream* stream, const DeviceMemory<Eigen::bfloat16>& x,
+      const DeviceMemory<float>& scale, const DeviceMemory<float>& offset,
+      const DeviceMemory<float>& estimated_mean,
+      const DeviceMemory<float>& estimated_variance,
+      const DeviceMemory<Eigen::bfloat16>& side_input,
+      const dnn::BatchDescriptor& x_desc,
+      const dnn::BatchDescriptor& scale_offset_desc, const double epsilon,
+      const double exponential_average_factor,
+      dnn::ActivationMode activation_mode, DeviceMemory<Eigen::bfloat16>* y,
+      DeviceMemory<float>* batch_mean, DeviceMemory<float>* batch_var,
+      DeviceMemory<float>* reserve_space_1,
+      DeviceMemory<float>* reserve_space_2, bool is_training,
+      ScratchAllocator* reserve_space_allocator,
+      ScratchAllocator* workspace_allocator) {
+    return false;
+  }
+
+  // Performs a single-precision backward batch normalization gradient
+  // computation operation onto the stream.
+  //
+  // Arguments:
+  //  stream: borrowed pointer to the stream that the batch normalization
+  //    gradient computation operation should be enqueued onto.
+  //  y_backprop: gradient with regard to output y.
+  //  x: input data.
+  //  scale: scaling parameters.
+  //  inv_var: 1/sqrt(epsilon + variance) of x.
+  //  x_desc: dimensions of the input data, which is the same as the dimensions
+  //    of the output.
+  //  scale_offset_desc: dimensions of scale and offset.
+  //  epsilon: a small floating point number added to the variance of x.
+  //  x_backprop: gradient with respect to input x.
+  //  scale_backprop: gradient with respect to scale.
+  //  offset_backprop: gradient with respect to offset.
+  virtual bool DoBatchNormalizationBackward(
+      Stream* stream, const DeviceMemory<float>& y_backprop,
+      const DeviceMemory<float>& x, const DeviceMemory<float>& scale,
+      const DeviceMemory<float>& offset, const DeviceMemory<float>& mean,
+      const DeviceMemory<float>& inv_var, const DeviceMemory<float>& y,
+      const dnn::BatchDescriptor& x_desc,
+      const dnn::BatchDescriptor& scale_offset_desc, const double epsilon,
+      dnn::ActivationMode activation_mode, DeviceMemory<float>* x_backprop,
+      DeviceMemory<float>* scale_backprop, DeviceMemory<float>* offset_backprop,
+      DeviceMemory<float>* side_input_backprop,
+      DeviceMemory<uint8_t>* reserve_space_data,
+      ScratchAllocator* workspace_allocator) {
+    return false;
+  }
+
+  // Performs a half-precision backward batch normalization gradient computation
+  // operation onto the stream. See DoBatchNormalizationBackward above for
+  // argument details.
+  virtual bool DoBatchNormalizationBackward(
+      Stream* stream, const DeviceMemory<Eigen::half>& y_backprop,
+      const DeviceMemory<Eigen::half>& x, const DeviceMemory<float>& scale,
+      const DeviceMemory<float>& offset, const DeviceMemory<float>& mean,
+      const DeviceMemory<float>& inv_var, const DeviceMemory<Eigen::half>& y,
+      const dnn::BatchDescriptor& x_desc,
+      const dnn::BatchDescriptor& scale_offset_desc, const double epsilon,
+      dnn::ActivationMode activation_mode,
+      DeviceMemory<Eigen::half>* x_backprop,
+      DeviceMemory<float>* scale_backprop, DeviceMemory<float>* offset_backprop,
+      DeviceMemory<Eigen::half>* side_input_backprop,
+      DeviceMemory<uint8_t>* reserve_space_data,
+      ScratchAllocator* workspace_allocator) {
+    return false;
+  }
+
+  // Performs a bfloat16 backward batch normalization gradient computation
+  // operation onto the stream. See DoBatchNormalizationBackward above for
+  // argument details.
+  virtual bool DoBatchNormalizationBackward(
+      Stream* stream, const DeviceMemory<Eigen::bfloat16>& y_backprop,
+      const DeviceMemory<Eigen::bfloat16>& x, const DeviceMemory<float>& scale,
+      const DeviceMemory<float>& offset, const DeviceMemory<float>& mean,
+      const DeviceMemory<float>& inv_var,
+      const DeviceMemory<Eigen::bfloat16>& y,
+      const dnn::BatchDescriptor& x_desc,
+      const dnn::BatchDescriptor& scale_offset_desc, const double epsilon,
+      dnn::ActivationMode activation_mode,
+      DeviceMemory<Eigen::bfloat16>* x_backprop,
+      DeviceMemory<float>* scale_backprop, DeviceMemory<float>* offset_backprop,
+      DeviceMemory<Eigen::bfloat16>* side_input_backprop,
+      DeviceMemory<uint8_t>* reserve_space_data,
+      ScratchAllocator* workspace_allocator) {
+    return false;
+  }
+
+  // Enqueues a fused convolution operation onto the stream.
+  // We provide several variants with different types for inputs, biases and
+  // scaling parameters.
+  //
+  // Arguments (all borrowed):
+  //  stream: borrowed pointer to the stream that the 'convolve' operation
+  //    should be enqueued onto.
+  //  conv_input_descriptor: dimensions of the convolution input layer.
+  //  conv_input_data: un-owned device memory region which contains the
+  //    convolution input.
+  //  conv_input_scale: a floating point scale to multiply with each element
+  //    of conv_input_data.
+  //  filter_descriptor: dimensions of the convolution filter.
+  //  filter_data: un-owned device memory region which contains the
+  //    convolution filter weights.
+  //  convolution_descriptor: stride of the convolution filter.
+  //  biases: un-owned device memory region containing biases to add to the
+  //    input.
+  //  activation_mode: Type of activation to perform.
+  //  side_input_data: un-owned device memory region which contains optional
+  //    side input data. If 'side_input_scale' is non-zero, then this must
+  //    point to data in the tensor shape specified by output_shape.
+  //    It will be scaled by 'side_input_scale' and added to the convolution
+  //    result and bias prior to applying the activation function.
+  //  side_input_scale: a floating point scale to multiply with each element
+  //    of side_input_data.
+  //  output_descriptor: dimensions of the output layer.
+  //  output_data: un-owned device memory region in which to place the
+  //    convolution result.
+  //  scratch_allocator: un-owned, may-be-null object that may allocate scratch
+  //    space in order to speed up the convolution operation.
+  //  algorithm_config: specifies which algorithm should be used for the
+  //    operation.
+  //  output_profile_result: the output profile result for this call. The
+  //    profiling is only enabled when this is not nullptr.
+  //
+  // conv_input_descriptor, filter_descriptor, convolution_descriptor and
+  // output_descriptor together specify exactly how the convolution is aligned
+  // with the input data:
+  //
+  // * (input dimensions - filter size + 1) / filter stride == output dimensions
+  //   corresponds to dist_belief padding = VALID, i.e. the input is not padded.
+  // * input dimensions / filter stride == output dimensions
+  //   corresponds to dist_belief padding = SAME, i.e. input and output are the
+  //   same size - this requires padding the input.
+  // * (input dimensions + filter size - 1) / filter stride == output dimensions
+  //   corresponds to dist_belief padding = FULL, i.e. the output is sized so
+  //   that if the inverse of the filter is applied to the output in VALID mode
+  //   the result is the same size as the input - this requires even more
+  //   padding of the input.
+  virtual tsl::Status DoFusedConvolve(
+      Stream* stream, DataType input_type, DataType side_input_type,
+      DataType bias_type, DataType output_type,
+      const dnn::BatchDescriptor& conv_input_descriptor,
+      DeviceMemoryBase conv_input_data, double conv_input_scale,
+      const dnn::FilterDescriptor& filter_descriptor,
+      DeviceMemoryBase filter_data,
+      const dnn::ConvolutionDescriptor& convolution_descriptor,
+      DeviceMemoryBase side_input_data, double side_input_scale,
+      const dnn::BatchDescriptor& bias_descriptor, DeviceMemoryBase biases,
+      dnn::ActivationMode activation_mode,
+      const dnn::BatchDescriptor& output_descriptor,
+      DeviceMemoryBase output_data, ScratchAllocator* scratch_allocator,
+      const dnn::AlgorithmConfig& algorithm_config,
+      dnn::ProfileResult* output_profile_result) {
+    return tsl::errors::Unimplemented(
+        "DnnSupport::DoFusedConvolve not implemented on this platform.");
+  }
+
+  template <typename ElementType, typename OutputType>
+  tsl::Status PrepareForConvolution(
+      ConvolutionKind kind, Stream* stream,
+      const BatchDescriptor& batch_descriptor,
+      DeviceMemory<ElementType> input_data,
+      const FilterDescriptor& filter_descriptor,
+      DeviceMemory<ElementType> filter_data,
+      const BatchDescriptor& output_descriptor,
+      DeviceMemory<OutputType> output_data,
+      const ConvolutionDescriptor& convolution_descriptor,
+      const AlgorithmConfig& algorithm_config,
+      ScratchAllocator* scratch_allocator, AlgorithmDesc* algorithm_desc,
+      DeviceMemory<uint8_t>* scratch_memory) {
+    return DoPrepareForConvolution(
+        kind, ToDataType<ElementType>::value, stream, batch_descriptor,
+        input_data, filter_descriptor, filter_data, output_descriptor,
+        output_data, convolution_descriptor, algorithm_config,
+        scratch_allocator, algorithm_desc, scratch_memory);
+  }
+
+  // cuDNN-specific input transformation that allows running int8x32
+  // convolutions faster using Tensor Core IMMA instruction.
+  virtual tsl::Status CudnnReorderConvolutionFilterAndBias(
+      Stream* stream, const FilterDescriptor& filter_descriptor,
+      const DeviceMemory<int8_t>& filter_input,
+      DeviceMemory<int8_t>* filter_output,
+      std::optional<const DeviceMemory<float>> bias_input,
+      std::optional<DeviceMemory<float>> bias_output) {
+    return tsl::errors::Unimplemented(
+        "DnnSupport::CudnnReorderConvolutionFilterAndBias is specific to CUDA "
+        "convolution implementation.");
+  }
+
+  // Enqueues a single-precision convolution operation onto the stream.
+  //
+  // Arguments (all borrowed):
+  //  stream: borrowed pointer to the stream that the 'convolve' operation
+  //    should be enqueued onto.
+  //  input_descriptor: dimensions of the input layer.
+  //  input_data: un-owned device memory region which contains the
+  //    convolution input.
+  //  filter_descriptor: dimensions of the convolution filter.
+  //  convolution_descriptor: stride of the convolution filter.
+  //  output_descriptor: dimensions of the output layer.
+  //  output_data: un-owned device memory region in which to place the
+  //    convolution result.
+  //  algorithm_desc: specifies which algorithm should be used for the
+  //    operation.
+  //  scratch: un-owned device memory for scratch space in order to speed up
+  //    the convolution operation.
+  //  output_profile_result: the output profile result for this call. The
+  //    profiling is only enabled when this is not nullptr.
+  //
+  // input_descriptor, filter_descriptor, convolution_descriptor and
+  // output_descriptor together specify exactly how the convolution is aligned
+  // with the input data:
+  //
+  // * (input dimensions - filter size + 1) / filter stride == output dimensions
+  //   corresponds to dist_belief padding = VALID, i.e. the input is not padded.
+  // * input dimensions / filter stride == output dimensions
+  //   corresponds to dist_belief padding = SAME, i.e. input and output are the
+  //   same size - this requires padding the input.
+  // * (input dimensions + filter size - 1) / filter stride == output dimensions
+  //   corresponds to dist_belief padding = FULL, i.e. the output is sized so
+  //   that if the inverse of the filter is applied to the output in VALID mode
+  //   the result is the same size as the input - this requires even more
+  //   padding of the input.
+  virtual tsl::Status DoConvolve(
+      ConvolutionKind kind, DataType element_type, DataType output_type,
+      Stream* stream, const BatchDescriptor& input_descriptor,
+      DeviceMemoryBase input_data, const FilterDescriptor& filter_descriptor,
+      DeviceMemoryBase filter_data, const BatchDescriptor& output_descriptor,
+      DeviceMemoryBase output_data,
+      const ConvolutionDescriptor& convolution_descriptor,
+      AlgorithmDesc algorithm_desc, DeviceMemory<uint8_t> scratch_memory,
+      ProfileResult* output_profile_result) = 0;
+
+  virtual tsl::Status GetConvolveRunners(
+      bool use_cudnn_frontend, dnn::ConvolutionKind kind,
+      dnn::DataType input_type, dnn::DataType output_type, Stream* stream,
+      const dnn::BatchDescriptor& input_descriptor, DeviceMemoryBase input_data,
+      const dnn::FilterDescriptor& filter_descriptor,
+      DeviceMemoryBase filter_data,
+      const dnn::BatchDescriptor& output_descriptor,
+      DeviceMemoryBase output_data,
+      const dnn::ConvolutionDescriptor& convolution_descriptor,
+      bool use_fallback, ScratchAllocator* scratch_allocator,
+      const NumericOptions& numeric_options,
+      std::vector<std::unique_ptr<const dnn::ConvRunner>>* out_exec_plans);
+
+  virtual tsl::StatusOr<std::unique_ptr<const dnn::ConvRunner>>
+  ConvolveRunnerFromDesc(
+      Stream* stream, const dnn::AlgorithmDesc& algorithm_desc,
+      dnn::ConvolutionKind kind, dnn::DataType element_type,
+      dnn::DataType output_type, const dnn::BatchDescriptor& input_descriptor,
+      const dnn::FilterDescriptor& filter_descriptor,
+      const dnn::BatchDescriptor& output_descriptor,
+      const dnn::ConvolutionDescriptor& convolution_descriptor);
+
+  virtual tsl::Status GetGraphConvolveRunners(
+      dnn::ConvolutionKind kind, dnn::DataType input_type,
+      dnn::DataType output_type, Stream* stream,
+      const dnn::BatchDescriptor& input_descriptor,
+      const dnn::FilterDescriptor& filter_descriptor,
+      const dnn::BatchDescriptor& output_descriptor,
+      const dnn::ConvolutionDescriptor& convolution_descriptor,
+      bool use_fallback, const NumericOptions& numeric_options,
+      std::vector<std::unique_ptr<const dnn::GraphConvRunner>>* out_exec_plans,
+      std::string serialized_graph);
+
+  virtual tsl::StatusOr<std::unique_ptr<const dnn::GraphConvRunner>>
+  GraphConvolveRunnerFromDesc(
+      Stream* stream, const dnn::AlgorithmDesc& algorithm_desc,
+      dnn::ConvolutionKind kind, dnn::DataType element_type,
+      dnn::DataType output_type, const dnn::BatchDescriptor& input_descriptor,
+      const dnn::FilterDescriptor& filter_descriptor,
+      const dnn::BatchDescriptor& output_descriptor,
+      const dnn::ConvolutionDescriptor& convolution_descriptor,
+      std::string serialized_graph);
+
+  virtual tsl::Status GetFusedConvolveRunners(
+      bool use_cudnn_frontend, dnn::ConvolutionKind kind,
+      dnn::DataType element_type, dnn::DataType bias_type,
+      dnn::DataType output_type, double conv_input_scale,
+      double side_input_scale, double leakyrelu_alpha, Stream* stream,
+      const dnn::BatchDescriptor& input_descriptor,
+      const dnn::FilterDescriptor& filter_descriptor,
+      const dnn::BatchDescriptor& bias_descriptor,
+      const dnn::BatchDescriptor& output_descriptor,
+      const dnn::ConvolutionDescriptor& convolution_descriptor,
+      bool use_fallback, dnn::ActivationMode activation_mode,
+      const NumericOptions& numeric_options,
+      std::vector<std::unique_ptr<const dnn::FusedConvRunner>>* out_exec_plans);
+
+  virtual tsl::Status GetFusedMatmulRunners(
+      bool use_cudnn_frontend, dnn::DataType element_type,
+      dnn::DataType bias_type, dnn::DataType output_type, Stream* stream,
+      bool trans_a, bool trans_b, uint64_t m, uint64_t n, uint64_t k,
+      int64_t lda, int64_t ldb, int64_t ldc,
+      dnn::ActivationMode activation_mode, bool use_fallback,
+      const NumericOptions& numeric_options,
+      std::vector<std::unique_ptr<const dnn::FusedMatmulRunner>>*
+          out_exec_plans);
+
+  virtual tsl::StatusOr<std::unique_ptr<const dnn::FusedConvRunner>>
+  FusedConvolveRunnerFromDesc(
+      Stream* stream, const dnn::AlgorithmDesc& algorithm_desc,
+      dnn::ConvolutionKind kind, dnn::DataType element_type,
+      dnn::DataType bias_type, dnn::DataType output_type, double conv_scale,
+      double side_input_scale, double leakyrelu_alpha,
+      const dnn::BatchDescriptor& input_descriptor,
+      const dnn::FilterDescriptor& filter_descriptor,
+      const dnn::BatchDescriptor& bias_descriptor,
+      const dnn::BatchDescriptor& output_descriptor,
+      const dnn::ConvolutionDescriptor& convolution_descriptor,
+      dnn::ActivationMode activation_mode);
+
+  virtual tsl::StatusOr<std::unique_ptr<const dnn::FusedMHARunner>>
+  FusedMHARunnerFromDesc(
+      Stream* stream, const dnn::AlgorithmDesc& algorithm_desc,
+      dnn::FusedMHAKind kind,
+      const dnn::MatmulTensorDescriptor& bmm1_lhs_descriptor,
+      const dnn::MatmulTensorDescriptor& bmm1_rhs_descriptor,
+      const dnn::MatmulTensorDescriptor& bmm2_rhs_descriptor,
+      const dnn::MatmulTensorDescriptor& intermediate_bmm2_lhs_descriptor,
+      const dnn::TensorDescriptor& output_descriptor,
+      std::optional<dnn::TensorDescriptor> activation_descriptor,
+      std::optional<dnn::TensorDescriptor> mask_descriptor,
+      std::optional<dnn::TensorDescriptor> bias_descriptor, double scale,
+      std::optional<double> dropout_rate, std::optional<int64_t> seed);
+
+  virtual tsl::StatusOr<std::unique_ptr<const dnn::FusedMHABackwardRunner>>
+  FusedMHABackwardRunnerFromDesc(
+      Stream* stream, const dnn::AlgorithmDesc& algorithm_desc,
+      dnn::FusedMHAKind kind,
+      const MatmulTensorDescriptor& bmm1_grad_gemm1_rhs_descriptor,
+      const MatmulTensorDescriptor& bmm1_grad_gemm2_rhs_descriptor,
+      const MatmulTensorDescriptor& bmm2_grad_gemm1_lhs_descriptor,
+      const MatmulTensorDescriptor& bmm2_grad_gemm2_rhs_descriptor,
+      const MatmulTensorDescriptor& d_output_descriptor,
+      const TensorDescriptor& d_bmm1_lhs_descriptor,
+      const TensorDescriptor& d_bmm1_rhs_descriptor,
+      const TensorDescriptor& d_bmm2_rhs_descriptor,
+      const TensorDescriptor& d_s_descriptor,
+      std::optional<dnn::TensorDescriptor> mask_descriptor,
+      std::optional<dnn::TensorDescriptor> d_bias_descriptor, double scale,
+      std::optional<double> dropout_rate, std::optional<int64_t> seed);
+
+  virtual bool GetMIOpenConvolveAlgorithms(
+      dnn::ConvolutionKind kind, dnn::DataType element_type, Stream* stream,
+      const dnn::BatchDescriptor& input_descriptor, DeviceMemoryBase input_data,
+      const dnn::FilterDescriptor& filter_descriptor,
+      DeviceMemoryBase filter_data,
+      const dnn::BatchDescriptor& output_descriptor,
+      DeviceMemoryBase output_data,
+      const dnn::ConvolutionDescriptor& convolution_descriptor,
+      ScratchAllocator* scratch_allocator,
+      std::vector<ProfileResult>* out_algorithms);
+
+  // Returns a list of supported rnn algorithms.
+  virtual bool GetRnnAlgorithms(std::vector<AlgorithmDesc>* out_algorithms);
+
+  // Version of DoConvolve that uses pre-quantized 8 bit coefficients.
+  // coefficient_scales specifies the scaling of each column of coefficients:
+  // original float coefficient[row * num_columns + column] =
+  //     quantized coefficient[row * num_columns + column] *
+  //     coefficient_scales[column].
+  virtual bool DoConvolveQuantized(
+      Stream* stream, const dnn::BatchDescriptor& input_descriptor,
+      const DeviceMemory<float>& input_data,
+      const dnn::FilterDescriptor& filter_descriptor,
+      const DeviceMemory<int8_t>& filter_coefficients,
+      const DeviceMemory<float>& coefficient_scales,
+      const dnn::ConvolutionDescriptor& convolution_descriptor,
+      const dnn::BatchDescriptor& output_descriptor,
+      DeviceMemory<float>* output_data) = 0;
+
+  // Same as DoConvolveQuantized above, but int8 filter coefficients.
+  virtual bool DoConvolveQuantized(
+      Stream* stream, const dnn::BatchDescriptor& input_descriptor,
+      const DeviceMemory<float>& input_data,
+      const dnn::FilterDescriptor& filter_descriptor,
+      const DeviceMemory<int16>& filter_coefficients,
+      const DeviceMemory<float>& coefficient_scales,
+      const dnn::ConvolutionDescriptor& convolution_descriptor,
+      const dnn::BatchDescriptor& output_descriptor,
+      DeviceMemory<float>* output_data) = 0;
+
+  // Variation of the above with the weight matrix split into two matrices.
+  // first_weights: Coefficients of the first matrix.
+  // second_weights: Coefficients of the second matrix.
+  // depth_multiplier: specifies the columns of the first matrix and rows
+  // of the second one - first_weights columns = depth_multiplier,
+  // second_weights rows = depth_multiplier *
+  //                       filter_descriptor.input_feature_map_count().
+  // see go/separable for documentation on separable convolutions.
+  virtual bool DoSeparableConvolve(
+      Stream* stream, const BatchDescriptor& input_descriptor,
+      const DeviceMemory<float>& input_data,
+      const FilterDescriptor& filter_descriptor, int depth_multiplier,
+      const DeviceMemory<float>& first_weights,
+      const DeviceMemory<float>& second_weights,
+      const ConvolutionDescriptor& convolution_descriptor,
+      const BatchDescriptor& output_descriptor,
+      DeviceMemory<float>* output_data) = 0;
+
+  // Fully connects the "nodes" (float values) in input_data with
+  // shape input_dimensions to output_data with output_dimensions
+  // using provided weights. This is equivalent to computing a matrix
+  // product, hence the name MatMul.
+  //
+  // A BatchDescriptor has four dimensions: batch, y, x, depth. Matrix products
+  // happen in two dimensions. To get down to two dimensions, we consider the
+  // input y, x and depth dimension as one combined dimension T. For now,
+  // assume that the output height and width are 1 and let OD be the output
+  // depth.
+  //
+  // There are three device memory buffers passed in to this
+  // function. We can now view all three as matrices:
+  //
+  //   input_data: A batch x T matrix
+  //   weights: A T x OD matrix
+  //   output_data: A batch x OD matrix
+  //
+  // This function then computes the matrix product of input_data and
+  // weights and writes the result into output_data.
+  //
+  // Here the weights buffer is in row major order, i.e. the first OD
+  // entries in weights are the first row, the second OD entries in
+  // weights are the second row and so on.
+  //
+  // The case for output width*height > 1 is more complicated. Let K =
+  // OY * OX where OY is the output height and OX is the output
+  // width. Then weights is divided into K sub-arrays W_i, for
+  // i=0,...,k-1, that each represent a T x OD matrix. This function
+  // then computes the K matrix multiplications of input_data with
+  // each W_i. This creates K matrices with dimensions batch x
+  // OD. These K matrices are concatenated horizontally to form one
+  // larger matrix with dimensions batch x (K*OD); note that this is
+  // not the same as concatenating the bytes of the matrices. The
+  // combined matrix can then be interpreted as a tensor with
+  // dimensions (batch, OY, OX, OD). If the output tensor format is
+  // not kBatchYXDepth, this function would then need to arrange for
+  // the output to be in the requested layout, if that is
+  // supported. Note that the case K=1 is equivalent to the
+  // description above. It is recommended to prefer the case K=1.
+  //
+  // Arguments (all borrowed):
+  //  stream: borrowed pointer to the stream that the 'fully connect' operation
+  //    should be enqueued onto.
+  //  output_data: un-owned device memory region in which to place the
+  //    fully connected result.
+  virtual bool DoMatMul(Stream* stream, const DeviceMemory<float>& input_data,
+                        const DeviceMemory<float>& weights,
+                        const dnn::BatchDescriptor& input_dimensions,
+                        const dnn::BatchDescriptor& output_dimensions,
+                        DeviceMemory<float>* output_data) = 0;
+
+  // Version of DoMatMul that uses pre-quantized 8 bit weights.
+  // weight_scales specifies the scaling of each column of weights:
+  // original float weight[row * num_columns + column] =
+  //     quantized_weight[row * nnum_columns + column] * weight_scales[column].
+  virtual bool DoMatMulQuantized(Stream* stream,
+                                 const DeviceMemory<float>& input_data,
+                                 const DeviceMemory<int8_t>& quantized_weights,
+                                 const DeviceMemory<float>& weight_scales,
+                                 const dnn::BatchDescriptor& input_dimensions,
+                                 const dnn::BatchDescriptor& output_dimensions,
+                                 DeviceMemory<float>* output_data) = 0;
+
+  // Version of DoMatMul that uses pre-quantized 16 bit weights.
+  // weight_scales specifies the scaling of each column of weights:
+  // original float weight[row * num_columns + column] =
+  //     quantized_weight[row * nnum_columns + column] * weight_scales[column].
+  virtual bool DoMatMulQuantized(Stream* stream,
+                                 const DeviceMemory<float>& input_data,
+                                 const DeviceMemory<int16>& quantized_weights,
+                                 const DeviceMemory<float>& weight_scales,
+                                 const dnn::BatchDescriptor& input_dimensions,
+                                 const dnn::BatchDescriptor& output_dimensions,
+                                 DeviceMemory<float>* output_data) = 0;
+
+  // Adds biases to the feature maps in input_data producing
+  // output_data. input_data can equal output_data, but must not
+  // partially overlap it.
+  //
+  // Let K = count() * height() * width() and N = feature_map_count()
+  // on dimensions. Then input_value contains K*N values and biases
+  // contains N values. We can thus logically consider input_value to
+  // contain K vectors of N elements each. This function adds biases
+  // to each of those N vectors.
+  //
+  // TODO(broune): This works differently when width() * height() > 1
+  // and the call to ThenBiasAdd() follows a call to ThenMatMul(). In
+  // that case there should be width() * height() *
+  // feature_map_count() biases, but this is not implemented on all
+  // StreamExecutors.
+  //
+  // Arguments (all borrowed):
+  //  stream: borrowed pointer to the stream that the 'bias add' operation
+  //    should be enqueued onto.
+  //  input_data: un-owned device memory region containing the input.
+  //  biases: un-owned device memory region containing biases to add to the
+  //    input.
+  //  dimensions: dimensions of input_data and output_data.
+  //  output_data: un-owned device memory region in which to place the result.
+  virtual bool DoBiasAdd(Stream* stream, const DeviceMemory<float>& input_data,
+                         const DeviceMemory<float>& biases,
+                         const dnn::BatchDescriptor& dimensions,
+                         DeviceMemory<float>* output_data) = 0;
+
+  // Performs a forward pooling operation on input_data, writing to
+  // output_data. See PoolingDescriptor for how to configure the
+  // pooling operation.
+  //
+  // Pooling happens as a window that moves across the Y and X
+  // dimensions of input_data, where each position of the window
+  // yields one output value. E.g. for max pooling, the computed value
+  // is the maximum element in the window. The operation is applied
+  // independently to each batch and at each feature map (depth), so
+  // that the output depth and feature_map_count are the same as for
+  // the input. The output width and height can be different.
+  //
+  // See PoolingDescriptor for how to configure the pooling operation.
+  virtual tsl::Status DoPoolForward(
+      DataType element_type, Stream* stream,
+      const dnn::PoolingDescriptor& pooling_dimensions,
+      const dnn::BatchDescriptor& input_dimensions, DeviceMemoryBase input_data,
+      const dnn::BatchDescriptor& output_dimensions,
+      DeviceMemoryBase output_data, ScratchAllocator* workspace_allocator) = 0;
+
+  virtual tsl::Status DoPoolForward(
+      DataType element_type, Stream* stream,
+      const dnn::PoolingDescriptor& pooling_dimensions,
+      const NumericOptions& numeric_options,
+      const dnn::BatchDescriptor& input_dimensions, DeviceMemoryBase input_data,
+      const dnn::BatchDescriptor& output_dimensions,
+      DeviceMemoryBase output_data, ScratchAllocator* workspace_allocator);
+
+  // Performs differentiation of the pooling operation.
+  virtual tsl::Status DoPoolBackward(
+      DataType element_type, Stream* stream,
+      const dnn::PoolingDescriptor& pooling_dimensions,
+      const dnn::BatchDescriptor& input_dimensions, DeviceMemoryBase input_data,
+      const dnn::BatchDescriptor& output_dimensions,
+      DeviceMemoryBase output_data, DeviceMemoryBase input_diff_data,
+      DeviceMemoryBase output_diff_data,
+      ScratchAllocator* workspace_allocator) = 0;
+
+  virtual tsl::Status DoPoolBackward(
+      DataType element_type, Stream* stream,
+      const dnn::PoolingDescriptor& pooling_dimensions,
+      const NumericOptions& numeric_options,
+      const dnn::BatchDescriptor& input_dimensions, DeviceMemoryBase input_data,
+      const dnn::BatchDescriptor& output_dimensions,
+      DeviceMemoryBase output_data, DeviceMemoryBase input_diff_data,
+      DeviceMemoryBase output_diff_data, ScratchAllocator* workspace_allocator);
+
+  // Applies local response normalization to the values from input_data and
+  // writes the result to output_data.
+  //
+  // See comments on NormalizeDescriptor for a description of local response
+  // normalization.
+  virtual bool DoNormalizeWithDimensions(
+      Stream* stream, const dnn::NormalizeDescriptor& normalize_descriptor,
+      const dnn::BatchDescriptor& dimensions,
+      const DeviceMemory<float>& input_data, DeviceMemory<float>* output_data) {
+    return false;
+  }
+
+  // Performs backpropagation for the normalization operation
+  //
+  // Given raw data, its corresponding normalized output, and a gradient of some
+  // unspecified function with respect to the normalized variables, computes the
+  // gradient of that unspecified function with respect to the raw variables.
+  //
+  // The normalized data input array is expected to match the output that would
+  // be obtained by running the raw data input array through the DoNormalize
+  // method above.
+  //
+  // See comments on NormalizeDescriptor for a description of local response
+  // normalization.
+  virtual bool DoNormalizeBackwardWithDimensions(
+      Stream* stream, const dnn::NormalizeDescriptor& normalize_descriptor,
+      const dnn::BatchDescriptor& dimensions,
+      const DeviceMemory<float>& raw_data,
+      const DeviceMemory<float>& normalized_data,
+      const DeviceMemory<float>& normalized_variable_gradient,
+      DeviceMemory<float>* raw_variable_gradient,
+      ScratchAllocator* workspace_allocator) {
+    return false;
+  }
+
+  // Applies an activation function (see ActivationMode) to all of the values
+  // held on the device in 'input_data', whose dimensions are described by
+  // 'dimensions'.
+  //
+  // Arguments (all borrowed):
+  //  stream: borrowed pointer to the stream that the 'activate' operation
+  //    should be enqueued onto.
+  //  activation_mode: Type of activation to perform.
+  //  input_data: un-owned device memory region which contains the
+  //    activate input.
+  //  output_data: un-owned device memory region in which to place the
+  //    activate result.
+  virtual bool DoActivate(Stream* stream, ActivationMode activation_mode,
+                          const BatchDescriptor& dimensions,
+                          const DeviceMemory<float>& input_data,
+                          DeviceMemory<float>* output_data, uint64_t options) {
+    return false;
+  }
+
+  // Concatenates several layers into one, by concatenating the depth of each
+  // layer at matching x and y coordinates.
+  // The inputs must all have the same width and height, the output will have
+  // the same width and height as the inputs and its depth will be the sum of
+  // the input depths.
+  //
+  // Arguments (all borrowed):
+  //  stream: borrowed pointer to the stream that the 'depth concatenate'
+  // operation should be enqueued onto.
+  //  input_dimensions: The dimensions of each input.
+  //  input_data: un-owned device memory region which contains the
+  //    input data for each input layer.
+  //  output_data: un-owned device memory region in which to place the
+  //    depth concatenate result.
+  virtual bool DoDepthConcatenate(
+      Stream* stream, absl::Span<const dnn::BatchDescriptor> input_dimensions,
+      absl::Span<const DeviceMemory<float>* const> input_data,
+      DeviceMemory<float>* output_data) = 0;
+
+  // Depth to space takes an X by Y image with depth D*M^2 and changes it to an
+  // MX x MY image with depth D. Each input location (x,y) with depth D*M^2 in
+  // the input image is changed to an MxM contiguous area in the output image,
+  // with the values being laid out in the raster order by DepthToSpaceLayout,
+  // and will have a new depth of D.
+  //
+  // Example.
+  // M=2, Din =8, Xin=2, Yin=2. Xout=4, Yout=4,  Dout=2
+  // DepthHeightWidth layout
+  // Values within a 'cell' are at different depths and same x & y.
+  // Input:
+  // abcdefgh  ijklmnop
+  // qrstuvwx  yz012345
+  // Output:
+  // ae bf im jn
+  // cg dh ko lp
+  // qu rv y2 z3
+  // sw tx 04 15
+  //
+  // sqrt_depth_reduction: 'M' in the comment above
+  virtual bool DoDepthToSpace(Stream* stream,
+                              const dnn::BatchDescriptor& input_dimensions,
+                              const DeviceMemory<float>& input_data,
+                              const DepthToSpaceLayout& depth_to_space_layout,
+                              const int& sqrt_depth_reduction,
+                              DeviceMemory<float>* output_data) {
+    return false;
+  }
+
+  // Computes the specified operation (e.g. addition or multiplication)
+  // between corresponding elements in the inputs and stores the result in the
+  // output element.
+  // The inputs and output must all have the same dimensions, but may have
+  // different quantization parameters (min_value and max_value).
+  //
+  // Arguments (all borrowed):
+  //  stream: borrowed pointer to the stream that the 'elementwise operation'
+  // should be enqueued onto.
+  //  operation: The operation to perform.
+  //  input_dimensions: The dimensions of each input.
+  //  input_data: un-owned device memory region which contains the
+  //    input data for each input layer.
+  //  output_dimensions: The dimensions of the output.
+  //  output_data: un-owned device memory region in which to place the
+  //    operation result.
+  virtual bool DoElementwiseOperate(
+      Stream* stream, ElementwiseOperation operation,
+      absl::Span<const dnn::BatchDescriptor> input_dimensions,
+      absl::Span<const DeviceMemory<float>* const> input_data,
+      const dnn::BatchDescriptor& output_dimensions,
+      DeviceMemory<float>* output_data) = 0;
+
+  // Computes the specified operation (e.g. addition or multiplication)
+  // between corresponding elements in the inputs and stores the result in the
+  // output element. Each input is multiplied by a scalar constant and the
+  // result is divided by a scalar constant.
+  // e.g. To perform Z = 0.9*X + 1.1*Y, set the input multiplicands to 9 and 11
+  // and the output divisor to 10.
+  // The inputs and output must all have the same dimensions, but may have
+  // different quantization parameters (min_value and max_value).
+  //
+  // Arguments (all borrowed):
+  //  stream: borrowed pointer to the stream that the 'elementwise operation'
+  // should be enqueued onto.
+  //  operation: The operation to perform.
+  //  input_multiplicands: Amount to scale each input.
+  //  output_divisor: Amount to divide the output.
+  //  input_dimensions: The dimensions of each input.
+  //  input_data: un-owned device memory region which contains the
+  //    input data for each input layer.
+  //  output_dimensions: The dimensions of the output.
+  //  output_data: un-owned device memory region in which to place the
+  //    operation result.
+  virtual bool DoElementwiseOperateScaledQuantized(
+      Stream* stream, ElementwiseOperation operation,
+      absl::Span<const int> input_multiplicands, int output_divisor,
+      absl::Span<const dnn::BatchDescriptor> input_dimensions,
+      absl::Span<const DeviceMemory<float>* const> input_data,
+      const dnn::BatchDescriptor& output_dimensions,
+      DeviceMemory<float>* output_data) {
+    return false;
+  }
+
+  // Pads the input with zeros in the X and Y dimensions. The feature_map
+  // dimension is unchanged.
+  //
+  // Arguments (all borrowed):
+  //  stream: borrowed pointer to the stream that the 'elementwise operation'
+  // should be enqueued onto.
+  //  dimensions: The dimensions of the input.
+  //  input_data: un-owned device memory region which contains the
+  //    input data for the input layer.
+  //  left_pad: Amount to pad the input on the left.
+  //  right_pad: Amount to pad the input on the right.
+  //  top_pad: Amount to pad the input at the top (low Y).
+  //  bottom_pad: Amount to pad the input at the bottom (high Y).
+  //  output_data: un-owned device memory region in which to place the
+  //    padded result.
+  virtual bool DoXYPad(Stream* stream, const dnn::BatchDescriptor& dimensions,
+                       const DeviceMemory<float>& input_data, int64_t left_pad,
+                       int64_t right_pad, int64_t top_pad, int64_t bottom_pad,
+                       DeviceMemory<float>* output_data) = 0;
+
+  // Extracts a slice of the input in the X and Y dimensions. The feature_map
+  // dimension is unchanged.
+  //
+  // Arguments (all borrowed):
+  //  stream: borrowed pointer to the stream that the 'elementwise operation'
+  // should be enqueued onto.
+  //  dimensions: The dimensions of the input.
+  //  input_data: un-owned device memory region which contains the
+  //    input data for the input layer.
+  //  left_trim: Amount to cut off the input on the left.
+  //  right_trim: Amount to cut off the input on the right.
+  //  top_trim: Amount to cut off the input at the top (low y).
+  //  bottom_trim: Amount to cut off the input at the bottom (high Y).
+  //  output_data: un-owned device memory region in which to place the
+  //    padded result.
+  virtual bool DoXYSlice(Stream* stream, const dnn::BatchDescriptor& dimensions,
+                         const DeviceMemory<float>& input_data,
+                         int64_t left_trim, int64_t right_trim,
+                         int64_t top_trim, int64_t bottom_trim,
+                         DeviceMemory<float>* output_data) = 0;
+
+  // Grows the input tensor by replicating the X and Y dimensions. The batch and
+  // depth/feature_map dimensions are unchanged. Currently, the input tensor is
+  // limited to X=1 and Y=1.
+  //
+  // For example, the input has dimensions x=2, y=3, and replicate_x=3,
+  // replicate_y=2. The diagonal elements of the output would be: [x0y0, x1y1,
+  // x0y2, x1y0, x0y1, x1y2].
+  // Here is the example as a picture. input:
+  // AB
+  // CD
+  // EF
+  // broadcast result:
+  // ABABAB
+  // CDCDCD
+  // EFEFEF
+  // ABABAB
+  // CDCDCD
+  // EFEFEF
+  //
+  // Arguments (all borrowed):
+  //  stream: borrowed pointer to the stream that the 'elementwise operation'
+  // should be enqueued onto.
+  //  dimensions: The dimensions of the input.
+  //  input_data: un-owned device memory region which contains the
+  //    input data for the input layer.
+  //  replicate_x: Amount to replicate the input's X dimension.
+  //  replicate_y: Amount to replicate the input's Y dimension.
+  //  output_data: un-owned device memory region in which to place the
+  //    padded result.
+  virtual bool DoXYBroadcast(Stream* stream,
+                             const dnn::BatchDescriptor& dimensions,
+                             const DeviceMemory<float>& input_data,
+                             int64_t replicate_x, int64_t replicate_y,
+                             DeviceMemory<float>* output_data) {
+    return false;
+  }
+
+  // Enqueues an asynchronous memcpy of the *quantized* output of a layer (that
+  // is, bytes instead of scaled floats) into 'host_dst' if they are available
+  // for the underlying DNN implementation. If this quantized output is not
+  // available, false is returned, which will place 'stream' into an error
+  // state.
+  //
+  // Arguments (all borrowed):
+  //  stream: borrowed pointer to the stream that the 'quantized memcpy'
+  //    operation should be enqueued onto.
+  //  gpu_unquantized_src: the device memory that contains the unquantized data
+  //    -- this data should also have a corresponding quantized representation
+  //    on the device for this operation to succeed.
+  //  mode: Type of quantization of the data to write into host_dst.
+  //  host_dst: un-owned host memory region that is mutated in place,
+  //    it is clobbered by the values in 'gpu_unquantized_src' when the enqueued
+  //    (asynchronous) memcpy operation is performed.
+  //  size: size in bytes of the host_dst host memory region.
+  virtual bool DoMemcpyD2HQuantized(
+      Stream* stream, const DeviceMemory<float>& gpu_unquantized_src,
+      QuantizedActivationMode mode, void* host_dst, int64_t size) = 0;
+
+  // Enqueues an asynchronous memcpy of 'host_dst' into the *quantized* input
+  // of a layer (that is, bytes instead of scaled floats) if they are supported
+  // by the underlying DNN implementation. If this quantized input is not
+  // supported, false is returned, which will place 'stream' into an error
+  // state.
+  //
+  // Arguments (all borrowed):
+  //  stream: borrowed pointer to the stream that the 'quantized memcpy'
+  //    operation should be enqueued onto.
+  //  host_src: un-owned host memory region that contains the quantized data.
+  //  size: size in bytes of the host_src host memory region.
+  //  mode: Type of quantization of the data to read from host_src.
+  //  gpu_unquantized_dst: the device memory that is clobbered by the values in
+  //    'host_src' when the enqueued (asynchronous) memcpy operation is
+  //    performed. -- this data should also have a corresponding quantized
+  //    representation on the device for this operation to
+  //    succeed.
+  virtual bool DoMemcpyH2DQuantized(
+      Stream* stream, const void* host_src, int64_t size,
+      QuantizedActivationMode mode,
+      DeviceMemory<float>* gpu_unquantized_dst) = 0;
+
+  // Create an RNN descriptor based on model shapes and configurations.
+  // The caller retains the ownership of the descriptor.
+  //
+  // Arguments:
+  //  num_layers: the number of layers for a RNN model.
+  //  hidden_size: the size of the hidden state.
+  //  input_size: the size of the input state.
+  //  cell_size: the size of the cell state
+  //  input_mode: an enum to specify whether a linear transformation is added
+  //    after the input state. If input_size is different from hidden_size, this
+  //    is required.
+  //  direction_mode: an enum to specify whether this model is unidirectional or
+  //    bidirectional.
+  //  rnn_mode: an enum to specify the type of model to build.
+  //  data_type: an enum to specify the data types used in this model.
+  //  dropout: the dropout threshold between layers. When it is 0., no dropout
+  //    is added.
+  //  seed: a seed for initializing the dropout layers.
+  //  state_allocator: an memory allocator that will be used to store the state
+  //    for dropout layer. The user has to maintain the memory until the model
+  //    is no longer in use.
+  //  use_padded_io: a bool to specify whether the input is using padded IO.
+  virtual tsl::StatusOr<std::unique_ptr<dnn::RnnDescriptor>>
+  createRnnDescriptor(int num_layers, int hidden_size, int input_size,
+                      int cell_size, int batch_size,
+                      dnn::RnnInputMode input_mode,
+                      dnn::RnnDirectionMode direction_mode,
+                      dnn::RnnMode rnn_mode, dnn::DataType data_type,
+                      const dnn::AlgorithmConfig& algorithm_config,
+                      const NumericOptions& numeric_options, float dropout,
+                      uint64_t seed, ScratchAllocator* state_allocator,
+                      bool use_padded_io) {
+    return tsl::Status(absl::StatusCode::kUnimplemented,
+                       "createRnnDescriptor is unimplemented");
+  }
+
+  // Create a RNN sequence descriptor that specifies either the input or output
+  // sequence. The caller retains the ownership of the returned descriptor.
+  //
+  // Arguments:
+  //  max_seq_length: the max length of the sequences.
+  //  batch_size: the size of a minibatch.
+  //  data_size: the size of the state.
+  //  seq_lengths: the lengths of sequences in a batch.
+  //  data_type: an enum to specify the type for the underlying data.
+  virtual tsl::StatusOr<std::unique_ptr<dnn::RnnSequenceTensorDescriptor>>
+  createRnnSequenceTensorDescriptor(int max_seq_length, int batch_size,
+                                    int data_size, dnn::DataType data_type) {
+    return tsl::Status(absl::StatusCode::kUnimplemented,
+                       "createRnnSequenceTensorDescriptor is unimplemented");
+  }
+
+  virtual tsl::StatusOr<std::unique_ptr<dnn::RnnSequenceTensorDescriptor>>
+  createRnnSequenceTensorDescriptor(int max_seq_length, int batch_size,
+                                    int data_size,
+                                    const absl::Span<const int>& seq_lengths,
+                                    bool time_major, dnn::DataType data_type) {
+    return tsl::Status(absl::StatusCode::kUnimplemented,
+                       "createRnnSequenceTensorDescriptor is unimplemented");
+  }
+
+  // Create an RNN state descriptor that specifies the input or hidden state.
+  // The caller retains the ownership of the returned descriptor.
+  virtual tsl::StatusOr<std::unique_ptr<dnn::RnnStateTensorDescriptor>>
+  createRnnStateTensorDescriptor(int num_layer, int batch_size, int data_size,
+                                 dnn::DataType data_type) {
+    return tsl::Status(absl::StatusCode::kUnimplemented,
+                       "createRnnStateTensorDescriptor is unimplemented");
+  }
+
+  // Enqueue a forward operation of the RNN model onto the stream.
+  //
+  // Arguments:
+  //  stream: pointer to the stream where this operation should be enqueued to.
+  //  rnn_desc: a RNN descriptor created by createRnnDescriptor.
+  //  input_desc: descriptor for the input sequence.
+  //  input_data: the device memory region that contains the input data.
+  //  input_h_desc: descriptor for the input "h" state.
+  //  input_h_data: the device memory region that contains the input "h" data.
+  //  input_c_desc: descriptor for the input "c" state.
+  //  input_c_data: the device memory region that contains the input "c" data.
+  //    This must be specified for LSTM models.
+  //  params: the device memory region that contains the parameters used in this
+  //    model.
+  //  output_desc: descriptor for the output sequence.
+  //  output_data: the memory region that stores the output sequence data.
+  //  output_h_desc: descriptor for the output "h" state.
+  //  output_h_data: the memory region that stores the output "h" data.
+  //  output_c_desc: descriptor for the output "c" state.
+  //  output_c_data: the memory region that stores the output "c" data. This
+  //    must be specified for LSTM models.
+  //  is_training: whether this is used in training or inference. That decides
+  //    whether respace_space data need to be produced.
+  //  reserve_space_allocator: if "is_training" is true, an memory allocator
+  //    to create memory that holds the produced reserve_space. The caller is
+  //  retains the data and feed it to the backward pass.
+  //  workspace_allocator: an allocator to create temporary workspace used in
+  //    this kernel. The caller is responsible for retaining the memory long
+  //    enough for the lifespan of this operation, and recycles afterwards.
+  virtual bool DoRnnForward(Stream* stream, const dnn::RnnDescriptor& rnn_desc,
+                            const dnn::RnnSequenceTensorDescriptor& input_desc,
+                            const DeviceMemory<Eigen::half>& input_data,
+                            const DeviceMemory<int>& seq_lengths_data,
+                            const dnn::RnnStateTensorDescriptor& input_h_desc,
+                            const DeviceMemory<Eigen::half>& input_h_data,
+                            const dnn::RnnStateTensorDescriptor& input_c_desc,
+                            const DeviceMemory<Eigen::half>& input_c_data,
+                            const DeviceMemory<Eigen::half>& params,
+                            const dnn::RnnSequenceTensorDescriptor& output_desc,
+                            DeviceMemory<Eigen::half>* output_data,
+                            const dnn::RnnStateTensorDescriptor& output_h_desc,
+                            DeviceMemory<Eigen::half>* output_h_data,
+                            const dnn::RnnStateTensorDescriptor& output_c_desc,
+                            DeviceMemory<Eigen::half>* output_c_data,
+                            bool is_training,
+                            ScratchAllocator* reserve_space_allocator,
+                            ScratchAllocator* workspace_allocator,
+                            dnn::ProfileResult* output_profile_result) {
+    return false;
+  }
+
+  virtual bool DoRnnForward(Stream* stream, const dnn::RnnDescriptor& rnn_desc,
+                            const dnn::RnnSequenceTensorDescriptor& input_desc,
+                            const DeviceMemory<float>& input_data,
+                            const DeviceMemory<int>& seq_lengths_data,
+                            const dnn::RnnStateTensorDescriptor& input_h_desc,
+                            const DeviceMemory<float>& input_h_data,
+                            const dnn::RnnStateTensorDescriptor& input_c_desc,
+                            const DeviceMemory<float>& input_c_data,
+                            const DeviceMemory<float>& params,
+                            const dnn::RnnSequenceTensorDescriptor& output_desc,
+                            DeviceMemory<float>* output_data,
+                            const dnn::RnnStateTensorDescriptor& output_h_desc,
+                            DeviceMemory<float>* output_h_data,
+                            const dnn::RnnStateTensorDescriptor& output_c_desc,
+                            DeviceMemory<float>* output_c_data,
+                            bool is_training,
+                            ScratchAllocator* reserve_space_allocator,
+                            ScratchAllocator* workspace_allocator,
+                            dnn::ProfileResult* output_profile_result) {
+    return false;
+  }
+
+  virtual bool DoRnnForward(Stream* stream, const dnn::RnnDescriptor& rnn_desc,
+                            const dnn::RnnSequenceTensorDescriptor& input_desc,
+                            const DeviceMemory<double>& input_data,
+                            const DeviceMemory<int>& seq_lengths_data,
+                            const dnn::RnnStateTensorDescriptor& input_h_desc,
+                            const DeviceMemory<double>& input_h_data,
+                            const dnn::RnnStateTensorDescriptor& input_c_desc,
+                            const DeviceMemory<double>& input_c_data,
+                            const DeviceMemory<double>& params,
+                            const dnn::RnnSequenceTensorDescriptor& output_desc,
+                            DeviceMemory<double>* output_data,
+                            const dnn::RnnStateTensorDescriptor& output_h_desc,
+                            DeviceMemory<double>* output_h_data,
+                            const dnn::RnnStateTensorDescriptor& output_c_desc,
+                            DeviceMemory<double>* output_c_data,
+                            bool is_training,
+                            ScratchAllocator* reserve_space_allocator,
+                            ScratchAllocator* workspace_allocator,
+                            dnn::ProfileResult* output_profile_result) {
+    return false;
+  }
+  // Enqueue a backward operation of the RNN model onto the stream.
+  //
+  // Arguments:
+  //  stream: pointer to the stream where this operation should be enqueued to.
+  //  rnn_desc: a RNN descriptor created by createRnnDescriptor.
+  //  input_desc: descriptor for the input sequence.
+  //  input_data: the device memory region that contains the input data.
+  //  input_h_desc: descriptor for the input "h" state.
+  //  input_h_data: the device memory region that contains the input "h" data.
+  //  input_c_desc: descriptor for the input "c" state.
+  //  input_c_data: the device memory region that contains the input "c" data.
+  //    This must be specified for LSTM models.
+  //  params: the device memory region that contains the parameters used in this
+  //    model.
+  //  output_desc: descriptor for the output sequence.
+  //  output_data: the memory region that stores the output sequence data.
+  //  output_h_desc: descriptor for the output "h" state.
+  //  output_h_data: the memory region that stores the output "h" data.
+  //  output_c_desc: descriptor for the output "c" state.
+  //  output_c_data: the memory region that stores the output "c" data. This
+  //    must be specified for LSTM models.
+  //  output_backprop_data: the device memory region that contains the backprop
+  //    to the output sequence.
+  //  output_h_backprop_data: the device memory region that contains the
+  //    backprop to the output "h" state.
+  //  output_c_backprop_data: the device memory region that contains the
+  //    backprop to the output "c" state.
+  //  input_backprop_data: the device memory region that stores the backprop
+  //    to the input sequence.
+  //  input_h_backprop_data: the device memory region that stores the backprop
+  //    to the input "h" state.
+  //  input_c_backprop_data: the device memory region that stores the backprop
+  //    to the input "c" state.
+  //  params_backprop_data: the device memory region that stores the backprop
+  //    to the parameters.
+  //  reserve_space_data: the reserve_space data that is produced by the forward
+  //    operation. This memory region could be modified by this operation.
+  //  workspace_allocator: a memory allocator that creates the temporary
+  //    workspace memory used by this operation. The caller is responsible for
+  //    keeping the memory alive long enough for this operation, and recylces
+  //    afterwards.
+  virtual bool DoRnnBackward(
+      Stream* stream, const dnn::RnnDescriptor& rnn_desc,
+      const dnn::RnnSequenceTensorDescriptor& input_desc,
+      const DeviceMemory<Eigen::half>& input_data,
+      const DeviceMemory<int>& seq_lengths_data,
+      const dnn::RnnStateTensorDescriptor& input_h_desc,
+      const DeviceMemory<Eigen::half>& input_h_data,
+      const dnn::RnnStateTensorDescriptor& input_c_desc,
+      const DeviceMemory<Eigen::half>& input_c_data,
+      const DeviceMemory<Eigen::half>& params,
+      const dnn::RnnSequenceTensorDescriptor& output_desc,
+      const DeviceMemory<Eigen::half>& output_data,
+      const dnn::RnnStateTensorDescriptor& output_h_desc,
+      const DeviceMemory<Eigen::half>& output_h_data,
+      const dnn::RnnStateTensorDescriptor& output_c_desc,
+      const DeviceMemory<Eigen::half>& output_c_data,
+      const DeviceMemory<Eigen::half>& output_backprop_data,
+      const DeviceMemory<Eigen::half>& output_h_backprop_data,
+      const DeviceMemory<Eigen::half>& output_c_backprop_data,
+      DeviceMemory<Eigen::half>* input_backprop_data,
+      DeviceMemory<Eigen::half>* input_h_backprop_data,
+      DeviceMemory<Eigen::half>* input_c_backprop_data,
+      DeviceMemory<Eigen::half>* params_backprop_data,
+      DeviceMemory<uint8_t>* reserve_space_data,
+      ScratchAllocator* workspace_allocator,
+      dnn::ProfileResult* output_profile_result) {
+    return false;
+  }
+
+  virtual bool DoRnnBackward(
+      Stream* stream, const dnn::RnnDescriptor& rnn_desc,
+      const dnn::RnnSequenceTensorDescriptor& input_desc,
+      const DeviceMemory<float>& input_data,
+      const DeviceMemory<int>& seq_lengths_data,
+      const dnn::RnnStateTensorDescriptor& input_h_desc,
+      const DeviceMemory<float>& input_h_data,
+      const dnn::RnnStateTensorDescriptor& input_c_desc,
+      const DeviceMemory<float>& input_c_data,
+      const DeviceMemory<float>& params,
+      const dnn::RnnSequenceTensorDescriptor& output_desc,
+      const DeviceMemory<float>& output_data,
+      const dnn::RnnStateTensorDescriptor& output_h_desc,
+      const DeviceMemory<float>& output_h_data,
+      const dnn::RnnStateTensorDescriptor& output_c_desc,
+      const DeviceMemory<float>& output_c_data,
+      const DeviceMemory<float>& output_backprop_data,
+      const DeviceMemory<float>& output_h_backprop_data,
+      const DeviceMemory<float>& output_c_backprop_data,
+      DeviceMemory<float>* input_backprop_data,
+      DeviceMemory<float>* input_h_backprop_data,
+      DeviceMemory<float>* input_c_backprop_data,
+      DeviceMemory<float>* params_backprop_data,
+      DeviceMemory<uint8_t>* reserve_space_data,
+      ScratchAllocator* workspace_allocator,
+      dnn::ProfileResult* output_profile_result) {
+    return false;
+  }
+
+  virtual bool DoRnnBackward(
+      Stream* stream, const dnn::RnnDescriptor& rnn_desc,
+      const dnn::RnnSequenceTensorDescriptor& input_desc,
+      const DeviceMemory<double>& input_data,
+      const DeviceMemory<int>& seq_lengths_data,
+      const dnn::RnnStateTensorDescriptor& input_h_desc,
+      const DeviceMemory<double>& input_h_data,
+      const dnn::RnnStateTensorDescriptor& input_c_desc,
+      const DeviceMemory<double>& input_c_data,
+      const DeviceMemory<double>& params,
+      const dnn::RnnSequenceTensorDescriptor& output_desc,
+      const DeviceMemory<double>& output_data,
+      const dnn::RnnStateTensorDescriptor& output_h_desc,
+      const DeviceMemory<double>& output_h_data,
+      const dnn::RnnStateTensorDescriptor& output_c_desc,
+      const DeviceMemory<double>& output_c_data,
+      const DeviceMemory<double>& output_backprop_data,
+      const DeviceMemory<double>& output_h_backprop_data,
+      const DeviceMemory<double>& output_c_backprop_data,
+      DeviceMemory<double>* input_backprop_data,
+      DeviceMemory<double>* input_h_backprop_data,
+      DeviceMemory<double>* input_c_backprop_data,
+      DeviceMemory<double>* params_backprop_data,
+      DeviceMemory<uint8_t>* reserve_space_data,
+      ScratchAllocator* workspace_allocator,
+      dnn::ProfileResult* output_profile_result) {
+    return false;
+  }
+
+  template <typename ElementType>
+  tsl::Status PrepareForCtcLoss(Stream* stream,
+                                const RnnStateTensorDescriptor& probs_desc,
+                                DeviceMemory<ElementType> probs_data,
+                                const RnnStateTensorDescriptor& grads_desc,
+                                absl::Span<const int> labels_data,
+                                absl::Span<const int> labels_lengths_data,
+                                absl::Span<const int> input_lengths_data,
+                                const NumericOptions& numeric_options,
+                                ScratchAllocator* workspace_allocator,
+                                DeviceMemory<uint8_t>* scratch_memory,
+                                int* ctc_loss_algo_id) {
+    return DoPrepareForCtcLoss(
+        stream, ToDataType<ElementType>::value, probs_desc, grads_desc,
+        labels_data, labels_lengths_data, input_lengths_data, numeric_options,
+        workspace_allocator, scratch_memory, ctc_loss_algo_id);
+  }
+
+  // Enqueue a CTC Loss operation onto the stream.
+  //
+  // Arguments:
+  //  stream: pointer to the stream where this operation should be enqueued to.
+  //  element_type: date type of the input tensors
+  //  probs_desc: specifies the shape and the data layout of the input tensor.
+  //  probs_data: the device memory region that contains the input tensor.
+  //  labels_data: the device memory region that contains the labels_value
+  //    tensor.
+  //  labels_lengths_data: the device memory region that contains the
+  //    labels_lengths tensor
+  //  input_lengths_data: the device memory region that contains the seq_lengths
+  //    tensor
+  //  costs_data: the device memory region that contains the costs tensor.
+  //  grads_desc: specifies the shape and the data layout of the grads tensor.
+  //  grads_data: the device memory region that contains the grads tensor.
+  //  ctc_loss_desc: a CTCLoss descriptor.
+  //  workspace_allocator: a memory allocator that creates the temporary
+  //    workspace memory used by this operation. The caller is responsible for
+  //    keeping the memory alive long enough for this operation, and recylces
+  //    afterwards.
+  virtual tsl::Status DoCtcLoss(
+      Stream* stream, dnn::DataType element_type,
+      const RnnStateTensorDescriptor& probs_desc,
+      const DeviceMemoryBase probs_data, absl::Span<const int> labels_data,
+      absl::Span<const int> labels_lengths_data,
+      absl::Span<const int> input_lengths_data, DeviceMemoryBase costs_data,
+      const RnnStateTensorDescriptor& grads_desc, DeviceMemoryBase grads_data,
+      DeviceMemory<uint8_t> scratch_memory, int ctc_loss_algo_id);
+
+  template <typename ElementType>
+  bool DoCtcLoss(Stream* stream,
+                 const dnn::RnnStateTensorDescriptor& probs_desc,
+                 const DeviceMemory<ElementType>& probs_data,
+                 absl::Span<const int> labels_data,
+                 absl::Span<const int> labels_lengths_data,
+                 absl::Span<const int> input_lengths_data,
+                 DeviceMemory<ElementType>* costs_data,
+                 const dnn::RnnStateTensorDescriptor& grads_desc,
+                 DeviceMemory<ElementType>* grads_data,
+                 DeviceMemory<uint8_t>* scratch_memory, int ctc_loss_algo_id) {
+    return IsStatusOk(
+        DoCtcLoss(stream, ToDataType<ElementType>::value, probs_desc,
+                  probs_data, labels_data, labels_lengths_data,
+                  input_lengths_data, *costs_data, grads_desc, *grads_data,
+                  *scratch_memory, ctc_loss_algo_id),
+        false);
+  }
+
+  // Transforms a tensor into another tensor with a different layout and/or data
+  // type.
+  //
+  // Arguments:
+  //  stream: pointer to the stream where this operation should be enqueued to.
+  //  input_desc: specifies the shape and the data layout of the input tensor.
+  //  input_type: the data type of the input tensor.
+  //  input_data: the device memory region that contains the input tensor.
+  //  output_desc: specifies the shape and the data layout of the output tensor.
+  //  output_type: the data type of the output tensor.
+  //  scale: an element-wise scaling factor to apply.
+  //  output_data: the device memory region that contains the output tensor.
+  virtual bool DoTransformTensor(Stream* stream,
+                                 const dnn::BatchDescriptor& input_desc,
+                                 dnn::DataType input_type,
+                                 const DeviceMemoryBase& input_data,
+                                 const dnn::BatchDescriptor& output_desc,
+                                 dnn::DataType output_type, float scale,
+                                 DeviceMemoryBase* output_data) {
+    return false;
+  }
+
+  // Notifies that a stream is being destroyed and should be invalidated from
+  // any internal caching.  This exists to allow the CUDA implementation to
+  // avoid redundant cudnnSetStream calls without risking problems when a stream
+  // is destroyed and a new stream later created in the same memory.
+  virtual void NotifyStreamDestroyed(Stream* stream) {}
+
+ protected:
+  // Returns whether status is 'ok', and potentially logs the error.
+  static bool IsStatusOk(const tsl::Status& status, bool report_error);
+
+ private:
+  virtual tsl::Status DoPrepareForConvolution(
+      ConvolutionKind kind, DataType element_type, Stream* stream,
+      const BatchDescriptor& batch_descriptor, DeviceMemoryBase input_data,
+      const FilterDescriptor& filter_descriptor, DeviceMemoryBase filter_data,
+      const BatchDescriptor& output_descriptor, DeviceMemoryBase output_data,
+      const ConvolutionDescriptor& convolution_descriptor,
+      const AlgorithmConfig& algorithm_config,
+      ScratchAllocator* scratch_allocator, AlgorithmDesc* algorithm_desc,
+      DeviceMemory<uint8_t>* scratch_memory) {
+    *algorithm_desc = {};
+    *scratch_memory = {};
+    return ::tsl::OkStatus();
+  }
+
+  virtual tsl::Status DoPrepareForCtcLoss(
+      Stream* stream, DataType element_type,
+      const RnnStateTensorDescriptor& probs_desc,
+      const RnnStateTensorDescriptor& grads_desc,
+      absl::Span<const int> labels_data,
+      absl::Span<const int> labels_lengths_data,
+      absl::Span<const int> input_lengths_data,
+      const NumericOptions& numeric_options,
+      ScratchAllocator* scratch_allocator,
+      DeviceMemory<uint8_t>* scratch_memory, int* ctc_loss_algo_id) {
+    *scratch_memory = {};
+    return ::tsl::OkStatus();
+  }
+
+  DnnSupport(const DnnSupport&) = delete;
+  void operator=(const DnnSupport&) = delete;
+};
+
+}  // namespace dnn
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_DNN_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/event.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/event.h
new file mode 100644
index 0000000000000000000000000000000000000000..8721c9d53d559b512726b88e59efffa156ace847
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/event.h
@@ -0,0 +1,89 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_STREAM_EXECUTOR_EVENT_H_
+#define XLA_STREAM_EXECUTOR_EVENT_H_
+
+#include <memory>
+
+#include "xla/stream_executor/platform/port.h"
+#include "tsl/platform/status.h"
+
+namespace stream_executor {
+
+namespace internal {
+class EventInterface;
+}
+
+class Stream;
+class StreamExecutor;
+
+// The Event class, when supported by a platform, enables low-overhead status
+// reporting for a Stream. An Event is inserted at a location in a stream via
+// the Stream::ThenRecordEvent() API. From then on, the Event's status can be
+// monitored via the nonblocking Event::PollForStatus() call.
+class Event {
+ public:
+  // Potential states for an Event. If PollForStatus() returns anything aside
+  // from kPending or kComplete, an error has occurred; kUnknown is a bad state.
+  // Not all implementations are able to return all enumeration values. Refer to
+  // the platform-specific implementation for details.
+  enum class Status {
+    kUnknown,
+    kError,
+    kPending,
+    kComplete,
+  };
+
+  explicit Event(StreamExecutor* stream_exec);  // NOLINT
+
+  // Releases any resources held by the Event object.
+  ~Event();
+
+  // Performs any platform-specific or potentially error-generating
+  // initialization.
+  bool Init();
+
+  // Returns the current Status for the event.
+  Status PollForStatus();
+
+  // Blocks `stream` on this event. `stream` is a raw platform-specific
+  // stream (e.g. GpuStreamHandle).
+  tsl::Status WaitForEventOnExternalStream(std::intptr_t stream);
+
+  // Returns a pointer to the underlying platform-specific implementation.
+  internal::EventInterface* implementation() { return implementation_.get(); }
+
+  Event(Event&&);
+  Event& operator=(Event&&);
+
+ private:
+  friend class Stream;
+
+  // Pointer to the StreamExecutor interface used to create this object.
+  // Not owned.
+  StreamExecutor* stream_exec_;
+
+  // Pointer to the platform-specific EventInterface implementation underlying
+  // the object. Owned.
+  std::unique_ptr<internal::EventInterface> implementation_;
+
+  Event(const Event&) = delete;
+  void operator=(const Event&) = delete;
+};
+
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_EVENT_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/executor_cache.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/executor_cache.h
new file mode 100644
index 0000000000000000000000000000000000000000..6e9668afdbf39da6f2c04cb19123c4e30dabb3d7
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/executor_cache.h
@@ -0,0 +1,90 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_STREAM_EXECUTOR_EXECUTOR_CACHE_H_
+#define XLA_STREAM_EXECUTOR_EXECUTOR_CACHE_H_
+
+#include <functional>
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include "absl/base/thread_annotations.h"
+#include "absl/container/node_hash_map.h"
+#include "absl/synchronization/mutex.h"
+#include "xla/stream_executor/platform.h"
+#include "xla/stream_executor/platform/port.h"
+#include "tsl/platform/statusor.h"
+
+namespace stream_executor {
+
+// Forward declare.
+class StreamExecutor;
+
+// Utility class to allow Platform objects to manage cached StreamExecutors.
+// Thread-safe.
+class ExecutorCache {
+ public:
+  using ExecutorFactory =
+      std::function<tsl::StatusOr<std::unique_ptr<StreamExecutor>>()>;
+
+  ExecutorCache();
+  ~ExecutorCache();
+
+  // Looks up 'config' in the cache. Returns a pointer to the existing executor,
+  // if already present, or creates it using 'factory', if it does not.
+  // Factories may be executed concurrently for different device ordinals.
+  tsl::StatusOr<StreamExecutor*> GetOrCreate(const StreamExecutorConfig& config,
+                                             const ExecutorFactory& factory);
+
+  // Returns a pointer to the described executor (if one with a matching config
+  // has been created), or a NOT_FOUND status.
+  tsl::StatusOr<StreamExecutor*> Get(const StreamExecutorConfig& config);
+
+  // Destroys all Executors and clears the cache.
+  // Performs no synchronization with the executors - undefined behavior may
+  // occur if any executors are active!
+  void DestroyAllExecutors();
+
+ private:
+  // Each Entry contains zero or more cached executors for a device ordinal.
+  struct Entry {
+    ~Entry();
+
+    // Mutex that guards the contents of each entry. The 'mutex_' of the
+    // ExecutorCache class protects both the 'cache_' and the existence of each
+    // Entry, but not the Entry's contents. 'configurations_mutex' protects the
+    // contents of the entry after 'mutex_' has been dropped.
+    absl::Mutex configurations_mutex;
+
+    // Vector of cached {config, executor} pairs.
+    std::vector<
+        std::pair<StreamExecutorConfig, std::unique_ptr<StreamExecutor>>>
+        configurations ABSL_GUARDED_BY(configurations_mutex);
+  };
+
+  // Maps ordinal number to a list of cached executors for that ordinal.
+  // We key off of ordinal (instead of just looking up all fields in the
+  // StreamExecutorConfig) for a slight improvement in lookup time.
+  absl::Mutex mutex_;
+  absl::node_hash_map<int, Entry> cache_ ABSL_GUARDED_BY(mutex_);
+
+  ExecutorCache(const ExecutorCache&) = delete;
+  void operator=(const ExecutorCache&) = delete;
+};
+
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_EXECUTOR_CACHE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/fft.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/fft.h
new file mode 100644
index 0000000000000000000000000000000000000000..88a383b84cb1e74e762260fe54fbc803546ef4a0
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/fft.h
@@ -0,0 +1,270 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// Exposes the family of FFT routines as pre-canned high performance calls for
+// use in conjunction with the StreamExecutor abstraction.
+//
+// Note that this interface is optionally supported by platforms..
+//
+// This abstraction makes it simple to entrain FFT operations on GPU data into
+// a Stream -- users typically will not use this API directly, but will use the
+// Stream builder methods to entrain these operations "under the hood". For
+// example:
+//
+//  DeviceMemory<std::complex<float>> x =
+//    stream_exec->AllocateArray<std::complex<float>>(1024);
+//  DeviceMemory<std::complex<float>> y =
+//    stream_exec->AllocateArray<std::complex<float>>(1024);
+//  // ... populate x and y ...
+//  Stream stream{stream_exec};
+//  std::unique_ptr<Plan> plan =
+//     stream_exec.AsFft()->Create1dPlan(&stream, 1024, Type::kC2CForward);
+//  stream
+//    .Init()
+//    .ThenFft(plan.get(), x, &y);
+//  TF_CHECK_OK(stream.BlockHostUntilDone());
+//
+// By using stream operations in this manner the user can easily intermix custom
+// kernel launches (via StreamExecutor::ThenLaunch()) with these pre-canned FFT
+// routines.
+
+#ifndef XLA_STREAM_EXECUTOR_FFT_H_
+#define XLA_STREAM_EXECUTOR_FFT_H_
+
+#include <complex>
+#include <memory>
+
+#include "xla/stream_executor/platform/port.h"
+
+namespace stream_executor {
+
+class Stream;
+template <typename ElemT>
+class DeviceMemory;
+class ScratchAllocator;
+
+namespace fft {
+
+// Specifies FFT input and output types, and the direction.
+// R, D, C, and Z stand for SP real, DP real, SP complex, and DP complex.
+enum class Type {
+  kInvalid,
+  kC2CForward,
+  kC2CInverse,
+  kC2R,
+  kR2C,
+  kZ2ZForward,
+  kZ2ZInverse,
+  kZ2D,
+  kD2Z
+};
+
+// FFT plan class. Each FFT implementation should define a plan class that is
+// derived from this class. It does not provide any interface but serves
+// as a common type that is used to execute the plan.
+class Plan {
+ public:
+  virtual ~Plan() {}
+};
+
+// FFT support interface -- this can be derived from a GPU executor when the
+// underlying platform has an FFT library implementation available. See
+// StreamExecutor::AsFft().
+//
+// This support interface is not generally thread-safe; it is only thread-safe
+// for the CUDA platform (cuFFT) usage; host side FFT support is known
+// thread-compatible, but not thread-safe.
+class FftSupport {
+ public:
+  virtual ~FftSupport() {}
+
+  // Creates a 1d FFT plan.
+  virtual std::unique_ptr<Plan> Create1dPlan(Stream *stream, uint64_t num_x,
+                                             Type type, bool in_place_fft) = 0;
+
+  // Creates a 2d FFT plan.
+  virtual std::unique_ptr<Plan> Create2dPlan(Stream *stream, uint64_t num_x,
+                                             uint64_t num_y, Type type,
+                                             bool in_place_fft) = 0;
+
+  // Creates a 3d FFT plan.
+  virtual std::unique_ptr<Plan> Create3dPlan(Stream *stream, uint64_t num_x,
+                                             uint64_t num_y, uint64 num_z,
+                                             Type type, bool in_place_fft) = 0;
+
+  // Creates a 1d FFT plan with scratch allocator.
+  virtual std::unique_ptr<Plan> Create1dPlanWithScratchAllocator(
+      Stream *stream, uint64_t num_x, Type type, bool in_place_fft,
+      ScratchAllocator *scratch_allocator) = 0;
+
+  // Creates a 2d FFT plan with scratch allocator.
+  virtual std::unique_ptr<Plan> Create2dPlanWithScratchAllocator(
+      Stream *stream, uint64_t num_x, uint64 num_y, Type type,
+      bool in_place_fft, ScratchAllocator *scratch_allocator) = 0;
+
+  // Creates a 3d FFT plan with scratch allocator.
+  virtual std::unique_ptr<Plan> Create3dPlanWithScratchAllocator(
+      Stream *stream, uint64_t num_x, uint64 num_y, uint64 num_z, Type type,
+      bool in_place_fft, ScratchAllocator *scratch_allocator) = 0;
+
+  // Creates a batched FFT plan.
+  //
+  // stream:          The GPU stream in which the FFT runs.
+  // rank:            Dimensionality of the transform (1, 2, or 3).
+  // elem_count:      Array of size rank, describing the size of each dimension.
+  // input_embed, output_embed:
+  //                  Pointer of size rank that indicates the storage dimensions
+  //                  of the input/output data in memory. If set to null_ptr all
+  //                  other advanced data layout parameters are ignored.
+  // input_stride:    Indicates the distance (number of elements; same below)
+  //                  between two successive input elements.
+  // input_distance:  Indicates the distance between the first element of two
+  //                  consecutive signals in a batch of the input data.
+  // output_stride:   Indicates the distance between two successive output
+  //                  elements.
+  // output_distance: Indicates the distance between the first element of two
+  //                  consecutive signals in a batch of the output data.
+  virtual std::unique_ptr<Plan> CreateBatchedPlan(
+      Stream *stream, int rank, uint64_t *elem_count, uint64 *input_embed,
+      uint64_t input_stride, uint64 input_distance, uint64 *output_embed,
+      uint64_t output_stride, uint64 output_distance, Type type,
+      bool in_place_fft, int batch_count) = 0;
+
+  // Creates a batched FFT plan with scratch allocator.
+  //
+  // stream:          The GPU stream in which the FFT runs.
+  // rank:            Dimensionality of the transform (1, 2, or 3).
+  // elem_count:      Array of size rank, describing the size of each dimension.
+  // input_embed, output_embed:
+  //                  Pointer of size rank that indicates the storage dimensions
+  //                  of the input/output data in memory. If set to null_ptr all
+  //                  other advanced data layout parameters are ignored.
+  // input_stride:    Indicates the distance (number of elements; same below)
+  //                  between two successive input elements.
+  // input_distance:  Indicates the distance between the first element of two
+  //                  consecutive signals in a batch of the input data.
+  // output_stride:   Indicates the distance between two successive output
+  //                  elements.
+  // output_distance: Indicates the distance between the first element of two
+  //                  consecutive signals in a batch of the output data.
+  virtual std::unique_ptr<Plan> CreateBatchedPlanWithScratchAllocator(
+      Stream *stream, int rank, uint64_t *elem_count, uint64 *input_embed,
+      uint64_t input_stride, uint64 input_distance, uint64 *output_embed,
+      uint64_t output_stride, uint64 output_distance, Type type,
+      bool in_place_fft, int batch_count,
+      ScratchAllocator *scratch_allocator) = 0;
+
+  // Updates the plan's work area with space allocated by a new scratch
+  // allocator. This facilitates plan reuse with scratch allocators.
+  //
+  // This requires that the plan was originally created using a scratch
+  // allocator, as otherwise scratch space will have been allocated internally
+  // by cuFFT.
+  virtual void UpdatePlanWithScratchAllocator(
+      Stream *stream, Plan *plan, ScratchAllocator *scratch_allocator) = 0;
+
+  // Computes complex-to-complex FFT in the transform direction as specified
+  // by direction parameter.
+  virtual bool DoFft(Stream *stream, Plan *plan,
+                     const DeviceMemory<std::complex<float>> &input,
+                     DeviceMemory<std::complex<float>> *output) = 0;
+  virtual bool DoFft(Stream *stream, Plan *plan,
+                     const DeviceMemory<std::complex<double>> &input,
+                     DeviceMemory<std::complex<double>> *output) = 0;
+
+  // Computes real-to-complex FFT in forward direction.
+  virtual bool DoFft(Stream *stream, Plan *plan,
+                     const DeviceMemory<float> &input,
+                     DeviceMemory<std::complex<float>> *output) = 0;
+  virtual bool DoFft(Stream *stream, Plan *plan,
+                     const DeviceMemory<double> &input,
+                     DeviceMemory<std::complex<double>> *output) = 0;
+
+  // Computes complex-to-real FFT in inverse direction.
+  virtual bool DoFft(Stream *stream, Plan *plan,
+                     const DeviceMemory<std::complex<float>> &input,
+                     DeviceMemory<float> *output) = 0;
+  virtual bool DoFft(Stream *stream, Plan *plan,
+                     const DeviceMemory<std::complex<double>> &input,
+                     DeviceMemory<double> *output) = 0;
+
+ protected:
+  FftSupport() {}
+
+ private:
+  FftSupport(const FftSupport &) = delete;
+  void operator=(const FftSupport &) = delete;
+};
+
+// Macro used to quickly declare overrides for abstract virtuals in the
+// fft::FftSupport base class. Assumes that it's emitted somewhere inside the
+// ::stream_executor namespace.
+#define TENSORFLOW_STREAM_EXECUTOR_GPU_FFT_SUPPORT_OVERRIDES                   \
+  std::unique_ptr<fft::Plan> Create1dPlan(Stream *stream, uint64_t num_x,      \
+                                          fft::Type type, bool in_place_fft)   \
+      override;                                                                \
+  std::unique_ptr<fft::Plan> Create2dPlan(Stream *stream, uint64_t num_x,      \
+                                          uint64_t num_y, fft::Type type,      \
+                                          bool in_place_fft) override;         \
+  std::unique_ptr<fft::Plan> Create3dPlan(                                     \
+      Stream *stream, uint64_t num_x, uint64 num_y, uint64 num_z,              \
+      fft::Type type, bool in_place_fft) override;                             \
+  std::unique_ptr<fft::Plan> Create1dPlanWithScratchAllocator(                 \
+      Stream *stream, uint64_t num_x, fft::Type type, bool in_place_fft,       \
+      ScratchAllocator *scratch_allocator) override;                           \
+  std::unique_ptr<fft::Plan> Create2dPlanWithScratchAllocator(                 \
+      Stream *stream, uint64_t num_x, uint64 num_y, fft::Type type,            \
+      bool in_place_fft, ScratchAllocator *scratch_allocator) override;        \
+  std::unique_ptr<fft::Plan> Create3dPlanWithScratchAllocator(                 \
+      Stream *stream, uint64_t num_x, uint64 num_y, uint64 num_z,              \
+      fft::Type type, bool in_place_fft, ScratchAllocator *scratch_allocator)  \
+      override;                                                                \
+  std::unique_ptr<fft::Plan> CreateBatchedPlan(                                \
+      Stream *stream, int rank, uint64_t *elem_count, uint64 *input_embed,     \
+      uint64_t input_stride, uint64 input_distance, uint64 *output_embed,      \
+      uint64_t output_stride, uint64 output_distance, fft::Type type,          \
+      bool in_place_fft, int batch_count) override;                            \
+  std::unique_ptr<fft::Plan> CreateBatchedPlanWithScratchAllocator(            \
+      Stream *stream, int rank, uint64_t *elem_count, uint64 *input_embed,     \
+      uint64_t input_stride, uint64 input_distance, uint64 *output_embed,      \
+      uint64_t output_stride, uint64 output_distance, fft::Type type,          \
+      bool in_place_fft, int batch_count, ScratchAllocator *scratch_allocator) \
+      override;                                                                \
+  void UpdatePlanWithScratchAllocator(Stream *stream, fft::Plan *plan,         \
+                                      ScratchAllocator *scratch_allocator)     \
+      override;                                                                \
+  bool DoFft(Stream *stream, fft::Plan *plan,                                  \
+             const DeviceMemory<std::complex<float>> &input,                   \
+             DeviceMemory<std::complex<float>> *output) override;              \
+  bool DoFft(Stream *stream, fft::Plan *plan,                                  \
+             const DeviceMemory<std::complex<double>> &input,                  \
+             DeviceMemory<std::complex<double>> *output) override;             \
+  bool DoFft(Stream *stream, fft::Plan *plan,                                  \
+             const DeviceMemory<float> &input,                                 \
+             DeviceMemory<std::complex<float>> *output) override;              \
+  bool DoFft(Stream *stream, fft::Plan *plan,                                  \
+             const DeviceMemory<double> &input,                                \
+             DeviceMemory<std::complex<double>> *output) override;             \
+  bool DoFft(Stream *stream, fft::Plan *plan,                                  \
+             const DeviceMemory<std::complex<float>> &input,                   \
+             DeviceMemory<float> *output) override;                            \
+  bool DoFft(Stream *stream, fft::Plan *plan,                                  \
+             const DeviceMemory<std::complex<double>> &input,                  \
+             DeviceMemory<double> *output) override;
+
+}  // namespace fft
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_FFT_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/gpu/asm_compiler.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/gpu/asm_compiler.h
new file mode 100644
index 0000000000000000000000000000000000000000..0e15e326ca23e5ca7eb086065c42ee12c0c9def2
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/gpu/asm_compiler.h
@@ -0,0 +1,143 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_STREAM_EXECUTOR_GPU_ASM_COMPILER_H_
+#define XLA_STREAM_EXECUTOR_GPU_ASM_COMPILER_H_
+
+#include <array>
+#include <cstdint>
+#include <tuple>
+#include <vector>
+
+#include "absl/base/const_init.h"
+#include "absl/base/thread_annotations.h"
+#include "absl/container/flat_hash_map.h"
+#include "absl/synchronization/mutex.h"
+#include "absl/types/span.h"
+#include "xla/stream_executor/gpu/gpu_asm_opts.h"
+#include "xla/stream_executor/kernel.h"
+#include "xla/stream_executor/platform/port.h"
+#include "xla/stream_executor/stream_executor.h"
+#include "tsl/platform/statusor.h"
+#if GOOGLE_CUDA
+#include "xla/stream_executor/cuda/cuda_driver.h"
+#endif  // GOOGLE_CUDA
+
+namespace stream_executor {
+namespace gpu {
+class GpuContext;
+}
+
+// Compiles the given PTX string using ptxas and returns the resulting machine
+// code (i.e. a cubin) as a byte array. The generated cubin matches the compute
+// capabilities of the device associated with 'device_ordinal'.
+//
+// 'options' is used to query for the CUDA location in case it is
+// customized in a passed flag, and for controlling ptxas optimizations.
+tsl::StatusOr<std::vector<uint8_t>> CompileGpuAsm(int device_ordinal,
+                                                  const char* ptx_contents,
+                                                  GpuAsmOpts options);
+
+// Compiles the given PTX string using ptxas and returns the resulting machine
+// code (i.e. a cubin) as a byte array. The generated cubin matches the compute
+// capabilities provided by 'cc_major' and 'cc_minor'.
+//
+// 'options' is used to query for the CUDA location in case it is
+// customized in a passed flag, and for controlling ptxas optimizations.
+tsl::StatusOr<std::vector<uint8_t>> CompileGpuAsm(
+    int cc_major, int cc_minor, const char* ptx_contents, GpuAsmOpts options,
+    bool cancel_if_reg_spill = false);
+
+// Same as CompileGpuAsm, but caches the result, and returns unowned view of
+// the compiled binary.
+//
+// A copy of the string provided in ptx will be made.
+tsl::StatusOr<absl::Span<const uint8_t>> CompileGpuAsmOrGetCached(
+    int device_ordinal, const char* ptx, GpuAsmOpts compilation_options);
+
+struct CubinOrPTXImage {
+  std::string profile;
+  std::vector<uint8_t> bytes;
+};
+
+// Bundles the GPU machine code (cubins) and PTX if requested and returns the
+// resulting binary (i.e. a fatbin) as a byte array.
+tsl::StatusOr<std::vector<uint8_t>> BundleGpuAsm(
+    std::vector<CubinOrPTXImage> images, GpuAsmOpts options);
+
+struct HsacoImage {
+  std::string gfx_arch;
+  std::vector<uint8_t> bytes;
+};
+
+// Bundles the GPU machine code (HSA Code Object) and returns the resulting
+// binary (i.e. a fatbin) as a byte array.
+tsl::StatusOr<std::vector<uint8_t>> BundleGpuAsm(
+    std::vector<HsacoImage> images, const std::string rocm_root_dir);
+
+// Links multiple relocatable GPU images (e.g. results of ptxas -c) into a
+// single image.
+tsl::StatusOr<std::vector<uint8_t>> LinkGpuAsm(
+    gpu::GpuContext* context, std::vector<CubinOrPTXImage> images);
+
+tsl::StatusOr<std::vector<uint8_t>> LinkUsingNvlink(
+    absl::string_view preferred_cuda_dir, gpu::GpuContext* context,
+    std::vector<CubinOrPTXImage> images);
+
+std::string FindCudaExecutable(const std::string& binary_name,
+                               const std::string& preferred_cuda_dir);
+
+// Runs tool --version and parses its version string.
+tsl::StatusOr<std::array<int64_t, 3>> GetToolVersion(
+    absl::string_view tool_path);
+
+// On NVIDIA GPUs, returns the CUDA toolkit version supported by the driver,
+tsl::StatusOr<std::array<int64_t, 3>> GetAsmCompilerVersion(
+    const std::string& preferred_cuda_dir);
+
+#if GOOGLE_CUDA
+// Maintains a cache of pointers to loaded kernels
+template <typename... Args>
+tsl::StatusOr<std::shared_ptr<TypedKernel<Args...>>> LoadKernelOrGetPtr(
+    StreamExecutor* executor, absl::string_view kernel_name,
+    absl::string_view ptx, absl::Span<const uint8_t> cubin_data) {
+  using KernelPtrCacheKey =
+      std::tuple<CUcontext, absl::string_view, absl::string_view>;
+
+  static absl::Mutex kernel_ptr_cache_mutex(absl::kConstInit);
+  static auto& kernel_ptr_cache ABSL_GUARDED_BY(kernel_ptr_cache_mutex) =
+      *new absl::flat_hash_map<KernelPtrCacheKey,
+                               std::shared_ptr<TypedKernel<Args...>>>();
+  CUcontext current_context = cuda::CurrentContextOrDie();
+  KernelPtrCacheKey kernel_ptr_cache_key{current_context, kernel_name, ptx};
+  absl::MutexLock lock(&kernel_ptr_cache_mutex);
+
+  auto it = kernel_ptr_cache.find(kernel_ptr_cache_key);
+  if (it == kernel_ptr_cache.end()) {
+    TF_ASSIGN_OR_RETURN(
+        std::shared_ptr<TypedKernel<Args...>> loaded,
+        executor->CreateTypedKernel<Args...>(kernel_name, ptx, cubin_data));
+    it =
+        kernel_ptr_cache.emplace(kernel_ptr_cache_key, std::move(loaded)).first;
+  }
+
+  CHECK(it != kernel_ptr_cache.end());
+  return it->second;
+}
+#endif  // GOOGLE_CUDA
+
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_GPU_ASM_COMPILER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/gpu/gpu_activation.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/gpu/gpu_activation.h
new file mode 100644
index 0000000000000000000000000000000000000000..385644d7ac197529765e8058dcce2660f3af169c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/gpu/gpu_activation.h
@@ -0,0 +1,60 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// This file contains APIs that assume a StreamExecutor is backed by CUDA.
+// It reaches into the CUDA implementation to activate an underlying CUDA
+// context.
+//
+// Having this file separate from gpu/gpu_executor.h means that dependent
+// code does not also have to depend on cuda.h.
+
+#ifndef XLA_STREAM_EXECUTOR_GPU_GPU_ACTIVATION_H_
+#define XLA_STREAM_EXECUTOR_GPU_GPU_ACTIVATION_H_
+
+#include "xla/stream_executor/platform/port.h"
+
+namespace stream_executor {
+
+class StreamExecutor;
+
+namespace gpu {
+
+class GpuExecutor;
+class ScopedActivateContext;
+
+// Activates a CUDA context within an enclosing scope.
+class ScopedActivateExecutorContext {
+ public:
+  // Form that takes a CUDA executor implementation.
+  explicit ScopedActivateExecutorContext(GpuExecutor* gpu_exec);
+
+  // Form that takes a pImpl executor and extracts a CUDA implementation --
+  // fatal failure if it is not CUDA inside.
+  explicit ScopedActivateExecutorContext(StreamExecutor* stream_exec);
+
+  ~ScopedActivateExecutorContext();
+
+ private:
+  // The cuda.h-using datatype that we wrap.
+  ScopedActivateContext* driver_scoped_activate_context_;
+
+  ScopedActivateExecutorContext(const ScopedActivateExecutorContext&) = delete;
+  void operator=(const ScopedActivateExecutorContext&) = delete;
+};
+
+}  // namespace gpu
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_GPU_GPU_ACTIVATION_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/gpu/gpu_asm_opts.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/gpu/gpu_asm_opts.h
new file mode 100644
index 0000000000000000000000000000000000000000..6a10c2653e906c8340fa205996e3e24ea4d216ea
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/gpu/gpu_asm_opts.h
@@ -0,0 +1,54 @@
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_STREAM_EXECUTOR_GPU_GPU_ASM_OPTS_H_
+#define XLA_STREAM_EXECUTOR_GPU_GPU_ASM_OPTS_H_
+
+#include <string>
+#include <tuple>
+#include <vector>
+
+#include "absl/strings/string_view.h"
+#include "absl/types/span.h"
+
+namespace stream_executor {
+// Compilation options for compiling ptxas.
+struct GpuAsmOpts {
+  // Disable Cuda ptxas optimizations.
+  bool disable_gpuasm_optimizations;
+
+  // Cuda directory which would be searched first.
+  std::string preferred_cuda_dir;
+
+  std::vector<std::string> extra_flags;
+
+  explicit GpuAsmOpts(bool disable_gpuasm_optimizations = false,
+                      absl::string_view preferred_cuda_dir = "",
+                      absl::Span<const std::string> extra_flags = {})
+      : disable_gpuasm_optimizations(disable_gpuasm_optimizations),
+        preferred_cuda_dir(preferred_cuda_dir),
+        extra_flags(extra_flags.begin(), extra_flags.end()) {}
+
+  using PtxOptionsTuple =
+      std::tuple<bool, std::string, std::vector<std::string>>;
+
+  PtxOptionsTuple ToTuple() {
+    return std::make_tuple(disable_gpuasm_optimizations, preferred_cuda_dir,
+                           extra_flags);
+  }
+};
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_GPU_GPU_ASM_OPTS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/gpu/gpu_command_buffer.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/gpu/gpu_command_buffer.h
new file mode 100644
index 0000000000000000000000000000000000000000..9b620e7bca1801f0920d627ff26727e193bd5c48
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/gpu/gpu_command_buffer.h
@@ -0,0 +1,112 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_STREAM_EXECUTOR_GPU_GPU_COMMAND_BUFFER_H_
+#define XLA_STREAM_EXECUTOR_GPU_GPU_COMMAND_BUFFER_H_
+
+#include <cstdint>
+#include <type_traits>
+#include <vector>
+
+#include "absl/functional/any_invocable.h"
+#include "xla/stream_executor/command_buffer.h"
+#include "xla/stream_executor/gpu/gpu_executor.h"
+#include "xla/stream_executor/gpu/gpu_types.h"
+#include "xla/stream_executor/kernel.h"
+#include "xla/stream_executor/launch_dim.h"
+#include "xla/stream_executor/stream_executor_internal.h"
+#include "tsl/platform/status.h"
+
+namespace stream_executor::gpu {
+
+// GpuCommandBuffer provides platform-specific CommandBufferInterface
+// implementation (it's backed by CUDA or HIP graphs on NVIDIA and AMD devices).
+class GpuCommandBuffer : public internal::CommandBufferInterface {
+ public:
+  GpuCommandBuffer(CommandBuffer::Mode mode, GpuExecutor* parent,
+                   GpuGraphHandle graph);
+  ~GpuCommandBuffer() override;
+
+  tsl::Status Trace(Stream* stream,
+                    absl::AnyInvocable<tsl::Status()> function) override;
+
+  tsl::Status Launch(const ThreadDim& threads, const BlockDim& blocks,
+                     const KernelBase& kernel,
+                     const KernelArgsArrayBase& args) override;
+
+  tsl::Status MemcpyDeviceToDevice(DeviceMemoryBase* dst,
+                                   const DeviceMemoryBase& src,
+                                   uint64_t size) override;
+
+  tsl::Status Finalize() override;
+  tsl::Status Update() override;
+
+  GpuGraphExecHandle executable() const { return exec_; }
+
+  CommandBuffer::Mode mode() const override { return mode_; }
+  CommandBuffer::State state() const override { return state_; }
+
+  // We track the total number of allocated and alive executable graphs in the
+  // process to track the command buffers resource usage. Executable graph
+  // allocates resources on a GPU devices (rule of thumb is ~8kb per node), so
+  // we have to be careful not to keep too many of them alive for too long, or
+  // we have a higher risk of OOM errors.
+  //
+  // TODO(ezhulenev): We need to have a policy for how to evict unused
+  // executable graph instances from a device, currently lifetime of an
+  // executable graph is tied to a parent command buffer, and we can have
+  // thousands of command buffers alive at the same time.
+  static int64_t AllocatedExecs();
+  static int64_t AliveExecs();
+
+  static const GpuCommandBuffer* Cast(const CommandBuffer* command_buffer) {
+    return static_cast<const GpuCommandBuffer*>(
+        command_buffer->implementation());
+  }
+
+ private:
+  // Returns OK status if command buffer is not finalized and it is still
+  // possible to add new commands to it, otherwise returns internal error.
+  tsl::Status CheckNotFinalized();
+
+  static_assert(std::is_pointer_v<GpuGraphHandle>,
+                "GpuGraphHandle must be a pointer");
+  static_assert(std::is_pointer_v<GpuGraphExecHandle>,
+                "GpuGraphExecHandle must be a pointer");
+  static_assert(std::is_pointer_v<GpuGraphNodeHandle>,
+                "GpuGraphNodeHandle must be a pointer");
+
+  CommandBuffer::Mode mode_;
+  CommandBuffer::State state_ = CommandBuffer::State::kCreate;
+
+  GpuExecutor* parent_;                // not owned, must outlive *this
+  GpuGraphHandle graph_ = nullptr;     // owned handle
+  GpuGraphExecHandle exec_ = nullptr;  // owned handle
+
+  // Handles to graph nodes corresponding to command buffer commands. Owned by
+  // the `graph_` instance.
+  std::vector<GpuGraphNodeHandle> nodes_;
+
+  // When command buffer is in update state this index will point to the graph
+  // node inside `nodes_` that will be updated next.
+  int64_t node_update_idx_ = 0;
+
+  // Track the number of command buffer updates for debugging.
+  int64_t num_updates_ = 0;
+};
+
+}  // namespace stream_executor::gpu
+
+#endif  // XLA_STREAM_EXECUTOR_GPU_GPU_COMMAND_BUFFER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/gpu/gpu_cudamallocasync_allocator.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/gpu/gpu_cudamallocasync_allocator.h
new file mode 100644
index 0000000000000000000000000000000000000000..c428132d74aa9367deb6c158b3c9d62a6a1501ef
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/gpu/gpu_cudamallocasync_allocator.h
@@ -0,0 +1,142 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_STREAM_EXECUTOR_GPU_GPU_CUDAMALLOCASYNC_ALLOCATOR_H_
+#define XLA_STREAM_EXECUTOR_GPU_GPU_CUDAMALLOCASYNC_ALLOCATOR_H_
+
+#include <memory>
+#include <optional>
+#include <string>
+
+#include "absl/base/thread_annotations.h"
+#include "absl/container/flat_hash_map.h"
+#include "xla/stream_executor/stream_executor.h"
+#include "tsl/framework/allocator.h"
+#include "tsl/framework/device_id.h"
+#include "tsl/platform/macros.h"
+#include "tsl/platform/mutex.h"
+
+#if GOOGLE_CUDA
+#include "third_party/gpus/cuda/include/cuda.h"
+
+#define TF_CUDA_MALLOC_ASYNC_SUPPORTED CUDA_VERSION >= 11020
+#endif  // GOOGLE_CUDA
+
+
+namespace stream_executor {
+
+// An allocator that wraps cudaMallocAsync. It has fewer fragmentation
+// issues then the BFC memory allocator.  The compute-sanitizer tool
+// helps to detect OOB memory errors when using cudaMallocAsync. Use
+// the environment variable `TF_GPU_ALLOCATOR=cuda_malloc_async` to
+// enable it.
+//
+// It needs CUDA 11.2+. When using a container, this only needs the
+// container driver to be 11.2. It has a WAR again a driver bug in
+// multi-GPU setup with CUDA 11.2. The WAR creates an extra context on
+// GPU 0.
+//
+// We configure cudaMallocAsync to grow when more memory is needed
+// instead of preallocating everything up front and to keep a local
+// pool up to pool_size bytes that is never released to other processes.
+// So no other process will "steal" the GPU memory already used by the
+// current process. This is to speed up execution and prevent crashes
+// of long-running jobs. Use `reserve_memory=true` if you want to
+// preallocate the full pool_size. You can also use the environment
+// variable `TF_CUDA_MALLOC_ASYNC_SUPPORTED_PREALLOC=nb_bytes` to preallocate
+// that amount of memory. `TF_CUDA_MALLOC_ASYNC_SUPPORTED_PREALLOC=-1` is a
+// special value that preallocate all what the BFC memory allocator
+// would have allocated. This is useful when benchmarking as it doesn't
+// change when driver allocations are done.
+//
+// Here, the pool_size isn't the absolute max as for [Gpu]BFCAllocator.
+// The pool can grow above that up to the total GPU memory.  But the
+// driver can return the excess memory to other processes.
+class GpuCudaMallocAsyncAllocator : public tsl::Allocator {
+ public:
+  explicit GpuCudaMallocAsyncAllocator(tsl::PlatformDeviceId platform_device_id,
+                                       size_t pool_size,
+                                       bool reserve_memory = false,
+                                       bool compute_stats = true);
+  ~GpuCudaMallocAsyncAllocator() override;
+  std::string Name() override { return name_; }
+  void* AllocateRaw(size_t alignment,
+                    size_t num_bytes) override ABSL_NO_THREAD_SAFETY_ANALYSIS;
+  void DeallocateRaw(void* ptr) override ABSL_NO_THREAD_SAFETY_ANALYSIS;
+
+  bool TracksAllocationSizes() const override;
+
+  size_t RequestedSize(const void* ptr) const override;
+
+  size_t AllocatedSize(const void* ptr) const override;
+
+  std::optional<tsl::AllocatorStats> GetStats() override;
+
+  bool ClearStats() override;
+
+  void SetStreamAndPreallocateMemory(void* stream) override;
+
+  // With the right VLOG set, it prints:
+  // - the number of ptr currently allocated per size (histogram).
+  // - each ptr value and its size.
+  // - If CUDA_VERSION >= 11030, print cudaMallocAsync statistics.
+  void PrintAllocatorStatistics();
+
+  static int GetInstantiatedCountTestOnly() { return number_instantiated_; }
+
+  tsl::AllocatorMemoryType GetMemoryType() const override {
+    return tsl::AllocatorMemoryType::kDevice;
+  }
+
+ private:
+  void PrintAllocatorStatisticsNoLock() ABSL_EXCLUSIVE_LOCKS_REQUIRED(lock_);
+
+#if TF_CUDA_MALLOC_ASYNC_SUPPORTED
+  StreamExecutor* stream_exec_;  // Not owned.
+
+  // cudaMallocAsync is stream aware. But TF StreamExecutor use only 1
+  // compute stream and already synchronize with the h2d, d2h and d2d
+  // stream. So we do not need to ask cudaMallocAsync to add extra
+  // synchronization.
+  // Not owned.
+  CUstream cuda_stream_;
+
+  // Not owned. The default pool of the associated GPU.
+  // If null, then the instanciation failed and the first allocation
+  // will return an error.
+  CUmemoryPool pool_;
+#endif  // TF_CUDA_MALLOC_ASYNC_SUPPORTED
+
+  // Just a counter for the number of time this class is instantiated.
+  // Only useful for tests.
+  static std::atomic<int> number_instantiated_;
+
+  std::string name_;
+
+  bool reserve_memory_;
+
+  GpuCudaMallocAsyncAllocator(const GpuCudaMallocAsyncAllocator&) = delete;
+  void operator=(const GpuCudaMallocAsyncAllocator&) = delete;
+
+  // Stats.
+  // Structures mutable after construction
+  mutable tsl::mutex lock_;
+  std::unique_ptr<tsl::AllocatorStats> stats_ ABSL_PT_GUARDED_BY(lock_);
+  absl::flat_hash_map<const void*, size_t> size_map_ ABSL_GUARDED_BY(lock_);
+};
+
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_GPU_GPU_CUDAMALLOCASYNC_ALLOCATOR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/gpu/gpu_diagnostics.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/gpu/gpu_diagnostics.h
new file mode 100644
index 0000000000000000000000000000000000000000..7892a3bcf4f50830b53b94bd69614b9c0afb28dd
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/gpu/gpu_diagnostics.h
@@ -0,0 +1,99 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_STREAM_EXECUTOR_GPU_GPU_DIAGNOSTICS_H_
+#define XLA_STREAM_EXECUTOR_GPU_GPU_DIAGNOSTICS_H_
+
+#include <tuple>
+
+#include "xla/stream_executor/platform/port.h"
+#include "tsl/platform/statusor.h"
+
+namespace stream_executor {
+namespace gpu {
+
+// e.g. DriverVersion{346, 3, 4}
+using DriverVersion = std::tuple<int, int, int>;
+
+// FIXME: These functions are in stream_executor::cuda namespaces for now
+// Will move to stream_executor::gpu namespace in the near future
+//
+//// Converts a parsed driver version to string form.
+// string DriverVersionToString(DriverVersion version);
+//
+//// Converts a parsed driver version or status value to natural string form.
+// string DriverVersionStatusToString(tsl::StatusOr<DriverVersion> version);
+//
+//// Converts a string of a form like "331.79" to a DriverVersion{331, 79}.
+// tsl::StatusOr<DriverVersion> StringToDriverVersion(const string& value);
+
+class Diagnostician {
+ public:
+  // Logs diagnostic information when CUDA appears to be misconfigured (e.g. is
+  // not initializing).
+  //
+  // Note: if we're running on a machine that has no GPUs, we don't want to
+  // produce very much log spew beyond saying, "looks like there's no CUDA
+  // kernel
+  // module running".
+  //
+  // Note: we use non-Google-File:: API here because we may be called before
+  // InitGoogle has completed.
+  static void LogDiagnosticInformation();
+
+  // Given the driver version file contents, finds the kernel module version and
+  // returns it as a string.
+  //
+  // This is solely used for more informative log messages when the user is
+  // running on a machine that happens to have a libcuda/kernel driver mismatch.
+  static tsl::StatusOr<DriverVersion> FindKernelModuleVersion(
+      const std::string& driver_version_file_contents);
+
+  // Extracts the kernel driver version from the current host.
+  static tsl::StatusOr<DriverVersion> FindKernelDriverVersion();
+
+  // Iterates through loaded DSOs with DlIteratePhdrCallback to find the
+  // driver-interfacing DSO version number. Returns it as a string.
+  static tsl::StatusOr<DriverVersion> FindDsoVersion();
+
+  // Logs information about the kernel driver version and userspace driver
+  // library version.
+  static void LogDriverVersionInformation();
+
+ private:
+  // Given the DSO version number and the driver version file contents, extracts
+  // the driver version and compares, warning the user in the case of
+  // incompatibility.
+  //
+  // This is solely used for more informative log messages when the user is
+  // running on a machine that happens to have a libcuda/kernel driver mismatch.
+  static void WarnOnDsoKernelMismatch(
+      tsl::StatusOr<DriverVersion> dso_version,
+      tsl::StatusOr<DriverVersion> kernel_version);
+
+  // Logs information about the dev nodes present on this machine: their
+  // existence, permissions, accessibility from this uid/gid.
+  static void LogDevNodeDiagnosticInformation();
+
+  static std::string GetDevNodePath(int dev_node_ordinal);
+
+  Diagnostician(const Diagnostician&) = delete;
+  void operator=(const Diagnostician&) = delete;
+};
+
+}  // namespace gpu
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_GPU_GPU_DIAGNOSTICS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/gpu/gpu_driver.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/gpu/gpu_driver.h
new file mode 100644
index 0000000000000000000000000000000000000000..3895e7b0bf008c9132b85d5ce95089349cc90d39
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/gpu/gpu_driver.h
@@ -0,0 +1,793 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// CUDA/ROCm userspace driver library wrapper functionality.
+
+#ifndef XLA_STREAM_EXECUTOR_GPU_GPU_DRIVER_H_
+#define XLA_STREAM_EXECUTOR_GPU_GPU_DRIVER_H_
+
+#include <stddef.h>
+
+#include <cstdint>
+
+#include "xla/stream_executor/device_options.h"
+#include "xla/stream_executor/gpu/gpu_types.h"
+#include "xla/stream_executor/platform.h"
+#include "tsl/platform/status.h"
+#include "tsl/platform/statusor.h"
+
+namespace stream_executor {
+namespace gpu {
+
+// Identifies the memory space where an allocation resides. See
+// GpuDriver::GetPointerMemorySpace().
+enum class MemorySpace { kHost, kDevice };
+
+// Returns a casual string, such as "host" for the provided memory space.
+std::string MemorySpaceString(MemorySpace memory_space);
+
+class GpuContext;
+
+// GpuDriver contains wrappers for calls to the userspace library driver. It's
+// useful to isolate these calls and put basic wrappers around them to separate
+// userspace library driver behaviors from the rest of the program.
+//
+// At the moment it's simply used as a namespace.
+//
+// The calls log any specific errors internally and return whether the operation
+// was successful to the caller.
+//
+// The order of parameters is generally kept symmetric with the underlying
+// CUDA/ROCm driver API.
+//
+// Links on functions are to specific documentation under
+// http://docs.nvidia.com/cuda/cuda-driver-api/
+// https://rocm.docs.amd.com/projects/HIPIFY/en/latest/tables/CUDA_Driver_API_functions_supported_by_HIP.html
+//
+// Thread safety: these functions should not be used from signal handlers.
+class GpuDriver {
+ public:
+  // Wraps a call to cuInit/hipInit with logging to help indicate what has gone
+  // wrong in the case of failure. Safe to call multiple times; will be fast on
+  // all calls after the first.
+  // http://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__INITIALIZE.html#group__CUDA__INITIALIZE_1g0a2f1517e1bd8502c7194c3a8c134bc3
+  // https://rocm.docs.amd.com/projects/HIPIFY/en/latest/tables/CUDA_Driver_API_functions_supported_by_HIP.html#initialization
+  static tsl::Status Init();
+
+  // Returns the device associated with the given context.
+  // device is an outparam owned by the caller, must not be null.
+  // http://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__CTX.html#group__CUDA__CTX_1g4e84b109eba36cdaaade167f34ae881e
+  static tsl::StatusOr<GpuDeviceHandle> DeviceFromContext(GpuContext* context);
+
+  // Creates a new CUDA/HIP stream associated with the given context via
+  // cuStreamCreate/hipStreamCreateWithFlags.
+  // stream is an outparam owned by the caller, must not be null.
+  // http://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__STREAM.html#group__CUDA__STREAM_1ga581f0c5833e21ded8b5a56594e243f4
+  // https://rocm.docs.amd.com/projects/HIPIFY/en/latest/tables/CUDA_Driver_API_functions_supported_by_HIP.html#stream-management
+  static bool CreateStream(GpuContext* context, GpuStreamHandle* stream,
+                           int priority = 0);
+
+  // Destroys a CUDA/HIP stream associated with the given context.
+  // stream is owned by the caller, must not be null, and *stream is set to null
+  // if the stream is successfully destroyed.
+  // http://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__STREAM.html#group__CUDA__STREAM_1g244c8833de4596bcd31a06cdf21ee758
+  // https://rocm.docs.amd.com/projects/HIPIFY/en/latest/tables/CUDA_Driver_API_functions_supported_by_HIP.html#stream-management
+  static void DestroyStream(GpuContext* context, GpuStreamHandle* stream);
+
+  // CUDA/HIP events can explicitly disable event TSC retrieval for some
+  // presumed performance improvement if timing is unnecessary.
+  // http://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__EVENT.html#group__CUDA__EVENT_1g450687e75f3ff992fe01662a43d9d3db
+  // https://rocm.docs.amd.com/projects/HIPIFY/en/latest/tables/CUDA_Driver_API_functions_supported_by_HIP.html#cuda-driver-data-types
+  enum class EventFlags { kDefault, kDisableTiming };
+
+  // Creates a new event associated with the given context.
+  // result is an outparam owned by the caller and must not be null.
+  // http://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__EVENT.html#group__CUDA__EVENT_1g450687e75f3ff992fe01662a43d9d3db
+  // https://rocm.docs.amd.com/projects/HIPIFY/en/latest/tables/CUDA_Driver_API_functions_supported_by_HIP.html#cuda-driver-data-types
+  static tsl::Status InitEvent(GpuContext* context, GpuEventHandle* result,
+                               EventFlags flags);
+
+  // Destroys *event and turns it into a nullptr. event may not be null, but
+  // *event may be, via cuEventDestroy/hipEventDestroy
+  // http://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__EVENT.html#group__CUDA__EVENT_1g593ec73a8ec5a5fc031311d3e4dca1ef
+  // https://rocm.docs.amd.com/projects/HIPIFY/en/latest/tables/CUDA_Driver_API_functions_supported_by_HIP.html#event-management
+  static tsl::Status DestroyEvent(GpuContext* context, GpuEventHandle* event);
+
+  // Allocates a GPU memory space of size bytes associated with the given
+  // context via cuMemAlloc/hipMalloc.
+  // http://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__MEM.html#group__CUDA__MEM_1gb82d2a09844a58dd9e744dc31e8aa467
+  // https://rocm.docs.amd.com/projects/HIPIFY/en/latest/tables/CUDA_Driver_API_functions_supported_by_HIP.html#memory-management
+  static void* DeviceAllocate(GpuContext* context, uint64_t bytes);
+
+  // Deallocates a GPU memory space of size bytes associated with the given
+  // context via cuMemFree/hipFree.
+  // http://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__MEM.html#group__CUDA__MEM_1g89b3f154e17cc89b6eea277dbdf5c93a
+  // https://rocm.docs.amd.com/projects/HIPIFY/en/latest/tables/CUDA_Driver_API_functions_supported_by_HIP.html#memory-management
+  static void DeviceDeallocate(GpuContext* context, void* location);
+
+  // Allocates a unified memory space of size bytes associated with the given
+  // context via cuMemAllocManaged.
+  // https://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__MEM.html#group__CUDA__MEM_1gb347ded34dc326af404aa02af5388a32
+  // (supported on CUDA only)
+  static void* UnifiedMemoryAllocate(GpuContext* context, uint64_t bytes);
+
+  // Deallocates a unified memory space of size bytes associated with the given
+  // context via cuMemFree.
+  // http://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__MEM.html#group__CUDA__MEM_1g89b3f154e17cc89b6eea277dbdf5c93a
+  // (supported on CUDA only)
+  static void UnifiedMemoryDeallocate(GpuContext* context, void* location);
+
+  // Allocates page-locked and CUDA-registered memory on the host via
+  // cuMemAllocHost/hipHostMalloc.
+  // http://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__MEM.html#group__CUDA__MEM_1gdd8311286d2c2691605362c689bc64e0
+  // https://rocm.docs.amd.com/projects/HIPIFY/en/latest/tables/CUDA_Driver_API_functions_supported_by_HIP.html#memory-management
+  static void* HostAllocate(GpuContext* context, uint64_t bytes);
+
+  // Deallocates a location created by HostAllocate, via
+  // cuMemFreeHost/hipHostFree.
+  // http://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__MEM.html#group__CUDA__MEM_1g62e0fdbe181dab6b1c90fa1a51c7b92c
+  // https://rocm.docs.amd.com/projects/HIPIFY/en/latest/tables/CUDA_Driver_API_functions_supported_by_HIP.html#memory-management
+  static void HostDeallocate(GpuContext* context, void* location);
+
+  // Registers a memory region at location of size bytes via
+  // cuMemHostRegister/hipHostRegister.
+  // http://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__MEM.html#group__CUDA__MEM_1gf0a9fe11544326dabd743b7aa6b54223
+  // https://rocm.docs.amd.com/projects/HIPIFY/en/latest/tables/CUDA_Driver_API_functions_supported_by_HIP.html#memory-management
+  static bool HostRegister(GpuContext* context, void* location, uint64_t bytes);
+
+  // Unregisters a memory region that was previously registered at location via
+  // cuMemHostUnregister/hipHostUnregister.
+  //
+  // http://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__MEM.html#group__CUDA__MEM_1g63f450c8125359be87b7623b1c0b2a14
+  // https://rocm.docs.amd.com/projects/HIPIFY/en/latest/tables/CUDA_Driver_API_functions_supported_by_HIP.html#memory-management
+  //
+  // TODO(leary) verify an error will be returned if the location wasn't
+  // previously registered.
+  static bool HostUnregister(GpuContext* context, void* location);
+
+  // Queries the priority range and returns the corresponding integer value via
+  // cuCtxGetStreamPriorityRange/hipDeviceGetStreamPriorityRange
+  //
+  // https://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__CTX.html#group__CUDA__CTX_1g137920ab61a71be6ce67605b9f294091
+  // https://rocm.docs.amd.com/projects/HIPIFY/en/latest/tables/CUDA_Driver_API_functions_supported_by_HIP.html#context-management
+  static int GetGpuStreamPriority(
+      GpuContext* context, stream_executor::StreamPriority stream_priority);
+
+  // Virtual memory support was added to CUDA in 10.2
+#if CUDA_VERSION >= 10020
+
+  // Reserves a range of virtual device memory addresses via
+  // cuMemAddressReserve. bytes must be a multiple of the host page size.
+  // Returns nullptr base address in VmemSpan if the reservation fails.
+  // https://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__VA.html#group__CUDA__VA_1ge489256c107df2a07ddf96d80c86cd9b
+  struct VmemSpan {
+    GpuDevicePtr base;
+    // Size in bytes.
+    uint64_t size_bytes;
+  };
+  static tsl::StatusOr<VmemSpan> ReserveVirtualMemory(GpuContext* context,
+                                                      uint64_t bytes);
+
+  // Frees a range of virtual addresses that were previously reserved through
+  // ReserveVirtualMemory via cuMemAddressFree.
+  // https://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__VA.html#group__CUDA__VA_1g6993ecea2ea03e1b802b8255edc2da5b
+  static void FreeVirtualMemory(GpuContext* context, VmemSpan reservation);
+
+  // Calculates the minimum alignment for memory allocations done through
+  // cuMemCreate via cuMemGetAllocationGranularity.
+  // https://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__VA.html#group__CUDA__VA_1g30ee906c2cf66a0347b3dfec3d7eb31a
+  static tsl::StatusOr<uint64_t> GetMinAllocationGranularity(
+      GpuDeviceHandle device);
+
+  // Allocates physical memory and returns a handle that can be mapped to
+  // virtual addresses via cuMemCreate. bytes must be a multiple of the
+  // granularity returned by GetMinAllocationGranularity.
+  // https://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__VA.html#group__CUDA__VA_1g899d69a862bba36449789c64b430dc7c
+  struct GenericMemoryHandle {
+    uint64_t handle;
+    uint64_t bytes;
+  };
+  static tsl::StatusOr<GenericMemoryHandle> CreateMemoryHandle(
+      GpuContext* context, uint64_t bytes);
+
+  // Frees memory represented by the provided MemoryHandle via cuMemRelease.
+  // https://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__VA.html#group__CUDA__VA_1g3014f0759f43a8d82db951b8e4b91d68
+  static void ReleaseMemoryHandle(GpuContext* context,
+                                  GenericMemoryHandle handle);
+
+  // Maps a memory allocation handle to a reserved virtual address range via
+  // cuMemMap and sets the appropriate access settings via cuMemSetAccess.
+  // https://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__VA.html#group__CUDA__VA_1gff1d395423af5c5c75375516959dae56
+  // https://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__VA.html#group__CUDA__VA_1g1b6b12b10e8324bf462ecab4e7ef30e1
+  static tsl::Status MapMemory(
+      GpuContext* context, GpuDevicePtr va, const GenericMemoryHandle& handle,
+      const std::vector<GpuDeviceHandle>& device_handles);
+
+  // Unmaps the backing memory from the given virtual address range. This range
+  // must fully unmap a memory handle that was mapped using MapMemory; partial
+  // unmapping is not supported.
+  // https://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__VA.html#group__CUDA__VA_1gfb50aac00c848fd7087e858f59bf7e2a
+  static void UnmapMemory(GpuContext* context, GpuDevicePtr va, uint64_t bytes);
+
+#endif  // CUDA_VERSION >= 10200
+
+  // Given a device ordinal, returns a device handle into the device outparam,
+  // which must not be null.
+  //
+  // N.B. these device handles do not have a corresponding destroy function in
+  // the CUDA/HIP driver API.
+  static tsl::Status GetDevice(int device_ordinal, GpuDeviceHandle* device);
+
+  // Given a device handle, returns the name reported by the driver for the
+  // device.
+  static tsl::Status GetDeviceName(GpuDeviceHandle device,
+                                   std::string* device_name);
+
+  // Given a device to create a context for, returns a context handle into the
+  // context outparam, which must not be null.
+  //
+  // N.B. CUDA contexts are weird. They are implicitly associated with the
+  // calling thread. Current documentation on contexts and their influence on
+  // userspace processes is given here:
+  // http://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__CTX.html#group__CUDA__CTX_1g65dc0012348bc84810e2103a40d8e2cf
+  static tsl::Status CreateContext(int device_ordinal, GpuDeviceHandle device,
+                                   const DeviceOptions& device_options,
+                                   GpuContext** context);
+
+  // Destroys the provided context via cuCtxDestroy.
+  // Don't do this while clients could still be using the context, per the docs
+  // bad things will happen.
+  // http://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__CTX.html#group__CUDA__CTX_1g27a365aebb0eb548166309f58a1e8b8e
+  static void DestroyContext(GpuContext* context);
+
+  // Returns the context handle (CUcontext for CUDA and hipCtx_t for ROCm) of a
+  // GpuContext.
+  static GpuContextHandle GetContextHandle(GpuContext* context);
+
+  // Queries the runtime for the specified attribute of the specified function.
+  // cuFuncGetAttribute (the underlying CUDA driver API routine) only operates
+  // in terms of integer-sized values, so there's no potential for overrun (as
+  // of CUDA 5.5).
+  // http://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__EXEC.html#group__CUDA__EXEC_1g5e92a1b0d8d1b82cb00dcfb2de15961b
+  static tsl::Status FuncGetAttribute(GpuFunctionAttribute attribute,
+                                      GpuFunctionHandle function,
+                                      int* attribute_value);
+
+  // Sets the preferred cache configuration for the specified function.
+  // http://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__EXEC.html#group__CUDA__EXEC_1g40f8c11e81def95dc0072a375f965681
+  static tsl::Status FuncSetCacheConfig(GpuFunctionHandle function,
+                                        GpuFuncCachePreference cache_config);
+
+  // Gets the preferred shared memory bank configuration for the specified
+  // CONTEXT (not function!), either default or four- or eight-byte bank size.
+  // http://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__CTX.html#group__CUDA__CTX_1g17153a1b8b8c756f7ab8505686a4ad74
+  // https://rocm.docs.amd.com/projects/HIP/en/latest/.doxygen/docBin/html/group___execution.html
+  static tsl::StatusOr<GpuSharedMemConfig> ContextGetSharedMemConfig(
+      GpuContext* context);
+
+  // Sets the preferred shared memory bank configuration for the specified
+  // CONTEXT (not function!), either default or four- or eight-byte bank size.
+  // http://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__CTX.html#group__CUDA__CTX_1g2574235fa643f8f251bf7bc28fac3692
+  // https://rocm.docs.amd.com/projects/HIP/en/latest/.doxygen/docBin/html/group___execution.html
+  static tsl::Status ContextSetSharedMemConfig(
+      GpuContext* context, GpuSharedMemConfig shared_mem_config);
+
+  // Launches a CUDA/ROCm kernel via cuLaunchKernel/hipModuleLaunchKernel.
+  // TODO(leary) describe the structure of kernel_params and extra in a readable
+  // way.
+  // http://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__EXEC.html#group__CUDA__EXEC_1gb8f3dc3031b40da29d5f9a7139e52e15
+  // https://rocm.docs.amd.com/projects/HIPIFY/en/latest/tables/CUDA_Driver_API_functions_supported_by_HIP.html#execution-control
+  static tsl::Status LaunchKernel(
+      GpuContext* context, absl::string_view kernel_name,
+      GpuFunctionHandle function, unsigned int grid_dim_x,
+      unsigned int grid_dim_y, unsigned int grid_dim_z,
+      unsigned int block_dim_x, unsigned int block_dim_y,
+      unsigned int block_dim_z, unsigned int shared_mem_bytes,
+      GpuStreamHandle stream, void** kernel_params, void** extra);
+
+  // Creates a new GPU graph.
+  // https://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__GRAPH.html#group__CUDA__GRAPH_1gd885f719186010727b75c3315f865fdf
+  // https://rocm.docs.amd.com/projects/HIPIFY/en/latest/tables/CUDA_Driver_API_functions_supported_by_HIP.html#graph-management
+  static tsl::Status CreateGraph(GpuGraphHandle* graph);
+
+  // Destroys GPU graph.
+  // https://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__GRAPH.html#group__CUDA__GRAPH_1g718cfd9681f078693d4be2426fd689c8
+  // https://rocm.docs.amd.com/projects/HIPIFY/en/latest/tables/CUDA_Driver_API_functions_supported_by_HIP.html#graph-management
+  static tsl::Status DestroyGraph(GpuGraphHandle graph);
+
+  // Begins graph capture on a stream.
+  // https://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__STREAM.html#group__CUDA__STREAM_1g767167da0bbf07157dc20b6c258a2143
+  // https://rocm.docs.amd.com/projects/HIPIFY/en/latest/tables/CUDA_Driver_API_functions_supported_by_HIP.html#graph-management
+  enum class StreamCaptureMode { kGlobal, kThreadLocal, kRelaxed };
+  static tsl::Status StreamBeginCapture(GpuStreamHandle stream,
+                                        StreamCaptureMode mode);
+
+  // Ends capture on a stream, returning the captured graph.
+  // https://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__STREAM.html#group__CUDA__STREAM_1g03dab8b2ba76b00718955177a929970c
+  // https://rocm.docs.amd.com/projects/HIPIFY/en/latest/tables/CUDA_Driver_API_functions_supported_by_HIP.html#graph-management
+  static tsl::Status StreamEndCapture(GpuStreamHandle stream,
+                                      GpuGraphHandle* graph);
+
+  // Graph instantiation flags.
+  // https://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__TYPES.html#group__CUDA__TYPES_1g070bf5517d3a7915667c256eefce4956
+  // https://rocm.docs.amd.com/projects/HIPIFY/en/latest/tables/CUDA_Driver_API_functions_supported_by_HIP.html#cuda-driver-data-types
+  struct GraphInstantiateFlags {
+    // Automatically free memory allocated in a graph before relaunching.
+    bool auto_free_on_launch = false;
+    // Automatically upload the graph after instantiation.
+    bool upload = false;
+    // Instantiate the graph to be launchable from the device.
+    bool device_launch = false;
+    // Run the graph using the per-node priority attributes rather than the
+    // priority of the stream it is launched into.
+    bool use_node_prirotiy = false;
+  };
+
+  // Creates an executable graph from a graph.
+  // https://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__GRAPH.html#group__CUDA__GRAPH_1gb53b435e178cccfa37ac87285d2c3fa1
+  // https://rocm.docs.amd.com/projects/HIPIFY/en/latest/tables/CUDA_Driver_API_functions_supported_by_HIP.html#graph-management
+  static tsl::Status GraphInstantiate(GpuGraphExecHandle* exec,
+                                      GpuGraphHandle graph,
+                                      const GraphInstantiateFlags& flags);
+
+  // Launches an executable graph in a stream.
+  // https://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__GRAPH.html#group__CUDA__GRAPH_1g6b2dceb3901e71a390d2bd8b0491e471
+  // https://rocm.docs.amd.com/projects/HIPIFY/en/latest/tables/CUDA_Driver_API_functions_supported_by_HIP.html#graph-management
+  static tsl::Status GraphLaunch(GpuGraphExecHandle exec,
+                                 GpuStreamHandle stream);
+
+  // Graph update result.
+  // https://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__TYPES.html#group__CUDA__TYPES_1g8edc8969ff6ae00b7cd5d7292f812c3c
+  // https://rocm.docs.amd.com/projects/HIPIFY/en/latest/tables/CUDA_Driver_API_functions_supported_by_HIP.html#cuda-driver-data-types
+  enum class GraphExecUpdateResult {
+    kSuccess,
+    kError,
+    kTopologyChanged,
+    kNodeTypeChanged,
+    kFunctionChanged,
+    kParametersChanged,
+    kNotSupported,
+    kUnsupportedFunctionChange,
+    kAttributesChanged
+  };
+
+  // Graph update result info.
+  // https://docs.nvidia.com/cuda/cuda-driver-api/structCUgraphExecUpdateResultInfo__v1.html#structCUgraphExecUpdateResultInfo__v1
+  // https://rocm.docs.amd.com/projects/HIPIFY/en/latest/tables/CUDA_Driver_API_functions_supported_by_HIP.html#graph-management
+  struct GraphExecUpdateResultInfo {
+    GpuGraphNodeHandle error_from_node;
+    GpuGraphNodeHandle error_node;
+    GraphExecUpdateResult result;
+  };
+
+  // Check whether an executable graph can be updated with a graph and perform
+  // the update if possible.
+  // https://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__GRAPH.html#group__CUDA__GRAPH_1g96efefc56df46927da7297f122adfb9f
+  // https://rocm.docs.amd.com/projects/HIPIFY/en/latest/tables/CUDA_Driver_API_functions_supported_by_HIP.html#graph-management
+  static tsl::Status GraphExecUpdate(GpuGraphExecHandle exec,
+                                     GpuGraphHandle graph,
+                                     GraphExecUpdateResultInfo* result);
+
+  // Graph node type.
+  // https://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__TYPES.html#group__CUDA__TYPES_1g0731a28f826922120d783d8444e154dc
+  // https://docs.amd.com/projects/HIP/en/docs-5.0.0/doxygen/html/group___graph.html#ga4727d20b89566832c74b762f987b9728
+  enum class GraphNodeType {
+    kKernel,
+    kMemcpy,
+    kMemset,
+    kHost,
+    kGraph,
+    kEmpty,
+    kWaitEvent,
+    kEventRecord,
+    kExtSemasSignal,
+    kExtSemasWait,
+    kMemAlloc,
+    kMemFree,
+    kBatchMemOp,
+  };
+
+  // Return the node type of the graph node.
+  // https://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__GRAPH.html#group__CUDA__GRAPH_1gdb1776d97aa1c9d5144774b29e4b8c3e
+  // https://docs.amd.com/projects/HIP/en/docs-5.0.0/doxygen/html/group___graph.html#ga87c68ae9408a6438d4a1101560ceea11
+  static tsl::StatusOr<GraphNodeType> GraphNodeGetType(GpuGraphNodeHandle node);
+
+  // Destroys an executable graph.
+  // https://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__GRAPH.html#group__CUDA__GRAPH_1ga32ad4944cc5d408158207c978bc43a7
+  // https://rocm.docs.amd.com/projects/HIPIFY/en/latest/tables/CUDA_Driver_API_functions_supported_by_HIP.html#graph-management
+  static tsl::Status DestroyGraphExec(GpuGraphExecHandle exec);
+
+  // Write a DOT file describing graph structure.
+  // https://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__GRAPH.html#group__CUDA__GRAPH_1g0fb0c4d319477a0a98da005fcb0dacc4
+  // https://rocm.docs.amd.com/projects/HIPIFY/en/latest/tables/CUDA_Driver_API_functions_supported_by_HIP.html#graph-management
+  static tsl::Status GraphDebugDotPrint(GpuGraphHandle graph, const char* path);
+
+  // Returns a stream's capture status.
+  // https://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__STREAM.html#group__CUDA__STREAM_1g37823c49206e3704ae23c7ad78560bca
+  // https://rocm.docs.amd.com/projects/HIPIFY/en/latest/tables/CUDA_Driver_API_functions_supported_by_HIP.html#stream-management
+  static tsl::StatusOr<bool> StreamIsCapturing(GpuStreamHandle stream);
+
+  // Creates a kernel execution node and adds it to a graph.
+  // https://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__GRAPH.html#group__CUDA__GRAPH_1g50d871e3bd06c1b835e52f2966ef366b
+  // https://rocm.docs.amd.com/projects/HIPIFY/en/latest/tables/CUDA_Driver_API_functions_supported_by_HIP.html#graph-management
+  static tsl::Status GraphAddKernelNode(
+      GpuGraphNodeHandle* node, GpuGraphHandle graph,
+      absl::Span<GpuGraphNodeHandle> deps, absl::string_view kernel_name,
+      GpuFunctionHandle function, unsigned int grid_dim_x,
+      unsigned int grid_dim_y, unsigned int grid_dim_z,
+      unsigned int block_dim_x, unsigned int block_dim_y,
+      unsigned int block_dim_z, unsigned int shared_mem_bytes,
+      void** kernel_params, void** extra);
+
+  // Sets the parameters for a kernel node in the given graph exec.
+  // https://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__GRAPH.html#group__CUDA__GRAPH_1gd84243569e4c3d6356b9f2eea20ed48c
+  static tsl::Status GraphExecKernelNodeSetParams(
+      GpuGraphExecHandle exec, GpuGraphNodeHandle node,
+      absl::string_view kernel_name, GpuFunctionHandle function,
+      unsigned int grid_dim_x, unsigned int grid_dim_y, unsigned int grid_dim_z,
+      unsigned int block_dim_x, unsigned int block_dim_y,
+      unsigned int block_dim_z, unsigned int shared_mem_bytes,
+      void** kernel_params, void** extra);
+
+  // Creates a memcpy node and adds it to a graph.
+  // https://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__GRAPH.html#group__CUDA__GRAPH_1g674da6ab54a677f13e0e0e8206ff5073
+  static tsl::Status GraphAddMemcpyD2DNode(GpuContext* context,
+                                           GpuGraphNodeHandle* node,
+                                           GpuGraphHandle graph,
+                                           absl::Span<GpuGraphNodeHandle> deps,
+                                           GpuDevicePtr gpu_dst,
+                                           GpuDevicePtr gpu_src, uint64_t size);
+
+  // Loads ptx_contents with the CUDA driver's PTX JIT and stores the resulting
+  // handle in "module". Any error logs that are produced are logged internally.
+  // (supported on CUDA only)
+  static tsl::Status LoadPtx(GpuContext* context, const char* ptx_contents,
+                             GpuModuleHandle* module);
+
+  // Loads cubin_bytes with the CUDA driver's blob loading interface and stores
+  // the resulting handle in "module".
+  // (supported on CUDA only)
+  static tsl::Status LoadCubin(GpuContext* context, const char* cubin_bytes,
+                               GpuModuleHandle* module);
+
+  // Loads HSACO with the ROCM runtime and stores the resulting handle in
+  // "module". Any error logs that are produced are logged internally.
+  // (supported on ROCm only)
+  static tsl::Status LoadHsaco(GpuContext* context, const char* hsaco_contents,
+                               GpuModuleHandle* module);
+
+  // Retrieves a named kernel from a loaded module, and places the resulting
+  // handle into function (outparam) on success. Neither kernel_name nor
+  // function may be null. No ownership is taken of kernel_name.
+  static tsl::Status GetModuleFunction(GpuContext* context,
+                                       GpuModuleHandle module,
+                                       const char* kernel_name,
+                                       GpuFunctionHandle* function);
+
+  // Retrieves a named global/constant symbol from a loaded module, and returns
+  // a device pointer and size of the symbol on success. symbol_name may not be
+  // null. At least one of dptr or bytes should not be null. No ownership is
+  // taken of symbol_name.
+  static bool GetModuleSymbol(GpuContext* context, GpuModuleHandle module,
+                              const char* symbol_name, GpuDevicePtr* dptr,
+                              size_t* bytes);
+
+  // Unloads module from the current context via cuModuleUnload.
+  // TODO(leary) the documentation doesn't say what kind of disasters happen
+  // if you try to unload a module while its GpuFunctionHandles are in use.
+  // http://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__MODULE.html#group__CUDA__MODULE_1g8ea3d716524369de3763104ced4ea57b
+  static void UnloadModule(GpuContext* context, GpuModuleHandle module);
+
+  // Performs a synchronous memset of the device memory segment via cuMemsetD8.
+  // http://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__MEM.html#group__CUDA__MEM_1g6e582bf866e9e2fb014297bfaf354d7b
+  static tsl::Status SynchronousMemsetUint8(GpuContext* context,
+                                            GpuDevicePtr location,
+                                            uint8_t value, size_t size);
+
+  // Performs a synchronous memset of the device memory segment via cuMemsetD32.
+  // http://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__MEM.html#group__CUDA__MEM_1g983e8d8759acd1b64326317481fbf132
+  static tsl::Status SynchronousMemsetUint32(GpuContext* context,
+                                             GpuDevicePtr location,
+                                             uint32_t value,
+                                             size_t uint32_count);
+
+  // Performs an asynchronous memset of the device memory segment via
+  // cuMemsetD8Async.
+  // http://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__MEM.html#group__CUDA__MEM_1gaef08a7ccd61112f94e82f2b30d43627
+  static tsl::Status AsynchronousMemsetUint8(GpuContext* context,
+                                             GpuDevicePtr location,
+                                             uint8_t value, size_t uint32_count,
+                                             GpuStreamHandle stream);
+
+  // Performs an asynchronous memset of the device memory segment via
+  // cuMemsetD32Async.
+  // http://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__MEM.html#group__CUDA__MEM_1g58229da5d30f1c0cdf667b320ec2c0f5
+  static tsl::Status AsynchronousMemsetUint32(GpuContext* context,
+                                              GpuDevicePtr location,
+                                              uint32_t value,
+                                              size_t uint32_count,
+                                              GpuStreamHandle stream);
+
+  // -- Synchronous memcopies.
+  // http://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__MEM.html#group__CUDA__MEM_1g4d32266788c440b0220b1a9ba5795169
+
+  static tsl::Status SynchronousMemcpyD2H(GpuContext* context, void* host_dst,
+                                          GpuDevicePtr gpu_src, uint64_t size);
+  static tsl::Status SynchronousMemcpyH2D(GpuContext* context,
+                                          GpuDevicePtr gpu_dst,
+                                          const void* host_src, uint64_t size);
+  static tsl::Status SynchronousMemcpyD2D(GpuContext* context,
+                                          GpuDevicePtr gpu_dst,
+                                          GpuDevicePtr gpu_src, uint64_t size);
+
+  // -- Asynchronous memcopies.
+  // http://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__MEM.html#group__CUDA__MEM_1g56f30236c7c5247f8e061b59d3268362
+
+  static bool AsynchronousMemcpyD2H(GpuContext* context, void* host_dst,
+                                    GpuDevicePtr gpu_src, uint64_t size,
+                                    GpuStreamHandle stream);
+  static bool AsynchronousMemcpyH2D(GpuContext* context, GpuDevicePtr gpu_dst,
+                                    const void* host_src, uint64_t size,
+                                    GpuStreamHandle stream);
+  static bool AsynchronousMemcpyD2D(GpuContext* context, GpuDevicePtr gpu_dst,
+                                    GpuDevicePtr gpu_src, uint64_t size,
+                                    GpuStreamHandle stream);
+
+  // The CUDA stream callback type signature.
+  // The data passed to AddStreamCallback is subsequently passed to this
+  // callback when it fires.
+  //
+  // Some notable things:
+  // * Callbacks must not make any CUDA API calls.
+  // * Callbacks from independent streams execute in an undefined order and may
+  //   be serialized.
+  // https://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__EXEC.html#group__CUDA__EXEC_1gab95a78143bae7f21eebb978f91e7f3f
+  typedef void (*StreamCallback)(void* data);
+
+  // Enqueues a callback operation into stream.
+  // See StreamCallback above and the NVIDIA documentation for additional
+  // details.
+  static bool AddStreamCallback(GpuContext* context, GpuStreamHandle stream,
+                                StreamCallback callback, void* data);
+
+  // Causes stream to wait for event to trigger before proceeding via
+  // cuStreamWaitEvent.
+  // http://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__STREAM.html#axzz334nAXAhM
+  static bool WaitStreamOnEvent(GpuContext* context, GpuStreamHandle stream,
+                                GpuEventHandle event);
+
+  // Blocks the calling thread until the operations enqueued onto stream have
+  // been completed, via cuStreamSynchronize.
+  //
+  // TODO(leary) if a pathological thread enqueues operations onto the stream
+  // while another thread blocks like this, can you wind up waiting an unbounded
+  // amount of time?
+  //
+  // http://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__STREAM.html#group__CUDA__STREAM_1g15e49dd91ec15991eb7c0a741beb7dad
+  static tsl::Status SynchronizeStream(GpuContext* context,
+                                       GpuStreamHandle stream);
+
+  // Blocks the calling thread until the operations associated with the context
+  // have been completed, via cuCtxSynchronize.
+  //
+  // http://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__CTX.html#group__CUDA__CTX_1g7a54725f28d34b8c6299f0c6ca579616
+  static bool SynchronizeContext(GpuContext* context);
+
+  // Returns true if all stream tasks have completed at time of the call. Note
+  // the potential for races around this call (if another thread adds work to
+  // the stream immediately after this returns).
+  static bool IsStreamIdle(GpuContext* context, GpuStreamHandle stream);
+
+  // Returns whether code in the from context can access memory in the to
+  // context via cuDeviceCanAccessPeer.
+  // http://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__PEER__ACCESS.html#group__CUDA__PEER__ACCESS_1g496bdaae1f632ebfb695b99d2c40f19e
+  static bool CanEnablePeerAccess(GpuContext* from, GpuContext* to);
+
+  // Returns whether the from device can access memory in the to
+  // device via cuDeviceCanAccessPeer. Because of differences between ROCM and
+  // CUDA, this API is not supported in ROCM builds and will result in a link
+  // error if used.
+  // http://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__PEER__ACCESS.html#group__CUDA__PEER__ACCESS_1g496bdaae1f632ebfb695b99d2c40f19e
+  static bool CanEnablePeerAccess(GpuDeviceHandle from, GpuDeviceHandle to);
+
+  // Enables peer access per CanEnablePeerAccess, via cuCtxEnablePeerAccess.
+  // http://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__PEER__ACCESS.html#group__CUDA__PEER__ACCESS_1g0889ec6728e61c05ed359551d67b3f5a
+  static tsl::Status EnablePeerAccess(GpuContext* from, GpuContext* to);
+
+  // Returns the elapsed milliseconds between start and stop via
+  // cuEventElapsedTime.
+  // http://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__EVENT.html#group__CUDA__EVENT_1gdfb1178807353bbcaa9e245da497cf97
+  static bool GetEventElapsedTime(GpuContext* context,
+                                  float* elapsed_milliseconds,
+                                  GpuEventHandle start, GpuEventHandle stop);
+
+  // Records that an event occurred when execution reaches the current point in
+  // thestream via cuEventRecord.
+  // http://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__EVENT.html#group__CUDA__EVENT_1g95424d3be52c4eb95d83861b70fb89d1
+  static tsl::Status RecordEvent(GpuContext* context, GpuEventHandle event,
+                                 GpuStreamHandle stream);
+
+  // Polls (without blocking) to determine the status of an event - pending or
+  // complete (or an error status).
+  // http://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__EVENT.html#group__CUDA__EVENT_1g6f0704d755066b0ee705749ae911deef
+  static tsl::StatusOr<GpuStatus> QueryEvent(GpuContext* context,
+                                             GpuEventHandle event);
+
+  // -- Pointer-specific calls.
+
+  // Returns the context in which pointer was allocated or registered.
+  static tsl::StatusOr<GpuContext*> GetPointerContext(GpuDevicePtr pointer);
+
+  // Returns the device associated with the context from GetPointerContext().
+  static tsl::StatusOr<GpuDeviceHandle> GetPointerDevice(GpuDevicePtr pointer);
+
+  // Returns the memory space addressed by pointer.
+  static tsl::StatusOr<MemorySpace> GetPointerMemorySpace(GpuDevicePtr pointer);
+
+  // Returns the base address and size of the device pointer dptr.
+  static tsl::Status GetPointerAddressRange(GpuDevicePtr dptr,
+                                            GpuDevicePtr* base, size_t* size);
+
+  // -- Device-specific calls.
+
+  // Returns the compute capability for the device; i.e (3, 5).
+  // This is currently done via the deprecated device API.
+  // http://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__DEVICE__DEPRECATED.html#group__CUDA__DEVICE__DEPRECATED_1ge2091bbac7e1fb18c2821612115607ea
+  // (supported on CUDA only)
+  static tsl::Status GetComputeCapability(int* cc_major, int* cc_minor,
+                                          GpuDeviceHandle device);
+
+  // Returns Gpu ISA version for the device; i.e 803, 900.
+  // (supported on ROCm only)
+  static tsl::Status GetGpuISAVersion(int* version, GpuDeviceHandle device);
+
+  // Return the full GCN Architecture Name for the device
+  // for eg: amdgcn-amd-amdhsa--gfx908:sramecc+:xnack-
+  // (supported on ROCm only)
+  static tsl::Status GetGpuGCNArchName(GpuDeviceHandle device,
+                                       std::string* gcnArchName);
+
+#if TENSORFLOW_USE_ROCM
+  // tests the current device for MFMA insn support (ROCm only)
+  static tsl::StatusOr<bool> GetMFMASupport();
+#endif
+
+  // Returns the number of multiprocessors on the device (note that the device
+  // may be multi-GPU-per-board).
+  static tsl::StatusOr<int> GetMultiprocessorCount(GpuDeviceHandle device);
+
+  // Returns the limit on number of threads that can be resident in a single
+  // multiprocessor.
+  static tsl::StatusOr<int64_t> GetMaxThreadsPerMultiprocessor(
+      GpuDeviceHandle device);
+
+  // Returns the limit on number of threads which may be resident for a single
+  // block (cooperative thread array).
+  static tsl::StatusOr<int64_t> GetMaxThreadsPerBlock(GpuDeviceHandle device);
+
+  // Returns the amount of shared memory available on a single GPU core (i.e.
+  // SM on NVIDIA devices).
+  static tsl::StatusOr<int64_t> GetMaxSharedMemoryPerCore(
+      GpuDeviceHandle device);
+
+  // Returns the amount of static shared memory available for a single block
+  // (cooperative thread array).
+  static tsl::StatusOr<int64_t> GetMaxSharedMemoryPerBlock(
+      GpuDeviceHandle device);
+
+  // Returns the total amount of shared memory available for a single block
+  // (cooperative thread array).
+  static tsl::StatusOr<int64_t> GetMaxSharedMemoryPerBlockOptin(
+      GpuDeviceHandle device);
+
+  // Returns the maximum supported number of registers per block.
+  static tsl::StatusOr<int64_t> GetMaxRegistersPerBlock(GpuDeviceHandle device);
+
+  // Returns the number of threads per warp.
+  static tsl::StatusOr<int64_t> GetThreadsPerWarp(GpuDeviceHandle device);
+
+  // Queries the grid limits for device with cuDeviceGetAttribute calls.
+  // http://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__DEVICE.html#group__CUDA__DEVICE_1g9c3e1414f0ad901d3278a4d6645fc266
+  static tsl::Status GetGridLimits(int* x, int* y, int* z,
+                                   GpuDeviceHandle device);
+
+  // Returns a grab-bag of device properties in a caller-owned device_properties
+  // structure for device_ordinal via cuDeviceGetProperties.
+  //
+  // This call is deprecated in the NVIDIA driver API; its replacement is
+  // GetDeviceAttribute
+  //
+  // http://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__DEVICE__DEPRECATED.html#group__CUDA__DEVICE__DEPRECATED_1g65a5b4e25186bd257df80b98c98cffe6
+  static bool GetDeviceProperties(GpuDeviceProperty* device_properties,
+                                  int device_ordinal);
+
+  // Gets a specific integer-valued property about the given device.
+  //
+  // http://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__DEVICE.html#group__CUDA__DEVICE_1g9c3e1414f0ad901d3278a4d6645fc266
+  static tsl::StatusOr<int> GetDeviceAttribute(GpuDeviceAttribute attribute,
+                                               GpuDeviceHandle device);
+
+  // Returns whether ECC is enabled for the given GpuDeviceHandle via
+  // cuDeviceGetattribute with CU_DEVICE_ATTRIBUTE_ECC_ENABLED.
+  // http://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__DEVICE.html#group__CUDA__DEVICE_1g9c3e1414f0ad901d3278a4d6645fc266
+  static bool IsEccEnabled(GpuDeviceHandle device, bool* result);
+
+  // Returns the total amount of memory available for allocation by the CUDA
+  // context, in bytes, via cuDeviceTotalMem.
+  static bool GetDeviceTotalMemory(GpuDeviceHandle device, uint64_t* result);
+
+  // Returns the free amount of memory and total amount of memory, as reported
+  // by cuMemGetInfo.
+  // http://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__MEM.html#group__CUDA__MEM_1g808f555540d0143a331cc42aa98835c0
+  static bool GetDeviceMemoryInfo(GpuContext* context, int64_t* free,
+                                  int64_t* total);
+
+  // Returns a PCI bus id string for the device.
+  // [domain]:[bus]:[device].[function]
+  // http://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__MEM.html#group__CUDA__MEM_1g85295e7d9745ab8f0aa80dd1e172acfc
+  static std::string GetPCIBusID(GpuDeviceHandle device);
+
+  // -- Context- and device-independent calls.
+
+  // Returns the number of visible CUDA device via cuDeviceGetCount.
+  // This should correspond to the set of device ordinals available.
+  // http://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__DEVICE.html#group__CUDA__DEVICE_1g52b5ce05cb8c5fb6831b2c0ff2887c74
+  static int GetDeviceCount();
+
+  // Returns the driver version number via cuDriverGetVersion.
+  // This is, surprisingly, NOT the actual driver version (e.g. 331.79) but,
+  // instead, the CUDA toolkit release number that this driver is compatible
+  // with; e.g. 6000 (for a CUDA 6.0 compatible driver) or 6050 (for a CUDA 6.5
+  // compatible driver).
+  //
+  // http://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__VERSION.html#group__CUDA__VERSION_1g8b7a10395392e049006e61bcdc8ebe71
+  static bool GetDriverVersion(int* driver_version);
+
+  // -- Other calls
+
+  // Returns the maximum number of blocks (per multiprocessor) occupied by the
+  // specified kernel/GpuFunctionHandle when launched with the specified
+  // parameters.
+  // http://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__OCCUPANCY.html#group__CUDA__OCCUPANCY_1gcc6e1094d05cba2cee17fe33ddd04a98
+  static tsl::StatusOr<int> GetMaxOccupiedBlocksPerCore(
+      GpuContext* context, GpuFunctionHandle kernel, int threads_per_block,
+      size_t dynamic_shared_memory_bytes);
+
+  // Seam for injecting an error at CUDA initialization time for testing
+  // purposes.
+  static bool driver_inject_init_error_;
+};
+
+// Ensures a context is activated within a scope.
+class ScopedActivateContext {
+ public:
+  // Activates the context via cuCtxSetCurrent, if it is not the currently
+  // active context (a la cuCtxGetCurrent). Note the alternative push/pop
+  // mechanism is said by NVIDIA to be relatively slow and deprecated.
+  // http://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__CTX.html#group__CUDA__CTX_1gbe562ee6258b4fcc272ca6478ca2a2f7
+  explicit ScopedActivateContext(GpuContext* context);
+
+  // Checks that the context has remained activated for the duration of the
+  // scope.
+  ~ScopedActivateContext();
+
+ private:
+  GpuContext* to_restore_ = nullptr;
+};
+
+}  // namespace gpu
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_GPU_GPU_DRIVER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/gpu/gpu_event.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/gpu/gpu_event.h
new file mode 100644
index 0000000000000000000000000000000000000000..5653e309c675f2af5a02b85fc9d5c442e5fafa90
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/gpu/gpu_event.h
@@ -0,0 +1,62 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_STREAM_EXECUTOR_GPU_GPU_EVENT_H_
+#define XLA_STREAM_EXECUTOR_GPU_GPU_EVENT_H_
+
+#include "xla/stream_executor/event.h"
+#include "xla/stream_executor/gpu/gpu_driver.h"
+#include "xla/stream_executor/gpu/gpu_stream.h"
+#include "tsl/platform/status.h"
+
+namespace stream_executor {
+namespace gpu {
+
+// GpuEvent wraps a GpuEventHandle in the platform-independent EventInterface
+// interface.
+class GpuEvent : public internal::EventInterface {
+ public:
+  explicit GpuEvent(GpuExecutor* parent);
+
+  ~GpuEvent() override;
+
+  // Populates the CUDA-platform-specific elements of this object.
+  tsl::Status Init();
+
+  // Deallocates any platform-specific elements of this object. This is broken
+  // out (not part of the destructor) to allow for error reporting.
+  tsl::Status Destroy();
+
+  // Inserts the event at the current position into the specified stream.
+  tsl::Status Record(GpuStream* stream);
+
+  // Polls the CUDA platform for the event's current status.
+  Event::Status PollForStatus();
+
+  // The underlying CUDA event element.
+  GpuEventHandle gpu_event();
+
+ private:
+  // The Executor used to which this object and GpuEventHandle are bound.
+  GpuExecutor* parent_;
+
+  // The underlying CUDA event element.
+  GpuEventHandle gpu_event_;
+};
+
+}  // namespace gpu
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_GPU_GPU_EVENT_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/gpu/gpu_executor.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/gpu/gpu_executor.h
new file mode 100644
index 0000000000000000000000000000000000000000..c93073ffd9dafabfaf3712b1a224f1197c1ff865
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/gpu/gpu_executor.h
@@ -0,0 +1,401 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// The CUDA implementation of the StreamExecutorInterface functionality.
+// CUDA inclusions are ideally confined to this implementation file.
+//
+// The notions from the StreamExecutor basically correspond to the CUDA streams
+// programming model provided by the libcuda.so driver APIs, so we don't have
+// to do much more than wrap the calls to the libraries appropriately.
+#ifndef XLA_STREAM_EXECUTOR_GPU_GPU_EXECUTOR_H_
+#define XLA_STREAM_EXECUTOR_GPU_GPU_EXECUTOR_H_
+
+#include <cstdint>
+#include <memory>
+#include <optional>
+#include <set>
+#include <string>
+#include <type_traits>
+#include <unordered_map>
+
+#include "absl/base/thread_annotations.h"
+#include "absl/container/flat_hash_map.h"
+#include "absl/functional/any_invocable.h"
+#include "absl/strings/string_view.h"
+#include "xla/stream_executor/command_buffer.h"
+#include "xla/stream_executor/event.h"
+#include "xla/stream_executor/gpu/gpu_kernel.h"
+#include "xla/stream_executor/platform.h"
+#include "xla/stream_executor/platform/port.h"
+#include "xla/stream_executor/stream_executor.h"
+#include "xla/stream_executor/stream_executor_internal.h"
+#include "tsl/platform/fingerprint.h"
+#include "tsl/platform/status.h"
+#include "tsl/platform/statusor.h"
+
+namespace stream_executor {
+
+class StreamExecutor;
+
+namespace gpu {
+
+// CUDA-platform implementation of the platform-agnostic
+// StreamExecutorInterface.
+class GpuExecutor : public internal::StreamExecutorInterface {
+  // Helper classes to attach a type erased state to the GpuExecutor. Currently,
+  // we just need to support some XLA specific state.
+  class Object {
+    struct Concept {
+      virtual ~Concept() {}
+    };
+    template <typename T>
+    struct Model : Concept {
+      explicit Model(StreamExecutor* se) : object(se) {}
+      T object;
+    };
+
+   public:
+    template <typename T>
+    T* getOrCreate(StreamExecutor* se) {
+      absl::MutexLock l(&mu_);
+      if (!object_) {
+        object_ = std::make_unique<Model<T>>(se);
+      }
+      return &(dynamic_cast<Model<T>*>(object_.get())->object);
+    }
+
+   private:
+    absl::Mutex mu_;
+    std::unique_ptr<Concept> object_ ABSL_GUARDED_BY(mu_);
+  };
+
+ public:
+  // sub_platform indicates the subplatform used in this executor; it must
+  // be a CUDA type.
+  GpuExecutor()
+      : device_(0),
+        context_(nullptr),
+        device_ordinal_(0),
+        cc_major_(0),
+        cc_minor_(0),
+        version_(0) {}
+
+  // See the corresponding StreamExecutor methods for method comments on the
+  // following overrides.
+
+  ~GpuExecutor() override;
+
+  tsl::Status Init(int device_ordinal, DeviceOptions device_options) override;
+
+  tsl::Status GetKernel(const MultiKernelLoaderSpec& spec,
+                        KernelBase* kernel) override;
+
+  // (supported on CUDA only)
+  void UnloadKernel(const KernelBase* kernel) override;
+  tsl::Status LoadModule(const MultiModuleLoaderSpec& spec,
+                         ModuleHandle* module_handle) override;
+  bool UnloadModule(ModuleHandle module_handle) override;
+
+  // Allocates and initializes a new constant on the device with the given
+  // content. Or, if a device with identical content is already on-device,
+  // returns a pointer to that buffer with shared ownership.
+  tsl::StatusOr<std::shared_ptr<DeviceMemoryBase>> CreateOrShareConstant(
+      Stream* stream, const std::vector<uint8_t>& content) override;
+
+  tsl::Status Launch(Stream* stream, const ThreadDim& thread_dims,
+                     const BlockDim& block_dims, const KernelBase& k,
+                     const KernelArgsArrayBase& args) override;
+
+  tsl::Status Submit(Stream* stream,
+                     const CommandBuffer& command_buffer) override;
+
+  // (supported on CUDA only)
+  int CalculateOccupancy(const DeviceDescription& device_description,
+                         uint64_t registers_per_thread,
+                         uint64_t shared_memory_per_block,
+                         const ThreadDim& thread_dims, GpuFunctionHandle func);
+
+  // (supported on CUDA only)
+  int CompareOccupancy(int* initial_blocks,
+                       const DeviceDescription& device_description,
+                       uint64_t registers_per_thread,
+                       uint64_t shared_memory_per_block,
+                       const ThreadDim& thread_dims, GpuFunctionHandle func);
+
+  DeviceMemoryBase Allocate(uint64_t size, int64_t memory_space) override;
+
+  void* GetSubBuffer(DeviceMemoryBase* mem, uint64_t offset_bytes,
+                     uint64_t size_bytes) override;
+
+  void Deallocate(DeviceMemoryBase* mem) override;
+
+  void* UnifiedMemoryAllocate(uint64_t size) override {
+    return GpuDriver::UnifiedMemoryAllocate(context_, size);
+  }
+
+  void UnifiedMemoryDeallocate(void* location) override {
+    return GpuDriver::UnifiedMemoryDeallocate(context_, location);
+  }
+
+  // CUDA allocation/registration functions are necessary because the driver
+  // internally sets up buffers for DMA operations (and page locks them).
+  // There's no external interface for us to otherwise control these DMA
+  // settings.
+  void* HostMemoryAllocate(uint64_t size) override {
+    return GpuDriver::HostAllocate(context_, size);
+  }
+
+  void HostMemoryDeallocate(void* location) override {
+    return GpuDriver::HostDeallocate(context_, location);
+  }
+
+  bool HostMemoryRegister(void* location, uint64_t size) override;
+
+  bool HostMemoryUnregister(void* location) override;
+
+  bool SynchronizeAllActivity() override;
+
+  tsl::Status SynchronousMemZero(DeviceMemoryBase* location,
+                                 uint64_t size) override;
+
+  tsl::Status SynchronousMemSet(DeviceMemoryBase* location, int value,
+                                uint64_t size) override;
+
+  tsl::Status SynchronousMemcpy(DeviceMemoryBase* gpu_dst, const void* host_src,
+                                uint64_t size) override;
+
+  tsl::Status SynchronousMemcpy(void* host_dst, const DeviceMemoryBase& gpu_src,
+                                uint64_t size) override;
+
+  tsl::Status SynchronousMemcpyDeviceToDevice(DeviceMemoryBase* gpu_dst,
+                                              const DeviceMemoryBase& gpu_src,
+                                              uint64_t size) override;
+
+  tsl::Status MemZero(Stream* stream, DeviceMemoryBase* location,
+                      uint64_t size) override;
+  tsl::Status Memset(Stream* stream, DeviceMemoryBase* location,
+                     uint8_t pattern, uint64_t size) override;
+  tsl::Status Memset32(Stream* stream, DeviceMemoryBase* location,
+                       uint32_t pattern, uint64_t size) override;
+
+  bool Memcpy(Stream* stream, void* host_dst, const DeviceMemoryBase& gpu_src,
+              uint64_t size) override;
+
+  bool Memcpy(Stream* stream, DeviceMemoryBase* gpu_dst, const void* host_src,
+              uint64_t size) override;
+
+  bool MemcpyDeviceToDevice(Stream* stream, DeviceMemoryBase* gpu_dst,
+                            const DeviceMemoryBase& gpu_src,
+                            uint64_t size) override;
+
+  bool HostCallback(Stream* stream,
+                    absl::AnyInvocable<tsl::Status() &&> callback) override;
+
+  bool AllocateStream(Stream* stream) override;
+
+  void DeallocateStream(Stream* stream) override;
+
+  bool CreateStreamDependency(Stream* dependent, Stream* other) override;
+
+  tsl::Status AllocateEvent(Event* event) override;
+
+  tsl::Status DeallocateEvent(Event* event) override;
+
+  tsl::Status RecordEvent(Stream* stream, Event* event) override;
+
+  tsl::Status WaitForEvent(Stream* stream, Event* event) override;
+
+  tsl::Status WaitForEventOnExternalStream(std::intptr_t stream,
+                                           Event* event) override;
+
+  Event::Status PollForEventStatus(Event* event) override;
+
+  tsl::Status BlockHostUntilDone(Stream* stream) override;
+
+  tsl::Status EnablePeerAccessTo(StreamExecutorInterface* other) override;
+
+  bool CanEnablePeerAccessTo(StreamExecutorInterface* other) override;
+
+  bool DeviceMemoryUsage(int64_t* free, int64_t* total) const override;
+
+  // Search for the symbol in the given module and returns a device pointer and
+  // size. Returns false if symbol does not exist. 'module_handle' must not
+  // be null.
+  bool GetSymbol(const std::string& symbol_name, ModuleHandle module_handle,
+                 void** mem, size_t* bytes) override;
+
+  tsl::StatusOr<std::unique_ptr<DeviceDescription>> CreateDeviceDescription()
+      const override {
+    return CreateDeviceDescription(device_ordinal_);
+  }
+
+  static tsl::StatusOr<std::unique_ptr<DeviceDescription>>
+  CreateDeviceDescription(int device_ordinal);
+
+  blas::BlasSupport* CreateBlas() override;
+
+  fft::FftSupport* CreateFft() override;
+
+  dnn::DnnSupport* CreateDnn() override;
+
+  std::unique_ptr<internal::EventInterface> CreateEventImplementation()
+      override;
+
+  std::unique_ptr<internal::KernelInterface> CreateKernelImplementation()
+      override;
+
+  std::unique_ptr<internal::StreamInterface> GetStreamImplementation() override;
+
+  tsl::StatusOr<std::unique_ptr<internal::CommandBufferInterface>>
+  GetCommandBufferImplementation(CommandBuffer::Mode mode) override;
+
+  void* GpuContextHack() override;
+
+  GpuContext* gpu_context();
+
+  // Provide a type-erased way of attaching arbitrary XLA specific state to the
+  // GpuExecutor. XLA based execution will use this method to attach per-stream
+  // executor XLA specific objects (like the Infeed and Outfeed managers) to the
+  // stream executor, so that their lifetimes can be tied to the lifetime of the
+  // stream executor for which that object is allocated for. This simplifies
+  // memory management as compared to having these objects reside on the side
+  // and then either leaking or having to implement callbacks that the SE
+  // destructors call to deallocate any side state that is associated with that
+  // SE object.
+  template <typename T>
+  T* getOrCreateXLAState(StreamExecutor* se) {
+    return xla_state_.getOrCreate<T>(se);
+  }
+
+  Stream* FindAllocatedStream(void* gpu_stream) override {
+    absl::MutexLock lock(&alive_gpu_streams_mu_);
+    auto it = alive_gpu_streams_.find(gpu_stream);
+    if (it == alive_gpu_streams_.end()) {
+      return nullptr;
+    }
+    return it->second;
+  }
+
+ private:
+  // Host callback landing routine invoked by CUDA.
+  // data: User-provided callback provided to HostCallback() above, captured
+  //       as a std::function<void()>. Allocated/initialized inside
+  //       HostCallback() and owned and deleted by this call.
+  static void InternalHostCallback(void* data);
+
+  // Collects metadata for the specified kernel.
+  tsl::Status GetKernelMetadata(GpuKernel* cuda_kernel,
+                                KernelMetadata* kernel_metadata);
+
+  // Prints to VLOG(2) information about the kernel's occupancy and how it might
+  // be improved.
+  void VlogOccupancyInfo(const KernelBase& kernel, const ThreadDim& thread_dims,
+                         const BlockDim& block_dims);
+
+  // (supported on CUDA only)
+  tsl::Status LoadModuleFromCuBin(const char* cubin, GpuModuleHandle* module)
+      TF_EXCLUSIVE_LOCKS_REQUIRED(in_memory_modules_mu_);
+
+  // Loads the PTX text `ptx` as a CUDA module.  `ptx` must be null terminated.
+  // (supported on CUDA only)
+  tsl::Status LoadModuleFromPtx(const char* ptx, GpuModuleHandle* module)
+      TF_EXCLUSIVE_LOCKS_REQUIRED(in_memory_modules_mu_);
+
+  // (supported on ROCm only)
+  tsl::Status LoadModuleFromHsaco(const char* hsaco, GpuModuleHandle* module)
+      TF_EXCLUSIVE_LOCKS_REQUIRED(in_memory_modules_mu_);
+
+  bool UnloadGpuBinary(const void* gpu_binary)
+      TF_EXCLUSIVE_LOCKS_REQUIRED(in_memory_modules_mu_);
+
+  // Guards the on-disk-module mapping.
+  absl::Mutex disk_modules_mu_;
+
+  // Mapping from filename to GPUModuleHandle, if it was already retrieved.
+  // Multiple GPUFunctionHandle are usually obtained from a single
+  // GPUModuleHandle so we attempt to hit in this mapping first, before
+  // retrieving it.
+  std::map<std::string, GpuModuleHandle> disk_modules_
+      ABSL_GUARDED_BY(disk_modules_mu_);
+
+  // Guards the in-memory-module mapping.
+  absl::Mutex in_memory_modules_mu_;
+
+  std::map<const char*, GpuModuleHandle> in_memory_modules_
+      ABSL_GUARDED_BY(in_memory_modules_mu_);
+
+  absl::Mutex shared_constants_mu_;
+  // On-device constants that can be shared between multiple executables. A
+  // pointer for a given constant will expire when no executables require use
+  // of that constant anymore.
+  std::map<const absl::uint128, std::weak_ptr<DeviceMemoryBase>>
+      shared_constants_ ABSL_GUARDED_BY(shared_constants_mu_);
+
+  // Kernel -> loaded GPU binary. Many kernels may load the same binary.
+  std::unordered_map<const KernelBase*, const void*> kernel_to_gpu_binary_
+      ABSL_GUARDED_BY(in_memory_modules_mu_);
+  // GPU binary (PTX or CUBIN or HSACO) -> {CUDA module, reference count}.
+  std::unordered_map<const void*, std::pair<GpuModuleHandle, uint64_t>>
+      gpu_binary_to_module_ ABSL_GUARDED_BY(in_memory_modules_mu_);
+
+  // Guards the launched kernel set.
+  absl::Mutex launched_kernels_mu_;
+
+  // Keeps track of the set of launched kernels. Currently used to suppress the
+  // occupancy check on subsequent launches.
+  std::set<GpuFunctionHandle> launched_kernels_
+      ABSL_GUARDED_BY(launched_kernels_mu_);
+
+  // Handle for the CUDA device being operated on. Immutable
+  // post-initialization.
+  GpuDeviceHandle device_;
+
+  // Handle for session with the library/driver. Immutable post-initialization.
+  GpuContext* context_;
+
+  // The device ordinal value that this executor was initialized with; recorded
+  // for use in getting device metadata. Immutable post-initialization.
+  int device_ordinal_;
+
+  // The major version of the compute capability for device_.
+  int cc_major_;
+
+  // The minor version of the compute capability for device_.
+  int cc_minor_;
+
+  // GPU ISA version for device_.
+  int version_;
+
+  // Type erased XLA specific state attached to GpuExecutor.
+  Object xla_state_;
+
+  absl::Mutex alive_gpu_streams_mu_;
+
+  // Lookup map for alive streams, from raw stream pointers.
+  absl::flat_hash_map<void*, Stream*> alive_gpu_streams_
+      ABSL_GUARDED_BY(alive_gpu_streams_mu_);
+
+  GpuExecutor(const GpuExecutor&) = delete;
+  void operator=(const GpuExecutor&) = delete;
+};
+
+inline GpuExecutor* ExtractGpuExecutor(StreamExecutor* stream_exec) {
+  return static_cast<GpuExecutor*>(stream_exec->implementation());
+}
+
+}  // namespace gpu
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_GPU_GPU_EXECUTOR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/gpu/gpu_graph.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/gpu/gpu_graph.h
new file mode 100644
index 0000000000000000000000000000000000000000..af58a4102c29f3d6eef9073443b9a48fbef4aab4
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/gpu/gpu_graph.h
@@ -0,0 +1,140 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_STREAM_EXECUTOR_GPU_GPU_GRAPH_H_
+#define XLA_STREAM_EXECUTOR_GPU_GPU_GRAPH_H_
+
+#include <atomic>
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <type_traits>
+
+#include "absl/functional/any_invocable.h"
+#include "absl/types/span.h"
+#include "xla/stream_executor/gpu/gpu_types.h"
+#include "xla/stream_executor/kernel.h"
+#include "xla/stream_executor/launch_dim.h"
+#include "xla/stream_executor/stream.h"
+#include "tsl/platform/status.h"
+#include "tsl/platform/statusor.h"
+
+namespace stream_executor {
+namespace gpu {
+
+// Forward declare.
+class GpuContext;
+
+class GpuGraphSupport {
+ public:
+  // Deleters for gpu graph and graph exec instance that check the returned
+  // status and terminate on error.
+  struct DestroyGraph {
+    void operator()(GpuGraphHandle);
+  };
+  struct DestroyGraphExec {
+    void operator()(GpuGraphExecHandle);
+  };
+
+  static size_t NotifyGraphExecCreated();
+  static size_t NotifyGraphExecDestroyed();
+
+  static size_t allocated_gpu_graph_execs();
+  static size_t alive_gpu_graph_execs();
+
+ private:
+  // Global counters for the total number of allocated and alive gpu graph
+  // execs to track the resource usage at run time.
+  static std::atomic<size_t> allocated_gpu_graph_execs_;
+  static std::atomic<size_t> alive_gpu_graph_execs_;
+};
+
+//===----------------------------------------------------------------------===//
+// RAII helpers for gpu graph types.
+//===----------------------------------------------------------------------===//
+
+class OwnedGpuGraph
+    : public std::unique_ptr<std::remove_pointer_t<GpuGraphHandle>,
+                             GpuGraphSupport::DestroyGraph> {
+  // Bring std::unique_ptr constructors in scope.
+  using std::unique_ptr<std::remove_pointer_t<GpuGraphHandle>,
+                        GpuGraphSupport::DestroyGraph>::unique_ptr;
+};
+
+class OwnedGpuGraphExec
+    : public std::unique_ptr<std::remove_pointer_t<GpuGraphExecHandle>,
+                             GpuGraphSupport::DestroyGraphExec> {
+  using Base = std::unique_ptr<std::remove_pointer_t<GpuGraphExecHandle>,
+                               GpuGraphSupport::DestroyGraphExec>;
+
+ public:
+  OwnedGpuGraphExec(uint64_t id, GpuGraphExecHandle exec)
+      : Base(exec), id_(id) {}
+  ~OwnedGpuGraphExec();
+
+  OwnedGpuGraphExec(OwnedGpuGraphExec&&) = default;
+  OwnedGpuGraphExec& operator=(OwnedGpuGraphExec&&) = default;
+
+  enum class UpdateResult { kSuccess, kFallback };
+
+  // Updates executable graph instance with a newly captured graph. Returns an
+  // error if the new graph is not compatible (see `cudaGraphExecUpdate`).
+  tsl::StatusOr<UpdateResult> Update(OwnedGpuGraph graph);
+
+  // Launches captured graph on a given stream.
+  tsl::Status Launch(stream_executor::Stream* stream);
+
+  uint64_t id() const { return id_; }
+
+ private:
+  uint64_t id_;
+  uint64_t num_updates_ = 0;
+  uint64_t num_launches_ = 0;
+};
+
+//===----------------------------------------------------------------------===//
+// Gpu Graph Helpers.
+//===----------------------------------------------------------------------===//
+
+// Creates new empty Gpu graph.
+tsl::StatusOr<OwnedGpuGraph> CreateGpuGraph();
+
+// Adds a kernel node to the graph.
+tsl::StatusOr<GpuGraphNodeHandle> AddKernelNode(
+    GpuGraphHandle graph, absl::Span<GpuGraphNodeHandle> deps,
+    ThreadDim threads, BlockDim blocks, const KernelBase& kernel,
+    const KernelArgsArrayBase& args);
+
+// Adds a memory copy node to the graph.
+tsl::StatusOr<GpuGraphNodeHandle> AddMemcpyD2DNode(
+    GpuContext* context, GpuGraphHandle graph,
+    absl::Span<GpuGraphNodeHandle> deps, const DeviceMemoryBase& dst,
+    const DeviceMemoryBase& src);
+
+// Captures all operations added to a `stream` by the `capture` function into
+// the gpu graph instance.
+tsl::StatusOr<OwnedGpuGraph> CaptureGpuGraph(
+    stream_executor::Stream* stream, absl::AnyInvocable<tsl::Status()> capture);
+
+// Instantiates a captured gpu graph instance into a gpu graph executable.
+tsl::StatusOr<OwnedGpuGraphExec> InstantiateGpuGraph(OwnedGpuGraph graph);
+
+// Returns true if the stream is in graph capture mode
+tsl::StatusOr<bool> IsStreamCapturing(stream_executor ::Stream* stream);
+
+}  // namespace gpu
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_GPU_GPU_GRAPH_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/gpu/gpu_helpers.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/gpu/gpu_helpers.h
new file mode 100644
index 0000000000000000000000000000000000000000..cefd0a6af15dfd70d06c94677230a20d66d219f4
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/gpu/gpu_helpers.h
@@ -0,0 +1,114 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// Common helper functions used for dealing with CUDA API datatypes.
+//
+// These are typically placed here for use by multiple source components (for
+// example, BLAS and executor components).
+
+#ifndef XLA_STREAM_EXECUTOR_GPU_GPU_HELPERS_H_
+#define XLA_STREAM_EXECUTOR_GPU_GPU_HELPERS_H_
+
+#include <stddef.h>
+
+#include <complex>
+
+#include "xla/stream_executor/gpu/gpu_types.h"
+#include "tsl/platform/logging.h"
+
+namespace stream_executor {
+
+template <typename ElemT>
+class DeviceMemory;
+
+namespace gpu {
+
+// Converts a const DeviceMemory reference to its underlying typed pointer in
+// CUDA device memory.
+template <typename T>
+const T* GpuMemory(const DeviceMemory<T>& mem) {
+  return static_cast<const T*>(mem.opaque());
+}
+
+// Converts a (non-const) DeviceMemory pointer reference to its underlying typed
+// pointer in CUDA device memory.
+template <typename T>
+T* GpuMemoryMutable(DeviceMemory<T>* mem) {
+  return static_cast<T*>(mem->opaque());
+}
+
+static_assert(
+    sizeof(std::complex<float>) == sizeof(GpuComplexType),
+    "std::complex<float> and GpuComplexType should have the same size");
+static_assert(offsetof(GpuComplexType, x) == 0,
+              "The real part of GpuComplexType should appear first.");
+static_assert(
+    sizeof(std::complex<double>) == sizeof(GpuDoubleComplexType),
+    "std::complex<double> and GpuDoubleComplexType should have the same "
+    "size");
+static_assert(offsetof(GpuDoubleComplexType, x) == 0,
+              "The real part of GpuDoubleComplexType should appear first.");
+
+// Type traits to get CUDA complex types from std::complex<>.
+
+template <typename T>
+struct GpuComplexT {
+  typedef T type;
+};
+
+template <>
+struct GpuComplexT<std::complex<float>> {
+  typedef GpuComplexType type;
+};
+
+template <>
+struct GpuComplexT<std::complex<double>> {
+  typedef GpuDoubleComplexType type;
+};
+
+// Converts pointers of std::complex<> to pointers of
+// GpuComplexType/GpuDoubleComplexType. No type conversion for non-complex
+// types.
+
+template <typename T>
+inline const typename GpuComplexT<T>::type* GpuComplex(const T* p) {
+  auto* result = reinterpret_cast<const typename GpuComplexT<T>::type*>(p);
+  CHECK_EQ(reinterpret_cast<uintptr_t>(p) % alignof(decltype(*result)), 0)
+      << "Source pointer is not aligned by " << alignof(decltype(*result));
+  return result;
+}
+
+template <typename T>
+inline typename GpuComplexT<T>::type* GpuComplex(T* p) {
+  auto* result = reinterpret_cast<typename GpuComplexT<T>::type*>(p);
+  CHECK_EQ(reinterpret_cast<uintptr_t>(p) % alignof(decltype(*result)), 0)
+      << "Source pointer is not aligned by " << alignof(decltype(*result));
+  return result;
+}
+
+// Converts values of std::complex<float/double> to values of
+// GpuComplexType/GpuDoubleComplexType.
+inline GpuComplexType GpuComplexValue(std::complex<float> val) {
+  return {val.real(), val.imag()};
+}
+
+inline GpuDoubleComplexType GpuComplexValue(std::complex<double> val) {
+  return {val.real(), val.imag()};
+}
+
+}  // namespace gpu
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_GPU_GPU_HELPERS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/gpu/gpu_init.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/gpu/gpu_init.h
new file mode 100644
index 0000000000000000000000000000000000000000..bcdce71f9ffce79f59d14f7d3e6e84db13d6ac29
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/gpu/gpu_init.h
@@ -0,0 +1,43 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_STREAM_EXECUTOR_GPU_GPU_INIT_H_
+#define XLA_STREAM_EXECUTOR_GPU_GPU_INIT_H_
+
+#include <string>
+
+#include "tsl/platform/status.h"
+
+namespace stream_executor {
+class Platform;
+
+// Initializes the GPU platform and returns OK if the GPU
+// platform could be initialized.
+tsl::Status ValidateGPUMachineManager();
+
+// Returns the GPU machine manager singleton, creating it and
+// initializing the GPUs on the machine if needed the first time it is
+// called.  Must only be called when there is a valid GPU environment
+// in the process (e.g., ValidateGPUMachineManager() returns OK).
+Platform* GPUMachineManager();
+
+// Returns the string describing the name of the GPU platform in use.
+// This value is "CUDA" by default, and
+// "ROCM" when TF is built with `--config==rocm`
+std::string GpuPlatformName();
+
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_GPU_GPU_INIT_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/gpu/gpu_kernel.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/gpu/gpu_kernel.h
new file mode 100644
index 0000000000000000000000000000000000000000..b7fa33c87e5acefbf1932be3b18ba825bab65bbb
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/gpu/gpu_kernel.h
@@ -0,0 +1,105 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// The CUDA implementation of the StreamExecutorInterface functionality.
+// CUDA inclusions are ideally confined to this implementation file.
+//
+// The notions from the StreamExecutor basically correspond to the CUDA streams
+// programming model provided by the libcuda.so driver APIs, so we don't have
+// to do much more than wrap the calls to the libraries appropriately.
+#ifndef XLA_STREAM_EXECUTOR_GPU_GPU_KERNEL_H_
+#define XLA_STREAM_EXECUTOR_GPU_GPU_KERNEL_H_
+
+#include "xla/stream_executor/gpu/gpu_driver.h"
+#include "xla/stream_executor/kernel_cache_config.h"
+#include "xla/stream_executor/platform/port.h"
+#include "xla/stream_executor/stream_executor_internal.h"
+#include "tsl/platform/logging.h"
+
+namespace stream_executor {
+namespace gpu {
+
+// Wraps a GpuFunctionHandle to implement the platform-independent
+// KernelInterface.
+class GpuKernel : public internal::KernelInterface {
+ public:
+  GpuKernel()
+      : gpu_function_(nullptr),
+        arity_(0),
+        preferred_cache_config_(KernelCacheConfig::kNoPreference) {}
+
+  // Note that the function is unloaded when the module is unloaded, and the
+  // module that the function is contained in is owned by the GpuExecutor.
+  ~GpuKernel() override {}
+
+  // As arity cannot be reflected upon using the CUDA API, the arity is
+  // explicitly set during the GpuExecutor::GetKernel initialization process.
+  void set_arity(unsigned arity) { arity_ = arity; }
+  unsigned Arity() const override { return arity_; }
+
+  // Returns the GpuFunctionHandle value for passing to the CUDA API.
+  GpuFunctionHandle AsGpuFunctionHandle() const {
+    DCHECK(gpu_function_ != nullptr);
+    return const_cast<GpuFunctionHandle>(gpu_function_);
+  }
+
+  // Returns the slot that the GpuFunctionHandle is stored within for this
+  // object, for the CUDA API which wants to load into a GpuFunctionHandle*.
+  GpuFunctionHandle* gpu_function_ptr() { return &gpu_function_; }
+
+  // CUDA supports setting the preferred cache configuration of a
+  // GpuFunctionHandle (more-or-less equivalent to a GpuKernel). We support this
+  // via the below functions; users can set a preference, and that is applied
+  // when the kernel is [lazy-]loaded (in GpuExecutor::Launch). The alternative
+  // would be to load the kernel & set the preference when the user calls the
+  // setter below; either approach is valid. Sets the current kernel cache
+  // configuration preference.
+  void SetPreferredCacheConfig(KernelCacheConfig config) override {
+    preferred_cache_config_ = config;
+  }
+
+  // Returns the current kernel cache configuration preference.
+  KernelCacheConfig GetPreferredCacheConfig() const override {
+    return preferred_cache_config_;
+  }
+
+  // Returns the current kernel cache configuration preference as a
+  // CUfunc_cache.
+  GpuFuncCachePreference GetGpuCacheConfig() const;
+
+ private:
+  GpuFunctionHandle gpu_function_;  // Wrapped CUDA kernel handle.
+  unsigned arity_;  // Number of formal parameters the kernel takes.
+
+  // Preferred (but not required) cache configuration for this kernel.
+  KernelCacheConfig preferred_cache_config_;
+};
+
+// Given a platform-independent kernel datatype, returns the (const) internal
+// CUDA platform implementation pointer.
+inline const GpuKernel* AsGpuKernel(const KernelBase* kernel) {
+  return static_cast<const GpuKernel*>(kernel->implementation());
+}
+
+// Given a platform-independent kernel datatype, returns the (non-const)
+// internal CUDA platform implementation pointer.
+inline GpuKernel* AsGpuKernel(KernelBase* kernel) {
+  return static_cast<GpuKernel*>(kernel->implementation());
+}
+
+}  // namespace gpu
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_GPU_GPU_KERNEL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/gpu/gpu_stream.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/gpu/gpu_stream.h
new file mode 100644
index 0000000000000000000000000000000000000000..66a6df44ee1012f2999fd08a326d4f34a423a955
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/gpu/gpu_stream.h
@@ -0,0 +1,107 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// Defines the GpuStream type - the CUDA-specific implementation of the generic
+// StreamExecutor Stream interface.
+
+#ifndef XLA_STREAM_EXECUTOR_GPU_GPU_STREAM_H_
+#define XLA_STREAM_EXECUTOR_GPU_GPU_STREAM_H_
+
+#include <variant>
+
+#include "xla/stream_executor/gpu/gpu_types.h"
+#include "xla/stream_executor/stream_executor_internal.h"
+
+namespace stream_executor {
+namespace gpu {
+
+class GpuExecutor;
+
+// Wraps a GpuStreamHandle in order to satisfy the platform-independent
+// StreamInterface.
+//
+// Thread-safe post-initialization.
+class GpuStream : public internal::StreamInterface {
+ public:
+  explicit GpuStream(GpuExecutor* parent)
+      : parent_(parent), gpu_stream_(nullptr), completed_event_(nullptr) {}
+
+  // Note: teardown is handled by a parent's call to DeallocateStream.
+  ~GpuStream() override = default;
+
+  void* GpuStreamHack() override { return gpu_stream_; }
+  void** GpuStreamMemberHack() override {
+    return reinterpret_cast<void**>(&gpu_stream_);
+  }
+
+  // Explicitly initialize the CUDA resources associated with this stream, used
+  // by StreamExecutor::AllocateStream().
+  bool Init();
+
+  void SetPriority(StreamPriority priority) override {
+    stream_priority_ = priority;
+  }
+
+  void SetPriority(int priority) override { stream_priority_ = priority; }
+
+  std::variant<StreamPriority, int> priority() const override {
+    return stream_priority_;
+  }
+
+  // Explicitly destroy the CUDA resources associated with this stream, used by
+  // StreamExecutor::DeallocateStream().
+  void Destroy();
+
+  // Returns true if no work is pending or executing on the stream.
+  bool IsIdle() const;
+
+  // Retrieves an event which indicates that all work enqueued into the stream
+  // has completed. Ownership of the event is not transferred to the caller, the
+  // event is owned by this stream.
+  GpuEventHandle* completed_event() { return &completed_event_; }
+
+  // Returns the GpuStreamHandle value for passing to the CUDA API.
+  //
+  // Precond: this GpuStream has been allocated (otherwise passing a nullptr
+  // into the NVIDIA library causes difficult-to-understand faults).
+  GpuStreamHandle gpu_stream() const {
+    DCHECK(gpu_stream_ != nullptr);
+    return const_cast<GpuStreamHandle>(gpu_stream_);
+  }
+
+  // TODO(timshen): Migrate away and remove this function.
+  GpuStreamHandle cuda_stream() const { return gpu_stream(); }
+
+  GpuExecutor* parent() const { return parent_; }
+
+ private:
+  GpuExecutor* parent_;         // Executor that spawned this stream.
+  GpuStreamHandle gpu_stream_;  // Wrapped CUDA stream handle.
+  std::variant<StreamPriority, int> stream_priority_;
+
+  // Event that indicates this stream has completed.
+  GpuEventHandle completed_event_ = nullptr;
+};
+
+// Helper functions to simplify extremely common flows.
+// Converts a Stream to the underlying GpuStream implementation.
+GpuStream* AsGpuStream(Stream* stream);
+
+// Extracts a GpuStreamHandle from a GpuStream-backed Stream object.
+GpuStreamHandle AsGpuStreamValue(Stream* stream);
+}  // namespace gpu
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_GPU_GPU_STREAM_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/gpu/gpu_timer.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/gpu/gpu_timer.h
new file mode 100644
index 0000000000000000000000000000000000000000..23663cb1d978f1dc6a42d81db033330a87c86cf5
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/gpu/gpu_timer.h
@@ -0,0 +1,76 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_STREAM_EXECUTOR_GPU_GPU_TIMER_H_
+#define XLA_STREAM_EXECUTOR_GPU_GPU_TIMER_H_
+
+#include <optional>
+#include <utility>
+
+#include "xla/stream_executor/gpu/gpu_driver.h"
+#include "xla/stream_executor/gpu/gpu_executor.h"
+#include "xla/stream_executor/stream_executor_internal.h"
+
+namespace stream_executor {
+namespace gpu {
+
+class GpuExecutor;
+class GpuStream;
+
+// Timer is started once it's created, and is stopped once read.
+class GpuTimer {
+ public:
+  static tsl::StatusOr<GpuTimer> Create(GpuStream* stream);
+
+  // An ugly but a very convenient helper: creates a timer only when we need
+  // one, but always returns an object. If `is_needed` is false, returns an
+  // empty optional, acts like `Create` otherwise.
+  static tsl::StatusOr<std::optional<GpuTimer>> CreateIfNeeded(
+      GpuStream* stream, bool is_needed);
+
+  explicit GpuTimer(GpuExecutor* parent, GpuEventHandle start_event,
+                    GpuEventHandle stop_event, GpuStream* stream)
+      : parent_(parent),
+        start_event_(start_event),
+        stop_event_(stop_event),
+        stream_(stream) {}
+
+  GpuTimer(GpuTimer&& other)
+      : parent_(other.parent_),
+        start_event_(std::exchange(other.start_event_, nullptr)),
+        stop_event_(std::exchange(other.stop_event_, nullptr)),
+        stream_(other.stream_) {}
+
+  ~GpuTimer();
+
+  // Stops the timer on the first call and returns the elapsed duration.
+  // Subsequent calls error out.
+  tsl::StatusOr<absl::Duration> GetElapsedDuration();
+
+ private:
+  GpuExecutor* parent_;
+  GpuEventHandle start_event_ = nullptr;
+  GpuEventHandle stop_event_ = nullptr;
+  GpuStream* stream_;
+  bool is_stopped_ = false;
+
+  GpuTimer(const GpuTimer&) = delete;
+  void operator=(const GpuTimer&) = delete;
+};
+
+}  // namespace gpu
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_GPU_GPU_TIMER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/gpu/gpu_types.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/gpu/gpu_types.h
new file mode 100644
index 0000000000000000000000000000000000000000..dea81d66a1d59dbf6d95b7118845de39652cb37f
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/gpu/gpu_types.h
@@ -0,0 +1,87 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// GPU (ROCm / CUDA) specific type handle resolution
+
+#ifndef XLA_STREAM_EXECUTOR_GPU_GPU_TYPES_H_
+#define XLA_STREAM_EXECUTOR_GPU_GPU_TYPES_H_
+
+#if TENSORFLOW_USE_ROCM
+
+#define __HIP_DISABLE_CPP_FUNCTIONS__
+
+#include "rocm/include/hip/hip_complex.h"
+#include "rocm/include/hip/hip_runtime.h"
+#include "rocm/include/hiprand/hiprand.h"
+
+#else  // CUDA
+
+#include "third_party/gpus/cuda/include/cuComplex.h"
+#include "third_party/gpus/cuda/include/cuda.h"
+
+#endif
+
+namespace stream_executor {
+namespace gpu {
+
+#if TENSORFLOW_USE_ROCM
+
+using GpuContextHandle = hipCtx_t;
+using GpuStreamHandle = hipStream_t;
+using GpuEventHandle = hipEvent_t;
+using GpuFunctionHandle = hipFunction_t;
+using GpuFunctionAttribute = hipFunction_attribute;
+using GpuDeviceHandle = hipDevice_t;
+using GpuDevicePtr = hipDeviceptr_t;
+using GpuDeviceAttribute = hipDeviceAttribute_t;
+using GpuDeviceProperty = hipDeviceProp_t;
+using GpuModuleHandle = hipModule_t;
+using GpuStatus = hipError_t;
+using GpuFuncCachePreference = hipFuncCache_t;
+using GpuSharedMemConfig = hipSharedMemConfig;
+using GpuComplexType = hipComplex;
+using GpuDoubleComplexType = hipDoubleComplex;
+using GpuRngHandle = hiprandGenerator_t;
+using GpuGraphHandle = hipGraph_t;
+using GpuGraphExecHandle = hipGraphExec_t;
+using GpuGraphNodeHandle = hipGraphNode_t;
+
+#else  // CUDA
+
+using GpuContextHandle = CUcontext;
+using GpuStreamHandle = CUstream;
+using GpuEventHandle = CUevent;
+using GpuFunctionHandle = CUfunction;
+using GpuFunctionAttribute = CUfunction_attribute;
+using GpuDeviceHandle = CUdevice;
+using GpuDevicePtr = CUdeviceptr;
+using GpuDeviceAttribute = CUdevice_attribute;
+using GpuDeviceProperty = CUdevprop;
+using GpuModuleHandle = CUmodule;
+using GpuStatus = CUresult;
+using GpuFuncCachePreference = CUfunc_cache;
+using GpuSharedMemConfig = CUsharedconfig;
+using GpuComplexType = cuComplex;
+using GpuDoubleComplexType = cuDoubleComplex;
+using GpuGraphHandle = CUgraph;
+using GpuGraphExecHandle = CUgraphExec;
+using GpuGraphNodeHandle = CUgraphNode;
+
+#endif
+
+}  // namespace gpu
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_GPU_GPU_TYPES_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/gpu/redzone_allocator.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/gpu/redzone_allocator.h
new file mode 100644
index 0000000000000000000000000000000000000000..43694d3295c3864980e379438f09d7abc880c4de
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/gpu/redzone_allocator.h
@@ -0,0 +1,135 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_STREAM_EXECUTOR_GPU_REDZONE_ALLOCATOR_H_
+#define XLA_STREAM_EXECUTOR_GPU_REDZONE_ALLOCATOR_H_
+
+#include <cstdint>
+#include <vector>
+
+#include "xla/stream_executor/device_memory_allocator.h"
+#include "xla/stream_executor/gpu/asm_compiler.h"
+#include "xla/stream_executor/gpu/gpu_asm_opts.h"
+#include "xla/stream_executor/scratch_allocator.h"
+#include "xla/stream_executor/stream_executor.h"
+#include "tsl/lib/math/math_util.h"
+
+namespace stream_executor {
+
+// An allocator that allocates a bit of extra memory around the beginning/end of
+// every allocation and can check that this memory is unmodified.
+//
+// This can be used to check for out-of-bounds writes, and, if the redzone is
+// filled with a sufficiently "ugly" pattern, may also be able to check for
+// out-of-bounds reads.  The default fill pattern of -1 is an unusual NaN
+// pattern when interpreted as a floating-point number, so hopefully works for
+// out-of-bounds reads and writes in those cases.
+//
+// This class implements ScratchAllocator, so can be used to allocate temp
+// memory for cudnn convolutions.
+class RedzoneAllocator : public ScratchAllocator {
+ public:
+  static constexpr int64_t kDefaultRedzoneSize =
+      1LL << 23;  // 8MiB per side, 16MiB total.
+  static constexpr uint8_t kDefaultRedzonePattern = -1;  // NOLINT
+  RedzoneAllocator(Stream* stream, DeviceMemoryAllocator* memory_allocator,
+                   GpuAsmOpts gpu_compilation_opts_,
+                   int64_t memory_limit = (1LL << 32),  // 4GB
+                   int64_t redzone_size = kDefaultRedzoneSize,
+                   uint8_t redzone_pattern = kDefaultRedzonePattern);
+
+  // Redzones don't count towards the memory limit.
+  int64_t GetMemoryLimitInBytes() override { return memory_limit_; }
+
+  int64_t TotalAllocatedBytesExcludingRedzones() const {
+    return allocated_bytes_excluding_redzones_;
+  }
+
+  tsl::StatusOr<DeviceMemory<uint8>> AllocateBytes(int64_t byte_size) override;
+
+  // Non-empty redzone check status implies that there was a write into a
+  // redzone, with a string communicating the location of the write.
+  struct RedzoneCheckStatus {
+    RedzoneCheckStatus() = default;
+
+    RedzoneCheckStatus(absl::string_view buffer_name, void* user_buffer_address,
+                       int64_t offset, uint64_t expected_value,
+                       uint64_t actual_value)
+        : buffer_name(buffer_name),
+          user_buffer_address(user_buffer_address),
+          offset(offset),
+          expected_value(expected_value),
+          actual_value(actual_value) {}
+
+    static RedzoneCheckStatus OK() { return {}; }
+
+    bool ok() { return user_buffer_address == nullptr; }
+
+    std::string RedzoneFailureMsg() const;
+
+    std::string buffer_name = {};
+    void* user_buffer_address = nullptr;
+    int64_t offset = 0;
+    uint64_t expected_value = 0;
+    uint64_t actual_value = 0;
+  };
+
+  // Determines whether redzones around all allocated buffers are unmodified.
+  //
+  // Reinitializes redzones to the expected value, so that the same buffer
+  // can be reused for multiple checks.
+  //
+  // Returns:
+  //
+  //  - RedzoneCheckStatus::OK() if everything went well.
+  //  - RedzoneCheckStatus with a non-empty error message iff a write into a
+  //    redzone has been detected.
+  //  - A stream error, if loading or launching the kernel has failed.
+  tsl::StatusOr<RedzoneCheckStatus> CheckRedzones() const;
+
+  Stream* stream() const { return stream_; }
+
+ private:
+  const int device_ordinal_;
+  Stream* stream_;
+
+  // Memory limit of the allocator in bytes.
+  const int64_t memory_limit_;
+
+  // Redzone size on *one side* of allocation in bytes.
+  //
+  // Must be a multiple of kXlaAllocatedBufferAlignBytes, otherwise the buffers
+  // returned to users will be misaligned.
+  const int64_t redzone_size_;
+
+  const uint8_t redzone_pattern_;
+  DeviceMemoryAllocator* memory_allocator_;
+  GpuAsmOpts gpu_compilation_opts_;
+
+  // The second element of the pair is the size of the user allocation.  This
+  // isn't necessarily just first.size() - 2 * redzone_size_ because when the
+  // user allocation size is not a multiple of 4 bytes, we round up the size of
+  // the RHS redzone.
+  //
+  // ScratchAllocators need to free all allocated memory on destruction so we
+  // use `OwningDeviceMemory` here.
+  std::vector<std::pair<OwningDeviceMemory, int64_t>> allocated_buffers_;
+
+  int64_t allocated_bytes_excluding_redzones_ = 0;
+};
+
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_GPU_REDZONE_ALLOCATOR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/host/host_gpu_executor.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/host/host_gpu_executor.h
new file mode 100644
index 0000000000000000000000000000000000000000..2a92fd17c35ac4966c9d5680b0ebff1261de7724
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/host/host_gpu_executor.h
@@ -0,0 +1,164 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// Declares the HostExecutor class, which is a CPU-only implementation of
+// the StreamExecutor interface. For now, this is used for testing and to
+// examine the performance of host-based StreamExecutor code.
+#ifndef XLA_STREAM_EXECUTOR_HOST_HOST_GPU_EXECUTOR_H_
+#define XLA_STREAM_EXECUTOR_HOST_HOST_GPU_EXECUTOR_H_
+
+#include <cstdint>
+
+#include "absl/functional/any_invocable.h"
+#include "xla/stream_executor/blas.h"
+#include "xla/stream_executor/host/host_stream.h"
+#include "xla/stream_executor/stream_executor.h"
+#include "xla/stream_executor/stream_executor_internal.h"
+#include "tsl/platform/errors.h"
+
+namespace stream_executor {
+namespace host {
+
+// An implementation of StreamExecutor that does no communication or interaction
+// with a device, but DOES perform memory operations backed by the host.
+// Plugin routines (BLAS) are also supported and functional.
+// Kernel invocations will fail, but host callbacks may be enqueued on this
+// executor and its associated stream, and should follow standard ordering
+// semantics.
+//
+// This is useful for evaluating the performance of host-based or fallback
+// routines executed under the context of a GPU executor.
+// See stream_executor.h for description of the below operations.
+class HostExecutor : public internal::StreamExecutorInterface {
+ public:
+  HostExecutor() = default;
+
+  // The stack size used for host streams can be set via
+  // device_options.non_portable_tags["host_stack_size"].
+  tsl::Status Init(int device_ordinal, DeviceOptions device_options) override;
+
+  tsl::Status GetKernel(const MultiKernelLoaderSpec& spec,
+                        KernelBase* kernel) override {
+    return tsl::errors::Unimplemented("Not Implemented");
+  }
+  tsl::Status Launch(Stream* stream, const ThreadDim& thread_dims,
+                     const BlockDim& block_dims, const KernelBase& kernel,
+                     const KernelArgsArrayBase& args) override {
+    return tsl::errors::Unimplemented("Not Implemented");
+  }
+
+  DeviceMemoryBase Allocate(uint64_t size, int64_t memory_space) override;
+  void* GetSubBuffer(DeviceMemoryBase* parent, uint64_t offset_bytes,
+                     uint64_t size_bytes) override;
+  void Deallocate(DeviceMemoryBase* mem) override;
+
+  void* HostMemoryAllocate(uint64_t size) override { return new char[size]; }
+  void HostMemoryDeallocate(void* mem) override {
+    delete[] static_cast<char*>(mem);
+  }
+  bool HostMemoryRegister(void* mem, uint64_t size) override { return true; }
+  bool HostMemoryUnregister(void* mem) override { return true; }
+
+  bool Memcpy(Stream* stream, void* host_dst, const DeviceMemoryBase& gpu_src,
+              uint64_t size) override;
+  bool Memcpy(Stream* stream, DeviceMemoryBase* gpu_dst, const void* host_src,
+              uint64_t size) override;
+  bool MemcpyDeviceToDevice(Stream* stream, DeviceMemoryBase* gpu_dst,
+                            const DeviceMemoryBase& gpu_src,
+                            uint64_t size) override;
+
+  tsl::Status MemZero(Stream* stream, DeviceMemoryBase* location,
+                      uint64_t size) override;
+  tsl::Status Memset(Stream* stream, DeviceMemoryBase* location,
+                     uint8_t pattern, uint64_t size) override;
+  tsl::Status Memset32(Stream* stream, DeviceMemoryBase* location,
+                       uint32_t pattern, uint64_t size) override;
+
+  // No "synchronize all activity" implemented for this platform at the moment.
+  bool SynchronizeAllActivity() override { return true; }
+  tsl::Status SynchronousMemZero(DeviceMemoryBase* location,
+                                 uint64_t size) override;
+
+  tsl::Status SynchronousMemSet(DeviceMemoryBase* location, int value,
+                                uint64_t size) override;
+
+  tsl::Status SynchronousMemcpy(DeviceMemoryBase* gpu_dst, const void* host_src,
+                                uint64_t size) override;
+  tsl::Status SynchronousMemcpy(void* host_dst, const DeviceMemoryBase& gpu_src,
+                                uint64_t size) override;
+  tsl::Status SynchronousMemcpyDeviceToDevice(DeviceMemoryBase* gpu_dst,
+                                              const DeviceMemoryBase& gpu_src,
+                                              uint64_t size) override;
+
+  bool HostCallback(Stream* stream,
+                    absl::AnyInvocable<tsl::Status() &&> callback) override;
+
+  tsl::Status AllocateEvent(Event* event) override;
+  tsl::Status DeallocateEvent(Event* event) override;
+  tsl::Status RecordEvent(Stream* stream, Event* event) override;
+  tsl::Status WaitForEvent(Stream* stream, Event* event) override;
+  Event::Status PollForEventStatus(Event* event) override;
+
+  bool AllocateStream(Stream* stream) override;
+  void DeallocateStream(Stream* stream) override;
+  bool CreateStreamDependency(Stream* dependent, Stream* other) override;
+
+  tsl::Status BlockHostUntilDone(Stream* stream) override;
+
+  bool DeviceMemoryUsage(int64_t* free, int64_t* total) const override;
+
+  tsl::StatusOr<std::unique_ptr<DeviceDescription>> CreateDeviceDescription()
+      const override {
+    return CreateDeviceDescription(0);
+  }
+
+  static tsl::StatusOr<std::unique_ptr<DeviceDescription>>
+  CreateDeviceDescription(int device_ordinal);
+
+  tsl::Status EnablePeerAccessTo(StreamExecutorInterface* other) override {
+    return ::tsl::OkStatus();
+  }
+
+  bool CanEnablePeerAccessTo(StreamExecutorInterface* other) override {
+    return true;
+  }
+
+  blas::BlasSupport* CreateBlas() override;
+
+  dnn::DnnSupport* CreateDnn() override { return nullptr; }
+
+  fft::FftSupport* CreateFft() override;
+
+  std::unique_ptr<internal::EventInterface> CreateEventImplementation()
+      override;
+
+  std::unique_ptr<internal::KernelInterface> CreateKernelImplementation()
+      override {
+    return nullptr;
+  }
+
+  std::unique_ptr<internal::StreamInterface> GetStreamImplementation() override;
+
+  void* GpuContextHack() override { return nullptr; }
+
+ private:
+  // Size of thread stacks for streams in bytes. '0' means "the default size".
+  size_t thread_stack_size_in_bytes_ = 0;
+};
+
+}  // namespace host
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_HOST_HOST_GPU_EXECUTOR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/host/host_platform.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/host/host_platform.h
new file mode 100644
index 0000000000000000000000000000000000000000..4461669b95bbd5a6a9d901680a983f830937c569
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/host/host_platform.h
@@ -0,0 +1,77 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// Declares the "host" platform, which is a CPU-only implementation of the
+// StreamExecutor. The host platform only supports memory operations and plugin
+// routines, and is primarily used for testing.
+#ifndef XLA_STREAM_EXECUTOR_HOST_HOST_PLATFORM_H_
+#define XLA_STREAM_EXECUTOR_HOST_HOST_PLATFORM_H_
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "xla/stream_executor/executor_cache.h"
+#include "xla/stream_executor/multi_platform_manager.h"
+#include "xla/stream_executor/platform.h"
+#include "xla/stream_executor/platform/port.h"
+#include "xla/stream_executor/stream_executor.h"
+#include "xla/stream_executor/trace_listener.h"
+
+namespace stream_executor {
+namespace host {
+
+// Host (CPU) platform plugin, registered as a singleton value via module
+// initializer.
+class HostPlatform : public Platform {
+ public:
+  HostPlatform();
+  ~HostPlatform() override;
+
+  Platform::Id id() const override;
+
+  // Device count is less clear-cut for CPUs than accelerators. This call
+  // currently returns the number of thread units in the host, as reported by
+  // base::NumCPUs().
+  int VisibleDeviceCount() const override;
+
+  const std::string& Name() const override;
+
+  tsl::StatusOr<std::unique_ptr<DeviceDescription>> DescriptionForDevice(
+      int ordinal) const override;
+
+  tsl::StatusOr<StreamExecutor*> ExecutorForDevice(int ordinal) override;
+
+  tsl::StatusOr<StreamExecutor*> GetExecutor(
+      const StreamExecutorConfig& config) override;
+
+  tsl::StatusOr<std::unique_ptr<StreamExecutor>> GetUncachedExecutor(
+      const StreamExecutorConfig& config) override;
+
+ private:
+  // This platform's name.
+  std::string name_;
+
+  // Cache of created StreamExecutors.
+  ExecutorCache executor_cache_;
+
+  HostPlatform(const HostPlatform&) = delete;
+  void operator=(const HostPlatform&) = delete;
+};
+
+}  // namespace host
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_HOST_HOST_PLATFORM_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/host/host_platform_id.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/host/host_platform_id.h
new file mode 100644
index 0000000000000000000000000000000000000000..e29fb5a5188b53d86bee610c176340dec19416d4
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/host/host_platform_id.h
@@ -0,0 +1,34 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_STREAM_EXECUTOR_HOST_HOST_PLATFORM_ID_H_
+#define XLA_STREAM_EXECUTOR_HOST_HOST_PLATFORM_ID_H_
+
+#include "xla/stream_executor/platform.h"
+
+namespace stream_executor {
+namespace host {
+
+// Opaque and unique identifier for the host platform.
+// This is needed so that plugins can refer to/identify this platform without
+// instantiating a HostPlatform object.
+// This is broken out here to avoid a circular dependency between HostPlatform
+// and HostStreamExecutor.
+extern const Platform::Id kHostPlatformId;
+
+}  // namespace host
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_HOST_HOST_PLATFORM_ID_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/host/host_stream.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/host/host_stream.h
new file mode 100644
index 0000000000000000000000000000000000000000..ed5bc0b056fc18b47363d69da5ffc9f0b0b0d3fb
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/host/host_stream.h
@@ -0,0 +1,66 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// Class declaration for Stream type that enqueues tasks onto a host/CPU-based
+// execution context (as opposed to a GPU device), HostExecutor.
+#ifndef XLA_STREAM_EXECUTOR_HOST_HOST_STREAM_H_
+#define XLA_STREAM_EXECUTOR_HOST_HOST_STREAM_H_
+
+#include <functional>
+#include <memory>
+#include <queue>
+
+#include "absl/functional/any_invocable.h"
+#include "absl/synchronization/mutex.h"
+#include "xla/stream_executor/stream_executor_internal.h"
+#include "tsl/platform/env.h"
+
+namespace stream_executor {
+namespace host {
+
+class HostStream : public internal::StreamInterface {
+ public:
+  // stack_size_in_bytes may be '0', meaning "use the default thread stack
+  // size".
+  explicit HostStream(size_t stack_size_in_bytes);
+  ~HostStream() override;
+
+  // Enqueue a task that reports a status when finished. Tasks that fail do not
+  // stop the stream or block any other tasks from executing; rather, the stream
+  // will remember the first error encountered and return it from
+  // 'BlockUntilDone'.
+  bool EnqueueTaskWithStatus(absl::AnyInvocable<tsl::Status() &&> task);
+  // Enqueue a task that doesn't report any status.
+  bool EnqueueTask(absl::AnyInvocable<void() &&> task);
+
+  // Blocks until all tasks are done, returns the first error reported by a task
+  // (if any) and clears the error status.
+  tsl::Status BlockUntilDone();
+
+ private:
+  bool WorkAvailable() TF_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+  void WorkLoop();
+
+  absl::Mutex mu_;
+  std::queue<absl::AnyInvocable<tsl::Status() &&>> work_queue_
+      ABSL_GUARDED_BY(mu_);
+  std::unique_ptr<tsl::Thread> thread_;
+  tsl::Status status_;
+};
+
+}  // namespace host
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_HOST_HOST_STREAM_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/host_or_device_scalar.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/host_or_device_scalar.h
new file mode 100644
index 0000000000000000000000000000000000000000..a7d428d05e5657459bd9f5c5aa8e83c07bf8eddc
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/host_or_device_scalar.h
@@ -0,0 +1,52 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_STREAM_EXECUTOR_HOST_OR_DEVICE_SCALAR_H_
+#define XLA_STREAM_EXECUTOR_HOST_OR_DEVICE_SCALAR_H_
+
+#include <utility>
+#include <variant>
+
+#include "xla/stream_executor/device_memory.h"
+
+namespace stream_executor {
+
+// Allows to represent a value that is either a host scalar or a scalar stored
+// on the device.
+template <typename T>
+class HostOrDeviceScalar {
+ public:
+  explicit HostOrDeviceScalar(T host_value) : value_(std::move(host_value)) {}
+  explicit HostOrDeviceScalar(DeviceMemory<T> device_ptr)
+      : value_(std::move(device_ptr)) {
+    CHECK_EQ(1, device_ptr.ElementCount());
+  }
+
+  bool on_device() const {
+    return std::holds_alternative<DeviceMemory<T>>(value_);
+  }
+
+  const void* opaque() const {
+    return on_device() ? std::get<DeviceMemory<T>>(value_).opaque()
+                       : &std::get<T>(value_);
+  }
+
+ private:
+  std::variant<T, DeviceMemory<T>> value_;
+};
+
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_HOST_OR_DEVICE_SCALAR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/kernel.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/kernel.h
new file mode 100644
index 0000000000000000000000000000000000000000..4a9f7fbbc95c66261d1447190c4249958de8d223
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/kernel.h
@@ -0,0 +1,743 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// Suite of datatypes to represent data-parallel kernel objects (code entities).
+// Kernel is the untyped variant, whereas TypedKernel takes a type signature
+// to do some template-based helper generation and give compile-time type
+// checking for kernel launch parameters.
+//
+// Users typically don't see KernelBase, they see typed kernels, analogous to a
+// typed function pointer. TypedKernels express their argument types via
+// template parameters like so:
+//
+//  TypedKernel<DeviceMemory<int>*, int>
+//
+// Which expresses a data parallel kernel signature for:
+//
+//  void(int*, int);
+//
+// And for a const memory region:
+//
+//  TypedKernel<const DeviceMemory<int>&, int>
+//
+// Corresponds to a data parallel kernel signature for:
+//
+//  void(const int*, int)
+//
+// Note that kernels always have a void return type, so results typically must
+// be memcpy'ied from device memory to the host.
+//
+// Also note that a scalar integer residing in device memory and an array of
+// integers residing in device memory have the same signature: DeviceMemory<T>.
+// However, in the future, checks may be added for additional safety that arrays
+// of minimum sizes are passed when those minimum sizes are contractually
+// expected by the kernel.
+//
+// For user-defined types whose definitions are appropriately shared between the
+// host code doing the launching and the kernel code being launched, the user
+// defined types are similarly permitted to be expressed as residing in device
+// memory:
+//
+//  TypedKernel<DeviceMemory<MyUserDefinedStructure>>
+//
+// And, when the alignment and padding are agreed upon, POD types will also be
+// able to be passed by value; for example, it is a common idiom to specify a
+// bunch of options simultaneously with a structure:
+//
+//  TypedKernel<MyOptionsStructurePassedByValue, DeviceMemory<float>>
+//
+// Which corresponds to a data parallel kernel signature like:
+//
+//  void(MyOptionsStructurePassedByValue value, float *result);
+//
+// Users typically won't need to type out the TypedKernel signature in full, it
+// will be typedef'd by automatically generated code; for example, see
+// stream_executor::executor_sample::VecReduceAddKernel.
+
+#ifndef XLA_STREAM_EXECUTOR_KERNEL_H_
+#define XLA_STREAM_EXECUTOR_KERNEL_H_
+
+#include <array>
+#include <cstdint>
+#include <cstring>
+#include <memory>
+#include <string>
+#include <tuple>
+#include <type_traits>
+
+#include "absl/log/check.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/span.h"
+#include "xla/stream_executor/device_memory.h"
+#include "xla/stream_executor/kernel_cache_config.h"
+#include "xla/stream_executor/platform/port.h"
+
+namespace stream_executor {
+
+class DeviceMemoryBase;
+template <typename ElemT>
+class DeviceMemory;
+class StreamExecutor;
+
+namespace internal {
+class KernelInterface;
+}  // namespace internal
+
+// KernelMetadata holds runtime-queryable attributes of a loaded kernel, such as
+// registers allocated, shared memory used, etc.
+// Not all platforms support reporting of all information, so each accessor
+// returns false if the associated field is not populated in the underlying
+// platform.
+class KernelMetadata {
+ public:
+  KernelMetadata()
+      : has_registers_per_thread_(false), has_shared_memory_bytes_(false) {}
+
+  // Returns the number of registers used per thread executing this kernel.
+  bool registers_per_thread(int *registers_per_thread) const;
+
+  // Sets the number of registers used per thread executing this kernel.
+  void set_registers_per_thread(int registers_per_thread);
+
+  // Returns the amount of [static] shared memory used per block executing this
+  // kernel. Note that dynamic shared memory allocations are not (and can not)
+  // be reported here (since they're not specified until kernel launch time).
+  bool shared_memory_bytes(int *shared_memory_bytes) const;
+
+  // Sets the amount of [static] shared memory used per block executing this
+  // kernel.
+  void set_shared_memory_bytes(int shared_memory_bytes);
+
+ private:
+  // Holds the value returned by registers_per_thread above.
+  bool has_registers_per_thread_;
+  int registers_per_thread_;
+
+  // Holds the value returned by shared_memory_bytes above.
+  bool has_shared_memory_bytes_;
+  int64_t shared_memory_bytes_;
+};
+
+// A data-parallel kernel (code entity) for launching via the StreamExecutor,
+// analogous to a void* device function pointer. See TypedKernel for the typed
+// variant.
+//
+// Thread-compatible.
+class KernelBase {
+ public:
+  KernelBase(KernelBase &&from);
+
+  // Constructs an "empty" (not-yet-loaded) kernel instance.
+  //
+  // parent is the StreamExecutor that will be responsible for loading the
+  // implementation of this kernel. It must not be null.
+  explicit KernelBase(StreamExecutor *parent);
+
+  // Test-only constructor that can take a mock KernelInterface implementation.
+  KernelBase(StreamExecutor *parent, internal::KernelInterface *implementation);
+
+  // Releases resources associated with the kernel instance (i.e.
+  // platform-specific implementation).
+  ~KernelBase();
+
+  // Returns the number of parameters that this kernel accepts. (Arity refers to
+  // nullary, unary, ...).
+  unsigned Arity() const;
+
+  // Returns the StreamExecutor that represents the platform this kernel
+  // executes upon.
+  StreamExecutor *parent() const { return parent_; }
+
+  // Returns a const pointer to the (opaque) platform-dependent implementation.
+  const internal::KernelInterface *implementation() const {
+    return implementation_.get();
+  }
+
+  // Returns a non-const pointer to the (opaque) platform-dependent
+  // implementation.
+  internal::KernelInterface *implementation() { return implementation_.get(); }
+
+  void set_metadata(const KernelMetadata &metadata) { metadata_ = metadata; }
+
+  const KernelMetadata &metadata() const { return metadata_; }
+
+  // Sets the preferred cache configuration for a kernel. This is just a
+  // suggestion to the runtime, and may not be honored during execution.
+  void SetPreferredCacheConfig(KernelCacheConfig config);
+
+  // Gets the preferred cache configuration for a kernel.
+  KernelCacheConfig GetPreferredCacheConfig() const;
+
+  void set_name(absl::string_view name);
+  const std::string &name() const { return name_; }
+  const std::string &demangled_name() const { return demangled_name_; }
+
+ private:
+  // The StreamExecutor that loads this kernel object.
+  StreamExecutor *parent_;
+
+  // Implementation delegated to for platform-specific functionality.
+  std::unique_ptr<internal::KernelInterface> implementation_;
+
+  std::string name_;
+  std::string demangled_name_;
+
+  KernelMetadata metadata_;
+
+  KernelBase(const KernelBase &) = delete;
+  void operator=(const KernelBase &) = delete;
+};
+
+// Whether T is a DeviceMemory-family pointer.
+template <typename T>
+struct IsDeviceMemoryPointer {
+  static constexpr bool value = false;
+};
+
+template <typename U>
+struct IsDeviceMemoryPointer<DeviceMemory<U> *> {
+  static constexpr bool value = true;
+};
+
+template <>
+struct IsDeviceMemoryPointer<DeviceMemoryBase *> {
+  static constexpr bool value = true;
+};
+
+// Whether T is a DeviceMemory-family value-like thing (which includes a
+// reference). This trait is useful because we pack values in the same manner as
+// references.
+template <typename T>
+struct IsDeviceMemoryValueLike {
+  static constexpr bool value = false;
+};
+
+template <typename U>
+struct IsDeviceMemoryValueLike<DeviceMemory<U> &> {
+  static constexpr bool value = true;
+};
+
+// We need to treat SharedDeviceMemory types differently than other DeviceMemory
+// types (since they maintain no allocations), hence these specializations.
+template <typename U>
+struct IsDeviceMemoryValueLike<SharedDeviceMemory<U> &> {
+  static constexpr bool value = false;
+};
+
+template <>
+struct IsDeviceMemoryValueLike<DeviceMemoryBase &> {
+  static constexpr bool value = true;
+};
+
+template <typename U>
+struct IsDeviceMemoryValueLike<DeviceMemory<U>> {
+  static constexpr bool value = true;
+};
+
+template <typename U>
+struct IsDeviceMemoryValueLike<SharedDeviceMemory<U>> {
+  static constexpr bool value = false;
+};
+
+template <>
+struct IsDeviceMemoryValueLike<DeviceMemoryBase> {
+  static constexpr bool value = true;
+};
+
+template <typename U>
+struct IsSharedDeviceMemory {
+  static constexpr bool value = false;
+};
+
+template <typename U>
+struct IsSharedDeviceMemory<SharedDeviceMemory<U> &> {
+  static constexpr bool value = true;
+};
+
+template <typename U>
+struct IsSharedDeviceMemory<SharedDeviceMemory<U>> {
+  static constexpr bool value = true;
+};
+
+// Basic data about a kernel argument.
+struct KernelArg {
+  bool is_shared;
+  const void *address;
+  size_t size;
+};
+
+// An iterator for traversing all the arguments of a KernelArgsArray.
+class KernelArgIterator {
+ public:
+  KernelArgIterator(int number_of_argument_addresses,
+                    int number_of_shared_memory_arguments,
+                    const void *const *arg_addresses_data,
+                    const size_t *arg_sizes_data,
+                    const size_t *shmem_bytes_data,
+                    const size_t *shmem_indices_data)
+      : arg_index_(0),
+        number_of_arguments_(number_of_argument_addresses +
+                             number_of_shared_memory_arguments),
+        arg_address_iter_(arg_addresses_data),
+        arg_size_iter_(arg_sizes_data),
+        shmem_bytes_iter_(shmem_bytes_data),
+        shmem_indices_iter_(shmem_indices_data),
+        shmem_indices_end_(shmem_indices_data +
+                           number_of_shared_memory_arguments) {}
+
+  // Returns true if another argument is present in the iterator.
+  bool has_next() { return arg_index_ < number_of_arguments_; }
+
+  // Returns the next argument in the iterator.
+  //
+  // Returns a default-constructed KernelArg if there is no next argument.
+  KernelArg next() {
+    KernelArg result = {};
+    if (!has_next()) {
+      return result;
+    } else if ((shmem_indices_iter_ != shmem_indices_end_) &&
+               (arg_index_ == *shmem_indices_iter_)) {
+      result.is_shared = true;
+      result.address = nullptr;
+      result.size = *shmem_bytes_iter_;
+      ++shmem_indices_iter_;
+      ++shmem_bytes_iter_;
+    } else {
+      result.is_shared = false;
+      result.address = *arg_address_iter_;
+      result.size = *arg_size_iter_;
+      ++arg_address_iter_;
+      ++arg_size_iter_;
+    }
+    ++arg_index_;
+    return result;
+  }
+
+ private:
+  size_t arg_index_;
+  size_t number_of_arguments_;
+  const void *const *arg_address_iter_;
+  const size_t *arg_size_iter_;
+  const size_t *shmem_bytes_iter_;
+  const size_t *shmem_indices_iter_;
+  const size_t *const shmem_indices_end_;
+};
+
+// Base class for KernelArgsArray.
+//
+// Supports all the getter methods that do not depend on the compile-time number
+// of arguments template parameter.
+//
+// This class exists as a way to pass kernel arguments to
+// StreamExecutorInterface::Launch. That Launch method is virtual, so it can't
+// be templated to accept any KernelArgsArray type, therefore a reference to
+// this base type is passed instead.
+//
+// Performance is not a concern here because each of these methods will be
+// called at most once per kernel launch. Past performance concerns with
+// KernelArgsArray have been in reference to the argument packing routines which
+// are called once per kernel argument. Those packing routines are now handled
+// by the templated KernelArgsArray subclass of this class where they can take
+// advantage of compile-time knowledge of the number of arguments in order to be
+// very efficient.
+class KernelArgsArrayBase {
+ public:
+  virtual ~KernelArgsArrayBase() = default;
+
+  // Gets the number of arguments added so far, including shared memory
+  // arguments.
+  virtual size_t number_of_arguments() const = 0;
+
+  // Gets the total number of shared memory bytes added so far.
+  virtual uint64_t number_of_shared_bytes() const = 0;
+
+  // Gets the list of argument addresses.
+  virtual absl::Span<const void *const> argument_addresses() const = 0;
+
+  // Gets an iterator to the arguments in the array.
+  virtual KernelArgIterator arg_iterator() const = 0;
+};
+
+// A list of arguments for a kernel call.
+//
+// The template parameter kNumArgs is the maximum number of arguments which can
+// be stored in the list.
+//
+// Contains a list of addresses for non-shared-memory arguments and a list of
+// sizes for shared-memory arguments. Since the shared-memory arguments may be
+// interspersed with the non-shared-memory arguments, it also stores a list of
+// the indices at which the shared-memory arguments appeared.
+//
+// For example, if the argument address list contains {a, b, c, d, e}, the
+// shared-memory arguments list contains the sizes of {A, B, C}, and the
+// shared-memory indices list contains {0, 3, 5}, then the original list of
+// arguments was {A, a, b, B, c, C, d, e}.
+//
+// This way of storing the arguments makes CUDA kernel calls efficient because
+// they only require the argument address list and the total number of shared
+// bytes, but it also makes it possible for OpenCL kernel calls because they
+// depend on the location of each shared-memory argument and its size.
+//
+// Note that the code for adding arguments has been identified as a performance
+// hotspot in some real-world applications so this structure has been optimized
+// for the performance of argument adding.
+template <size_t kNumArgs>
+class KernelArgsArray : public KernelArgsArrayBase {
+ public:
+  static constexpr int kMaxGenericArgSize = 8;
+
+  // Adds an argument to the list.
+  template <typename T>
+  void add_argument(const T &arg) {
+    static_assert(sizeof(T) <= kMaxGenericArgSize,
+                  "Please adjust kMaxGenericArgSize");
+    static_assert(std::is_pod<T>::value, "Only pod types supported!");
+    char *generic_arg_storage =
+        &generic_arguments_[number_of_generic_arguments_++ *
+                            kMaxGenericArgSize];
+
+    CHECK_EQ(reinterpret_cast<uintptr_t>(generic_arg_storage) % alignof(T), 0);
+    std::memcpy(generic_arg_storage, &arg, sizeof(T));
+
+    argument_addresses_[number_of_argument_addresses_] = generic_arg_storage;
+    argument_sizes_[number_of_argument_addresses_] = sizeof(arg);
+    ++number_of_argument_addresses_;
+  }
+
+  // Adds a device memory argument to the list.
+  void add_device_memory_argument(const DeviceMemoryBase &arg) {
+    const void **copy_ptr =
+        &device_memory_opaque_pointers_[number_of_argument_addresses_];
+    *copy_ptr = arg.opaque();
+    argument_addresses_[number_of_argument_addresses_] = copy_ptr;
+    argument_sizes_[number_of_argument_addresses_] = sizeof(void *);
+    ++number_of_argument_addresses_;
+  }
+
+  // Adds a shared memory argument to the list.
+  //
+  // The only significant information about a shared argument is its size, so
+  // that is the only parameter in this function.
+  void add_shared_bytes(size_t number_of_bytes) {
+    shared_memory_indices_[number_of_shared_memory_arguments_] =
+        number_of_argument_addresses_ + number_of_shared_memory_arguments_;
+    shared_memory_bytes_[number_of_shared_memory_arguments_] = number_of_bytes;
+    ++number_of_shared_memory_arguments_;
+    total_shared_memory_bytes_ += number_of_bytes;
+  }
+
+  // Gets the number of arguments added so far, including shared memory
+  // arguments.
+  size_t number_of_arguments() const override {
+    return number_of_argument_addresses_ + number_of_shared_memory_arguments_;
+  }
+
+  // Gets the total number of shared memory bytes added so far.
+  uint64_t number_of_shared_bytes() const override {
+    return total_shared_memory_bytes_;
+  }
+
+  // Gets the list of argument addresses.
+  absl::Span<const void *const> argument_addresses() const override {
+    return absl::Span<const void *const>(argument_addresses_.data(),
+                                         number_of_argument_addresses_);
+  }
+
+  // Gets an iterator to the arguments in the array.
+  KernelArgIterator arg_iterator() const override {
+    return KernelArgIterator(
+        number_of_argument_addresses_, number_of_shared_memory_arguments_,
+        argument_addresses_.data(), argument_sizes_.data(),
+        shared_memory_bytes_.data(), shared_memory_indices_.data());
+  }
+
+ private:
+  // A place to store copies of opaque pointers from device memory arguments.
+  std::array<const void *, kNumArgs> device_memory_opaque_pointers_;
+
+  // Addresses for non-shared-memory arguments.
+  std::array<const void *, kNumArgs> argument_addresses_;
+
+  // Storage for arguments of templated type.
+  alignas(kMaxGenericArgSize)
+      std::array<char, kNumArgs * kMaxGenericArgSize> generic_arguments_;
+
+  // Sizes for non-shared-memory arguments.
+  std::array<size_t, kNumArgs> argument_sizes_;
+
+  // Size in bytes for each shared memory argument.
+  std::array<size_t, kNumArgs> shared_memory_bytes_;
+
+  // Indices in the arguments array for shared memory arguments.
+  std::array<size_t, kNumArgs> shared_memory_indices_;
+
+  // Total of all shared memory sizes.
+  size_t total_shared_memory_bytes_ = 0;
+
+  // Number of significant entries in argument_addresses_ and argument_sizes_.
+  size_t number_of_argument_addresses_ = 0;
+
+  // Number of significant entries in shared_memory_bytes_ and
+  // shared_memory_indices_.
+  size_t number_of_shared_memory_arguments_ = 0;
+
+  // The number of generic arguments that have been added to generic_arguments_.
+  size_t number_of_generic_arguments_ = 0;
+};
+
+template <int n>
+std::unique_ptr<KernelArgsArrayBase> MakeKernelArgs(
+    absl::Span<const DeviceMemoryBase> args, uint32_t shared_mem_bytes) {
+  auto kernel_args = std::make_unique<KernelArgsArray<n>>();
+  for (const DeviceMemoryBase &buf : args) {
+    kernel_args->add_device_memory_argument(buf);
+  }
+  if (shared_mem_bytes > 0) {
+    kernel_args->add_shared_bytes(shared_mem_bytes);
+  }
+  return kernel_args;
+}
+
+// Typed variant of KernelBase, like a typed device function pointer. See the
+// file comment for details and example usage.
+//
+// This class contains template metaprogramming magic to type check the
+// parameters passed to a kernel launch are acceptable, and subsequently pack
+// them into a form which can be used by the StreamExecutorInterface
+// implementation. (i.e.  CUDA and OpenCL both bind void*s with associated
+// sizes as kernel arguments.)
+//
+// Thread-compatible.
+template <typename... Params>
+class TypedKernel : public KernelBase {
+ public:
+  static constexpr size_t kNumberOfParameters = sizeof...(Params);
+
+  // Delegates to KernelBase::KernelBase(), see that constructor.
+  explicit TypedKernel(StreamExecutor *parent) : KernelBase(parent) {}
+
+  // Test-only constructor that can take a mock KernelInterface implementation.
+  // Takes ownership of implementation, it should not be null.
+  TypedKernel(StreamExecutor *parent, internal::KernelInterface *implementation)
+      : KernelBase(parent, implementation) {}
+
+  // This is the main entry point into the magic. Packs the parameters (which
+  // must type check against the class template) into the args and sizes
+  // arrays.
+  //
+  // Const refs are taken as parameters on all of the handlers to avoid
+  // implicit type promotion of integers.
+  //
+  // WARNING: as a performance optimization this method may store pointers to
+  // some of the input parameters in the kernel args structure, so any params
+  // passed into this method must live at least as long as the kernel args
+  // structure.
+  void PackParams(KernelArgsArray<kNumberOfParameters> *args,
+                  const Params &...params) const {
+    PackOneParamFromList(args, params...);
+  }
+
+ private:
+  // Stream needs access to the specific parameter-packing functionality that
+  // the TypedKernel provides for its corresponding type signature (and no other
+  // type signatures).
+  friend class Stream;
+
+  template <typename T, typename... RestOfParams>
+  void PackOneParamFromList(KernelArgsArray<kNumberOfParameters> *args,
+                            const T &arg, const RestOfParams &...rest) const {
+    PackOneParam(args, arg);
+    PackOneParamFromList(args, rest...);
+  }
+
+  // Base case for variadic template expansion - nothing to do!
+  void PackOneParamFromList(KernelArgsArray<kNumberOfParameters> *args) const {}
+
+  // Packs one (non-DeviceMemoryBase) parameter into the arg and sizes array.
+  // The enable_if<> is for excluding DeviceMemoryBase args, which have a
+  // separate implementation below.
+  template <typename T>
+  void PackOneParam(
+      KernelArgsArray<kNumberOfParameters> *args, const T &arg,
+      typename std::enable_if<!IsDeviceMemoryValueLike<T>::value &&
+                              !IsDeviceMemoryPointer<T>::value &&
+                              !IsSharedDeviceMemory<T>::value>::type * =
+          nullptr) const {
+    static_assert(!std::is_pointer<T>::value,
+                  "cannot pass raw pointer to the device");
+    static_assert(!std::is_convertible<T, DeviceMemoryBase>::value,
+                  "cannot pass device memory as a normal value");
+    args->add_argument(arg);
+  }
+
+  // DeviceMemoryBase family reference override.
+  template <typename T>
+  void PackOneParam(
+      KernelArgsArray<kNumberOfParameters> *args, const T &arg,
+      typename std::enable_if<IsDeviceMemoryValueLike<T>::value>::type * =
+          nullptr) const {
+    args->add_device_memory_argument(arg);
+  }
+
+  // DeviceMemoryBase family pointer override.
+  template <typename T>
+  void PackOneParam(
+      KernelArgsArray<kNumberOfParameters> *args, T arg,
+      typename std::enable_if<IsDeviceMemoryPointer<T>::value>::type * =
+          nullptr) const {
+    DeviceMemoryBase *ptr = static_cast<DeviceMemoryBase *>(arg);
+    args->add_device_memory_argument(*ptr);
+  }
+
+  // Dynamic shared device memory has a size, but no associated allocation on
+  // the host; internally, the device will allocate storage.
+  template <typename T>
+  void PackOneParam(
+      KernelArgsArray<kNumberOfParameters> *args, T arg,
+      typename std::enable_if<IsSharedDeviceMemory<T>::value>::type * =
+          nullptr) const {
+    args->add_shared_bytes(arg.size());
+  }
+
+  TypedKernel(const TypedKernel &) = delete;
+  void operator=(const TypedKernel &) = delete;
+};
+
+// Template metaprogramming helper type that helps us produce better error
+// messages at compile time when the are mismatches between the parameter
+// type list and the argument type list.
+template <typename ParamTuple, typename ArgTuple>
+struct KernelInvocationChecker {
+  // Whether the parameter tuple and argument tuple match in length.
+  static constexpr bool kLengthMatches =
+      std::tuple_size<ParamTuple>::value == std::tuple_size<ArgTuple>::value;
+
+  // The (matching) length of the parameters and arguments type lists.
+  static constexpr int kTupleLength =
+      static_cast<int>(std::tuple_size<ArgTuple>::value);
+
+  // Helper trait to say whether the parameter wants a DeviceMemory-reference
+  // compatible type. This is for inexact type matches, so that it doesn't have
+  // to be precisely a const DeviceMemory<T>&, but can also be a value that
+  // represents the same.
+  template <typename ParamType, typename ArgType>
+  struct IsCompatibleDeviceMemoryRef {
+    static constexpr bool value = false;
+  };
+
+  // See type trait definition above.
+  template <typename U>
+  struct IsCompatibleDeviceMemoryRef<const DeviceMemory<U> &, DeviceMemory<U>> {
+    static constexpr bool value = true;
+  };
+
+  // See type trait definition above.
+  template <typename U>
+  struct IsCompatibleDeviceMemoryRef<const SharedDeviceMemory<U> &,
+                                     SharedDeviceMemory<U>> {
+    static constexpr bool value = true;
+  };
+
+  // Returns whether ParamT and ArgT are compatible for data parallel kernel
+  // parameter packing without any assert functionality.
+  template <typename ParamT, typename ArgT>
+  static constexpr bool CompatibleNoAssert() {
+    return std::is_same<typename std::remove_const<ParamT>::type,
+                        ArgT>::value ||
+           IsCompatibleDeviceMemoryRef<ParamT, ArgT>::value;
+  }
+
+  // Checks whether ParamT and ArgT are compatible for data parallel kernel
+  // parameter packing. kArgumentNumber is unused, it just for error display.
+  //
+  // NOTE: if you encounter an error here, you can see the mismatch by looking
+  // at the end of the last error message, which will be of the form:
+  //
+  //    ...::Compatible<const stream_executor::DeviceMemory<OneThing> &,
+  //                    stream_executor::DeviceMemory<AnotherThing>, true,
+  //                    0>'
+  //    requested here
+  //
+  // This means that the 0th argument you passed to the kernel invocation should
+  // have been DeviceMemory<OneThing> but was observed to be
+  // DeviceMemory<AnotherThing>.
+  template <typename ParamT, typename ArgT, bool kShouldStaticAssert,
+            int kArgumentNumber>
+  static constexpr bool Compatible() {
+    static_assert(
+        kShouldStaticAssert ? CompatibleNoAssert<ParamT, ArgT>() : true,
+        "parameter type (LHS) is not compatible with argument type (RHS)");
+    return CompatibleNoAssert<ParamT, ArgT>();
+  }
+
+  // Checks the parameter/argument match at kArgumentNumber for an out of bounds
+  // argument number.
+  //
+  // This is the base case: we've run out of argument to check, so we're all
+  // good.
+  template <int kArgumentNumber, bool kShouldStaticAssert>
+  static constexpr bool CheckParam(
+      typename std::enable_if<(kArgumentNumber < 0)>::type *dummy = nullptr) {
+    return true;
+  }
+
+  // Checks the parameter/argument match at kArgumentNumber.
+  // kShouldStaticAssert determines whether to assert out on a mismatch, or just
+  // yield the constexpr boolean value.
+  template <int kArgumentNumber, bool kShouldStaticAssert>
+  static constexpr bool CheckParam(
+      typename std::enable_if<kArgumentNumber >= 0>::type *dummy = nullptr) {
+    typedef
+        typename std::tuple_element<kArgumentNumber, ParamTuple>::type ParamT;
+    typedef typename std::tuple_element<kArgumentNumber, ArgTuple>::type ArgT;
+    return Compatible<ParamT, ArgT, kShouldStaticAssert, kArgumentNumber>() &&
+           CheckParam<kArgumentNumber - 1, kShouldStaticAssert>();
+  }
+
+  // Checks the parameters/arguments for match, but doesn't static assert out.
+  // This is useful for testing/inspecting whether a set of parameters match in
+  // things like tests.
+  static constexpr bool CheckAllNoStaticAssert() {
+    return kLengthMatches && CheckParam<kTupleLength - 1, false>();
+  }
+
+  // Checks the parameters and static asserts out with a helpful error message
+  // (and useful template parameters in the instantiation stack) if there is an
+  // error.
+  static constexpr bool CheckAllStaticAssert() {
+    static_assert(kLengthMatches,
+                  "argument length mismatched against typed kernel parameters");
+    return kLengthMatches && CheckParam<kTupleLength - 1, true>();
+  }
+};
+
+// This is a convenience type for checking whether a typed kernel matches
+// against a type list.
+template <typename KernelT, typename... Params>
+struct KernelParamsOk {
+  static constexpr bool kResult = false;
+};
+
+// See above.
+template <typename... Params, typename... Args>
+struct KernelParamsOk<TypedKernel<Params...>, Args...> {
+  static constexpr bool kResult =
+      KernelInvocationChecker<std::tuple<Params...>,
+                              std::tuple<Args...>>::CheckAllNoStaticAssert();
+};
+
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_KERNEL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/kernel_cache_config.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/kernel_cache_config.h
new file mode 100644
index 0000000000000000000000000000000000000000..f72b3fcbf53fe3247f7caa2ab9c893ac49c8a38a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/kernel_cache_config.h
@@ -0,0 +1,42 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// This file contains declarations relating to kernel cache configuration
+// parameters recognized by the StreamExecutor.
+#ifndef XLA_STREAM_EXECUTOR_KERNEL_CACHE_CONFIG_H_
+#define XLA_STREAM_EXECUTOR_KERNEL_CACHE_CONFIG_H_
+
+namespace stream_executor {
+
+// This enum represents potential configurations of L1/shared memory when
+// running a particular kernel. These values represent user preference, and
+// the runtime is not required to respect these choices.
+enum class KernelCacheConfig {
+  // Indicates no preference for device L1/shared memory configuration.
+  kNoPreference,
+
+  // Indicates a preference for more shared memory than L1 cache.
+  kPreferShared,
+
+  // Indicates a preference for more L1 cache than shared memory.
+  kPreferL1,
+
+  // Indicates a preference for equal amounts of L1 cache and shared memory.
+  kPreferEqual,
+};
+
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_KERNEL_CACHE_CONFIG_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/kernel_spec.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/kernel_spec.h
new file mode 100644
index 0000000000000000000000000000000000000000..68f45a0ee07f4df19349e12ca2e3932f81cf8ddc
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/kernel_spec.h
@@ -0,0 +1,316 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// Kernel-loader specs are structures that describe how to load a data-parallel
+// kernel on a given platform for subsequent launching. Headers that instantiate
+// these data structures will typically be auto-generated. However, users can
+// also instantiate them by hand.
+//
+// A kernel with the same exact functionality and type signature may be
+// implemented on several different platforms. Typical usage is to create a
+// singleton that describes how to load a kernel on the various supported
+// platforms:
+//
+//  static const MultiKernelLoaderSpec &SaxpySpec() {
+//    static auto *mkls =
+//        (new MultiKernelLoaderSpec{4 /* = arity */})
+//            ->AddCudaPtxOnDisk(ptx_file_path, ptx_kernel_name);
+//    };
+//
+//    return *mkls;
+//  }
+//
+// This lazily instantiates an object that describes how to load CUDA PTX
+// present on disk that implements saxpy for the CUDA platform. The
+// CudaPtxOnDisk object is a subtype of KernelLoaderSpec -- KernelLoaderSpec
+// describes how to load a kernel for subsequent launching on a single platform.
+//
+// For the loader functionality that accepts these KernelLoaderSpecs in order
+// to grab the kernel appropriately, see StreamExecutor::GetKernel().
+
+#ifndef XLA_STREAM_EXECUTOR_KERNEL_SPEC_H_
+#define XLA_STREAM_EXECUTOR_KERNEL_SPEC_H_
+
+#include <stddef.h>
+
+#include <initializer_list>
+#include <map>
+#include <memory>
+#include <string>
+#include <tuple>
+
+#include "absl/log/check.h"
+#include "absl/strings/string_view.h"
+#include "absl/synchronization/mutex.h"
+#include "xla/stream_executor/platform/port.h"
+#include "tsl/platform/logging.h"
+
+namespace stream_executor {
+
+// Describes how to load a kernel on a target platform.
+//
+// This is an abstract base class, subclassed for specific platforms.
+// The filename_or_text field represents the program location (i.e. PTX or
+// OpenCL loadable translation unit path) and is simply stored; whether it is a
+// filename or text is exposed via more specifically named accessors in
+// subclasses.
+//
+// These kernel loader specifications are typically auto-generated into header
+// files at build time, but can also be specified manually.
+class KernelLoaderSpec {
+ public:
+  virtual ~KernelLoaderSpec() {}
+
+  // Returns the kernel name to load out of the program.
+  const std::string &kernel_name() const { return kernel_name_; }
+
+ protected:
+  explicit KernelLoaderSpec(absl::string_view kernel_name);
+
+ private:
+  // The kernel name that should be loaded out of the program description given
+  // above.
+  std::string kernel_name_;
+
+  KernelLoaderSpec(const KernelLoaderSpec &) = delete;
+  void operator=(const KernelLoaderSpec &) = delete;
+};
+
+// An abstract kernel loader spec that has an associated file path, where
+// there's a canonical suffix for the filename; e.g. see CudaPtxOnDisk whose
+// canonical filename suffix is ".ptx".
+class OnDiskKernelLoaderSpec : public KernelLoaderSpec {
+ public:
+  ~OnDiskKernelLoaderSpec() override {}
+
+  // Returns the path to the on-disk loadable kernel file.
+  const std::string &filename() const { return filename_; }
+
+  // Returns the canonical suffix for this on-disk kernel loader spec format;
+  // e.g. PTX files on disk have a canonical suffix of ".ptx".
+  virtual const char *CanonicalSuffix() const = 0;
+
+ protected:
+  OnDiskKernelLoaderSpec(absl::string_view filename,
+                         absl::string_view kernel_name);
+
+  std::string filename_;
+
+ private:
+  OnDiskKernelLoaderSpec(const OnDiskKernelLoaderSpec &) = delete;
+  void operator=(const OnDiskKernelLoaderSpec &) = delete;
+};
+
+// Kernel loader specification for PTX text that resides on disk.
+class CudaPtxOnDisk : public OnDiskKernelLoaderSpec {
+ public:
+  CudaPtxOnDisk(absl::string_view filename, absl::string_view kernel_name);
+  ~CudaPtxOnDisk() override {}
+
+  const char *CanonicalSuffix() const override { return ".ptx"; }
+
+ private:
+  CudaPtxOnDisk(const CudaPtxOnDisk &) = delete;
+  void operator=(const CudaPtxOnDisk &) = delete;
+};
+
+// Kernel loader specification for CUBIN binary that resides on disk.
+class CudaCubinOnDisk : public OnDiskKernelLoaderSpec {
+ public:
+  CudaCubinOnDisk(absl::string_view filename, absl::string_view kernel_name);
+  ~CudaCubinOnDisk() override {}
+
+  const std::string &filename() const { return filename_; }
+
+  const char *CanonicalSuffix() const override { return ".cubin"; }
+
+ private:
+  std::string filename_;
+
+  CudaCubinOnDisk(const CudaCubinOnDisk &) = delete;
+  void operator=(const CudaCubinOnDisk &) = delete;
+};
+
+// Kernel loader specification for PTX text that resides in memory.
+class CudaPtxInMemory : public KernelLoaderSpec {
+ public:
+  // Components: compute capability major number, compute capability minor
+  // number, and PTX source.
+  typedef std::tuple<int, int, absl::string_view> PtxSpec;
+
+  // Single-PTX constructor. Adds the provided PTX version with an unknown
+  // compute capability. Since the CC is unknown, the PTX is assumed to be very
+  // generally usable - in other words, PTX specified in this manner is VERY
+  // likely to be used as the default! Note that the PTX can be compressed,
+  // which is indicated by the argument ptx_compressed.
+  //
+  // Warning: the string backing the provided absl::string_view ptx must outlive
+  // this instance.
+  CudaPtxInMemory(absl::string_view ptx, absl::string_view kernel_name,
+                  bool ptx_compressed = false);
+
+  // Multiple-PTX-version constructor. Adds each item in spec_list to this
+  // object. Note that the PTX can be compressed, which is indicated by the
+  // argument ptx_compressed.
+  CudaPtxInMemory(const std::initializer_list<PtxSpec> &spec_list,
+                  absl::string_view kernel_name, bool ptx_compressed = false);
+  ~CudaPtxInMemory() override {}
+
+  // Add the PTX implementation described by ptx_spec to this object. On
+  // collision (i.e., if a version with the same compute_capability already
+  // exists), the existing implementation will be overwritten.
+  void AddSpec(PtxSpec ptx_spec);
+
+  // Returns pointer to the ptx of available implementation with the
+  // lowest-valued compute capability. For example, if PTX written to CC2.0,
+  // 3.0, and 3.5 are all available, the version for CC2.0 will be set. Returns
+  // nullptr on failed lookup (if any version is not available).
+  // When the ptx is compressed, returns the decompressed ptx.
+  const char *default_text() const;
+
+  // Similar to default_text().
+  // When the ptx is compressed, returns the decompressed ptx.
+  const char *original_default_text() const;
+
+  // Returns pointer to the ptx for the requested compute capability.
+  // Returns nullptr on failed lookup (if the requested version is not
+  // available).
+  // When the ptx is compressed, returns the decompressed ptx.
+  const char *text(int compute_capability_major,
+                   int compute_capability_minor) const;
+
+  // Similar to text().
+  // When the ptx is compressed, returns the original compressed ptx.
+  const char *original_text(int compute_capability_major,
+                            int compute_capability_minor) const;
+
+  // Decompresses the PTX string using bzip2.
+  static std::string DecompressPtx(const char *ptx);
+
+ private:
+  // PTX translation unit text contents in memory. The key is of as a tuple
+  // "<cc_major>,<cc_minor>", i.e., "2,0", "3,0", "3,5". Because CC's
+  // represented in this way have a clear sorting order, map::begin() will give
+  // the lowest-numbered version available, i.e. the default.
+  std::map<std::tuple<int, int>, const char *,
+           bool (*)(const std::tuple<int, int> &, const std::tuple<int, int> &)>
+      ptx_by_compute_capability_;
+
+  // Stores all decompressed ptx strings, with original ptx string as keys.
+  // It is marked as mutable for lazy decompression.
+  mutable std::map<const char *, std::string> decompressed_ptx_;
+  mutable absl::Mutex mu_;
+
+  // Defines the minimum compute capability possible. Used when PTX has no
+  // compute capability specified (in the single-PTX constructor).
+  static const std::tuple<int, int> kMinimumCapability;
+
+  CudaPtxInMemory(const CudaPtxInMemory &) = delete;
+  void operator=(const CudaPtxInMemory &) = delete;
+};
+
+// Kernel loader specification for a CUBIN blob that resides in memory.
+class CudaCubinInMemory : public KernelLoaderSpec {
+ public:
+  CudaCubinInMemory(const char *bytes, absl::string_view kernel_name);
+  ~CudaCubinInMemory() override {}
+
+  const char *bytes() const { return bytes_; }
+
+ private:
+  const char *bytes_;
+
+  CudaCubinInMemory(const CudaCubinInMemory &) = delete;
+  void operator=(const CudaCubinInMemory &) = delete;
+};
+
+// Describes how to load a kernel on any subset of a number of target platforms.
+class MultiKernelLoaderSpec {
+ public:
+  explicit MultiKernelLoaderSpec(size_t arity);
+
+  // Returns the number of arguments that this kernel accepts.
+  size_t arity() const { return arity_; }
+
+  // Convenience getters for testing whether these platform variants have
+  // kernel loader specifications available.
+  bool has_cuda_ptx_on_disk() const { return cuda_ptx_on_disk_ != nullptr; }
+  bool has_cuda_cubin_on_disk() const { return cuda_cubin_on_disk_ != nullptr; }
+  bool has_cuda_cubin_in_memory() const {
+    return cuda_cubin_in_memory_ != nullptr;
+  }
+  bool has_cuda_ptx_in_memory() const { return cuda_ptx_in_memory_ != nullptr; }
+
+  // Accessors for platform variant kernel load specifications.
+  // Precondition: corresponding has_* is true.
+  const CudaPtxOnDisk &cuda_ptx_on_disk() const {
+    CHECK(has_cuda_ptx_on_disk());
+    return *cuda_ptx_on_disk_;
+  }
+  const CudaCubinOnDisk &cuda_cubin_on_disk() const {
+    CHECK(has_cuda_cubin_on_disk());
+    return *cuda_cubin_on_disk_;
+  }
+  const CudaCubinInMemory &cuda_cubin_in_memory() const {
+    CHECK(has_cuda_cubin_in_memory());
+    return *cuda_cubin_in_memory_;
+  }
+  const CudaPtxInMemory &cuda_ptx_in_memory() const {
+    CHECK(has_cuda_ptx_in_memory());
+    return *cuda_ptx_in_memory_;
+  }
+  // Builder-pattern-like methods for use in initializing a
+  // MultiKernelLoaderSpec. Each of these should be used at most once for a
+  // single MultiKernelLoaderSpec object. See file comment for example usage.
+  //
+  // Note that the kernel_name parameter must be consistent with the kernel in
+  // the PTX being loaded. Also be aware that in CUDA C++ the kernel name may be
+  // mangled by the compiler if it is not declared in an extern "C" scope.
+  MultiKernelLoaderSpec *AddCudaPtxOnDisk(absl::string_view filename,
+                                          absl::string_view kernel_name);
+  MultiKernelLoaderSpec *AddCudaCubinOnDisk(absl::string_view filename,
+                                            absl::string_view kernel_name);
+  MultiKernelLoaderSpec *AddCudaCubinInMemory(const char *cubin_bytes,
+                                              absl::string_view kernel_name);
+  MultiKernelLoaderSpec *AddCudaPtxInMemory(absl::string_view ptx,
+                                            absl::string_view kernel_name);
+  MultiKernelLoaderSpec *AddCudaCompressedPtxInMemory(
+      absl::string_view ptx, absl::string_view kernel_name);
+  MultiKernelLoaderSpec *AddCudaPtxInMemory(
+      std::initializer_list<CudaPtxInMemory::PtxSpec> spec_list,
+      absl::string_view kernel_name);
+  MultiKernelLoaderSpec *AddCudaCompressedPtxInMemory(
+      std::initializer_list<CudaPtxInMemory::PtxSpec> spec_list,
+      absl::string_view kernel_name);
+
+ private:
+  std::unique_ptr<CudaPtxOnDisk>
+      cuda_ptx_on_disk_;  // PTX text that resides in a file.
+  std::unique_ptr<CudaCubinOnDisk>
+      cuda_cubin_on_disk_;  // Binary CUDA program in a file.
+  std::unique_ptr<CudaCubinInMemory>
+      cuda_cubin_in_memory_;  // Binary CUDA program in memory.
+  std::unique_ptr<CudaPtxInMemory>
+      cuda_ptx_in_memory_;  // PTX text that resides in memory.
+
+  // Number of parameters that the kernel takes. (This is nicer to have in a
+  // constexpr than having to determine it from the types via template
+  // metaprogramming).
+  size_t arity_;
+};
+
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_KERNEL_SPEC_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/launch_dim.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/launch_dim.h
new file mode 100644
index 0000000000000000000000000000000000000000..ef7d03311bb6239d76aae5523b1f3a400cd37da2
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/launch_dim.h
@@ -0,0 +1,75 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// Types to express dimensionality of a kernel launch. Blocks and threads
+// are (up to) 3-dimensional.
+//
+// A thread is conceptually like a SIMD lane. Some number, typically 32
+// (though that fact should not be relied on) SIMD lanes are tied together with
+// a single PC in a unit called a warp. There is a maximum number of threads
+// that can execute in a shared-context entity called a block. Presently, that
+// number is 1024 -- again, something that should not be relied on from this
+// comment, but checked via stream_executor::DeviceDescription.
+//
+// For additional information, see
+// http://docs.nvidia.com/cuda/kepler-tuning-guide/#device-utilization-and-occupancy
+//
+// Because of that modest thread-per-block limit, a kernel can be launched with
+// multiple blocks. Each block is indivisibly scheduled onto a single core.
+// Blocks can also be used in a multi-dimensional configuration, and the block
+// count has much less modest limits -- typically they're similar to the maximum
+// amount of addressable memory.
+
+#ifndef XLA_STREAM_EXECUTOR_LAUNCH_DIM_H_
+#define XLA_STREAM_EXECUTOR_LAUNCH_DIM_H_
+
+#include <cstdint>
+#include <string>
+
+#include "absl/strings/str_cat.h"
+
+namespace stream_executor {
+
+// Thread dimensionality for use in a kernel launch. See file comment for
+// details.
+struct ThreadDim {
+  explicit ThreadDim(uint64_t x = 1, uint64_t y = 1, uint64_t z = 1)
+      : x(x), y(y), z(z) {}
+
+  // Returns a string representation of the thread dimensionality.
+  std::string ToString() const {
+    return absl::StrCat("ThreadDim{", x, ", ", y, ", ", z, "}");
+  }
+
+  uint64_t x, y, z;
+};
+
+// Block dimensionality for use in a kernel launch. See file comment for
+// details.
+struct BlockDim {
+  explicit BlockDim(uint64_t x = 1, uint64_t y = 1, uint64_t z = 1)
+      : x(x), y(y), z(z) {}
+
+  // Returns a string representation of the block dimensionality.
+  std::string ToString() const {
+    return absl::StrCat("BlockDim{", x, ", ", y, ", ", z, "}");
+  }
+
+  uint64_t x, y, z;
+};
+
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_LAUNCH_DIM_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/lazy_op_runner.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/lazy_op_runner.h
new file mode 100644
index 0000000000000000000000000000000000000000..2c390d75f921486c7463d20496943a34ce967bae
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/lazy_op_runner.h
@@ -0,0 +1,301 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+------------------------------------------------------------------------------*/
+
+#ifndef XLA_STREAM_EXECUTOR_LAZY_OP_RUNNER_H_
+#define XLA_STREAM_EXECUTOR_LAZY_OP_RUNNER_H_
+
+#include <atomic>
+#include <memory>
+#include <optional>
+#include <string>
+#include <utility>
+
+#include "absl/base/call_once.h"
+#include "xla/stream_executor/dnn.h"
+#include "xla/stream_executor/stream.h"
+
+namespace stream_executor {
+namespace dnn {
+
+// A lazily-initialized OpRunner from an AlgorithmDesc.
+//
+// This exists to hold a choice of conv algorithm for a particular config,
+// initialize its OpRunner at most once, and defer that initialization until the
+// config is first needed.  This allows AoT autotuning to load configurations
+// for all convolutions it knows about, without doing expensive initialization
+// (e.g. runtime codegen) and retaining non-negligible resources (e.g.  compiled
+// kernels) for potentially irrelevant configurations.  It also enables XLA conv
+// thunks to defer binding to a particular stream executor until the first run.
+//
+// `Op` must satisfy the following "concept":
+//
+// struct Op {
+//   // The function type signature parameter of an OpRunner.
+//   using Signature = _;
+//
+//   // The parameter to be used by GetOrCreateRunner.
+//   struct Config;
+//
+//   // Use a StreamExecutor to create an OpRunner.
+//   static StatusOr<OpRunner<Config>> OpRunnerFromDesc(
+//       const AlgorithmDesc& desc, Config config, StreamExecutor* stream);
+// };
+template <typename Op>
+class LazyOpRunner {
+ public:
+  // Construct from a pre-initialized OpRunner; all calls to GetOrCreateRunner
+  // will return a pointer to exactly this runner.
+  static tsl::StatusOr<std::unique_ptr<LazyOpRunner>> FromOpRunner(
+      std::unique_ptr<const OpRunner<typename Op::Signature>> runner) {
+    if (!runner) {
+      return tsl::errors::Internal("Null runner argument to FromOpRunner");
+    }
+    TF_ASSIGN_OR_RETURN(auto desc, runner->ToAlgorithmDesc());
+    // Private constructor cannot be called by make_unique :(
+    return {std::unique_ptr<LazyOpRunner>(
+        new LazyOpRunner(desc, std::move(runner)))};
+  }
+
+  // Construct from an AlgorithmDesc, with no pre-initialized OpRunner; it will
+  // be created on the first call to GetOrCreateRunner.
+  explicit LazyOpRunner(AlgorithmDesc desc) : LazyOpRunner(desc, nullptr) {}
+
+  // Returns an already-initialized OpRunner if available, or creates one.
+  //
+  // Invariant: a particular instance of this class shall only receive calls
+  // with identical `config`s and `stream_executor`s.  If the config is changed,
+  // only the first config it sees will have any effect, and second and
+  // subsequent configs will be ignored.  If the stream executor is changed,
+  // some operations on the returned `OpRunner` using the changed stream
+  // executor will be errors.
+  //
+  // The result is owned by LazyOpRunner.
+  tsl::StatusOr<const OpRunner<typename Op::Signature>*> GetOrCreateRunner(
+      typename Op::Config config, Stream* stream) {
+    absl::call_once(once_flag_, [&] {
+      if (runner_) return;  // runner was passed via constructor argument
+
+      auto r = Op::RunnerFromAlgorithmDesc(desc_, std::move(config), stream);
+      if (!r.ok()) {
+        error_ = std::move(r).status();
+      } else {
+        runner_ = std::move(r).value();
+      }
+    });
+
+    if (!error_.ok()) return error_;
+    return runner_.get();
+  }
+
+  // Get the contained runner with the invariant that it's already initialized.
+  tsl::StatusOr<const OpRunner<typename Op::Signature>*> GetRunner() {
+    if (auto* runner = runner_ptr_.load(std::memory_order_acquire)) {
+      return runner;
+    }
+    return tsl::errors::Internal("LazyOpRunner::GetRunner: not initialized");
+  }
+
+  bool operator==(const LazyOpRunner& other) const {
+    return desc_ == other.desc_;
+  }
+
+  std::string ToString() const { return desc_.ToString(); }
+
+  const AlgorithmDesc& ToAlgorithmDesc() const { return desc_; }
+
+ private:
+  LazyOpRunner(AlgorithmDesc desc,
+               std::unique_ptr<const OpRunner<typename Op::Signature>> runner)
+      : desc_(std::move(desc)),
+        error_(tsl::OkStatus()),
+        runner_(std::move(runner)),
+        runner_ptr_(runner_.get()) {}
+
+  AlgorithmDesc desc_;
+
+  // We use absl::call_once to lazily initialize `runner_` (or `error_`).
+  absl::once_flag once_flag_;
+  tsl::Status error_;  // holds error if runner can't be initialized
+  std::unique_ptr<const OpRunner<typename Op::Signature>> runner_;
+
+  // Once we initialize `runner_` we publish a pointer through atomic so that
+  // `GetRunner` can read it without data races with initialization.
+  std::atomic<const OpRunner<typename Op::Signature>*> runner_ptr_;
+};
+
+// Implementation of the concept required by LazyOpRunner, for ConvRunner.
+struct ConvOp {
+  using Signature = ConvSignature;
+
+  struct Config {
+    ConvolutionKind kind;
+    DataType input_type, output_type;
+    const BatchDescriptor& input_descriptor;
+    const FilterDescriptor& filter_descriptor;
+    const BatchDescriptor& output_descriptor;
+    const ConvolutionDescriptor& convolution_descriptor;
+  };
+
+  static tsl::StatusOr<std::unique_ptr<const OpRunner<ConvSignature>>>
+  RunnerFromAlgorithmDesc(const AlgorithmDesc& desc, Config config,
+                          Stream* stream) {
+    return stream->ConvolveRunnerFromDesc(
+        desc, config.kind, config.input_type, config.output_type,
+        config.input_descriptor, config.filter_descriptor,
+        config.output_descriptor, config.convolution_descriptor);
+  }
+};
+
+// Implementation of the concept required by LazyOpRunner, for
+// GraphConvolveRunner.
+struct GraphConvOp {
+  using Signature = GraphConvSignature;
+
+  struct Config {
+    ConvolutionKind kind;
+    DataType input_type, output_type;
+    const BatchDescriptor& input_descriptor;
+    const FilterDescriptor& filter_descriptor;
+    const BatchDescriptor& output_descriptor;
+    const ConvolutionDescriptor& convolution_descriptor;
+    std::string serialized_graph;
+  };
+
+  static tsl::StatusOr<std::unique_ptr<const OpRunner<Signature>>>
+  RunnerFromAlgorithmDesc(const AlgorithmDesc& desc, Config config,
+                          Stream* stream) {
+    return stream->GraphConvolveRunnerFromDesc(
+        desc, config.kind, config.input_type, config.output_type,
+        config.input_descriptor, config.filter_descriptor,
+        config.output_descriptor, config.convolution_descriptor,
+        config.serialized_graph);
+  }
+};
+
+// Implementation of the concept required by LazyOpRunner, for LazyConvRunner.
+struct FusedConvOp {
+  using Signature = FusedConvSignature;
+
+  struct Config {
+    ConvolutionKind kind;
+    DataType input_type, bias_type, output_type;
+    double conv_scale, side_input_scale, leakyrelu_alpha;
+    const BatchDescriptor& input_descriptor;
+    const FilterDescriptor& filter_descriptor;
+    const BatchDescriptor& bias_descriptor;
+    const BatchDescriptor& output_descriptor;
+    const ConvolutionDescriptor& convolution_descriptor;
+    ActivationMode activation_mode;
+  };
+
+  static tsl::StatusOr<std::unique_ptr<const OpRunner<FusedConvSignature>>>
+  RunnerFromAlgorithmDesc(const AlgorithmDesc& desc, Config config,
+                          Stream* stream) {
+    return stream->FusedConvolveRunnerFromDesc(
+        desc, config.kind, config.input_type, config.bias_type,
+        config.output_type, config.conv_scale, config.side_input_scale,
+        config.leakyrelu_alpha, config.input_descriptor,
+        config.filter_descriptor, config.bias_descriptor,
+        config.output_descriptor, config.convolution_descriptor,
+        config.activation_mode);
+  }
+};
+
+// Implementation of the concept required by LazyOpRunner, for FusedMatmul.
+struct FusedMatmulOp {
+  using Signature = FusedMatmulSignature;
+
+  // Config is mainly used in RunnerFromAlgorithmDesc() to lazily create the
+  // runner. At this moment we only get existing runners and don't implement
+  // this feature.
+  struct Config {};
+
+  static tsl::StatusOr<std::unique_ptr<const OpRunner<Signature>>>
+  RunnerFromAlgorithmDesc(const AlgorithmDesc& desc, Config config,
+                          Stream* stream) {
+    return tsl::errors::Unimplemented("Unimplemented");
+  }
+};
+
+struct FusedMHAOp {
+  using Signature = FusedMHASignature;
+  struct Config {
+    FusedMHAKind kind;
+    double scale;
+    const MatmulTensorDescriptor& bmm1_lhs_descriptor;
+    const MatmulTensorDescriptor& bmm1_rhs_descriptor;
+    const MatmulTensorDescriptor& bmm2_rhs_descriptor;
+    const MatmulTensorDescriptor& intermediate_bmm2_lhs_descriptor;
+    const TensorDescriptor& output_descriptor;
+    std::optional<TensorDescriptor> bias_descriptor;
+    std::optional<TensorDescriptor> mask_descriptor;
+    std::optional<TensorDescriptor> activation_descriptor;
+    std::optional<double> dropout_rate;
+    std::optional<int64_t> seed;
+  };
+
+  static tsl::StatusOr<std::unique_ptr<const OpRunner<FusedMHASignature>>>
+  RunnerFromAlgorithmDesc(const AlgorithmDesc& desc, Config config,
+                          Stream* stream) {
+    return stream->FusedMHARunnerFromDesc(
+        desc, config.kind, config.bmm1_lhs_descriptor,
+        config.bmm1_rhs_descriptor, config.bmm2_rhs_descriptor,
+        config.intermediate_bmm2_lhs_descriptor, config.output_descriptor,
+        config.activation_descriptor, config.mask_descriptor,
+        config.bias_descriptor, config.scale, config.dropout_rate, config.seed);
+  }
+};
+
+struct FusedMHABackwardOp {
+  using Signature = FusedMHABackwardSignature;
+
+  struct Config {
+    FusedMHAKind kind;
+    double scale;
+    const MatmulTensorDescriptor& bmm1_grad_gemm1_rhs_descriptor;
+    const MatmulTensorDescriptor& bmm1_grad_gemm2_rhs_descriptor;
+    const MatmulTensorDescriptor& bmm2_grad_gemm1_lhs_descriptor;
+    const MatmulTensorDescriptor& bmm2_grad_gemm2_rhs_descriptor;
+    const MatmulTensorDescriptor& d_output_descriptor;
+    const TensorDescriptor& d_bmm1_lhs_descriptor;
+    const TensorDescriptor& d_bmm1_rhs_descriptor;
+    const TensorDescriptor& d_bmm2_rhs_descriptor;
+    const TensorDescriptor& d_s_descriptor;
+    std::optional<TensorDescriptor> mask_descriptor;
+    std::optional<TensorDescriptor> d_bias_descriptor;
+    std::optional<double> dropout_rate;
+    std::optional<int64_t> seed;
+  };
+
+  static tsl::StatusOr<
+      std::unique_ptr<const OpRunner<FusedMHABackwardSignature>>>
+  RunnerFromAlgorithmDesc(const AlgorithmDesc& desc, Config config,
+                          Stream* stream) {
+    return stream->FusedMHABackwardRunnerFromDesc(
+        desc, config.kind, config.bmm1_grad_gemm1_rhs_descriptor,
+        config.bmm1_grad_gemm2_rhs_descriptor,
+        config.bmm2_grad_gemm1_lhs_descriptor,
+        config.bmm2_grad_gemm2_rhs_descriptor, config.d_output_descriptor,
+        config.d_bmm1_lhs_descriptor, config.d_bmm1_rhs_descriptor,
+        config.d_bmm2_rhs_descriptor, config.d_s_descriptor,
+        config.mask_descriptor, config.d_bias_descriptor, config.scale,
+        config.dropout_rate, config.seed);
+  }
+};
+
+}  // namespace dnn
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_LAZY_OP_RUNNER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/module_spec.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/module_spec.h
new file mode 100644
index 0000000000000000000000000000000000000000..cfee31e514c14d4a72d6f6d01ec3f1d1798e4b70
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/module_spec.h
@@ -0,0 +1,92 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_STREAM_EXECUTOR_MODULE_SPEC_H_
+#define XLA_STREAM_EXECUTOR_MODULE_SPEC_H_
+
+#include <cstdint>
+
+#include "absl/types/span.h"
+#include "xla/stream_executor/platform/port.h"
+#include "tsl/platform/logging.h"
+
+namespace stream_executor {
+
+//===----------------------------------------------------------------------===//
+// ModuleHandle
+//===----------------------------------------------------------------------===//
+
+// An opaque handle to a loaded module.
+//
+// An instance of this is returned from StreamExecutor::GetModule.
+class ModuleHandle {
+ public:
+  explicit ModuleHandle(void* id = nullptr) : id_(id) {}
+
+  // A ModuleHandle with id() == nullptr is an invalid module handle, akin to a
+  // null pointer.
+  void* id() const { return id_; }
+
+  explicit operator bool() const { return id() != nullptr; }
+
+ private:
+  void* id_;
+};
+
+//===----------------------------------------------------------------------===//
+// MultiModuleLoaderSpec
+//===----------------------------------------------------------------------===//
+
+// Describes how to load a module on a target platform.
+//
+// The exact meaning of a "module" may differ from platform to platform but
+// loosely speaking a module a collection of kernels and global variables.  It
+// corresponds to CUmodule when running on CUDA.
+class MultiModuleLoaderSpec {
+ public:
+  bool has_cuda_cubin_in_memory() const { return has_cuda_cubin_in_memory_; }
+  absl::Span<const uint8_t> cuda_cubin_in_memory() const {
+    CHECK(has_cuda_cubin_in_memory());
+    return {cuda_cubin_in_memory_.data(), cuda_cubin_in_memory_.size()};
+  }
+
+  bool has_cuda_ptx_in_memory() const { return has_cuda_ptx_in_memory_; }
+  const char* cuda_ptx_in_memory() const {
+    CHECK(has_cuda_ptx_in_memory());
+    return cuda_ptx_in_memory_;
+  }
+
+  void AddCudaCubinInMemory(absl::Span<const uint8_t> cubin_bytes) {
+    CHECK(!cubin_bytes.empty());
+    has_cuda_cubin_in_memory_ = true;
+    cuda_cubin_in_memory_ = cubin_bytes;
+  }
+
+  void AddCudaPtxInMemory(const char* ptx) {
+    has_cuda_ptx_in_memory_ = true;
+    // The CUDA driver does not like getting an empty string as PTX.
+    cuda_ptx_in_memory_ = *ptx ? ptx : nullptr;
+  }
+
+ private:
+  absl::Span<const uint8_t> cuda_cubin_in_memory_;
+  bool has_cuda_cubin_in_memory_ = false;
+  const char* cuda_ptx_in_memory_;
+  bool has_cuda_ptx_in_memory_ = false;
+};
+
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_MODULE_SPEC_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/multi_platform_manager.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/multi_platform_manager.h
new file mode 100644
index 0000000000000000000000000000000000000000..f428bbf9bd81b8e13e297bc130d4acb6f7a243ea
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/multi_platform_manager.h
@@ -0,0 +1,158 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// This is a registration-oriented interface for multiple platforms. It will
+// replace the MachineManager singleton interface, as MachineManager does not
+// currently support simultaneous use of multiple platforms.
+//
+// Usage:
+//
+// In your BUILD rule, add a dependency on a platform plugin that you'd like
+// to use, such as:
+//
+//   //third_party/tensorflow/compiler/xla/stream_executor/cuda:cuda_platform
+//   //third_party/tensorflow/compiler/xla/stream_executor/opencl:opencl_platform
+//
+// This will register platform plugins that can be discovered via this
+// interface. Sample API usage:
+//
+//   tsl::StatusOr<Platform*> platform_status =
+//      se::MultiPlatformManager::PlatformWithName("OpenCL");
+//   if (!platform_status.ok()) { ... }
+//   Platform* platform = platform_status.value();
+//   LOG(INFO) << platform->VisibleDeviceCount() << " devices visible";
+//   if (platform->VisibleDeviceCount() <= 0) { return; }
+//
+//   for (int i = 0; i < platform->VisibleDeviceCount(); ++i) {
+//     tsl::StatusOr<StreamExecutor*> executor_status =
+//        platform->ExecutorForDevice(i);
+//     if (!executor_status.ok()) {
+//       LOG(INFO) << "could not retrieve executor for device ordinal " << i
+//                 << ": " << executor_status.status();
+//       continue;
+//     }
+//     LOG(INFO) << "found usable executor: " << executor_status.value();
+//   }
+//
+// A few things to note:
+//  - There is no standard formatting/practice for identifying the name of a
+//    platform. Ideally, a platform will list its registered name in its header
+//    or in other associated documentation.
+//  - Platform name lookup is case-insensitive. "OpenCL" or "opencl" (or even
+//    ("OpEnCl") would work correctly in the above example.
+//
+// And similarly, for standard interfaces (BLAS, etc.) you can add
+// dependencies on support libraries, e.g.:
+//
+//    //third_party/tensorflow/compiler/xla/stream_executor/cuda:pluton_blas_plugin
+//    //third_party/tensorflow/compiler/xla/stream_executor/cuda:cudnn_plugin
+//    //third_party/tensorflow/compiler/xla/stream_executor/cuda:cublas_plugin
+
+#ifndef XLA_STREAM_EXECUTOR_MULTI_PLATFORM_MANAGER_H_
+#define XLA_STREAM_EXECUTOR_MULTI_PLATFORM_MANAGER_H_
+
+#include <functional>
+#include <map>
+#include <memory>
+#include <vector>
+
+#include "absl/strings/string_view.h"
+#include "xla/stream_executor/platform.h"
+#include "xla/stream_executor/platform/initialize.h"
+#include "xla/stream_executor/platform/port.h"
+#include "tsl/platform/status.h"
+#include "tsl/platform/statusor.h"
+
+namespace stream_executor {
+
+// Manages multiple platforms that may be present on the current machine.
+class MultiPlatformManager {
+ public:
+  // Registers a platform object, returns an error status if the platform is
+  // already registered. The associated listener, if not null, will be used to
+  // trace events for ALL executors for that platform.
+  // Takes ownership of platform.
+  static tsl::Status RegisterPlatform(std::unique_ptr<Platform> platform);
+
+  // Retrieves the platform registered with the given platform name (e.g.
+  // "CUDA", "OpenCL", ...) or id (an opaque, comparable value provided by the
+  // Platform's Id() method).
+  //
+  // If the platform has not already been initialized, it will be initialized
+  // with a default set of parameters.
+  //
+  // If the requested platform is not registered, an error status is returned.
+  // Ownership of the platform is NOT transferred to the caller --
+  // the MultiPlatformManager owns the platforms in a singleton-like fashion.
+  static tsl::StatusOr<Platform*> PlatformWithName(absl::string_view target);
+  static tsl::StatusOr<Platform*> PlatformWithId(const Platform::Id& id);
+
+  // Same functions as above, but allows platforms to be returned without
+  // initialization if initialize_platform == false.
+  static tsl::StatusOr<Platform*> PlatformWithName(absl::string_view target,
+                                                   bool initialize_platform);
+
+  // Retrieves the platform registered with the given platform id (an opaque,
+  // comparable value provided by the Platform's Id() method).
+  //
+  // The platform will be initialized with the given options. If the platform
+  // was already initialized, an error will be returned.
+  //
+  // If the requested platform is not registered, an error status is returned.
+  // Ownership of the platform is NOT transferred to the caller --
+  // the MultiPlatformManager owns the platforms in a singleton-like fashion.
+  static tsl::StatusOr<Platform*> InitializePlatformWithId(
+      const Platform::Id& id,
+      const std::map<std::string, std::string>& options);
+
+  // Retrieves the platforms satisfying the given filter, i.e. returns true.
+  // Returned Platforms are always initialized.
+  static tsl::StatusOr<std::vector<Platform*>> PlatformsWithFilter(
+      const std::function<bool(const Platform*)>& filter);
+
+  static tsl::StatusOr<std::vector<Platform*>> PlatformsWithFilter(
+      const std::function<bool(const Platform*)>& filter,
+      bool initialize_platform);
+
+  // Although the MultiPlatformManager "owns" its platforms, it holds them as
+  // undecorated pointers to prevent races during program exit (between this
+  // object's data and the underlying platforms (e.g., CUDA, OpenCL).
+  // Because certain platforms have unpredictable deinitialization
+  // times/sequences, it is not possible to strucure a safe deinitialization
+  // sequence. Thus, we intentionally "leak" allocated platforms to defer
+  // cleanup to the OS. This should be acceptable, as these are one-time
+  // allocations per program invocation.
+  // The MultiPlatformManager should be considered the owner
+  // of any platforms registered with it, and leak checking should be disabled
+  // during allocation of such Platforms, to avoid spurious reporting at program
+  // exit.
+};
+
+}  // namespace stream_executor
+
+// multi_platform_manager.cc will define these instances.
+//
+// Registering a platform:
+// REGISTER_MODULE_INITIALIZER_SEQUENCE(my_platform, multi_platform_manager);
+// REGISTER_MODULE_INITIALIZER_SEQUENCE(multi_platform_manager_listener,
+// my_platform);
+//
+// Registering a listener:
+// REGISTER_MODULE_INITIALIZER_SEQUENCE(my_listener,
+// multi_platform_manager_listener);
+DECLARE_MODULE_INITIALIZER(multi_platform_manager);
+DECLARE_MODULE_INITIALIZER(multi_platform_manager_listener);
+
+#endif  // XLA_STREAM_EXECUTOR_MULTI_PLATFORM_MANAGER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/numeric_options.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/numeric_options.h
new file mode 100644
index 0000000000000000000000000000000000000000..f75dfb54ff65b33c76965ce01cad9d7c18ea0e71
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/numeric_options.h
@@ -0,0 +1,37 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+------------------------------------------------------------------------------*/
+
+#ifndef XLA_STREAM_EXECUTOR_NUMERIC_OPTIONS_H_
+#define XLA_STREAM_EXECUTOR_NUMERIC_OPTIONS_H_
+
+namespace stream_executor {
+
+// Options that specify the numeric behavior of operations like matrix
+// multiplications and convolutions
+struct NumericOptions {
+  NumericOptions(bool require_determinism, bool allow_tf32)
+      : require_determinism(require_determinism), allow_tf32(allow_tf32) {}
+
+  NumericOptions() : require_determinism(false), allow_tf32(true) {}
+
+  // If true, the op must be deterministic
+  bool require_determinism;
+  // If true, float32 inputs can be rounded to TensorFloat-32 precision
+  bool allow_tf32;
+};
+
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_NUMERIC_OPTIONS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/platform.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/platform.h
new file mode 100644
index 0000000000000000000000000000000000000000..b03d046220bbbc72efadf6fc94b3750b31eff507
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/platform.h
@@ -0,0 +1,153 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// Defines types and declares functions for identifying and extracting
+// information about the types of platforms and supporting libraries for which
+// StreamExecutor implementations exist.
+#ifndef XLA_STREAM_EXECUTOR_PLATFORM_H_
+#define XLA_STREAM_EXECUTOR_PLATFORM_H_
+
+#include <map>
+#include <memory>
+#include <string>
+
+#include "xla/stream_executor/device_description.h"
+#include "xla/stream_executor/device_options.h"
+#include "xla/stream_executor/platform/port.h"
+#include "tsl/platform/status.h"
+#include "tsl/platform/statusor.h"
+
+namespace stream_executor {
+
+class StreamExecutor;
+class DeviceDescription;
+
+// An enum to represent different levels of stream priorities.
+// This is to avoid platform-specific representations in abstractions.
+enum class StreamPriority { Default = 0, Lowest, Highest };
+
+// Returns a printable description of StreamPriority.
+std::string StreamPriorityToString(StreamPriority priority);
+
+// StreamExecutorConfig encapsulates the set of options for constructing a
+// StreamExecutor for a given platform.
+struct StreamExecutorConfig {
+  // Sets members to defaults: -1 for ordinal (must be changed), and default
+  // PluginConfig and DeviceOptions.
+  StreamExecutorConfig();
+
+  // Simple ordinal-setting constructor.
+  explicit StreamExecutorConfig(int ordinal);
+
+  // The GPU stream for which we are searching the executor.
+  // If this field is specified for the search, others will be ignored.
+  void* gpu_stream = nullptr;
+
+  // The ordinal of the device to be managed by the returned StreamExecutor.
+  int ordinal;
+
+  // The DeviceOptions for the returned StreamExecutor.
+  DeviceOptions device_options;
+};
+
+// Abstract base class for a platform registered with the MultiPlatformManager.
+class Platform {
+ public:
+  virtual ~Platform();
+
+  // A platform ID is a unique identifier for each registered platform type -
+  // each platform is required to expose an ID to ensure unique registration and
+  // as a target against which plugins can register.
+  //
+  // The macro below is provided to help generate a [process-unique] identifier.
+  using Id = void*;
+
+// Helper macro to define a plugin ID. To be used only inside plugin
+// implementation files. Works by "reserving" an address/value (guaranteed to be
+// unique) inside a process space.
+#define PLATFORM_DEFINE_ID(ID_VAR_NAME) \
+  namespace {                           \
+  int plugin_id_value;                  \
+  }                                     \
+  const ::stream_executor::Platform::Id ID_VAR_NAME = &plugin_id_value;
+
+  // Returns a key uniquely identifying this platform.
+  virtual Id id() const = 0;
+
+  // Name of this platform.
+  virtual const std::string& Name() const = 0;
+
+  // Returns the number of devices accessible on this platform.
+  //
+  // Note that, though these devices are visible, if there is only one userspace
+  // context allowed for the device at a time and another process is using this
+  // device, a call to ExecutorForDevice may return an error status.
+  virtual int VisibleDeviceCount() const = 0;
+
+  // Returns true iff the platform has been initialized.
+  virtual bool Initialized() const;
+
+  // Initializes the platform with a custom set of options. The platform must be
+  // initialized before obtaining StreamExecutor objects.  The interpretation of
+  // the platform_options argument is implementation specific.  This method may
+  // return an error if unrecognized options are provided.  If using
+  // MultiPlatformManager, this method will be called automatically by
+  // InitializePlatformWithId/InitializePlatformWithName.
+  virtual tsl::Status Initialize(
+      const std::map<std::string, std::string>& platform_options);
+
+  // Returns a populated DeviceDescription for the device at the given ordinal.
+  // This should not require device initialization. Note that not all platforms
+  // may support acquiring the DeviceDescription indirectly.
+  //
+  // Alternatively callers may call GetDeviceDescription() on the StreamExecutor
+  // which returns a cached instance specific to the initialized StreamExecutor.
+  virtual tsl::StatusOr<std::unique_ptr<DeviceDescription>>
+  DescriptionForDevice(int ordinal) const = 0;
+
+  // Returns a device with the given ordinal on this platform with a default
+  // plugin configuration or, if none can be found with the given ordinal or
+  // there is an error in opening a context to communicate with the device, an
+  // error status is returned.
+  //
+  // Ownership of the executor is NOT transferred to the caller --
+  // the Platform owns the executors in a singleton-like fashion.
+  virtual tsl::StatusOr<StreamExecutor*> ExecutorForDevice(int ordinal) = 0;
+
+  // Returns a device constructed with the options specified in "config".
+  // Ownership of the executor is NOT transferred to the caller.
+  virtual tsl::StatusOr<StreamExecutor*> GetExecutor(
+      const StreamExecutorConfig& config) = 0;
+
+  // Returns a device constructed with the options specified in "config" without
+  // looking in or storing to the Platform's executor cache.
+  // Ownership IS transferred to the caller.
+  virtual tsl::StatusOr<std::unique_ptr<StreamExecutor>> GetUncachedExecutor(
+      const StreamExecutorConfig& config) = 0;
+
+ protected:
+  // SE_DISALLOW_COPY_AND_ASSIGN declares a constructor, which suppresses the
+  // presence of the default constructor. This statement re-enables it, which
+  // simplifies subclassing.
+  Platform() = default;
+
+ private:
+  Platform(const Platform&) = delete;
+  void operator=(const Platform&) = delete;
+};
+
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_PLATFORM_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/platform/default/dso_loader.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/platform/default/dso_loader.h
new file mode 100644
index 0000000000000000000000000000000000000000..baf9de18876c676604b5c0b2136fb8b2318a9cc2
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/platform/default/dso_loader.h
@@ -0,0 +1,86 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// Common DSO loading functionality: exposes callables that dlopen DSOs
+// in either the runfiles directories
+
+#ifndef XLA_STREAM_EXECUTOR_PLATFORM_DEFAULT_DSO_LOADER_H_
+#define XLA_STREAM_EXECUTOR_PLATFORM_DEFAULT_DSO_LOADER_H_
+
+#include <vector>
+
+#include "absl/strings/string_view.h"
+#include "tsl/platform/dso_loader.h"
+#include "tsl/platform/status.h"
+#include "tsl/platform/statusor.h"
+
+namespace stream_executor {
+namespace internal {
+
+namespace DsoLoader {
+// NOLINTBEGIN(misc-unused-using-decls)
+using tsl::internal::DsoLoader::GetCublasDsoHandle;
+using tsl::internal::DsoLoader::GetCublasLtDsoHandle;
+using tsl::internal::DsoLoader::GetCudaDriverDsoHandle;
+using tsl::internal::DsoLoader::GetCudaRuntimeDsoHandle;
+using tsl::internal::DsoLoader::GetCudnnDsoHandle;
+using tsl::internal::DsoLoader::GetCufftDsoHandle;
+using tsl::internal::DsoLoader::GetCuptiDsoHandle;
+using tsl::internal::DsoLoader::GetCusolverDsoHandle;
+using tsl::internal::DsoLoader::GetCusparseDsoHandle;
+using tsl::internal::DsoLoader::GetHipDsoHandle;
+using tsl::internal::DsoLoader::GetHipfftDsoHandle;
+using tsl::internal::DsoLoader::GetHipsolverDsoHandle;
+using tsl::internal::DsoLoader::GetHipsparseDsoHandle;
+using tsl::internal::DsoLoader::GetMiopenDsoHandle;
+using tsl::internal::DsoLoader::GetNvInferDsoHandle;
+using tsl::internal::DsoLoader::GetNvInferPluginDsoHandle;
+using tsl::internal::DsoLoader::GetRocblasDsoHandle;
+using tsl::internal::DsoLoader::GetRocrandDsoHandle;
+using tsl::internal::DsoLoader::GetRocsolverDsoHandle;
+using tsl::internal::DsoLoader::GetRoctracerDsoHandle;
+using tsl::internal::DsoLoader::MaybeTryDlopenGPULibraries;
+using tsl::internal::DsoLoader::TryDlopenTensorRTLibraries;
+// NOLINTEND(misc-unused-using-decls)
+}  // namespace DsoLoader
+
+namespace CachedDsoLoader {
+// NOLINTBEGIN(misc-unused-using-decls)
+using tsl::internal::CachedDsoLoader::GetCublasDsoHandle;
+using tsl::internal::CachedDsoLoader::GetCublasLtDsoHandle;
+using tsl::internal::CachedDsoLoader::GetCudaDriverDsoHandle;
+using tsl::internal::CachedDsoLoader::GetCudaRuntimeDsoHandle;
+using tsl::internal::CachedDsoLoader::GetCudnnDsoHandle;
+using tsl::internal::CachedDsoLoader::GetCufftDsoHandle;
+using tsl::internal::CachedDsoLoader::GetCuptiDsoHandle;
+using tsl::internal::CachedDsoLoader::GetCusolverDsoHandle;
+using tsl::internal::CachedDsoLoader::GetCusparseDsoHandle;
+using tsl::internal::CachedDsoLoader::GetHipblasltDsoHandle;
+using tsl::internal::CachedDsoLoader::GetHipDsoHandle;
+using tsl::internal::CachedDsoLoader::GetHipfftDsoHandle;
+using tsl::internal::CachedDsoLoader::GetHipsolverDsoHandle;
+using tsl::internal::CachedDsoLoader::GetHipsparseDsoHandle;
+using tsl::internal::CachedDsoLoader::GetMiopenDsoHandle;
+using tsl::internal::CachedDsoLoader::GetRocblasDsoHandle;
+using tsl::internal::CachedDsoLoader::GetRocrandDsoHandle;
+using tsl::internal::CachedDsoLoader::GetRocsolverDsoHandle;
+using tsl::internal::CachedDsoLoader::GetRoctracerDsoHandle;
+// NOLINTEND(misc-unused-using-decls)
+}  // namespace CachedDsoLoader
+
+}  // namespace internal
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_PLATFORM_DEFAULT_DSO_LOADER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/platform/default/initialize.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/platform/default/initialize.h
new file mode 100644
index 0000000000000000000000000000000000000000..6928d6adbb0c23668d0fc13d5f1d41e095cff81e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/platform/default/initialize.h
@@ -0,0 +1,62 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_STREAM_EXECUTOR_PLATFORM_DEFAULT_INITIALIZE_H_
+#define XLA_STREAM_EXECUTOR_PLATFORM_DEFAULT_INITIALIZE_H_
+
+#undef REGISTER_MODULE_INITIALIZER
+#undef DECLARE_MODULE_INITIALIZER
+#undef REGISTER_MODULE_INITIALIZER_SEQUENCE
+
+namespace stream_executor {
+namespace port {
+
+class Initializer {
+ public:
+  typedef void (*InitializerFunc)();
+  explicit Initializer(InitializerFunc func) { func(); }
+
+  struct Dependency {
+    Dependency(const char *n, Initializer *i) : name(n), initializer(i) {}
+    const char *const name;
+    Initializer *const initializer;
+  };
+
+  struct DependencyRegisterer {
+    DependencyRegisterer(const char *type, const char *name,
+                         Initializer *initializer,
+                         const Dependency &dependency);
+  };
+};
+
+}  // namespace port
+}  // namespace stream_executor
+
+#define REGISTER_INITIALIZER(type, name, body)                             \
+  static void google_init_##type##_##name() { body; }                      \
+  ::stream_executor::port::Initializer google_initializer_##type##_##name( \
+      google_init_##type##_##name)
+
+#define REGISTER_MODULE_INITIALIZER(name, body) \
+  REGISTER_INITIALIZER(module, name, body)
+
+#define DECLARE_INITIALIZER(type, name) \
+  extern ::stream_executor::port::Initializer google_initializer_##type##_##name
+
+#define DECLARE_MODULE_INITIALIZER(name) DECLARE_INITIALIZER(module, name)
+
+#define REGISTER_MODULE_INITIALIZER_SEQUENCE(name1, name2)
+
+#endif  // XLA_STREAM_EXECUTOR_PLATFORM_DEFAULT_INITIALIZE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/platform/dso_loader.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/platform/dso_loader.h
new file mode 100644
index 0000000000000000000000000000000000000000..41538c0ef067ace7585cb10cc0abd92a781486ba
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/platform/dso_loader.h
@@ -0,0 +1,31 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_STREAM_EXECUTOR_PLATFORM_DSO_LOADER_H_
+#define XLA_STREAM_EXECUTOR_PLATFORM_DSO_LOADER_H_
+
+#include "xla/stream_executor/platform/platform.h"
+
+// Include appropriate platform-dependent implementations
+#if defined(PLATFORM_GOOGLE) || defined(PLATFORM_CHROMIUMOS)
+#include "xla/stream_executor/platform/google/dso_loader.h"
+#elif defined(PLATFORM_POSIX) || defined(PLATFORM_POSIX_ANDROID) || \
+    defined(PLATFORM_GOOGLE_ANDROID) || defined(PLATFORM_WINDOWS)
+#include "xla/stream_executor/platform/default/dso_loader.h"
+#else
+#error Define the appropriate PLATFORM_<foo> macro for this platform
+#endif
+
+#endif  // XLA_STREAM_EXECUTOR_PLATFORM_DSO_LOADER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/platform/initialize.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/platform/initialize.h
new file mode 100644
index 0000000000000000000000000000000000000000..d56bda8383ae2b3a2b0aa8aeccb871d1f9adcece
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/platform/initialize.h
@@ -0,0 +1,27 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_STREAM_EXECUTOR_PLATFORM_INITIALIZE_H_
+#define XLA_STREAM_EXECUTOR_PLATFORM_INITIALIZE_H_
+
+#include "xla/stream_executor/platform/platform.h"
+
+#if defined(PLATFORM_GOOGLE) || defined(PLATFORM_CHROMIUMOS)
+#include "xla/stream_executor/platform/google/initialize.h"  // IWYU pragma: export
+#else
+#include "xla/stream_executor/platform/default/initialize.h"  // IWYU pragma: export
+#endif
+
+#endif  // XLA_STREAM_EXECUTOR_PLATFORM_INITIALIZE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/platform/platform.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/platform/platform.h
new file mode 100644
index 0000000000000000000000000000000000000000..3ea6fa66d362fc2396710fcf53ff8453702f8250
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/platform/platform.h
@@ -0,0 +1,43 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_STREAM_EXECUTOR_PLATFORM_PLATFORM_H_
+#define XLA_STREAM_EXECUTOR_PLATFORM_PLATFORM_H_
+
+#if !defined(PLATFORM_POSIX) && !defined(PLATFORM_GOOGLE) &&                 \
+    !defined(PLATFORM_POSIX_ANDROID) && !defined(PLATFORM_GOOGLE_ANDROID) && \
+    !defined(PLATFORM_WINDOWS) && !defined(PLATFORM_CHROMIUMOS)
+
+// Choose which platform we are on.
+#if defined(ANDROID) || defined(__ANDROID__)
+#define PLATFORM_POSIX_ANDROID
+
+#elif defined(__APPLE__)
+#define PLATFORM_POSIX
+
+#elif defined(_WIN32)
+#define PLATFORM_WINDOWS
+
+#elif defined(__TF_CHROMIUMOS__)
+#define PLATFORM_CHROMIUMOS
+
+#else
+// If no platform specified, use:
+#define PLATFORM_POSIX
+
+#endif
+#endif
+
+#endif  // XLA_STREAM_EXECUTOR_PLATFORM_PLATFORM_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/platform/port.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/platform/port.h
new file mode 100644
index 0000000000000000000000000000000000000000..dfb9c1997baf3a7dfcdcea4fb88444fb10f4104a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/platform/port.h
@@ -0,0 +1,50 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// IWYU pragma: private, include "third_party/tensorflow/compiler/xla/stream_executor/stream_executor.h"
+
+#ifndef XLA_STREAM_EXECUTOR_PLATFORM_PORT_H_
+#define XLA_STREAM_EXECUTOR_PLATFORM_PORT_H_
+
+#include "tsl/platform/macros.h"
+#include "tsl/platform/types.h"
+
+namespace stream_executor {
+
+using tsl::int16;
+using tsl::int32;
+using tsl::int8;
+
+using tsl::uint16;
+using tsl::uint32;
+using tsl::uint64;
+using tsl::uint8;
+
+#if !defined(PLATFORM_GOOGLE)
+using std::string;
+#endif
+
+#define SE_FALLTHROUGH_INTENDED TF_FALLTHROUGH_INTENDED
+
+}  // namespace stream_executor
+
+// DEPRECATED: directly use the macro implementation instead.
+#define SE_DISALLOW_COPY_AND_ASSIGN TF_DISALLOW_COPY_AND_ASSIGN
+
+#define SE_MUST_USE_RESULT TF_MUST_USE_RESULT
+#define SE_PREDICT_TRUE TF_PREDICT_TRUE
+#define SE_PREDICT_FALSE TF_PREDICT_FALSE
+
+#endif  // XLA_STREAM_EXECUTOR_PLATFORM_PORT_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/plugin.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/plugin.h
new file mode 100644
index 0000000000000000000000000000000000000000..cb90171ac82bd1210ad6f1a73b36e79ad444e6eb
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/plugin.h
@@ -0,0 +1,31 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_STREAM_EXECUTOR_PLUGIN_H_
+#define XLA_STREAM_EXECUTOR_PLUGIN_H_
+
+namespace stream_executor {
+
+// Enumeration to list the supported types of plugins / support libraries.
+enum class PluginKind {
+  kInvalid,
+  kBlas,
+  kDnn,
+  kFft,
+};
+
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_PLUGIN_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/plugin_registry.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/plugin_registry.h
new file mode 100644
index 0000000000000000000000000000000000000000..26ddf0bd60f080902ab262cac6b51782c62539cb
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/plugin_registry.h
@@ -0,0 +1,122 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_STREAM_EXECUTOR_PLUGIN_REGISTRY_H_
+#define XLA_STREAM_EXECUTOR_PLUGIN_REGISTRY_H_
+
+#include <map>
+
+#include "absl/base/macros.h"
+#include "xla/stream_executor/blas.h"
+#include "xla/stream_executor/dnn.h"
+#include "xla/stream_executor/fft.h"
+#include "xla/stream_executor/platform.h"
+#include "xla/stream_executor/plugin.h"
+#include "tsl/platform/status.h"
+#include "tsl/platform/statusor.h"
+
+namespace stream_executor {
+
+namespace internal {
+class StreamExecutorInterface;
+}
+
+// The PluginRegistry is a singleton that maintains the set of registered
+// "support library" plugins. Currently, there are four kinds of plugins:
+// BLAS, DNN, and FFT. Each interface is defined in the corresponding
+// gpu_{kind}.h header.
+//
+// At runtime, a StreamExecutor object will query the singleton registry to
+// retrieve the plugin kind that StreamExecutor was configured with (refer to
+// the StreamExecutor declarations).
+//
+// Plugin libraries are best registered using REGISTER_MODULE_INITIALIZER,
+// but can be registered at any time. When registering a DSO-backed plugin, it
+// is usually a good idea to load the DSO at registration time, to prevent
+// late-loading from distorting performance/benchmarks as much as possible.
+class PluginRegistry {
+ public:
+  typedef blas::BlasSupport* (*BlasFactory)(internal::StreamExecutorInterface*);
+  typedef dnn::DnnSupport* (*DnnFactory)(internal::StreamExecutorInterface*);
+  typedef fft::FftSupport* (*FftFactory)(internal::StreamExecutorInterface*);
+
+  // Gets (and creates, if necessary) the singleton PluginRegistry instance.
+  static PluginRegistry* Instance();
+
+  // Registers the specified factory with the specified platform.
+  // Returns a non-successful status if the factory has already been registered
+  // with that platform (but execution should be otherwise unaffected).
+  template <typename FactoryT>
+  tsl::Status RegisterFactory(Platform::Id platform_id, const std::string& name,
+                              FactoryT factory);
+
+  // Return true if the factory/kind has been registered for the
+  // specified platform and plugin kind and false otherwise.
+  bool HasFactory(Platform::Id platform_id, PluginKind plugin_kind) const;
+
+  // Retrieves the factory registered for the specified kind,
+  // or a tsl::Status on error.
+  template <typename FactoryT>
+  tsl::StatusOr<FactoryT> GetFactory(Platform::Id platform_id);
+
+ private:
+  // Containers for the sets of registered factories, by plugin kind.
+  struct Factories {
+    std::optional<BlasFactory> blas;
+    std::optional<DnnFactory> dnn;
+    std::optional<FftFactory> fft;
+  };
+
+  PluginRegistry();
+
+  // Actually performs the work of registration.
+  template <typename FactoryT>
+  tsl::Status RegisterFactoryInternal(const std::string& plugin_name,
+                                      FactoryT factory,
+                                      std::optional<FactoryT>* factories);
+
+  // Returns true if the specified plugin has been registered with the specified
+  // platform factories. Unlike the other overload of this method, this does
+  // not implicitly examine the default factory lists.
+  bool HasFactory(const Factories& factories, PluginKind plugin_kind) const;
+
+  // The singleton itself.
+  static PluginRegistry* instance_;
+
+  // The set of registered factories, keyed by platform ID.
+  std::map<Platform::Id, Factories> factories_;
+
+  PluginRegistry(const PluginRegistry&) = delete;
+  void operator=(const PluginRegistry&) = delete;
+};
+
+// Explicit specializations are defined in plugin_registry.cc.
+#define DECLARE_PLUGIN_SPECIALIZATIONS(FACTORY_TYPE)                         \
+  template <>                                                                \
+  tsl::Status PluginRegistry::RegisterFactory<PluginRegistry::FACTORY_TYPE>( \
+      Platform::Id platform_id, const std::string& name,                     \
+      PluginRegistry::FACTORY_TYPE factory);                                 \
+  template <>                                                                \
+  tsl::StatusOr<PluginRegistry::FACTORY_TYPE> PluginRegistry::GetFactory(    \
+      Platform::Id platform_id)
+
+DECLARE_PLUGIN_SPECIALIZATIONS(BlasFactory);
+DECLARE_PLUGIN_SPECIALIZATIONS(DnnFactory);
+DECLARE_PLUGIN_SPECIALIZATIONS(FftFactory);
+#undef DECL_PLUGIN_SPECIALIZATIONS
+
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_PLUGIN_REGISTRY_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/rocm/rocm_platform_id.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/rocm/rocm_platform_id.h
new file mode 100644
index 0000000000000000000000000000000000000000..2ee37660ddea0b3d83c668eee270e15f64ecb559
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/rocm/rocm_platform_id.h
@@ -0,0 +1,34 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_STREAM_EXECUTOR_ROCM_ROCM_PLATFORM_ID_H_
+#define XLA_STREAM_EXECUTOR_ROCM_ROCM_PLATFORM_ID_H_
+
+#include "xla/stream_executor/platform.h"
+
+namespace stream_executor {
+namespace rocm {
+
+// Opaque and unique identifier for the ROCm platform.
+// This is needed so that plugins can refer to/identify this platform without
+// instantiating a ROCmPlatform object.
+// This is broken out here to avoid a circular dependency between ROCmPlatform
+// and ROCmExecutor.
+extern const Platform::Id kROCmPlatformId;
+
+}  // namespace rocm
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_ROCM_ROCM_PLATFORM_ID_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/scratch_allocator.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/scratch_allocator.h
new file mode 100644
index 0000000000000000000000000000000000000000..c3a321e9e5e8a8f1a5fb10d869ca5ef13e3e6500
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/scratch_allocator.h
@@ -0,0 +1,115 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_STREAM_EXECUTOR_SCRATCH_ALLOCATOR_H_
+#define XLA_STREAM_EXECUTOR_SCRATCH_ALLOCATOR_H_
+
+#include <cstdint>
+#include <memory>
+#include <utility>
+
+#include "absl/container/inlined_vector.h"
+#include "xla/stream_executor/device_memory.h"
+#include "xla/stream_executor/device_memory_allocator.h"
+#include "xla/stream_executor/platform/port.h"
+#include "xla/stream_executor/temporary_device_memory.h"
+#include "tsl/platform/statusor.h"
+
+namespace stream_executor {
+
+class Stream;
+
+// Interface for "scratch" allocator for device memory, which deallocates all
+// buffers it has allocated at destruction. Returned memory pointers are not
+// owning.
+//
+// Used by stream operations (e.g. Stream::ThenConvolveWithScratch) to
+// optionally request scratch space to speed up the operation.
+class ScratchAllocator {
+ public:
+  virtual ~ScratchAllocator() {}
+
+  // Returns a limit of memory this scratch allocator wants to produce, in
+  // bytes. This information may be used to help select an algorithm.
+  //
+  // Returns values < 0 to indicate that there is no recommended limit.
+  virtual int64_t GetMemoryLimitInBytes() = 0;
+
+  // Returns an allocation on byte_size bytes for use in an operation on stream.
+  //
+  // This is a temporary allocation, and the caller is responsible for
+  // deallocating at some known-safe point. See the class comment above.
+  virtual tsl::StatusOr<DeviceMemory<uint8_t>> AllocateBytes(
+      int64_t byte_size) = 0;
+};
+
+// Allocates a single temporary memory allocation -- this memory is deallocated
+// at the next stream synchronization point after this object has gone out of
+// scope. This satisfies the lifetime and deallocation properties given in the
+// class comment above.
+//
+// Thread-compatible, but not thread-safe (use in scenarios where only one
+// thread will request the scratch allocation).
+class OneTimeScratchAllocator : public ScratchAllocator {
+ public:
+  explicit OneTimeScratchAllocator(Stream* stream) : stream_(stream) {}
+
+  int64_t GetMemoryLimitInBytes() override { return -1; }
+
+  tsl::StatusOr<DeviceMemory<uint8_t>> AllocateBytes(
+      int64_t byte_size) override;
+
+ private:
+  std::unique_ptr<TemporaryDeviceMemory<uint8_t>> temporary_;
+  Stream* stream_;
+
+  OneTimeScratchAllocator(const OneTimeScratchAllocator&) = delete;
+  void operator=(const OneTimeScratchAllocator&) = delete;
+};
+
+// Can allocate several times -- this memory is deallocated when the scratch
+// allocator is destroyed.
+//
+// Thread-compatible, but not thread-safe (use in scenarios where only one
+// thread will request the scratch allocation).
+template <size_t N = 1>
+class OwningScratchAllocator : public ScratchAllocator {
+ public:
+  OwningScratchAllocator(int device_ordinal, DeviceMemoryAllocator* allocator)
+      : device_ordinal_(device_ordinal), allocator_(allocator) {}
+
+  int64_t GetMemoryLimitInBytes() override { return -1; }
+
+  tsl::StatusOr<DeviceMemory<uint8_t>> AllocateBytes(
+      int64_t byte_size) override {
+    TF_ASSIGN_OR_RETURN(OwningDeviceMemory buffer,
+                        allocator_->Allocate(device_ordinal_, byte_size,
+                                             /*retry_on_failure=*/false));
+    buffers_.push_back(std::move(buffer));
+    return *buffers_.back();
+  }
+
+ private:
+  int device_ordinal_;
+  DeviceMemoryAllocator* allocator_;
+  absl::InlinedVector<OwningDeviceMemory, N> buffers_;
+
+  OwningScratchAllocator(const OwningScratchAllocator&) = delete;
+  void operator=(const OwningScratchAllocator&) = delete;
+};
+
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_SCRATCH_ALLOCATOR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/stream.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/stream.h
new file mode 100644
index 0000000000000000000000000000000000000000..41a7435c30b67d0aa16e13a3eee05b74edeebede
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/stream.h
@@ -0,0 +1,1570 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// The Stream is used in conjunction with the StreamExecutor "parent" to
+// perform actions with a linear stream of dependencies. Dependencies can also
+// be created between Streams to do task management (i.e. limit which tasks
+// can be performed concurrently and specify what task dependencies exist).
+
+#ifndef XLA_STREAM_EXECUTOR_STREAM_H_
+#define XLA_STREAM_EXECUTOR_STREAM_H_
+
+#include <complex>
+#include <cstdint>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <string>
+#include <type_traits>
+#include <utility>
+#include <variant>
+#include <vector>
+
+#include "absl/base/thread_annotations.h"
+#include "absl/functional/any_invocable.h"
+#include "absl/synchronization/mutex.h"
+#include "xla/stream_executor/blas.h"
+#include "xla/stream_executor/device_memory.h"
+#include "xla/stream_executor/dnn.h"
+#include "xla/stream_executor/event.h"
+#include "xla/stream_executor/fft.h"
+#include "xla/stream_executor/kernel.h"
+#include "xla/stream_executor/launch_dim.h"
+#include "xla/stream_executor/numeric_options.h"
+#include "xla/stream_executor/platform.h"
+#include "xla/stream_executor/platform/port.h"
+#include "xla/stream_executor/stream_executor_pimpl.h"
+#include "xla/stream_executor/temporary_memory_manager.h"
+
+namespace stream_executor {
+
+namespace internal {
+class StreamInterface;
+}  // namespace internal
+
+class DeviceMemoryBase;
+template <typename ElemT>
+class DeviceMemory;
+
+namespace dnn {
+class BatchDescriptor;
+class FilterDescriptor;
+class ConvolutionDescriptor;
+class ProfileResult;
+class AlgorithmDesc;
+}  // namespace dnn
+
+class StreamExecutor;
+class ScratchAllocator;
+
+namespace detail {
+
+// Helper to return if `T` is the same type as `First` or any or `Rest`.
+template <typename T>
+constexpr bool is_any_of() {
+  return false;
+}
+
+template <typename T, typename First, typename... Rest>
+constexpr bool is_any_of() {
+  return std::is_same_v<T, First> || is_any_of<T, Rest...>();
+}
+
+}  // namespace detail
+
+// Convert a type to the corresponding QuantizedActivationMode.
+template <typename ElementType>
+struct Quantization;
+
+// Represents a stream of dependent computations on a GPU device.
+//
+// The operations within a stream execute linearly and asynchronously until
+// BlockHostUntilDone() is invoked, which synchronously joins host code with
+// the execution of the stream.
+//
+// If any given operation fails when entraining work for the stream, ok() will
+// indicate that an error has occurred. After initialization, once a stream is
+// !ok(), it will never be ok().
+//
+// Thread-safe post-initialization.
+class Stream {
+ public:
+  // Platform specific handle for the underlying resources behind a Stream
+  // implementation (e.g. it gives access to CUstream for CUDA platform).
+  struct PlatformSpecificHandle {
+    void *stream = nullptr;  // will be nullptr if not supported
+  };
+
+  // Instantiate a stream tied to parent as a platform executor. Work
+  // entrained onto this stream will be launched/managed on that
+  // StreamExecutor's platform.
+  explicit Stream(StreamExecutor *parent);
+
+  // Deallocates any stream resources that the parent StreamExecutor has
+  // bestowed
+  // upon this object.
+  ~Stream();
+
+  // TODO(ezhulenev): Consider removing this platform-specific accessor and
+  // forward all users to platform-specific headers, however it requires careful
+  // build rules set up to avoid leaking even more implementation details.
+  PlatformSpecificHandle platform_specific_handle() const;
+
+  // Returns whether any errors have occurred while entraining work for this
+  // stream.
+  bool ok() const { return !InErrorState(); }
+
+  // Retrieves execution status back into the stream from the underlying
+  // implementation without blocking the stream.
+  //
+  // Normally, Stream::BlockHostUntilDone is used to get execution status.
+  // However, some devices use out-of-band mechnanisms to ensure their streams
+  // have finished on-device work, without needing to block the streams. (These
+  // devices should also override AllowsSyncOnCompletion to return false.) For
+  // these devices, this method can be used after work is finished to retrieve
+  // execution status.
+  tsl::Status RefreshStatus() TF_LOCKS_EXCLUDED(mu_);
+
+  // Initialize the stream. This must be performed before entraining any other
+  // operations.
+  Stream &Init() TF_LOCKS_EXCLUDED(mu_);
+
+  // Get or create a sub-stream from this stream. If there is any sub-stream in
+  // the pool that can be reused then just return this sub-stream.  Otherwise
+  // create a new sub-stream.
+  //
+  // TODO(b/112196569): The semantics of failed sub-streams is error-prone.
+  Stream *GetOrCreateSubStream() TF_LOCKS_EXCLUDED(mu_);
+
+  // Return the sub-stream back to the host stream so that it can be reused
+  // later. Sub-streams that are !ok() will not be reused.
+  //
+  // TODO(b/112196569): The semantics of failed sub-streams is error-prone.
+  void ReturnSubStream(Stream *sub_stream) TF_LOCKS_EXCLUDED(mu_);
+
+  // Allocate temporary memories. The stream will deallocate them when blocked
+  // or destroyed.
+  template <typename T>
+  tsl::StatusOr<std::unique_ptr<TemporaryDeviceMemory<T>>>
+  AllocateTemporaryArray(uint64_t element_count);
+
+  // Entrains onto the stream of operations: a kernel launch with the given
+  // (variadic) parameters for the invocation. These arguments can be things
+  // like DeviceMemory or primitive types such as int. What arguments you may
+  // pass to a given kernel are noted as the template parameters to the
+  // TypedKernel type that the machocc compiler generates.
+  //
+  // Template parameters:
+  //  Params...   The type list of formal parameters that the typed kernel
+  //              expects, which is matched against Args...
+  //  Args...     The deduced type list for passed actual arguments
+  //
+  // Implementation: A compile-time compatibility check is performed that has
+  // some leniency versus an exact parameter pack match -- for example,
+  // `const DeviceMemory<T>` is considered "pack compatible" with a
+  // `const DeviceMemory<T>&` formal parameter; in part, because we don't have
+  // perfect forwarding support without rvalue references. It also attempts to
+  // spit out helpful static_assert error traces with information as to the
+  // argument number and types that were mismatched.
+  template <typename... Params, typename... Args>
+  tsl::Status ThenLaunch(ThreadDim thread_dims, BlockDim block_dims,
+                         const TypedKernel<Params...> &kernel, Args... args);
+
+  // Create a dependency for this stream's next work on the other stream
+  // completing. Does not take ownership of other, and other must not be
+  // null.
+  //
+  // Checks that a stream does not wait for itself, and it is up to the
+  // user to guarantee that a stream does not come to wait on itself in a
+  // cyclic manner; in that case, behavior is undefined.
+  //
+  // N.B. Base recursion case for the variadic ThenWaitFor.
+  Stream &ThenWaitFor(Stream *other);
+
+  // Waits for all streams values in others.
+  // Checks that there is no shallow circular wait (i.e. that "this" is not in
+  // others)
+  template <typename P>
+  Stream &ThenWaitFor(P others) {
+    for (auto &stream : *others) {
+      CHECK_NE(stream.get(), this);
+      ThenWaitFor(stream.get());
+    }
+    return *this;
+  }
+
+  // Waits for an event object to be set.
+  // Note that ThenRecordEvent must have been called on the event before
+  // you call this function; otherwise the event will be considered complete
+  // and this wait will do nothing.
+  Stream &ThenWaitFor(Event *event);
+
+  // Inserts the specified event into the end of this stream. Once the stream
+  // has processed all events prior to the insertion point, the event will be
+  // marked as completed.
+  // The stream does not take ownership of event - meaning that event's lifetime
+  // must extend past the point at which it is marked complete!
+  Stream &ThenRecordEvent(Event *event);
+
+  ////////////////
+  // DNN support
+  //
+  // See DnnSupport::* for comments on the following methods.
+
+  Stream &ThenBatchNormalizationForward(
+      const DeviceMemory<float> &x, const DeviceMemory<float> &scale,
+      const DeviceMemory<float> &offset,
+      const DeviceMemory<float> &estimated_mean,
+      const DeviceMemory<float> &estimated_variance,
+      const DeviceMemory<float> &side_input, const dnn::BatchDescriptor &x_desc,
+      const dnn::BatchDescriptor &scale_offset_desc, const double epsilon,
+      const double exponential_average_factor,
+      dnn::ActivationMode activation_mode, DeviceMemory<float> *y,
+      DeviceMemory<float> *batch_mean, DeviceMemory<float> *batch_var,
+      DeviceMemory<float> *saved_mean, DeviceMemory<float> *saved_inv_var,
+      bool is_training, ScratchAllocator *reserve_space_allocator,
+      ScratchAllocator *workspace_allocator);
+
+  Stream &ThenBatchNormalizationBackward(
+      const DeviceMemory<float> &y_backprop, const DeviceMemory<float> &x,
+      const DeviceMemory<float> &scale, const DeviceMemory<float> &offset,
+      const DeviceMemory<float> &mean, const DeviceMemory<float> &inv_var,
+      const DeviceMemory<float> &y, const dnn::BatchDescriptor &x_desc,
+      const dnn::BatchDescriptor &scale_offset_desc, const double epsilon,
+      dnn::ActivationMode activation_mode, DeviceMemory<float> *x_backprop,
+      DeviceMemory<float> *scale_backprop, DeviceMemory<float> *offset_backprop,
+      DeviceMemory<float> *side_input_backprop,
+      DeviceMemory<uint8_t> *reserve_space_data,
+      ScratchAllocator *workspace_allocator);
+
+  Stream &ThenBatchNormalizationForward(
+      const DeviceMemory<Eigen::half> &x, const DeviceMemory<float> &scale,
+      const DeviceMemory<float> &offset,
+      const DeviceMemory<float> &estimated_mean,
+      const DeviceMemory<float> &estimated_variance,
+      const DeviceMemory<Eigen::half> &side_input,
+      const dnn::BatchDescriptor &x_desc,
+      const dnn::BatchDescriptor &scale_offset_desc, const double epsilon,
+      const double exponential_average_factor,
+      dnn::ActivationMode activation_mode, DeviceMemory<Eigen::half> *y,
+      DeviceMemory<float> *batch_mean, DeviceMemory<float> *batch_var,
+      DeviceMemory<float> *saved_mean, DeviceMemory<float> *saved_inv_var,
+      bool is_training, ScratchAllocator *reserve_space_allocator,
+      ScratchAllocator *workspace_allocator);
+
+  Stream &ThenBatchNormalizationBackward(
+      const DeviceMemory<Eigen::half> &y_backprop,
+      const DeviceMemory<Eigen::half> &x, const DeviceMemory<float> &scale,
+      const DeviceMemory<float> &offset, const DeviceMemory<float> &mean,
+      const DeviceMemory<float> &inv_var, const DeviceMemory<Eigen::half> &y,
+      const dnn::BatchDescriptor &x_desc,
+      const dnn::BatchDescriptor &scale_offset_desc, const double epsilon,
+      dnn::ActivationMode activation_mode,
+      DeviceMemory<Eigen::half> *x_backprop,
+      DeviceMemory<float> *scale_backprop, DeviceMemory<float> *offset_backprop,
+      DeviceMemory<Eigen::half> *side_input_backprop,
+      DeviceMemory<uint8_t> *reserve_space_data,
+      ScratchAllocator *workspace_allocator);
+
+  Stream &ThenBatchNormalizationForward(
+      const DeviceMemory<Eigen::bfloat16> &x, const DeviceMemory<float> &scale,
+      const DeviceMemory<float> &offset,
+      const DeviceMemory<float> &estimated_mean,
+      const DeviceMemory<float> &estimated_variance,
+      const DeviceMemory<Eigen::bfloat16> &side_input,
+      const dnn::BatchDescriptor &x_desc,
+      const dnn::BatchDescriptor &scale_offset_desc, const double epsilon,
+      const double exponential_average_factor,
+      dnn::ActivationMode activation_mode, DeviceMemory<Eigen::bfloat16> *y,
+      DeviceMemory<float> *batch_mean, DeviceMemory<float> *batch_var,
+      DeviceMemory<float> *saved_mean, DeviceMemory<float> *saved_inv_var,
+      bool is_training, ScratchAllocator *reserve_space_allocator,
+      ScratchAllocator *workspace_allocator);
+
+  Stream &ThenBatchNormalizationBackward(
+      const DeviceMemory<Eigen::bfloat16> &y_backprop,
+      const DeviceMemory<Eigen::bfloat16> &x, const DeviceMemory<float> &scale,
+      const DeviceMemory<float> &offset, const DeviceMemory<float> &mean,
+      const DeviceMemory<float> &inv_var,
+      const DeviceMemory<Eigen::bfloat16> &y,
+      const dnn::BatchDescriptor &x_desc,
+      const dnn::BatchDescriptor &scale_offset_desc, const double epsilon,
+      dnn::ActivationMode activation_mode,
+      DeviceMemory<Eigen::bfloat16> *x_backprop,
+      DeviceMemory<float> *scale_backprop, DeviceMemory<float> *offset_backprop,
+      DeviceMemory<Eigen::bfloat16> *side_input_backprop,
+      DeviceMemory<uint8_t> *reserve_space_data,
+      ScratchAllocator *workspace_allocator);
+
+  Stream &ThenConvolve(const dnn::BatchDescriptor &input_descriptor,
+                       const DeviceMemory<float> &input_data,
+                       const dnn::FilterDescriptor &filter_descriptor,
+                       const DeviceMemory<float> &filter_data,
+                       const dnn::ConvolutionDescriptor &convolution_descriptor,
+                       const dnn::BatchDescriptor &output_descriptor,
+                       DeviceMemory<float> *output);
+
+  Stream &ThenConvolveQuantized(
+      const dnn::BatchDescriptor &input_descriptor,
+      const DeviceMemory<float> &input_data,
+      const dnn::FilterDescriptor &filter_descriptor,
+      const DeviceMemory<int8_t> &filter_coefficients,
+      const DeviceMemory<float> &coefficient_scales,
+      const dnn::ConvolutionDescriptor &convolution_descriptor,
+      const dnn::BatchDescriptor &output_descriptor,
+      DeviceMemory<float> *output_data);
+
+  template <typename InputType, typename OutputType>
+  tsl::Status ConvolveWithAlgorithm(
+      dnn::ConvolutionKind kind, const dnn::BatchDescriptor &input_descriptor,
+      DeviceMemory<InputType> input_data,
+      const dnn::FilterDescriptor &filter_descriptor,
+      DeviceMemory<InputType> filter_data,
+      const dnn::BatchDescriptor &output_descriptor,
+      DeviceMemory<OutputType> output_data,
+      const dnn::ConvolutionDescriptor &convolution_descriptor,
+      ScratchAllocator *scratch_allocator,
+      const dnn::AlgorithmConfig &algorithm_config,
+      dnn::ProfileResult *output_profile_result) {
+    DeviceMemory<uint8_t> scratch_memory;
+    dnn::AlgorithmDesc algorithm_desc;
+    if (dnn::DnnSupport *dnn = parent_->AsDnn()) {
+      TF_RETURN_IF_ERROR(dnn->PrepareForConvolution(
+          kind, this, input_descriptor, input_data, filter_descriptor,
+          filter_data, output_descriptor, output_data, convolution_descriptor,
+          algorithm_config, scratch_allocator, &algorithm_desc,
+          &scratch_memory));
+      return dnn->DoConvolve(kind, dnn::ToDataType<InputType>::value,
+                             dnn::ToDataType<OutputType>::value, this,
+                             input_descriptor, input_data, filter_descriptor,
+                             filter_data, output_descriptor, output_data,
+                             convolution_descriptor, algorithm_desc,
+                             scratch_memory, output_profile_result);
+    }
+    return tsl::errors::Unimplemented("DNN library is not found.");
+  }
+
+  template <typename InputT, typename ScaleT, typename SideInputT,
+            typename BiasT, typename OutputT>
+  tsl::Status FusedConvolveWithAlgorithm(
+      const dnn::BatchDescriptor &conv_input_descriptor,
+      const DeviceMemory<InputT> &conv_input_data, ScaleT conv_input_scale,
+      const dnn::FilterDescriptor &filter_descriptor,
+      const DeviceMemory<InputT> &filter_data,
+      const dnn::ConvolutionDescriptor &convolution_descriptor,
+      const DeviceMemory<SideInputT> &side_input_data, ScaleT side_input_scale,
+      const dnn::BatchDescriptor &bias_descriptor,
+      const DeviceMemory<BiasT> &biases, dnn::ActivationMode activation_mode,
+      const dnn::BatchDescriptor &output_descriptor,
+      DeviceMemory<OutputT> *output, ScratchAllocator *scratch_allocator,
+      const dnn::AlgorithmConfig &algorithm_config,
+      dnn::ProfileResult *output_profile_result) {
+    if (dnn::DnnSupport *dnn = parent_->AsDnn()) {
+      return dnn->DoFusedConvolve(
+          this, dnn::ToDataType<InputT>::value,
+          dnn::ToDataType<SideInputT>::value, dnn::ToDataType<BiasT>::value,
+          dnn::ToDataType<OutputT>::value, conv_input_descriptor,
+          conv_input_data, conv_input_scale, filter_descriptor, filter_data,
+          convolution_descriptor, side_input_data, side_input_scale,
+          bias_descriptor, biases, activation_mode, output_descriptor, *output,
+          scratch_allocator, algorithm_config, output_profile_result);
+    }
+    return tsl::errors::Unimplemented("DNN library is not found.");
+  }
+
+  tsl::Status CudnnReorderConvolutionFilterAndBias(
+      const dnn::FilterDescriptor &filter_descriptor,
+      const DeviceMemory<int8_t> &filter_input,
+      DeviceMemory<int8_t> *filter_output,
+      std::optional<const DeviceMemory<float>> bias_input,
+      std::optional<DeviceMemory<float>> bias_output) {
+    if (dnn::DnnSupport *dnn = parent_->AsDnn()) {
+      return dnn->CudnnReorderConvolutionFilterAndBias(
+          this, filter_descriptor, filter_input, filter_output,
+          std::move(bias_input), std::move(bias_output));
+    }
+    return tsl::errors::Unimplemented("DNN library is not found.");
+  }
+
+  tsl::StatusOr<std::unique_ptr<const dnn::ConvRunner>> ConvolveRunnerFromDesc(
+      const dnn::AlgorithmDesc &algorithm_desc, dnn::ConvolutionKind kind,
+      dnn::DataType element_type, dnn::DataType output_type,
+      const dnn::BatchDescriptor &input_descriptor,
+      const dnn::FilterDescriptor &filter_descriptor,
+      const dnn::BatchDescriptor &output_descriptor,
+      const dnn::ConvolutionDescriptor &convolution_descriptor) {
+    dnn::DnnSupport *dnn_support = parent_->AsDnn();
+    if (!dnn_support) {
+      return tsl::errors::Unimplemented("DNN library is not found.");
+    }
+    return dnn_support->ConvolveRunnerFromDesc(
+        this, algorithm_desc, kind, element_type, output_type, input_descriptor,
+        filter_descriptor, output_descriptor, convolution_descriptor);
+  }
+
+  tsl::StatusOr<std::unique_ptr<const dnn::GraphConvRunner>>
+  GraphConvolveRunnerFromDesc(
+      const dnn::AlgorithmDesc &algorithm_desc, dnn::ConvolutionKind kind,
+      dnn::DataType element_type, dnn::DataType output_type,
+      const dnn::BatchDescriptor &input_descriptor,
+      const dnn::FilterDescriptor &filter_descriptor,
+      const dnn::BatchDescriptor &output_descriptor,
+      const dnn::ConvolutionDescriptor &convolution_descriptor,
+      std::string serialized_graph) {
+    dnn::DnnSupport *dnn_support = parent_->AsDnn();
+    if (!dnn_support) {
+      return tsl::errors::Unimplemented("DNN library is not found.");
+    }
+    return dnn_support->GraphConvolveRunnerFromDesc(
+        this, algorithm_desc, kind, element_type, output_type, input_descriptor,
+        filter_descriptor, output_descriptor, convolution_descriptor,
+        serialized_graph);
+  }
+
+  tsl::StatusOr<std::unique_ptr<const dnn::FusedConvRunner>>
+  FusedConvolveRunnerFromDesc(
+      const dnn::AlgorithmDesc &algorithm_desc, dnn::ConvolutionKind kind,
+      dnn::DataType element_type, dnn::DataType bias_type,
+      dnn::DataType output_type, double conv_input_scale,
+      double side_input_scale, double leakyrelu_alpha,
+      const dnn::BatchDescriptor &input_descriptor,
+      const dnn::FilterDescriptor &filter_descriptor,
+      const dnn::BatchDescriptor &bias_descriptor,
+      const dnn::BatchDescriptor &output_descriptor,
+      const dnn::ConvolutionDescriptor &convolution_descriptor,
+      dnn::ActivationMode activation_mode) {
+    dnn::DnnSupport *dnn_support = parent_->AsDnn();
+    if (!dnn_support) {
+      return tsl::errors::Unimplemented("DNN library is not found.");
+    }
+    return dnn_support->FusedConvolveRunnerFromDesc(
+        this, algorithm_desc, kind, element_type, bias_type, output_type,
+        conv_input_scale, side_input_scale, leakyrelu_alpha, input_descriptor,
+        filter_descriptor, bias_descriptor, output_descriptor,
+        convolution_descriptor, activation_mode);
+  }
+
+  tsl::StatusOr<std::unique_ptr<const dnn::FusedMHARunner>>
+  FusedMHARunnerFromDesc(
+      const dnn::AlgorithmDesc &algorithm_desc, dnn::FusedMHAKind kind,
+      const dnn::MatmulTensorDescriptor &bmm1_lhs_descriptor,
+      const dnn::MatmulTensorDescriptor &bmm1_rhs_descriptor,
+      const dnn::MatmulTensorDescriptor &bmm2_rhs_descriptor,
+      const dnn::MatmulTensorDescriptor &intermediate_bmm2_lhs_descriptor,
+      const dnn::TensorDescriptor &output_descriptor,
+      std::optional<dnn::TensorDescriptor> activation_descriptor,
+      std::optional<dnn::TensorDescriptor> mask_descriptor,
+      std::optional<dnn::TensorDescriptor> bias_descriptor, double scale,
+      std::optional<double> dropout_rate, std::optional<int64_t> seed) {
+    dnn::DnnSupport *dnn_support = parent_->AsDnn();
+    if (!dnn_support) {
+      return absl::UnimplementedError("DNN library is not found.");
+    }
+    return dnn_support->FusedMHARunnerFromDesc(
+        this, algorithm_desc, kind, bmm1_lhs_descriptor, bmm1_rhs_descriptor,
+        bmm2_rhs_descriptor, intermediate_bmm2_lhs_descriptor,
+        output_descriptor, activation_descriptor, mask_descriptor,
+        bias_descriptor, scale, dropout_rate, seed);
+  }
+
+  tsl::StatusOr<std::unique_ptr<const dnn::FusedMHABackwardRunner>>
+  FusedMHABackwardRunnerFromDesc(
+      const dnn::AlgorithmDesc &algorithm_desc, dnn::FusedMHAKind kind,
+      const dnn::MatmulTensorDescriptor &bmm1_grad_gemm1_rhs_descriptor,
+      const dnn::MatmulTensorDescriptor &bmm1_grad_gemm2_rhs_descriptor,
+      const dnn::MatmulTensorDescriptor &bmm2_grad_gemm1_lhs_descriptor,
+      const dnn::MatmulTensorDescriptor &bmm2_grad_gemm2_rhs_descriptor,
+      const dnn::MatmulTensorDescriptor &d_output_descriptor,
+      const dnn::TensorDescriptor &d_bmm1_lhs_descriptor,
+      const dnn::TensorDescriptor &d_bmm1_rhs_descriptor,
+      const dnn::TensorDescriptor &d_bmm2_rhs_descriptor,
+      const dnn::TensorDescriptor &d_s_descriptor,
+      std::optional<dnn::TensorDescriptor> mask_descriptor,
+      std::optional<dnn::TensorDescriptor> d_bias_descriptor, double scale,
+      std::optional<double> dropout_rate, std::optional<int64_t> seed) {
+    dnn::DnnSupport *dnn_support = parent_->AsDnn();
+    if (!dnn_support) {
+      return absl::UnimplementedError("DNN library is not found.");
+    }
+    return dnn_support->FusedMHABackwardRunnerFromDesc(
+        this, algorithm_desc, kind, bmm1_grad_gemm1_rhs_descriptor,
+        bmm1_grad_gemm2_rhs_descriptor, bmm2_grad_gemm1_lhs_descriptor,
+        bmm2_grad_gemm2_rhs_descriptor, d_output_descriptor,
+        d_bmm1_lhs_descriptor, d_bmm1_rhs_descriptor, d_bmm2_rhs_descriptor,
+        d_s_descriptor, mask_descriptor, d_bias_descriptor, scale, dropout_rate,
+        seed);
+  }
+
+  Stream &ThenSeparableConvolve(
+      const dnn::BatchDescriptor &input_descriptor,
+      const DeviceMemory<float> &input_data,
+      const dnn::FilterDescriptor &filter_descriptor, int depth_multiplier,
+      const DeviceMemory<float> &first_weights,
+      const DeviceMemory<float> &second_weights,
+      const dnn::ConvolutionDescriptor &convolution_descriptor,
+      const dnn::BatchDescriptor &output_descriptor,
+      DeviceMemory<float> *output);
+
+  Stream &ThenMatMul(const DeviceMemory<float> &input_data,
+                     const DeviceMemory<float> &weights,
+                     const dnn::BatchDescriptor &input_dimensions,
+                     const dnn::BatchDescriptor &output_dimensions,
+                     DeviceMemory<float> *output_data);
+
+  Stream &ThenMatMulQuantized(const DeviceMemory<float> &input_data,
+                              const DeviceMemory<int8_t> &weights,
+                              const DeviceMemory<float> &weight_scales,
+                              const dnn::BatchDescriptor &input_dimensions,
+                              const dnn::BatchDescriptor &output_dimensions,
+                              DeviceMemory<float> *output_data);
+
+  Stream &ThenMatMulQuantized(const DeviceMemory<float> &input_data,
+                              const DeviceMemory<int16> &weights,
+                              const DeviceMemory<float> &weight_scales,
+                              const dnn::BatchDescriptor &input_dimensions,
+                              const dnn::BatchDescriptor &output_dimensions,
+                              DeviceMemory<float> *output_data);
+
+  Stream &ThenBiasAdd(const DeviceMemory<float> &input_data,
+                      const DeviceMemory<float> &biases,
+                      const dnn::BatchDescriptor &dimensions,
+                      DeviceMemory<float> *output_data);
+
+  template <typename ElementType>
+  tsl::Status ThenPoolForward(const dnn::PoolingDescriptor &pooling_dimensions,
+                              const dnn::BatchDescriptor &input_dimensions,
+                              const DeviceMemory<ElementType> &input_data,
+                              const dnn::BatchDescriptor &output_dimensions,
+                              DeviceMemory<ElementType> *output_data,
+                              ScratchAllocator *workspace_allocator = nullptr) {
+    if (dnn::DnnSupport *dnn = parent_->AsDnn()) {
+      return dnn->DoPoolForward(dnn::ToDataType<ElementType>::value, this,
+                                pooling_dimensions, input_dimensions,
+                                input_data, output_dimensions, *output_data,
+                                workspace_allocator);
+    }
+    return tsl::errors::Unimplemented("DNN library is not found.");
+  }
+
+  template <typename ElementType>
+  tsl::Status ThenPoolForward(const dnn::PoolingDescriptor &pooling_dimensions,
+                              const NumericOptions &numeric_options,
+                              const dnn::BatchDescriptor &input_dimensions,
+                              const DeviceMemory<ElementType> &input_data,
+                              const dnn::BatchDescriptor &output_dimensions,
+                              DeviceMemory<ElementType> *output_data,
+                              ScratchAllocator *workspace_allocator = nullptr) {
+    if (dnn::DnnSupport *dnn = parent_->AsDnn()) {
+      return dnn->DoPoolForward(dnn::ToDataType<ElementType>::value, this,
+                                pooling_dimensions, numeric_options,
+                                input_dimensions, input_data, output_dimensions,
+                                *output_data, workspace_allocator);
+    }
+    return tsl::errors::Unimplemented("DNN library is not found.");
+  }
+
+  template <typename ElementType>
+  tsl::Status ThenPoolBackward(
+      const dnn::PoolingDescriptor &pooling_dimensions,
+      const NumericOptions &numeric_options,
+      const dnn::BatchDescriptor &input_dimensions,
+      const DeviceMemory<ElementType> &input_data,
+      const dnn::BatchDescriptor &output_dimensions,
+      const DeviceMemory<ElementType> &output_data,
+      const DeviceMemory<ElementType> &input_diff_data,
+      DeviceMemory<ElementType> *output_diff_data,
+      ScratchAllocator *workspace_allocator = nullptr) {
+    if (dnn::DnnSupport *dnn = parent_->AsDnn()) {
+      return dnn->DoPoolBackward(
+          dnn::ToDataType<ElementType>::value, this, pooling_dimensions,
+          numeric_options, input_dimensions, input_data, output_dimensions,
+          output_data, input_diff_data, *output_diff_data, workspace_allocator);
+    }
+    return tsl::errors::Unimplemented("DNN library is not found.");
+  }
+
+  Stream &ThenNormalizeWithDimensions(
+      const dnn::NormalizeDescriptor &normalize_descriptor,
+      const dnn::BatchDescriptor &dimensions,
+      const DeviceMemory<float> &input_data, DeviceMemory<float> *output_data);
+
+  Stream &ThenNormalizeBackwardWithDimensions(
+      const dnn::NormalizeDescriptor &normalize_descriptor,
+      const dnn::BatchDescriptor &dimensions,
+      const DeviceMemory<float> &raw_data,
+      const DeviceMemory<float> &normalized_data,
+      const DeviceMemory<float> &normalized_variable_gradient,
+      DeviceMemory<float> *raw_variable_gradient,
+      ScratchAllocator *workspace_allocator = nullptr);
+
+  Stream &ThenActivate(dnn::ActivationMode activation_mode,
+                       const dnn::BatchDescriptor &dimensions,
+                       const DeviceMemory<float> &input_data,
+                       DeviceMemory<float> *output_data);
+
+  // Same as ThenActivate, but also takes an options argument that can be used
+  // for platform-specific option flags.
+  Stream &ThenActivateWithOptions(dnn::ActivationMode activation_mode,
+                                  const dnn::BatchDescriptor &dimensions,
+                                  const DeviceMemory<float> &input_data,
+                                  DeviceMemory<float> *output_data,
+                                  uint64_t options);
+
+  Stream &ThenDepthConcatenate(
+      absl::Span<const dnn::BatchDescriptor> input_dimensions,
+      absl::Span<const DeviceMemory<float> *const> input_data,
+      DeviceMemory<float> *output_data);
+
+  // Depth to space takes an X by Y image with depth D*M² and changes it to an
+  // MX x MY image with depth D. Each input location (x,y) with depth D*M² in
+  // the input image is changed to an MxM contiguous area in the output image,
+  // with the values being laid out in raster order specified by
+  // DepthToSpaceLayout, and will have a new depth of D.
+  // See the DoDepthToSpace comment for more information.
+  Stream &ThenDepthToSpace(const dnn::BatchDescriptor &input_dimensions,
+                           const DeviceMemory<float> &input_data,
+                           const dnn::DepthToSpaceLayout &depth_to_space_layout,
+                           const int sqrt_depth_reduction,
+                           DeviceMemory<float> *output_data);
+
+  Stream &ThenElementwiseOperate(
+      dnn::ElementwiseOperation operation,
+      absl::Span<const dnn::BatchDescriptor> input_dimensions,
+      absl::Span<const DeviceMemory<float> *const> input_data,
+      const dnn::BatchDescriptor &output_dimensions,
+      DeviceMemory<float> *output_data);
+
+  Stream &ThenXYPad(const dnn::BatchDescriptor &dimensions,
+                    const DeviceMemory<float> &input_data, int64_t left_pad,
+                    int64_t right_pad, int64_t top_pad, int64_t bottom_pad,
+                    DeviceMemory<float> *output_data);
+
+  Stream &ThenXYSlice(const dnn::BatchDescriptor &dimensions,
+                      const DeviceMemory<float> &input_data, int64_t left_trim,
+                      int64_t right_trim, int64_t top_trim, int64_t bottom_trim,
+                      DeviceMemory<float> *output_data);
+
+  // Grows the input tensor by replicating the X and Y dimensions. The batch and
+  // depth/feature_map dimensions are unchanged. Currently, the input tensor is
+  // limited to X=1 and Y=1.
+  Stream &ThenXYBroadcast(const dnn::BatchDescriptor &dimensions,
+                          const DeviceMemory<float> &input_data,
+                          int64_t replicate_x, int64_t replicate_y,
+                          DeviceMemory<float> *output_data);
+
+  // See DnnSupport::DoMemcpyD2HQuantized.
+  Stream &ThenMemcpyD2HQuantized(const DeviceMemory<float> &gpu_unquantized_src,
+                                 dnn::QuantizedActivationMode mode,
+                                 void *host_dst, uint64_t size);
+
+  // Template version of ThenMemcpyD2HQuantized that takes a mutable span and
+  // uses the Quantization trait to call the generic version of
+  // ThenMemcpyD2HQuantized with the correct QuantizedActivationMode.
+  template <typename ElementType>
+  Stream &ThenMemcpyD2HQuantized(const DeviceMemory<float> &gpu_unquantized_src,
+                                 absl::Span<ElementType> host_dst) {
+    return ThenMemcpyD2HQuantized(
+        gpu_unquantized_src, Quantization<ElementType>::kModeId,
+        host_dst.data(), host_dst.size() * sizeof(ElementType));
+  }
+
+  // See DnnSupport::DoMemcpyH2DQuantized.
+  Stream &ThenMemcpyH2DQuantized(const void *host_src, uint64_t size,
+                                 dnn::QuantizedActivationMode mode,
+                                 DeviceMemory<float> *gpu_unquantized_dst);
+
+  // Template version of ThenMemcpyH2DQuantized that takes an array slice
+  // and uses the Quantization trait to call the generic version of
+  // ThenMemcpyH2DQuantized with the correct QuantizedActivationMode.
+  template <typename ElementType>
+  Stream &ThenMemcpyH2DQuantized(absl::Span<const ElementType> host_src,
+                                 DeviceMemory<float> *gpu_unquantized_dst) {
+    return ThenMemcpyH2DQuantized(
+        host_src.data(), host_src.size() * sizeof(ElementType),
+        Quantization<ElementType>::kModeId, gpu_unquantized_dst);
+  }
+
+  /////////////////
+  // BLAS support
+
+  // See BlasSupport::DoBlasAxpy. Note that, even for the case where alpha is
+  // present in DeviceMemory, it must be an execution-time constant (i.e. a
+  // value
+  // that the stream does not change or populate during the course of
+  // execution). The value is effectively captured at stream-enqueue time.
+  Stream &ThenBlasAxpy(uint64_t elem_count, float alpha,
+                       const DeviceMemory<float> &x, int incx,
+                       DeviceMemory<float> *y, int incy);
+
+  // See BlasSupport::DoBlasCopy.
+  Stream &ThenBlasCopy(uint64_t elem_count, const DeviceMemory<float> &x,
+                       int incx, DeviceMemory<float> *y, int incy);
+
+  // See BlasSupport::DoBlasScal.
+  Stream &ThenBlasScal(uint64_t elem_count, float alpha, DeviceMemory<float> *x,
+                       int incx);
+  Stream &ThenBlasScal(uint64_t elem_count, double alpha,
+                       DeviceMemory<double> *x, int incx);
+  Stream &ThenBlasScal(uint64_t elem_count, float alpha,
+                       DeviceMemory<std::complex<float>> *x, int incx);
+  Stream &ThenBlasScal(uint64_t elem_count, double alpha,
+                       DeviceMemory<std::complex<double>> *x, int incx);
+  Stream &ThenBlasScal(uint64_t elem_count, std::complex<float> alpha,
+                       DeviceMemory<std::complex<float>> *x, int incx);
+  Stream &ThenBlasScal(uint64_t elem_count, std::complex<double> alpha,
+                       DeviceMemory<std::complex<double>> *x, int incx);
+
+  // See BlasSupport::DoBlasGemv.
+  Stream &ThenBlasGemv(blas::Transpose trans, uint64_t m, uint64 n, float alpha,
+                       const DeviceMemory<float> &a, int lda,
+                       const DeviceMemory<float> &x, int incx, float beta,
+                       DeviceMemory<float> *y, int incy);
+  Stream &ThenBlasGemv(blas::Transpose trans, uint64_t m, uint64 n,
+                       double alpha, const DeviceMemory<double> &a, int lda,
+                       const DeviceMemory<double> &x, int incx, double beta,
+                       DeviceMemory<double> *y, int incy);
+  Stream &ThenBlasGemv(blas::Transpose trans, uint64_t m, uint64 n,
+                       std::complex<float> alpha,
+                       const DeviceMemory<std::complex<float>> &a, int lda,
+                       const DeviceMemory<std::complex<float>> &x, int incx,
+                       std::complex<float> beta,
+                       DeviceMemory<std::complex<float>> *y, int incy);
+  Stream &ThenBlasGemv(blas::Transpose trans, uint64_t m, uint64 n,
+                       std::complex<double> alpha,
+                       const DeviceMemory<std::complex<double>> &a, int lda,
+                       const DeviceMemory<std::complex<double>> &x, int incx,
+                       std::complex<double> beta,
+                       DeviceMemory<std::complex<double>> *y, int incy);
+
+  // See BlasSupport::DoBlasSbmv.
+  Stream &ThenBlasSbmv(blas::UpperLower uplo, uint64_t n, uint64 k, float alpha,
+                       const DeviceMemory<float> &a, int lda,
+                       const DeviceMemory<float> &x, int incx, float beta,
+                       DeviceMemory<float> *y, int incy);
+
+  template <typename InputType, typename OutputType>
+  tsl::Status ThenBlasGemm(blas::Transpose transa, blas::Transpose transb,
+                           uint64_t m, uint64 n, uint64 k,
+                           const DeviceMemory<InputType> &a, int lda,
+                           const DeviceMemory<InputType> &b, int ldb,
+                           DeviceMemory<OutputType> *c, int ldc,
+                           const NumericOptions &numeric_options) {
+    InputType alpha{1.0};
+    InputType beta{0.0};
+    return ThenBlasGemm(transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c,
+                        ldc, numeric_options);
+  }
+
+  template <typename InputType, typename OutputType, typename ConstantType>
+  tsl::Status ThenBlasGemm(blas::Transpose transa, blas::Transpose transb,
+                           uint64_t m, uint64 n, uint64 k, ConstantType alpha,
+                           const DeviceMemory<InputType> &a, int lda,
+                           const DeviceMemory<InputType> &b, int ldb,
+                           ConstantType beta, DeviceMemory<OutputType> *c,
+                           int ldc, const NumericOptions &numeric_options) {
+    static_assert(
+        detail::is_any_of<InputType, int8_t, Eigen::half, Eigen::bfloat16,
+                          float, double, std::complex<float>,
+                          std::complex<double>>(),
+        "Input can be int8_t, half, bf16, float, double, std::complex<float> "
+        "or "
+        "std::complex<double>");
+    static_assert(!std::is_same_v<InputType, Eigen::half> ||
+                      detail::is_any_of<ConstantType, float, Eigen::half>(),
+                  "If input is Eigen::half, constant has to be either "
+                  "Eigen::half or float");
+    static_assert(detail::is_any_of<InputType, int8_t, Eigen::half,
+                                    Eigen::bfloat16, ConstantType>(),
+                  "If input is not int8_t, Eigen::half, constant and input "
+                  "types have to match");
+    blas::BlasSupport *blas = parent()->AsBlas();
+    if (!blas) {
+      return tsl::errors::Internal(
+          "Attempting to perform BLAS operation using "
+          "StreamExecutor without BLAS support");
+    }
+
+    void *alpha_ptr = &alpha;
+    void *beta_ptr = &beta;
+    float alpha_storage, beta_storage;
+    UpcastHalfToFloat<ConstantType>(&alpha_ptr, &beta_ptr, &alpha_storage,
+                                    &beta_storage);
+
+    return blas->DoBlasGemm(this, transa, transb, m, n, k,
+                            blas::ToDataType<InputType>::value, alpha_ptr, a,
+                            lda, b, ldb, beta_ptr, c, ldc, numeric_options);
+  }
+
+  // TODO(reedwm): Update all callers to pass correct NumericOptions.
+  template <typename InputType, typename OutputType, typename ConstantType>
+  tsl::Status ThenBlasGemm(blas::Transpose transa, blas::Transpose transb,
+                           uint64_t m, uint64 n, uint64 k, ConstantType alpha,
+                           const DeviceMemory<InputType> &a, int lda,
+                           const DeviceMemory<InputType> &b, int ldb,
+                           ConstantType beta, DeviceMemory<OutputType> *c,
+                           int ldc) {
+    return ThenBlasGemm(transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c,
+                        ldc, NumericOptions{});
+  }
+
+  template <typename InputType, typename OutputType>
+  tsl::Status ThenBlasGemmWithAlgorithm(
+      blas::Transpose transa, blas::Transpose transb, uint64_t m, uint64 n,
+      uint64_t k, const DeviceMemory<InputType> &a, int lda,
+      const DeviceMemory<InputType> &b, int ldb, DeviceMemory<OutputType> *c,
+      int ldc, blas::ComputationType computation_type,
+      blas::AlgorithmType algorithm,
+      blas::ProfileResult *output_profile_result) {
+    OutputType alpha{1};
+    OutputType beta{0};
+    return ThenBlasGemmWithAlgorithm(
+        transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc,
+        computation_type, algorithm, NumericOptions{}, output_profile_result);
+  }
+
+  template <typename InputType, typename OutputType, typename ConstantType>
+  tsl::Status ThenBlasGemmWithAlgorithm(
+      blas::Transpose transa, blas::Transpose transb, uint64_t m, uint64 n,
+      uint64_t k, ConstantType alpha, const DeviceMemory<InputType> &a, int lda,
+      const DeviceMemory<InputType> &b, int ldb, ConstantType beta,
+      DeviceMemory<OutputType> *c, int ldc,
+      blas::ComputationType computation_type, blas::AlgorithmType algorithm,
+      const NumericOptions &numeric_options,
+      blas::ProfileResult *output_profile_result) {
+    TF_RETURN_IF_ERROR(
+        CheckTypesForExtendedBlas<InputType, OutputType, ConstantType>(
+            computation_type));
+
+    blas::BlasSupport *blas = parent()->AsBlas();
+    if (!blas) {
+      return tsl::errors::Internal(
+          "Attempting to perform BLAS operation using "
+          "StreamExecutor without BLAS support");
+    }
+
+    void *alpha_ptr = &alpha;
+    void *beta_ptr = &beta;
+    float alpha_storage, beta_storage;
+    UpcastHalfToFloat<ConstantType>(&alpha_ptr, &beta_ptr, &alpha_storage,
+                                    &beta_storage);
+
+    tsl::Status st = blas->DoBlasGemmWithAlgorithm(
+        this, transa, transb, m, n, k, alpha_ptr, a,
+        blas::ToDataType<InputType>::value, lda, b,
+        blas::ToDataType<InputType>::value, ldb, beta_ptr, c,
+        blas::ToDataType<OutputType>::value, ldc, computation_type, algorithm,
+        numeric_options, output_profile_result);
+    if (output_profile_result) {
+      // The error is recorded in the profile.
+      return ::tsl::OkStatus();
+    }
+    return st;
+  }
+
+  template <typename InputType, typename OutputType, typename ConstantType>
+  tsl::Status ThenBlasGemmStridedBatchedWithAlgorithm(
+      blas::Transpose transa, blas::Transpose transb, uint64_t m, uint64 n,
+      uint64_t k, ConstantType alpha, const DeviceMemory<InputType> &a, int lda,
+      int64_t stride_a, const DeviceMemory<InputType> &b, int ldb,
+      int64_t stride_b, ConstantType beta, DeviceMemory<OutputType> *c, int ldc,
+      int64_t stride_c, int batch_count, blas::ComputationType computation_type,
+      blas::AlgorithmType algorithm, const NumericOptions &numeric_options,
+      blas::ProfileResult *output_profile_result) {
+    TF_RETURN_IF_ERROR(
+        CheckTypesForExtendedBlas<InputType, OutputType, ConstantType>(
+            computation_type));
+
+    blas::BlasSupport *blas = parent()->AsBlas();
+    if (!blas) {
+      return tsl::errors::Internal(
+          "Attempting to perform BLAS operation using "
+          "StreamExecutor without BLAS support");
+    }
+    void *alpha_ptr = &alpha;
+    void *beta_ptr = &beta;
+    float alpha_storage, beta_storage;
+    UpcastHalfToFloat<ConstantType>(&alpha_ptr, &beta_ptr, &alpha_storage,
+                                    &beta_storage);
+    tsl::Status st = blas->DoBlasGemmStridedBatchedWithAlgorithm(
+        this, transa, transb, m, n, k, alpha_ptr, a,
+        blas::ToDataType<InputType>::value, lda, stride_a, b,
+        blas::ToDataType<InputType>::value, ldb, stride_b, beta_ptr, c,
+        blas::ToDataType<OutputType>::value, ldc, stride_c, batch_count,
+        computation_type, algorithm, numeric_options, output_profile_result);
+    if (output_profile_result) {
+      // The error is recorded in the profile.
+      return ::tsl::OkStatus();
+    }
+    return st;
+  }
+
+  template <typename T>
+  using DeviceMemorySlice = absl::Span<DeviceMemory<T> *const>;
+
+  // See BlasSupport::DoBlasGemmBatched.
+  Stream &ThenBlasGemmBatched(blas::Transpose transa, blas::Transpose transb,
+                              uint64_t m, uint64 n, uint64 k, float alpha,
+                              DeviceMemorySlice<float> a, int lda,
+                              DeviceMemorySlice<float> b, int ldb, float beta,
+                              DeviceMemorySlice<float> c, int ldc,
+                              int batch_count,
+                              const NumericOptions &numeric_options);
+  Stream &ThenBlasGemmBatched(blas::Transpose transa, blas::Transpose transb,
+                              uint64_t m, uint64 n, uint64_t k,
+                              std::complex<float> alpha,
+                              DeviceMemorySlice<std::complex<float>> a, int lda,
+                              DeviceMemorySlice<std::complex<float>> b, int ldb,
+                              std::complex<float> beta,
+                              DeviceMemorySlice<std::complex<float>> c, int ldc,
+                              int batch_count,
+                              const NumericOptions &numeric_options);
+  Stream &ThenBlasGemmBatchedWithScratch(
+      blas::Transpose transa, blas::Transpose transb, uint64_t m, uint64 n,
+      uint64_t k, float alpha, DeviceMemorySlice<Eigen::half> a, int lda,
+      DeviceMemorySlice<Eigen::half> b, int ldb, float beta,
+      DeviceMemorySlice<Eigen::half> c, int ldc, int batch_count,
+      const NumericOptions &numeric_options,
+      ScratchAllocator *scratch_allocator);
+  Stream &ThenBlasGemmBatchedWithScratch(
+      blas::Transpose transa, blas::Transpose transb, uint64_t m, uint64 n,
+      uint64_t k, float alpha, DeviceMemorySlice<Eigen::bfloat16> a, int lda,
+      DeviceMemorySlice<Eigen::bfloat16> b, int ldb, float beta,
+      DeviceMemorySlice<Eigen::bfloat16> c, int ldc, int batch_count,
+      const NumericOptions &numeric_options,
+      ScratchAllocator *scratch_allocator);
+  Stream &ThenBlasGemmBatchedWithScratch(blas::Transpose transa,
+                                         blas::Transpose transb, uint64_t m,
+                                         uint64 n, uint64_t k, float alpha,
+                                         DeviceMemorySlice<float> a, int lda,
+                                         DeviceMemorySlice<float> b, int ldb,
+                                         float beta, DeviceMemorySlice<float> c,
+                                         int ldc, int batch_count,
+                                         const NumericOptions &numeric_options,
+                                         ScratchAllocator *scratch_allocator);
+  Stream &ThenBlasGemmBatchedWithScratch(
+      blas::Transpose transa, blas::Transpose transb, uint64_t m, uint64 n,
+      uint64_t k, double alpha, DeviceMemorySlice<double> a, int lda,
+      DeviceMemorySlice<double> b, int ldb, double beta,
+      DeviceMemorySlice<double> c, int ldc, int batch_count,
+      const NumericOptions &numeric_options,
+      ScratchAllocator *scratch_allocator);
+  Stream &ThenBlasGemmBatchedWithScratch(
+      blas::Transpose transa, blas::Transpose transb, uint64_t m, uint64 n,
+      uint64_t k, std::complex<float> alpha,
+      DeviceMemorySlice<std::complex<float>> a, int lda,
+      DeviceMemorySlice<std::complex<float>> b, int ldb,
+      std::complex<float> beta, DeviceMemorySlice<std::complex<float>> c,
+      int ldc, int batch_count, const NumericOptions &numeric_options,
+      ScratchAllocator *scratch_allocator);
+  Stream &ThenBlasGemmBatchedWithScratch(
+      blas::Transpose transa, blas::Transpose transb, uint64_t m, uint64 n,
+      uint64_t k, std::complex<double> alpha,
+      DeviceMemorySlice<std::complex<double>> a, int lda,
+      DeviceMemorySlice<std::complex<double>> b, int ldb,
+      std::complex<double> beta, DeviceMemorySlice<std::complex<double>> c,
+      int ldc, int batch_count, const NumericOptions &numeric_options,
+      ScratchAllocator *scratch_allocator);
+
+  template <typename InputType, typename OutputType, typename ConstantType>
+  tsl::Status ThenBlasGemmStridedBatched(
+      blas::Transpose transa, blas::Transpose transb, uint64_t m, uint64 n,
+      uint64_t k, ConstantType alpha, const DeviceMemory<InputType> &a, int lda,
+      int64_t stride_a, const DeviceMemory<InputType> &b, int ldb,
+      int64_t stride_b, ConstantType beta, DeviceMemory<OutputType> *c, int ldc,
+      int64_t stride_c, int batch_count,
+      const NumericOptions &numeric_options) {
+    static_assert(
+        detail::is_any_of<InputType, int8_t, float, Eigen::half,
+                          Eigen::bfloat16, double, std::complex<float>,
+                          std::complex<double>>(),
+        "Unsupported input type");
+    static_assert(std::is_same_v<ConstantType, InputType> ||
+                      (detail::is_any_of<InputType, int8_t, Eigen::half,
+                                         Eigen::bfloat16>() &&
+                       std::is_same_v<ConstantType, float>),
+                  "Mismatched input and alpha/beta types");
+    blas::BlasSupport *blas = parent()->AsBlas();
+    if (!blas) {
+      return tsl::errors::Internal(
+          "Attempting to perform BLAS operation using "
+          "StreamExecutor without BLAS support");
+    }
+
+    void *alpha_ptr = &alpha;
+    void *beta_ptr = &beta;
+    float alpha_storage, beta_storage;
+    UpcastHalfToFloat<ConstantType>(&alpha_ptr, &beta_ptr, &alpha_storage,
+                                    &beta_storage);
+
+    return blas->DoBlasGemmStridedBatched(
+        this, transa, transb, m, n, k, blas::ToDataType<InputType>::value,
+        alpha_ptr, a, lda, stride_a, b, ldb, stride_b, beta_ptr, c, ldc,
+        stride_c, batch_count, numeric_options);
+  }
+
+  // See BlasSupport::DoBlasTrsm.
+  Stream &ThenBlasTrsm(blas::Side side, blas::UpperLower uplo,
+                       blas::Transpose transa, blas::Diagonal diag, uint64_t m,
+                       uint64_t n, float alpha, const DeviceMemory<float> &a,
+                       int lda, DeviceMemory<float> *b, int ldb);
+  Stream &ThenBlasTrsm(blas::Side side, blas::UpperLower uplo,
+                       blas::Transpose transa, blas::Diagonal diag, uint64_t m,
+                       uint64_t n, double alpha, const DeviceMemory<double> &a,
+                       int lda, DeviceMemory<double> *b, int ldb);
+  Stream &ThenBlasTrsm(blas::Side side, blas::UpperLower uplo,
+                       blas::Transpose transa, blas::Diagonal diag, uint64_t m,
+                       uint64_t n, std::complex<float> alpha,
+                       const DeviceMemory<std::complex<float>> &a, int lda,
+                       DeviceMemory<std::complex<float>> *b, int ldb);
+  Stream &ThenBlasTrsm(blas::Side side, blas::UpperLower uplo,
+                       blas::Transpose transa, blas::Diagonal diag, uint64_t m,
+                       uint64_t n, std::complex<double> alpha,
+                       const DeviceMemory<std::complex<double>> &a, int lda,
+                       DeviceMemory<std::complex<double>> *b, int ldb);
+
+  // See BlasSupport::DoBlasTrsmBatched.
+  Stream &ThenBlasTrsmBatched(blas::Side side, blas::UpperLower uplo,
+                              blas::Transpose transa, blas::Diagonal diag,
+                              uint64_t m, uint64 n, float alpha,
+                              const DeviceMemory<float *> &as, int lda,
+                              DeviceMemory<float *> *bs, int ldb,
+                              int batch_count);
+  Stream &ThenBlasTrsmBatched(blas::Side side, blas::UpperLower uplo,
+                              blas::Transpose transa, blas::Diagonal diag,
+                              uint64_t m, uint64 n, double alpha,
+                              const DeviceMemory<double *> &as, int lda,
+                              DeviceMemory<double *> *bs, int ldb,
+                              int batch_count);
+  Stream &ThenBlasTrsmBatched(blas::Side side, blas::UpperLower uplo,
+                              blas::Transpose transa, blas::Diagonal diag,
+                              uint64_t m, uint64 n, std::complex<float> alpha,
+                              const DeviceMemory<std::complex<float> *> &as,
+                              int lda, DeviceMemory<std::complex<float> *> *bs,
+                              int ldb, int batch_count);
+  Stream &ThenBlasTrsmBatched(blas::Side side, blas::UpperLower uplo,
+                              blas::Transpose transa, blas::Diagonal diag,
+                              uint64_t m, uint64 n, std::complex<double> alpha,
+                              const DeviceMemory<std::complex<double> *> &as,
+                              int lda, DeviceMemory<std::complex<double> *> *bs,
+                              int ldb, int batch_count);
+
+  // See FftSupport::DoFft.
+  Stream &ThenFft(fft::Plan *plan,
+                  const DeviceMemory<std::complex<float>> &input,
+                  DeviceMemory<std::complex<float>> *output);
+  Stream &ThenFft(fft::Plan *plan,
+                  const DeviceMemory<std::complex<double>> &input,
+                  DeviceMemory<std::complex<double>> *output);
+  Stream &ThenFft(fft::Plan *plan, const DeviceMemory<float> &input,
+                  DeviceMemory<std::complex<float>> *output);
+  Stream &ThenFft(fft::Plan *plan, const DeviceMemory<double> &input,
+                  DeviceMemory<std::complex<double>> *output);
+  Stream &ThenFft(fft::Plan *plan,
+                  const DeviceMemory<std::complex<float>> &input,
+                  DeviceMemory<float> *output);
+  Stream &ThenFft(fft::Plan *plan,
+                  const DeviceMemory<std::complex<double>> &input,
+                  DeviceMemory<double> *output);
+
+  // Entrain onto the stream: a memcpy to a host destination from a GPU source
+  // of the given target size. host_dst must be a pointer to host memory
+  // allocated by StreamExecutor::HostMemoryAllocate or otherwise allocated and
+  // then registered with StreamExecutor::HostMemoryRegister.
+  Stream &ThenMemcpy(void *host_dst, const DeviceMemoryBase &gpu_src,
+                     uint64_t size);
+
+  // Entrain onto the stream: a memcpy to a GPU destination from a host source
+  // of the given target size. host_src must be a pointer to host memory
+  // allocated by StreamExecutor::HostMemoryAllocate or otherwise allocated and
+  // then registered with StreamExecutor::HostMemoryRegister.
+  Stream &ThenMemcpy(DeviceMemoryBase *gpu_dst, const void *host_src,
+                     uint64_t size);
+
+  // Alternative interface for memcpying from device to host that takes an
+  // array slice. Checks that the destination size can accommodate the host
+  // slice size.
+  template <typename T>
+  Stream &ThenMemcpyD2H(const DeviceMemory<T> &gpu_src,
+                        absl::Span<T> host_dst) {
+    auto host_size = host_dst.size() * sizeof(T);
+    CHECK(gpu_src.size() == 0 || host_size >= gpu_src.size());
+    return ThenMemcpy(host_dst.begin(), gpu_src, host_size);
+  }
+
+  // Alternative interface for memcpying from host to device that takes an
+  // array slice. Checks that the destination size can accommodate the host
+  // slice size.
+  template <typename T>
+  Stream &ThenMemcpyH2D(absl::Span<const T> host_src,
+                        DeviceMemory<T> *gpu_dst) {
+    auto host_size = host_src.size() * sizeof(T);
+    CHECK(gpu_dst->size() == 0 || gpu_dst->size() >= host_size);
+    return ThenMemcpy(gpu_dst, host_src.begin(), host_size);
+  }
+
+  // Entrain onto the stream: a memcpy to a GPU destination from a GPU source
+  // of the given target size. gpu_src/dst must be pointers to GPU memory and
+  // peer access must be enabled between their owning StreamExecutors.
+  Stream &ThenMemcpy(DeviceMemoryBase *gpu_dst, const DeviceMemoryBase &gpu_src,
+                     uint64_t size);
+
+  // Calls to the device-to-device copy overload of ThenMemcpy -- useful for
+  // ensuring that the host pointer isn't getting confused accidentally with a
+  // device pointer if you're not doing metaprogramming against the API.
+  Stream &ThenMemcpyD2D(DeviceMemoryBase *gpu_dst,
+                        const DeviceMemoryBase &gpu_src, uint64_t size) {
+    return ThenMemcpy(gpu_dst, gpu_src, size);
+  }
+
+  // Entrain onto the stream: a memset of zero at a GPU location of size bytes.
+  // The location must not be null.
+  Stream &ThenMemZero(DeviceMemoryBase *location, uint64_t size);
+
+  // Entrain onto the stream: a memset of a 32-bit pattern at a GPU location of
+  // size bytes, where bytes must be evenly 32-bit sized (i.e. evenly divisible
+  // by 4). The location must not be null.
+  Stream &ThenMemset32(DeviceMemoryBase *location, uint32_t pattern,
+                       uint64_t size);
+
+  // Enqueue a forward operation of the RNN model onto the stream.
+  // See DnnSupport::DoRnnForward for more details.
+  Stream &ThenRnnForward(const dnn::RnnDescriptor &rnn_desc,
+                         const dnn::RnnSequenceTensorDescriptor &input_desc,
+                         const DeviceMemory<Eigen::half> &input_data,
+                         const DeviceMemory<int> &seq_lengths_data,
+                         const dnn::RnnStateTensorDescriptor &input_h_desc,
+                         const DeviceMemory<Eigen::half> &input_h_data,
+                         const dnn::RnnStateTensorDescriptor &input_c_desc,
+                         const DeviceMemory<Eigen::half> &input_c_data,
+                         const DeviceMemory<Eigen::half> &params,
+                         const dnn::RnnSequenceTensorDescriptor &output_desc,
+                         DeviceMemory<Eigen::half> *output_data,
+                         const dnn::RnnStateTensorDescriptor &output_h_desc,
+                         DeviceMemory<Eigen::half> *output_h_data,
+                         const dnn::RnnStateTensorDescriptor &output_c_desc,
+                         DeviceMemory<Eigen::half> *output_c_data,
+                         bool is_training,
+                         ScratchAllocator *reserve_space_allocator,
+                         ScratchAllocator *workspace_allocator,
+                         dnn::ProfileResult *output_profile_result);
+
+  Stream &ThenRnnForward(const dnn::RnnDescriptor &rnn_desc,
+                         const dnn::RnnSequenceTensorDescriptor &input_desc,
+                         const DeviceMemory<float> &input_data,
+                         const DeviceMemory<int> &seq_lengths_data,
+                         const dnn::RnnStateTensorDescriptor &input_h_desc,
+                         const DeviceMemory<float> &input_h_data,
+                         const dnn::RnnStateTensorDescriptor &input_c_desc,
+                         const DeviceMemory<float> &input_c_data,
+                         const DeviceMemory<float> &params,
+                         const dnn::RnnSequenceTensorDescriptor &output_desc,
+                         DeviceMemory<float> *output_data,
+                         const dnn::RnnStateTensorDescriptor &output_h_desc,
+                         DeviceMemory<float> *output_h_data,
+                         const dnn::RnnStateTensorDescriptor &output_c_desc,
+                         DeviceMemory<float> *output_c_data, bool is_training,
+                         ScratchAllocator *reserve_space_allocator,
+                         ScratchAllocator *workspace_allocator,
+                         dnn::ProfileResult *output_profile_result);
+
+  Stream &ThenRnnForward(const dnn::RnnDescriptor &rnn_desc,
+                         const dnn::RnnSequenceTensorDescriptor &input_desc,
+                         const DeviceMemory<double> &input_data,
+                         const DeviceMemory<int> &seq_lengths_data,
+                         const dnn::RnnStateTensorDescriptor &input_h_desc,
+                         const DeviceMemory<double> &input_h_data,
+                         const dnn::RnnStateTensorDescriptor &input_c_desc,
+                         const DeviceMemory<double> &input_c_data,
+                         const DeviceMemory<double> &params,
+                         const dnn::RnnSequenceTensorDescriptor &output_desc,
+                         DeviceMemory<double> *output_data,
+                         const dnn::RnnStateTensorDescriptor &output_h_desc,
+                         DeviceMemory<double> *output_h_data,
+                         const dnn::RnnStateTensorDescriptor &output_c_desc,
+                         DeviceMemory<double> *output_c_data, bool is_training,
+                         ScratchAllocator *reserve_space_allocator,
+                         ScratchAllocator *workspace_allocator,
+                         dnn::ProfileResult *output_profile_result);
+
+  // Enqueue a backward operation of the RNN model onto the stream.
+  // See DnnSupport::DoRnnBackward for more details.
+  Stream &ThenRnnBackward(
+      const dnn::RnnDescriptor &rnn_desc,
+      const dnn::RnnSequenceTensorDescriptor &input_desc,
+      const DeviceMemory<Eigen::half> &input_data,
+      const DeviceMemory<int> &seq_lengths_data,
+      const dnn::RnnStateTensorDescriptor &input_h_desc,
+      const DeviceMemory<Eigen::half> &input_h_data,
+      const dnn::RnnStateTensorDescriptor &input_c_desc,
+      const DeviceMemory<Eigen::half> &input_c_data,
+      const DeviceMemory<Eigen::half> &params,
+      const dnn::RnnSequenceTensorDescriptor &output_desc,
+      const DeviceMemory<Eigen::half> &output_data,
+      const dnn::RnnStateTensorDescriptor &output_h_desc,
+      const DeviceMemory<Eigen::half> &output_h_data,
+      const dnn::RnnStateTensorDescriptor &output_c_desc,
+      const DeviceMemory<Eigen::half> &output_c_data,
+      const DeviceMemory<Eigen::half> &output_backprop_data,
+      const DeviceMemory<Eigen::half> &output_h_backprop_data,
+      const DeviceMemory<Eigen::half> &output_c_backprop_data,
+      DeviceMemory<Eigen::half> *input_backprop_data,
+      DeviceMemory<Eigen::half> *input_h_backprop_data,
+      DeviceMemory<Eigen::half> *input_c_backprop_data,
+      DeviceMemory<Eigen::half> *params_backprop_data,
+      DeviceMemory<uint8_t> *reserve_space_data,
+      ScratchAllocator *workspace_allocator,
+      dnn::ProfileResult *output_profile_result);
+
+  Stream &ThenRnnBackward(const dnn::RnnDescriptor &rnn_desc,
+                          const dnn::RnnSequenceTensorDescriptor &input_desc,
+                          const DeviceMemory<float> &input_data,
+                          const DeviceMemory<int> &seq_lengths_data,
+                          const dnn::RnnStateTensorDescriptor &input_h_desc,
+                          const DeviceMemory<float> &input_h_data,
+                          const dnn::RnnStateTensorDescriptor &input_c_desc,
+                          const DeviceMemory<float> &input_c_data,
+                          const DeviceMemory<float> &params,
+                          const dnn::RnnSequenceTensorDescriptor &output_desc,
+                          const DeviceMemory<float> &output_data,
+                          const dnn::RnnStateTensorDescriptor &output_h_desc,
+                          const DeviceMemory<float> &output_h_data,
+                          const dnn::RnnStateTensorDescriptor &output_c_desc,
+                          const DeviceMemory<float> &output_c_data,
+                          const DeviceMemory<float> &output_backprop_data,
+                          const DeviceMemory<float> &output_h_backprop_data,
+                          const DeviceMemory<float> &output_c_backprop_data,
+                          DeviceMemory<float> *input_backprop_data,
+                          DeviceMemory<float> *input_h_backprop_data,
+                          DeviceMemory<float> *input_c_backprop_data,
+                          DeviceMemory<float> *params_backprop_data,
+                          DeviceMemory<uint8_t> *reserve_space_data,
+                          ScratchAllocator *workspace_allocator,
+                          dnn::ProfileResult *output_profile_result);
+
+  Stream &ThenRnnBackward(const dnn::RnnDescriptor &rnn_desc,
+                          const dnn::RnnSequenceTensorDescriptor &input_desc,
+                          const DeviceMemory<double> &input_data,
+                          const DeviceMemory<int> &seq_lengths_data,
+                          const dnn::RnnStateTensorDescriptor &input_h_desc,
+                          const DeviceMemory<double> &input_h_data,
+                          const dnn::RnnStateTensorDescriptor &input_c_desc,
+                          const DeviceMemory<double> &input_c_data,
+                          const DeviceMemory<double> &params,
+                          const dnn::RnnSequenceTensorDescriptor &output_desc,
+                          const DeviceMemory<double> &output_data,
+                          const dnn::RnnStateTensorDescriptor &output_h_desc,
+                          const DeviceMemory<double> &output_h_data,
+                          const dnn::RnnStateTensorDescriptor &output_c_desc,
+                          const DeviceMemory<double> &output_c_data,
+                          const DeviceMemory<double> &output_backprop_data,
+                          const DeviceMemory<double> &output_h_backprop_data,
+                          const DeviceMemory<double> &output_c_backprop_data,
+                          DeviceMemory<double> *input_backprop_data,
+                          DeviceMemory<double> *input_h_backprop_data,
+                          DeviceMemory<double> *input_c_backprop_data,
+                          DeviceMemory<double> *params_backprop_data,
+                          DeviceMemory<uint8_t> *reserve_space_data,
+                          ScratchAllocator *workspace_allocator,
+                          dnn::ProfileResult *output_profile_result);
+
+  // Enqueue a CTCLoss operation onto the stream.
+  // See DnnSupport::DoCtcLoss for more details.
+  Stream &ThenCtcLoss(const dnn::RnnStateTensorDescriptor &probs_desc,
+                      const DeviceMemory<float> &probs_data,
+                      absl::Span<const int> labels_data,
+                      absl::Span<const int> labels_lengths_data,
+                      absl::Span<const int> input_lengths_data,
+                      const NumericOptions &numeric_options,
+                      DeviceMemory<float> *costs_data,
+                      const dnn::RnnStateTensorDescriptor &grads_desc,
+                      DeviceMemory<float> *grads_data,
+                      ScratchAllocator *workspace_allocator);
+
+  // Enqueue onto the stream a operation that transforms a tensor.
+  // See DnnSupport::DoTransformTensor for more details.
+  Stream &ThenTransformTensor(const dnn::BatchDescriptor &input_desc,
+                              dnn::DataType input_type,
+                              const DeviceMemoryBase &input_data,
+                              const dnn::BatchDescriptor &output_desc,
+                              dnn::DataType output_type, float scale,
+                              DeviceMemoryBase *output_data);
+
+  // (Synchronously) block the host code waiting for the operations
+  // entrained on the stream (enqueued to this point in program
+  // execution) to complete.
+  //
+  // Returns an OK status if the blocking was successful and the stream is ok().
+  // Otherwise returns an error describing why the blocking failed.
+  tsl::Status BlockHostUntilDone() TF_LOCKS_EXCLUDED(mu_);
+
+  // Warning! This method interacts with internal threads in
+  // sometimes-unpredictable ways and is intended for GPU-Executor-internal
+  // use
+  // only. Please check with a member of the FASTR team before making use of
+  // this method.
+  //
+  // Entrains onto the stream a function to be executed on the host at some
+  // point in the future.
+  // Async host callbacks DO NOT block the stream as device functions (or as
+  // synchronous host callbacks). No synchronization is possible with
+  // asynchronous callbacks; they are strictly fire-and-forget.
+  // This method is private due to the potential for undefined behavior with
+  // synchronization using OpenCL user events.
+  // The ONLY lifetime guarantee in these calls is that the StreamExecutor
+  // parameter will still be valid - this Stream may not be!
+  // Any callbacks requiring device API calls must use this method.
+  Stream &ThenEnqueueOnBackgroundThread(
+      std::function<void(StreamExecutor *)> task);
+
+  // Returns the (opaque) platform-specific backing object. Ownership is not
+  // transferred to the caller.
+  internal::StreamInterface *implementation() { return implementation_.get(); }
+
+  // Entrains onto the stream a callback to the host (from the device).
+  // Behaves as ThenDoHostCallbackWithStatus below, but the callback should
+  // never fail or its failure is inconsequential.
+  //
+  // This is kept for backward compatibility. Future code should use
+  // ThenDoHostCallbackWithStatus and explicitly return a success status.
+  // TODO(b/112125301): Eventually remove this method.
+  Stream &ThenDoHostCallback(absl::AnyInvocable<void() &&> callback);
+
+  // Entrains onto the stream a callback to the host (from the device).
+  // Host callbacks block/occupy the stream just as device functions
+  // (execute one at a time, block later stream operations).
+  // Whether the callback return status affects the result of BlockHostUntilDone
+  // is platform-dependent.
+  //
+  // Behavior is undefined when synchronizing using OpenCL user events.
+  // Behavior is undefined if host callbacks call device routines or insert
+  // them into any stream.
+  //
+  // On certain platforms, ThenDoHostCallback is expected to have significant
+  // negative effects on performance.
+  Stream &ThenDoHostCallbackWithStatus(
+      absl::AnyInvocable<tsl::Status() &&> callback);
+
+  // Returns the StreamExecutor (parent object) associated with this stream.
+  StreamExecutor *parent() const {
+    CHECK(parent_ != nullptr);
+    return parent_;
+  }
+
+  //
+  CudaComputeCapability GetCudaComputeCapability() const {
+    return parent()->GetDeviceDescription().cuda_compute_capability();
+  }
+
+  RocmComputeCapability GetRocmComputeCapability() const {
+    return parent()->GetDeviceDescription().rocm_compute_capability();
+  }
+  // Returns the (internal usage) temporary-memory-allocation manager associated
+  // with this stream.
+  internal::TemporaryMemoryManager *temporary_memory_manager();
+
+  // Returns a debugging string "[stream=0x...,impl=0x...]".
+  std::string DebugStreamPointers() const;
+
+  void SetPriority(StreamPriority priority);
+  void SetPriority(int priority);
+
+  std::variant<StreamPriority, int> priority() const;
+
+ private:
+  template <typename... Args>
+  friend struct ThenBlasImpl;  // for implementing ThenBlasXXX.
+
+  // Checks whether types match before a call to extended BLAS version.
+  template <typename ABType, typename CType, typename ScaleType>
+  tsl::Status CheckTypesForExtendedBlas(
+      blas::ComputationType computation_type) {
+    static_assert(
+        detail::is_any_of<ABType, Eigen::half, Eigen::bfloat16, float, double,
+                          int8_t, std::complex<float>, std::complex<double>>(),
+        "The only buffer types supported are: Eigen::half, float, "
+        "double, int8, std::complex<float> and std::complex<double>");
+    static_assert(
+        std::is_same_v<ScaleType, CType> ||
+            (std::is_same_v<ScaleType, float> &&
+             detail::is_any_of<CType, Eigen::half, Eigen::bfloat16>()),
+        "Mismatched alpha/beta and output types");
+
+    bool valid_computation_type = [computation_type] {
+      switch (computation_type) {
+        case blas::ComputationType::kF16:
+          return std::is_same_v<CType, Eigen::half>;
+        case blas::ComputationType::kF32:
+          return detail::is_any_of<CType, Eigen::half, Eigen::bfloat16, float,
+                                   std::complex<float>>();
+        case blas::ComputationType::kF64:
+          return detail::is_any_of<CType, double, std::complex<double>>();
+        case blas::ComputationType::kI32:
+          return std::is_same_v<CType, int32_t>;
+        case blas::ComputationType::kF16AsF32:   // fall-through
+        case blas::ComputationType::kBF16AsF32:  // fall-through
+        case blas::ComputationType::kTF32AsF32:
+          return detail::is_any_of<CType, float, std::complex<float>>();
+      }
+    }();
+
+    if (!valid_computation_type) {
+      return tsl::errors::Internal(
+          "Invalid computation type ",
+          blas::ComputationTypeString(computation_type), " for output type: ",
+          blas::DataTypeString(blas::ToDataType<CType>::value));
+    }
+    return ::tsl::OkStatus();
+  }
+
+  bool InErrorState() const TF_LOCKS_EXCLUDED(mu_) {
+    absl::ReaderMutexLock lock(&mu_);
+    return !status_.ok();
+  }
+
+  // Sets the error state if operation_retcode is false.
+  // This is a useful shorthand for many stream routines.
+  void CheckError(bool operation_retcode) TF_LOCKS_EXCLUDED(mu_);
+
+  // Checks the status and logs the error message, if any.
+  void CheckStatus(tsl::Status status) TF_LOCKS_EXCLUDED(mu_);
+
+  void SetError() { CheckError(false /* = operation_retcode */); }
+
+  void SetErrorAndLogNoDnnSupport() {
+    SetError();
+    LOG(WARNING) << "attempting to perform DNN operation using StreamExecutor "
+                    "without DNN support";
+  }
+
+  // Runs the set of callbacks that are intended to run after
+  // BlockHostUntilDone.
+  void RunAfterBlockHostUntilDoneCallbacks();
+
+  // The StreamExecutor that supports the operation of this stream.
+  StreamExecutor *parent_;
+
+  // The platform-dependent implementation that the StreamExecutor interface
+  // delegates to.
+  std::unique_ptr<internal::StreamInterface> implementation_;
+
+  // mutex that guards the allocation / error state flags.
+  // Mutable so that it can be obtained via const reader lock.
+  mutable absl::Mutex mu_;
+
+  // Whether Init() was successfully called to allocate this stream on the
+  // underlying platform. It simply flips from 0 to 1 with a sanity check.
+  // See StreamExecutor::AllocateStream.
+  bool allocated_ ABSL_GUARDED_BY(mu_);
+
+  // The last error (if any) of all method calls.
+  tsl::Status status_ ABSL_GUARDED_BY(mu_);
+
+  // Sub-streams that are generated from this stream. Each element has a pointer
+  // to sub-stream and a boolean value indicating if this substream is ready to
+  // be reused.
+  std::vector<std::pair<std::unique_ptr<Stream>, bool>> sub_streams_
+      ABSL_GUARDED_BY(mu_);
+
+  // Streams can allocate temporary memories to help with work they enqueue
+  // (e.g. for scratch memory spaces). This member tracks those allocations and
+  // notes when they can be reclaimed -- reclamation is attempted when
+  // BlockHostUntilDone() is called.
+  internal::TemporaryMemoryManager temporary_memory_manager_;
+
+  // Callbacks enqueued to be run after the next call to BlockHostUntilDone().
+  std::vector<absl::AnyInvocable<void() &&>>
+      after_block_host_until_done_callbacks_ ABSL_GUARDED_BY(mu_);
+
+  // Non-extended BLAS interface requires alpha/beta to be floats when input
+  // type is Eigen::half. However, for consistency purposes it is convenient
+  // for the interface to accept Eigen::half.
+  template <typename T>
+  void UpcastHalfToFloat(void **alpha_ptr, void **beta_ptr,
+                         float *alpha_storage, float *beta_storage) {
+    if (std::is_same<T, Eigen::half>::value) {
+      *alpha_storage =
+          static_cast<float>(*reinterpret_cast<Eigen::half *>(*alpha_ptr));
+      *beta_storage =
+          static_cast<float>(*reinterpret_cast<Eigen::half *>(*beta_ptr));
+      *alpha_ptr = alpha_storage;
+      *beta_ptr = beta_storage;
+    } else if (std::is_same<T, Eigen::bfloat16>::value) {
+      *alpha_storage =
+          static_cast<float>(*reinterpret_cast<Eigen::bfloat16 *>(*alpha_ptr));
+      *beta_storage =
+          static_cast<float>(*reinterpret_cast<Eigen::bfloat16 *>(*beta_ptr));
+      *alpha_ptr = alpha_storage;
+      *beta_ptr = beta_storage;
+    }
+  }
+
+  Stream(const Stream &) = delete;
+  void operator=(const Stream &) = delete;
+};
+
+////////////
+// Inlines
+
+template <typename... Params, typename... Args>
+inline tsl::Status Stream::ThenLaunch(ThreadDim thread_dims,
+                                      BlockDim block_dims,
+                                      const TypedKernel<Params...> &kernel,
+                                      Args... args) {
+  KernelInvocationChecker<std::tuple<Params...>,
+                          std::tuple<Args...>>::CheckAllStaticAssert();
+
+  // This is the core that allows type-safe kernel launching.
+  // Since the platforms take kernel arguments as tuples of (void *, size),
+  // we pack the variadic parameters passed as ...args into the desired
+  // tuple form and pass that packed form to the StreamExecutor::Launch()
+  // implementation.
+  KernelArgsArray<sizeof...(args)> kernel_args;
+  kernel.PackParams(&kernel_args, args...);
+  TF_RETURN_IF_ERROR(
+      parent_->Launch(this, thread_dims, block_dims, kernel, kernel_args));
+  return ::tsl::OkStatus();
+}
+
+template <typename T>
+inline tsl::StatusOr<std::unique_ptr<TemporaryDeviceMemory<T>>>
+Stream::AllocateTemporaryArray(uint64_t element_count) {
+  return temporary_memory_manager_.AllocateArray<T>(element_count);
+}
+
+inline internal::TemporaryMemoryManager *Stream::temporary_memory_manager() {
+  return &temporary_memory_manager_;
+}
+
+template <>
+struct Quantization<uint8_t> {
+  static constexpr dnn::QuantizedActivationMode kModeId =
+      dnn::QuantizedActivationMode::k8Bit;
+};
+
+template <>
+struct Quantization<uint16_t> {
+  static constexpr dnn::QuantizedActivationMode kModeId =
+      dnn::QuantizedActivationMode::k16Bit;
+};
+
+template <>
+struct Quantization<int32_t> {
+  static constexpr dnn::QuantizedActivationMode kModeId =
+      dnn::QuantizedActivationMode::k32Bit;
+};
+
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_STREAM_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/stream_executor.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/stream_executor.h
new file mode 100644
index 0000000000000000000000000000000000000000..76b9921b24052366fbeaa9a2dbddde435f9e61b5
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/stream_executor.h
@@ -0,0 +1,37 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// The StreamExecutor is a single-device abstraction for:
+//
+// * Loading/launching data-parallel-kernels
+// * Invoking pre-canned high-performance library routines (like matrix
+//   multiply)
+
+#ifndef XLA_STREAM_EXECUTOR_STREAM_EXECUTOR_H_
+#define XLA_STREAM_EXECUTOR_STREAM_EXECUTOR_H_
+
+#include "xla/stream_executor/device_description.h"  // IWYU pragma: export
+#include "xla/stream_executor/device_memory.h"  // IWYU pragma: export
+#include "xla/stream_executor/device_options.h"  // IWYU pragma: export
+#include "xla/stream_executor/event.h"  // IWYU pragma: export
+#include "xla/stream_executor/kernel.h"  // IWYU pragma: export
+#include "xla/stream_executor/kernel_spec.h"  // IWYU pragma: export
+#include "xla/stream_executor/launch_dim.h"  // IWYU pragma: export
+#include "xla/stream_executor/multi_platform_manager.h"  // IWYU pragma: export
+#include "xla/stream_executor/platform.h"  // IWYU pragma: export
+#include "xla/stream_executor/stream.h"  // IWYU pragma: export
+#include "xla/stream_executor/stream_executor_pimpl.h"  // IWYU pragma: export
+
+#endif  // XLA_STREAM_EXECUTOR_STREAM_EXECUTOR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/stream_executor_internal.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/stream_executor_internal.h
new file mode 100644
index 0000000000000000000000000000000000000000..47cd7de5bc19e8dd366693f5f4aa37784824d6c1
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/stream_executor_internal.h
@@ -0,0 +1,439 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// Interfaces for platform-dependent implementations to satisfy. This are
+// delegated to from the StreamExecutor in pointer-to-implementation style; i.e.
+// the StreamExecutor is just a husk that delegates calls to the
+// platform-specific objects which implement the interfaces defined here.
+
+#ifndef XLA_STREAM_EXECUTOR_STREAM_EXECUTOR_INTERNAL_H_
+#define XLA_STREAM_EXECUTOR_STREAM_EXECUTOR_INTERNAL_H_
+
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <optional>
+#include <string>
+#include <variant>
+#include <vector>
+
+#include "absl/functional/any_invocable.h"
+#include "absl/status/status.h"
+#include "xla/stream_executor/allocator_stats.h"
+#include "xla/stream_executor/command_buffer.h"
+#include "xla/stream_executor/device_description.h"
+#include "xla/stream_executor/device_memory.h"
+#include "xla/stream_executor/device_options.h"
+#include "xla/stream_executor/event.h"
+#include "xla/stream_executor/kernel.h"
+#include "xla/stream_executor/kernel_cache_config.h"
+#include "xla/stream_executor/kernel_spec.h"
+#include "xla/stream_executor/launch_dim.h"
+#include "xla/stream_executor/module_spec.h"
+#include "xla/stream_executor/platform.h"
+#include "xla/stream_executor/platform/port.h"
+#include "xla/stream_executor/plugin_registry.h"
+#include "xla/stream_executor/trace_listener.h"
+#include "tsl/platform/errors.h"
+#include "tsl/platform/status.h"
+#include "tsl/platform/statusor.h"
+
+namespace stream_executor {
+
+class Stream;
+
+namespace internal {
+
+//===----------------------------------------------------------------------===//
+// EventInterface
+//===----------------------------------------------------------------------===//
+
+// Platform-dependent interface class for the generic Events interface, in
+// the PIMPL style.
+class EventInterface {
+ public:
+  EventInterface() = default;
+  virtual ~EventInterface() = default;
+
+ private:
+  EventInterface(const EventInterface&) = delete;
+  void operator=(const EventInterface&) = delete;
+};
+
+//===----------------------------------------------------------------------===//
+// KernelInterface
+//===----------------------------------------------------------------------===//
+
+// Pointer-to-implementation object type (i.e. the KernelBase class delegates to
+// this interface) with virtual destruction. This class exists for the
+// platform-dependent code to hang any kernel data/resource info/functionality
+// off of.
+class KernelInterface {
+ public:
+  // Default constructor for the abstract interface.
+  KernelInterface() = default;
+
+  // Default destructor for the abstract interface.
+  virtual ~KernelInterface() = default;
+
+  // Returns the number of formal parameters that this kernel accepts.
+  virtual unsigned Arity() const = 0;
+
+  // Sets the preferred cache configuration.
+  virtual void SetPreferredCacheConfig(KernelCacheConfig config) = 0;
+
+  // Gets the preferred cache configuration.
+  virtual KernelCacheConfig GetPreferredCacheConfig() const = 0;
+
+ private:
+  KernelInterface(const KernelInterface&) = delete;
+  void operator=(const KernelInterface&) = delete;
+};
+
+//===----------------------------------------------------------------------===//
+// CommandBufferInterface
+//===----------------------------------------------------------------------===//
+
+// Platform-dependent interface class for implementing generic CommandBuffer.
+//
+// TODO(ezhulenev): Currently we assume that all operations between barriers
+// can execute concurrently, and it's up to the caller to insert barriers to
+// guarantee correctness. Consider adding finer grained synchronization
+// mechanism between different commands.
+//
+// TODO(ezhulenev): Currently command buffers do no support updates, and once
+// finalized can be executed as recorded. We need to support cheap command
+// buffer updates that in GPU backend will be mapped to CUDA/HIP graph node
+// updates.
+class CommandBufferInterface {
+ public:
+  CommandBufferInterface() = default;
+  virtual ~CommandBufferInterface() = default;
+
+  // Traces `function` invocation by recording all operations on the `stream`
+  // into the command buffer. Command buffer must be empty.
+  virtual tsl::Status Trace(Stream* stream,
+                            absl::AnyInvocable<tsl::Status()> function) = 0;
+
+  // Adds a kernel launch command to the command buffer.
+  virtual tsl::Status Launch(const ThreadDim& threads, const BlockDim& blocks,
+                             const KernelBase& kernel,
+                             const KernelArgsArrayBase& args) = 0;
+
+  // Adds a device-to-device memory copy to the command buffer.
+  virtual tsl::Status MemcpyDeviceToDevice(DeviceMemoryBase* dst,
+                                           const DeviceMemoryBase& src,
+                                           uint64_t size) = 0;
+
+  // Finalizes command buffer and makes it executable. Once command buffer is
+  // finalized no commands can be added to it.
+  virtual tsl::Status Finalize() = 0;
+
+  // Begins command buffer update. Command buffer update should be finalized
+  // before it can be executed.
+  virtual tsl::Status Update() = 0;
+
+  // Returns command buffer execution mode.
+  virtual CommandBuffer::Mode mode() const = 0;
+
+  // Returns command buffer state.
+  virtual CommandBuffer::State state() const = 0;
+
+ private:
+  CommandBufferInterface(const CommandBufferInterface&) = delete;
+  void operator=(const CommandBufferInterface&) = delete;
+};
+
+//===----------------------------------------------------------------------===//
+// StreamInterface
+//===----------------------------------------------------------------------===//
+
+// Pointer-to-implementation object type (i.e. the Stream class delegates to
+// this interface) with virtual destruction. This class exists for the
+// platform-dependent code to hang any kernel data/resource info/functionality
+// off of.
+class StreamInterface {
+ public:
+  // Default constructor for the abstract interface.
+  StreamInterface() = default;
+
+  // Default destructor for the abstract interface.
+  virtual ~StreamInterface() = default;
+
+  // Sets priority for a stream.
+  virtual void SetPriority(StreamPriority priority) {
+    LOG(ERROR) << "SetPriority unimplemented for this stream.";
+  }
+
+  virtual void SetPriority(int priority) {
+    LOG(ERROR) << "SetPriority unimplemented for this stream.";
+  }
+
+  // Gets priority for a stream.
+  virtual std::variant<StreamPriority, int> priority() const {
+    return StreamPriority::Default;
+  }
+
+  // Returns the GPU stream associated with this platform's stream
+  // implementation, or nullptr otherwise.
+  virtual void* GpuStreamHack() { return nullptr; }
+
+  // Returns a pointer to a GPU stream associated with this platform's stream,
+  // or a nullptr.
+  virtual void** GpuStreamMemberHack() { return nullptr; }
+
+ private:
+  StreamInterface(const StreamInterface&) = delete;
+  void operator=(const StreamInterface&) = delete;
+};
+
+//===----------------------------------------------------------------------===//
+// StreamExecutorInterface
+//===----------------------------------------------------------------------===//
+
+// Interface for the different StreamExecutor platforms (i.e. CUDA, OpenCL).
+//
+// Various platforms will provide an implementation that satisfy this interface.
+class StreamExecutorInterface {
+ public:
+  // Default constructor for the abstract interface.
+  StreamExecutorInterface() = default;
+
+  // Default destructor for the abstract interface.
+  virtual ~StreamExecutorInterface() = default;
+
+  // Returns the (transitively) wrapped executor if this executor is
+  // wrapping another executor; otherwise, returns this.
+  virtual StreamExecutorInterface* GetUnderlyingExecutor() { return this; }
+
+  // See the StreamExecutor interface for comments on the same-named methods.
+  virtual tsl::Status Init(int device_ordinal,
+                           DeviceOptions device_options) = 0;
+
+  // This value is cached by the wrapping StreamExecutor instance, so it's OK if
+  // this function is slow.
+  //
+  // The wrapping StreamExecutor will use the platform name if this is nullopt.
+  virtual std::optional<std::string> MakeDeviceDescriptionStr() const {
+    return std::nullopt;
+  }
+
+  virtual tsl::Status GetKernel(const MultiKernelLoaderSpec& spec,
+                                KernelBase* kernel) {
+    return absl::UnimplementedError("Not Implemented");
+  }
+  virtual bool UnloadModule(ModuleHandle module_handle) { return false; }
+  virtual tsl::Status LoadModule(const MultiModuleLoaderSpec& spec,
+                                 ModuleHandle* module_handle) {
+    return absl::UnimplementedError("Not Implemented");
+  }
+  virtual tsl::StatusOr<std::shared_ptr<DeviceMemoryBase>>
+  CreateOrShareConstant(Stream* stream, const std::vector<uint8_t>& content) {
+    return absl::UnimplementedError("Not Implemented");
+  }
+  virtual tsl::Status Launch(Stream* stream, const ThreadDim& thread_dims,
+                             const BlockDim& block_dims, const KernelBase& k,
+                             const KernelArgsArrayBase& args) {
+    return absl::UnimplementedError("Not Implemented");
+  }
+
+  virtual tsl::Status Submit(Stream* stream,
+                             const CommandBuffer& command_buffer) {
+    return absl::UnimplementedError("Not Implemented");
+  }
+
+  // Releases any state associated with the kernel.
+  virtual void UnloadKernel(const KernelBase* kernel) {}
+  virtual DeviceMemoryBase Allocate(uint64_t size, int64_t memory_space) = 0;
+  DeviceMemoryBase Allocate(uint64_t size) {
+    return Allocate(size, /*memory_space=*/0);
+  }
+  virtual void* GetSubBuffer(DeviceMemoryBase* parent, uint64_t offset,
+                             uint64_t size) = 0;
+  virtual void Deallocate(DeviceMemoryBase* mem) = 0;
+  // Allocates unified memory space of the given size, if supported.
+  // See
+  // https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#um-unified-memory-programming-hd
+  // for more details on unified memory.
+  virtual void* UnifiedMemoryAllocate(uint64_t size) { return nullptr; }
+
+  // Deallocates unified memory space previously allocated with
+  // UnifiedMemoryAllocate.
+  virtual void UnifiedMemoryDeallocate(void* mem) {}
+  virtual void* HostMemoryAllocate(uint64_t size) = 0;
+  virtual void HostMemoryDeallocate(void* mem) = 0;
+  virtual bool HostMemoryRegister(void* mem, uint64_t size) = 0;
+  virtual bool HostMemoryUnregister(void* mem) = 0;
+  virtual bool SynchronizeAllActivity() = 0;
+  virtual tsl::Status SynchronousMemZero(DeviceMemoryBase* location,
+                                         uint64_t size) = 0;
+  virtual tsl::Status SynchronousMemSet(DeviceMemoryBase* location, int value,
+                                        uint64_t size) = 0;
+  virtual tsl::Status SynchronousMemcpy(DeviceMemoryBase* gpu_dst,
+                                        const void* host_src,
+                                        uint64_t size) = 0;
+  virtual tsl::Status SynchronousMemcpy(void* host_dst,
+                                        const DeviceMemoryBase& gpu_src,
+                                        uint64_t size) = 0;
+  virtual tsl::Status SynchronousMemcpyDeviceToDevice(
+      DeviceMemoryBase* gpu_dst, const DeviceMemoryBase& gpu_src,
+      uint64_t size) = 0;
+  virtual tsl::Status MemZero(Stream* stream, DeviceMemoryBase* location,
+                              uint64_t size) = 0;
+  virtual tsl::Status Memset(Stream* stream, DeviceMemoryBase* location,
+                             uint8 pattern, uint64_t size) {
+    return tsl::errors::Internal("Not implemented");
+  }
+  virtual tsl::Status Memset32(Stream* stream, DeviceMemoryBase* location,
+                               uint32_t pattern, uint64_t size) = 0;
+  virtual bool Memcpy(Stream* stream, void* host_dst,
+                      const DeviceMemoryBase& gpu_src, uint64_t size) = 0;
+  virtual bool Memcpy(Stream* stream, DeviceMemoryBase* gpu_dst,
+                      const void* host_src, uint64_t size) = 0;
+  virtual bool MemcpyDeviceToDevice(Stream* stream, DeviceMemoryBase* gpu_dst,
+                                    const DeviceMemoryBase& gpu_src,
+                                    uint64_t size) = 0;
+  virtual bool HostCallback(Stream* stream,
+                            absl::AnyInvocable<tsl::Status() &&> callback) = 0;
+  virtual tsl::Status AllocateEvent(Event* event) = 0;
+  virtual tsl::Status DeallocateEvent(Event* event) = 0;
+  virtual tsl::Status RecordEvent(Stream* stream, Event* event) = 0;
+  virtual tsl::Status WaitForEvent(Stream* stream, Event* event) = 0;
+  virtual tsl::Status WaitForEventOnExternalStream(std::intptr_t stream,
+                                                   Event* event) {
+    return absl::UnimplementedError(
+        "WaitForEventOnExternalStream not supported on this executor.");
+  }
+  virtual Event::Status PollForEventStatus(Event* event) = 0;
+  virtual bool AllocateStream(Stream* stream) = 0;
+  virtual void DeallocateStream(Stream* stream) = 0;
+  virtual bool CreateStreamDependency(Stream* dependent, Stream* other) = 0;
+  virtual tsl::Status BlockHostUntilDone(Stream* stream) = 0;
+  virtual tsl::Status GetStatus(Stream* stream) {
+    return absl::UnimplementedError(
+        "GetStatus is not supported on this executor.");
+  }
+  virtual tsl::Status EnablePeerAccessTo(StreamExecutorInterface* other) = 0;
+  virtual bool CanEnablePeerAccessTo(StreamExecutorInterface* other) = 0;
+
+  virtual int64_t GetDeviceLoad() { return -1; }
+
+  virtual bool DeviceMemoryUsage(int64_t* free, int64_t* total) const {
+    return false;
+  }
+
+  // Retrieves device pointer and size for a symbol. The device pointer is
+  // stored at mem, and the size is stored at size. Either mem or bytes can be
+  // null, however, both of them cannot be null at the same time. To use
+  // constant memory in CUDA, GetSymbol has to be used. Returns true if symbol
+  // is found.
+  //
+  // If ModuleHandle is set then we search for `symbol_name` only within the
+  // module corresponding to `module_handle`.  Otherwise all loaded modules are
+  // searched.
+  virtual bool GetSymbol(const std::string& symbol_name,
+                         ModuleHandle module_handle, void** mem,
+                         size_t* bytes) {
+    return false;
+  }
+
+  // Creates a new DeviceDescription object. Ownership is transferred to the
+  // caller.
+  virtual tsl::StatusOr<std::unique_ptr<DeviceDescription>>
+  CreateDeviceDescription() const = 0;
+
+  // Attempts to register the provided TraceListener with the device-specific
+  // Executor implementation. When this is called, the PIMPL interface has
+  // already taken ownership of the object and is managing the generic tracing
+  // events. The device-specific implementation must determine if the passed
+  // listener is of a type appropriate for it to trace during registration (and
+  // before dispatching events to it).
+  // Returns true if the listener was successfully registered, false otherwise.
+  // Does not take ownership of listener.
+  virtual bool RegisterTraceListener(TraceListener* listener) { return false; }
+
+  // Unregisters the specified listener from the device-specific Executor.
+  // Returns true if the listener was successfully registered, false otherwise.
+  virtual bool UnregisterTraceListener(TraceListener* listener) {
+    return false;
+  }
+
+  // Creates a new BlasSupport object, ownership is transferred to the caller.
+  //
+  // This may return null if the BLAS initialization fails or this object does
+  // not support BLAS.
+  virtual blas::BlasSupport* CreateBlas() { return nullptr; }
+
+  // Creates a new fft::FftSupport object, ownership is transferred to the
+  // caller.
+  // This may return null if the FFT initialization fails or this object does
+  // not support FFT.
+  virtual fft::FftSupport* CreateFft() { return nullptr; }
+
+  // Creates a new DnnSupport object, ownership is transferred to the caller.
+  // This may return null if the DNN initialization fails or this object does
+  // not support Dnns.
+  virtual dnn::DnnSupport* CreateDnn() { return nullptr; }
+
+  // Each call creates a new instance of the platform-specific implementation of
+  // the corresponding interface type.
+  virtual std::unique_ptr<EventInterface> CreateEventImplementation() = 0;
+  virtual std::unique_ptr<KernelInterface> CreateKernelImplementation() = 0;
+  virtual std::unique_ptr<StreamInterface> GetStreamImplementation() = 0;
+
+  virtual tsl::StatusOr<std::unique_ptr<CommandBufferInterface>>
+  GetCommandBufferImplementation(CommandBuffer::Mode mode) {
+    return absl::UnimplementedError("Command buffers are not implemented");
+  }
+
+  // Returns the CUDA or ROCm context associated with this StreamExecutor
+  // platform implementation.
+  //
+  // WARNING: checks that the underlying platform is, in fact, CUDA or ROCm,
+  // causing a fatal error if it is not. This hack is made available solely for
+  // use from distbelief code, which temporarily has strong ties to CUDA or ROCm
+  // as a platform.
+  virtual void* GpuContextHack() { return nullptr; }
+
+  // Return allocator statistics.
+  virtual std::optional<AllocatorStats> GetAllocatorStats() {
+    return std::nullopt;
+  }
+
+  // If implemented, clears the internal stats except for the `in_use` fields
+  // and sets the `peak_bytes_in_use` to be equal to the `bytes_in_use`. Returns
+  // true if implemented.
+  //
+  // REQUIRES: GetAllocatorStats is overridden.
+  virtual bool ClearAllocatorStats() { return false; }
+
+  // Clears the compilation cache from volatile memory. Returns OK if no
+  // compilation cache exists or if clearing the compilation cache is
+  // unsupported. Caches in non-volatile storage are unaffected.
+  virtual tsl::Status FlushCompilationCache() { return ::tsl::OkStatus(); }
+
+  // Returns a stream allocated by this executor, or nullptr if not found.
+  // Performs linear search over alive GPU streams.
+  virtual Stream* FindAllocatedStream(void* /*gpu_stream*/) { return nullptr; }
+
+ private:
+  StreamExecutorInterface(const StreamExecutorInterface&) = delete;
+  void operator=(const StreamExecutorInterface&) = delete;
+};
+
+}  // namespace internal
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_STREAM_EXECUTOR_INTERNAL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/stream_executor_pimpl.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/stream_executor_pimpl.h
new file mode 100644
index 0000000000000000000000000000000000000000..f8903f1c946ff5b6d476fcce4b481f1394757ae2
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/stream_executor_pimpl.h
@@ -0,0 +1,752 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_STREAM_EXECUTOR_STREAM_EXECUTOR_PIMPL_H_
+#define XLA_STREAM_EXECUTOR_STREAM_EXECUTOR_PIMPL_H_
+
+#include <atomic>
+#include <cstdint>
+#include <memory>
+#include <optional>
+#include <set>
+#include <string>
+#include <vector>
+
+#include "absl/base/attributes.h"
+#include "absl/base/thread_annotations.h"
+#include "absl/functional/any_invocable.h"
+#include "absl/synchronization/mutex.h"
+#include "absl/types/span.h"
+#include "xla/stream_executor/allocator_stats.h"
+#include "xla/stream_executor/blas.h"
+#include "xla/stream_executor/command_buffer.h"
+#include "xla/stream_executor/device_memory_allocator.h"
+#include "xla/stream_executor/dnn.h"
+#include "xla/stream_executor/event.h"
+#include "xla/stream_executor/fft.h"
+#include "xla/stream_executor/kernel_spec.h"
+#include "xla/stream_executor/module_spec.h"
+#include "xla/stream_executor/numeric_options.h"
+#include "xla/stream_executor/platform.h"
+#include "xla/stream_executor/platform/port.h"
+#include "xla/stream_executor/trace_listener.h"
+#include "tsl/platform/status.h"
+#include "tsl/platform/threadpool.h"
+#include "tsl/protobuf/dnn.pb.h"
+
+// TODO(ezhulenev): Remove include of internal header. Currently we have too
+// many targets depending on transitive dependencies.
+#include "xla/stream_executor/stream_executor_internal.h"
+
+namespace stream_executor {
+
+class Stream;
+
+namespace internal {
+class StreamExecutorInterface;
+}  // namespace internal
+
+// Forward declaration of private friend class.
+template <typename BeginCallT, typename CompleteCallT, typename ReturnT,
+          typename... BeginArgsT>
+class ScopedTracer;
+
+// A StreamExecutor manages a single device, in terms of executing work (kernel
+// launches) and memory management (allocation/deallocation, memory copies to
+// and from the device). It is conceptually the "handle" for a device -- Stream
+// objects, which are used to enqueue work to run on the
+// coprocessor have a StreamExecutor instance as their "parent" object.
+//
+// StreamExecutor objects have an underlying platform that is specified up
+// front;
+// e.g. either it is a CUDA or OpenCL executor.
+//
+// Thread-safe after initialization.
+// StreamExecutor interface should not be invoked from a signal handler.
+class StreamExecutor {
+ public:
+  StreamExecutor(
+      const Platform* platform,
+      std::unique_ptr<internal::StreamExecutorInterface> implementation,
+      int device_ordinal);
+
+  ~StreamExecutor();
+
+  tsl::Status Init();
+  tsl::Status Init(DeviceOptions device_options);
+
+  // Returns a reference to the platform that created this executor.
+  const Platform* platform() const { return platform_; }
+
+  // Retrieves (loads) a kernel for the platform this StreamExecutor is acting
+  // upon, if one exists.
+  //
+  // Parameters:
+  //   spec: The MultiKernelLoaderSpec is usually generated as a compile-time
+  //    constant into an appropriate namespace. For example, see
+  //    stream_executor::executor_sample::kKernelLoaderSpecs, from which a
+  //    MultiKernelLoaderSpec is selected.
+  //   kernel: Outparam that the kernel is loaded into. A given Kernel
+  //    instantiation should not be loaded into more than once.
+  //
+  // If an error occurs, or there is no kernel available for the StreamExecutor
+  // platform, error status is returned.
+  tsl::Status GetKernel(const MultiKernelLoaderSpec& spec, KernelBase* kernel);
+
+  // Releases any state associated with the previously loaded kernel.
+  void UnloadKernel(const KernelBase* kernel);
+
+  // Loads a module for the platform this StreamExecutor is acting upon.
+  //
+  // `spec` describes the module to be loaded.  On success writes the handle for
+  // the loaded module to `module_handle` and returns OkStatus().  Otherwise,
+  // returns the error which has occurred.
+  tsl::Status LoadModule(const MultiModuleLoaderSpec& spec,
+                         ModuleHandle* module_handle);
+
+  // Unloads the module with handle `module_handle`.
+  bool UnloadModule(ModuleHandle module_handle);
+
+  tsl::StatusOr<std::shared_ptr<DeviceMemoryBase>> CreateOrShareConstant(
+      Stream* stream, const std::vector<uint8_t>& content);
+
+  // Synchronously allocates an array on the device of type T with element_count
+  // elements.
+  template <typename T>
+  DeviceMemory<T> AllocateArray(uint64_t element_count,
+                                int64_t memory_space = 0);
+
+  // As AllocateArray(), but returns a ScopedDeviceMemory<T>.
+  template <typename T>
+  ScopedDeviceMemory<T> AllocateOwnedArray(uint64_t element_count) {
+    return ScopedDeviceMemory<T>(this, AllocateArray<T>(element_count));
+  }
+
+  // Convenience wrapper that allocates space for a single element of type T in
+  // device memory.
+  template <typename T>
+  DeviceMemory<T> AllocateScalar() {
+    return AllocateArray<T>(1);
+  }
+
+  // As AllocateScalar(), but returns a ScopedDeviceMemory<T>.
+  template <typename T>
+  ScopedDeviceMemory<T> AllocateOwnedScalar() {
+    return AllocateOwnedArray<T>(1);
+  }
+
+  // Allocate a memory region inside another allocated memory region.
+  // Offset and size are specified in terms of T elements.
+  // Warning: Do not free a parent buffer before its sub-buffers; this may cause
+  // use-after-free issues (the specific behavior is not consistent across
+  // platforms).
+  //  - Note: OpenCL uses refcounting to manage buffer lifetimes, so use of a
+  //    sub-buffer after parent deallocation is expected to be safe. This will
+  //    render your code non-platform-portable, however.
+  template <typename T>
+  DeviceMemory<T> GetSubBuffer(DeviceMemory<T>* parent, uint64_t element_offset,
+                               uint64_t element_count);
+
+  // An untyped version of GetSymbol.
+  tsl::StatusOr<DeviceMemoryBase> GetUntypedSymbol(
+      const std::string& symbol_name, ModuleHandle module_handle);
+
+  // Deallocate the DeviceMemory previously allocated via this interface.
+  // Deallocation of a nullptr-representative value is permitted.
+  //
+  // Resets the internal contents of mem to be null-representative, but this
+  // null-out effect should not be relied upon in client code.
+  void Deallocate(DeviceMemoryBase* mem);
+
+  // Allocates unified memory space of the given size, if supported.
+  // See
+  // https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#um-unified-memory-programming-hd
+  // for more details on unified memory.
+  void* UnifiedMemoryAllocate(uint64_t bytes);
+
+  // Deallocates unified memory space previously allocated with
+  // UnifiedMemoryAllocate.
+  void UnifiedMemoryDeallocate(void* location);
+
+  // Allocates a region of host memory and registers it with the platform API.
+  // Memory allocated in this manner (or allocated and registered with
+  // HostMemoryRegister() is required for use in asynchronous memcpy operations,
+  // such as Stream::ThenMemcpy.
+  void* HostMemoryAllocate(uint64_t size);
+
+  // Deallocates a region of host memory allocated by HostMemoryAllocate().
+  void HostMemoryDeallocate(void* location);
+
+  // Synchronizes all activity occurring in the StreamExecutor's context (most
+  // likely a whole device).
+  bool SynchronizeAllActivity() ABSL_MUST_USE_RESULT;
+
+  // Blocks the caller while "size" bytes are zeroed out (in POD fashion) at the
+  // given location in device memory.
+  tsl::Status SynchronousMemZero(DeviceMemoryBase* location,
+                                 uint64_t size) ABSL_MUST_USE_RESULT;
+
+  // Same as SynchronousMemcpy(DeviceMemoryBase*, ...) above.
+  tsl::Status SynchronousMemcpyH2D(const void* host_src, int64_t size,
+                                   DeviceMemoryBase* device_dst);
+
+  // Alternative interface for memcpying from host to device that takes an
+  // array slice. Checks that the destination size can accommodate the host
+  // slice size.
+  template <class T>
+  tsl::Status SynchronousMemcpyH2D(absl::Span<const T> host_src,
+                                   DeviceMemoryBase* device_dst) {
+    auto host_size = host_src.size() * sizeof(T);
+    CHECK(device_dst->size() == 0 || device_dst->size() >= host_size);
+    return SynchronousMemcpyH2D(host_src.begin(), host_size, device_dst);
+  }
+
+  // Same as SynchronousMemcpy(void*, ...) above.
+  tsl::Status SynchronousMemcpyD2H(const DeviceMemoryBase& device_src,
+                                   int64_t size, void* host_dst);
+
+  // Blocks the caller while a data segment of the given size is copied from the
+  // device source to the device destination.
+  bool SynchronousMemcpy(DeviceMemoryBase* device_dst,
+                         const DeviceMemoryBase& device_src,
+                         uint64_t size) ABSL_MUST_USE_RESULT;
+
+  // Enqueues an operation onto stream to zero out size bytes at the given
+  // device memory location. Neither stream nor location may be null. Returns
+  // whether the operation was successfully enqueued onto the stream.
+  tsl::Status MemZero(Stream* stream, DeviceMemoryBase* location,
+                      uint64_t size) ABSL_MUST_USE_RESULT;
+
+  // Enqueues an operation onto stream to set 32-bit patterns starting at
+  // location, for byte count given by size. size must be 32-bit quantified
+  // (i.e. evently divisible by 4). Returns whether the operation was
+  // successfully enqueued onto the stream.
+  tsl::Status Memset32(Stream* stream, DeviceMemoryBase* location,
+                       uint32_t pattern, uint64_t size);
+
+  // Enables peer access from this StreamExecutor to memory
+  // allocated by other, such that launched device code, memcpies, etc may
+  // access it directly.
+  //
+  // Both this StreamExecutor and other must be backed by the same platform (as
+  // in
+  // CUDA vs OpenCL) implementation.
+  tsl::Status EnablePeerAccessTo(StreamExecutor* other);
+
+  // Returns whether it's possible to enable peer access from this
+  // StreamExecutor
+  // to memory allocated by another.
+  //
+  // Even when this returns true, EnablePeerAccessTo may fail for other reasons;
+  // this is more an up-front test as to whether it's expressly forbidden.
+  bool CanEnablePeerAccessTo(StreamExecutor* other);
+
+  // Obtains metadata about the underlying device.
+  // The value is cached on first use.
+  const DeviceDescription& GetDeviceDescription() const;
+
+  // If implemented, returns device specific measurement of load
+  // (e.g. pending requests).
+  int64_t GetDeviceLoad() const;
+
+  // Returns the underlying device memory usage information, if it is available.
+  // If it is not available (false is returned), free/total may not be
+  // initialized.
+  //
+  // Note: "Free" reflects the amount of free memory on the underlying device,
+  // so allocations via other StreamExecutors that have the same underlying
+  // device
+  // will be reflected in "free".
+  bool DeviceMemoryUsage(int64_t* free, int64_t* total) const;
+
+  // Returns the supported algorithms / execution plans for a convolution.
+  tsl::Status GetConvolveRunners(
+      bool use_cudnn_frontend, dnn::ConvolutionKind kind,
+      dnn::DataType input_type, dnn::DataType output_type, Stream* stream,
+      const dnn::BatchDescriptor& input_descriptor, DeviceMemoryBase input_data,
+      const dnn::FilterDescriptor& filter_descriptor,
+      DeviceMemoryBase filter_data,
+      const dnn::BatchDescriptor& output_descriptor,
+      DeviceMemoryBase output_data,
+      const dnn::ConvolutionDescriptor& convolution_descriptor,
+      bool use_fallback, ScratchAllocator* scratch_allocator,
+      const NumericOptions& numeric_options,
+      std::vector<std::unique_ptr<const dnn::ConvRunner>>* out_exec_plans);
+
+  tsl::Status GetGraphConvolveRunners(
+      dnn::ConvolutionKind kind, dnn::DataType input_type,
+      dnn::DataType output_type, Stream* stream,
+      const dnn::BatchDescriptor& input_descriptor,
+      const dnn::FilterDescriptor& filter_descriptor,
+      const dnn::BatchDescriptor& output_descriptor,
+      const dnn::ConvolutionDescriptor& convolution_descriptor,
+      bool use_fallback, const NumericOptions& numeric_options,
+      std::vector<std::unique_ptr<const dnn::GraphConvRunner>>* out_exec_plans,
+      std::string serialized_graph);
+
+  tsl::Status GetFusedConvolveRunners(
+      bool use_cudnn_frontend, dnn::ConvolutionKind kind,
+      dnn::DataType input_type, dnn::DataType bias_type,
+      dnn::DataType output_type, double conv_input_scale,
+      double side_input_scale, double leakyrelu_alpha, Stream* stream,
+      const dnn::BatchDescriptor& input_descriptor,
+      const dnn::FilterDescriptor& filter_descriptor,
+      const dnn::BatchDescriptor& bias_descriptor,
+      const dnn::BatchDescriptor& output_descriptor,
+      const dnn::ConvolutionDescriptor& convolution_descriptor,
+      bool use_fallback, dnn::ActivationMode activation_mode,
+      const NumericOptions& numeric_options,
+      std::vector<std::unique_ptr<const dnn::FusedConvRunner>>* out_exec_plans);
+
+  tsl::Status GetFusedMatmulRunners(
+      bool use_cudnn_frontend, dnn::DataType input_type,
+      dnn::DataType bias_type, dnn::DataType output_type, Stream* stream,
+      bool trans_a, bool trans_b, uint64_t m, uint64_t n, uint64_t k,
+      int64_t lda, int64_t ldb, int64_t ldc,
+      dnn::ActivationMode activation_mode, bool use_fallback,
+      const NumericOptions& numeric_options,
+      std::vector<std::unique_ptr<const dnn::FusedMatmulRunner>>*
+          out_exec_plans);
+
+  // Returns the list of supported algorithms for the forward convolution
+  // operation.
+  bool GetMIOpenConvolveAlgorithms(
+      dnn::ConvolutionKind kind, dnn::DataType element_type, Stream* stream,
+      const dnn::BatchDescriptor& input_descriptor, DeviceMemoryBase input_data,
+      const dnn::FilterDescriptor& filter_descriptor,
+      DeviceMemoryBase filter_data,
+      const dnn::BatchDescriptor& output_descriptor,
+      DeviceMemoryBase output_data,
+      const dnn::ConvolutionDescriptor& convolution_descriptor,
+      ScratchAllocator* scratch_allocator,
+      std::vector<dnn::ProfileResult>* out_algorithms);
+
+  // Returns the list of supported algorithms for rnn operation.
+  bool GetRnnAlgorithms(std::vector<dnn::AlgorithmDesc>* out_algorithms);
+
+  // Get the list of supported algorithms for BLAS gemm.
+  bool GetBlasGemmAlgorithms(Stream* stream,
+                             std::vector<blas::AlgorithmType>* out_algorithms);
+
+  // Create an RNN descriptor based on model shapes and configurations.
+  // The caller retains the ownership of the descriptor.
+  tsl::StatusOr<std::unique_ptr<dnn::RnnDescriptor>> createRnnDescriptor(
+      int num_layers, int hidden_size, int input_size, int cell_size,
+      int batch_size, dnn::RnnInputMode input_mode,
+      dnn::RnnDirectionMode direction_mode, dnn::RnnMode rnn_mode,
+      dnn::DataType data_type, const dnn::AlgorithmConfig& algorithm_config,
+      const NumericOptions& numeric_options, float dropout, uint64_t seed,
+      ScratchAllocator* state_allocator, bool use_padded_io);
+
+  // Create a RNN sequence descriptor that specifies either the input or output
+  // sequence. The caller retains the ownership of the returned descriptor.
+  tsl::StatusOr<std::unique_ptr<dnn::RnnSequenceTensorDescriptor>>
+  createRnnSequenceTensorDescriptor(int max_seq_length, int batch_size,
+                                    int data_size, dnn::DataType data_type);
+
+  tsl::StatusOr<std::unique_ptr<dnn::RnnSequenceTensorDescriptor>>
+  createRnnSequenceTensorDescriptor(int max_seq_length, int batch_size,
+                                    int data_size,
+                                    const absl::Span<const int>& seq_lengths,
+                                    bool time_major, dnn::DataType data_type);
+
+  // Create an RNN state descriptor that specifies the input or hidden state.
+  // The caller retains the ownership of the returned descriptor.
+  tsl::StatusOr<std::unique_ptr<dnn::RnnStateTensorDescriptor>>
+  createRnnStateTensorDescriptor(int num_layer, int batch_size, int data_size,
+                                 dnn::DataType data_type);
+
+  // Returns the device ordinal that this StreamExecutor was initialized with.
+  // Meaningless before initialization.
+  int device_ordinal() const { return device_ordinal_; }
+
+  // Returns a borrowed pointer to the underlying StreamExecutor implementation.
+  internal::StreamExecutorInterface* implementation();
+
+  // Creates a kernel which can be launched with stream.ThenLaunch, such that
+  // the types of the arguments provided for launch would have to match
+  // types of the arguments provided at creation time.
+  //
+  // The kernel has a name kernel_name, and is based from provided PTX in ptx,
+  // and (optional) compiled PTX in cubin_data.
+  // The canonical storage for both ptx and cubin_data should outlive the
+  // lifetime of the kernel.
+  template <typename... Args>
+  tsl::StatusOr<std::unique_ptr<TypedKernel<Args...>>> CreateTypedKernel(
+      absl::string_view kernel_name, absl::string_view ptx,
+      absl::Span<const uint8_t> cubin_data);
+
+  // Warning: use Stream::ThenLaunch instead, this method is not for general
+  // consumption. However, this is the only way to launch a kernel for which
+  // the type signature is only known at runtime; say, if an application
+  // supports loading/launching kernels with arbitrary type signatures.
+  // In this case, the application is expected to know how to do parameter
+  // packing that obeys the contract of the underlying platform implementation.
+  //
+  // Launches a data parallel kernel with the given thread/block
+  // dimensionality and already-packed args/sizes to pass to the underlying
+  // platform driver.
+  //
+  // This is called by Stream::Launch() to delegate to the platform's launch
+  // implementation in StreamExecutorInterface::Launch().
+  tsl::Status Launch(Stream* stream, const ThreadDim& thread_dims,
+                     const BlockDim& block_dims, const KernelBase& kernel,
+                     const KernelArgsArrayBase& args);
+
+  // Submits command buffer for execution to the underlying platform driver.
+  tsl::Status Submit(Stream* stream, const CommandBuffer& command_buffer);
+
+  // Gets-or-creates (creates with memoization) a FftSupport datatype that can
+  // be used to execute FFT routines on the current platform.
+  //
+  // Ownership and user-facing is the same as AsBlas() below.
+  //
+  // Returns null if there was an error initializing the FFT support for the
+  // underlying platform.
+  fft::FftSupport* AsFft();
+
+  // Gets-or-creates (creates with memoization) a DnnSupport datatype that can
+  // be used for neural network routines on the current platform.
+  //
+  // Ownership and user-facing is the same as AsBlas() below.
+  //
+  // Returns null if there was an error initializing the DNN support for the
+  // underlying platform.
+  dnn::DnnSupport* AsDnn();
+
+  // Gets-or-creates (creates with memoization) a BlasSupport datatype that can
+  // be used to execute BLAS routines on the current platform. This is typically
+  // not user-facing, as users will use the Stream::ThenBlas* family of routines
+  // to entrain BLAS operations. See blas.h for additional details.
+  //
+  // Ownership is not transferred to the caller -- ownership is retained by this
+  // object for memoization. This BLAS interface is also only expected to be
+  // used by a Stream for entraining calls to BLAS functionality.
+  //
+  // Returns null if there was an error initializing the BLAS support for the
+  // underlying platform.
+  blas::BlasSupport* AsBlas();
+
+  // Registers a trace listener to receive callbacks for only a single
+  // StreamExecutor instance.
+  // To register a listener for all executors for a given platform, see
+  // Platform::RegisterTraceListener().
+  // Does not take ownership of listener.
+  void RegisterTraceListener(TraceListener* listener);
+
+  // Removes a TraceListener from this StreamExecutor instance.
+  // Returns false (and logs) in cases where the argument listener was not
+  // previously registered.
+  bool UnregisterTraceListener(TraceListener* listener);
+
+  // Return allocator statistics.
+  std::optional<AllocatorStats> GetAllocatorStats();
+
+  // Clears the internal stats except for the `in_use` fields
+  // and sets the `peak_bytes_in_use` to be equal to the `bytes_in_use`.
+  bool ClearAllocatorStats();
+
+  // Return an allocator which delegates to this stream executor for memory
+  // allocation.
+  StreamExecutorMemoryAllocator* GetAllocator() { return &allocator_; }
+
+  // Returns a stream allocated by this executor, or nullptr if not found.
+  // Performs linear search over alive GPU streams.
+  Stream* FindAllocatedStream(void* gpu_stream);
+
+ private:
+  template <typename BeginCallT, typename CompleteCallT, typename ReturnT,
+            typename... BeginArgsT>
+  friend class ScopedTracer;
+  friend class Event;
+  friend class Stream;
+  template <typename... Params>
+  friend class TypedKernel;
+  template <typename... Args>
+  friend struct ThenBlasImpl;
+
+  // Synchronously allocates size bytes on the underlying platform and returns
+  // a DeviceMemoryBase representing that allocation. In the case of failure,
+  // nullptr is returned.
+  DeviceMemoryBase Allocate(uint64_t size, int64_t memory_space);
+
+  void* GetUntypedSubBuffer(DeviceMemoryBase* parent, uint64_t offset,
+                            uint64_t size);
+
+  // Causes the host code to synchronously wait for operations entrained
+  // onto stream to complete. Effectively a join on the asynchronous device
+  // operations enqueued on the stream before this program point.
+  tsl::Status BlockHostUntilDone(Stream* stream);
+
+  // Without blocking the device, retrieve the current stream status.
+  tsl::Status GetStatus(Stream* stream);
+
+  // Finds and retrieves device memory for the symbol on the underlying
+  // platform.
+  bool GetSymbol(const std::string& symbol_name, ModuleHandle module_handle,
+                 void** mem, size_t* bytes);
+
+  // Entrains a memcpy operation onto stream, with a host destination location
+  // host_dst and a device memory source, with target size size.
+  bool Memcpy(Stream* stream, void* host_dst,
+              const DeviceMemoryBase& device_src, uint64_t size);
+
+  // Entrains a memcpy operation onto stream, with a device destination location
+  // and a host memory source, with target size size.
+  bool Memcpy(Stream* stream, DeviceMemoryBase* device_dst,
+              const void* host_src, uint64_t size);
+
+  // Entrains a memcpy operation onto stream, with a device destination location
+  // and a device source location, with target size size. Peer access should
+  // have been enabled between the StreamExecutors owning the device memory
+  // regions.
+  bool MemcpyDeviceToDevice(Stream* stream, DeviceMemoryBase* device_dst,
+                            const DeviceMemoryBase& device_src, uint64_t size);
+
+  // Entrains on a stream a user-specified function to be run on the host.
+  // See Stream::ThenDoHostCallback for full details.
+  // This is the preferred form for a callback that may return an error.
+  bool HostCallback(Stream* stream,
+                    absl::AnyInvocable<tsl::Status() &&> callback);
+
+  // Performs platform-specific allocation and initialization of an event.
+  tsl::Status AllocateEvent(Event* event);
+
+  // Performs platform-specific deallocation and cleanup of an event.
+  tsl::Status DeallocateEvent(Event* event);
+
+  // Inserts the specified event at the end of the specified stream.
+  tsl::Status RecordEvent(Stream* stream, Event* event);
+
+  // Wait for the specified event at the end of the specified stream.
+  tsl::Status WaitForEvent(Stream* stream, Event* event);
+
+  // Wait for the specified event at the end of the raw platform-specific
+  // stream. Currently only implemented for GPU, where stream is a
+  // GpuStreamHandle (e.g. cudaStream_t).
+  tsl::Status WaitForEventOnExternalStream(std::intptr_t stream, Event* event);
+
+  // Requests the current status of the event from the underlying platform.
+  Event::Status PollForEventStatus(Event* event);
+
+  // Allocates stream resources on the underlying platform and initializes its
+  // internals.
+  bool AllocateStream(Stream* stream);
+
+  // Deallocates stream resources on the underlying platform.
+  void DeallocateStream(Stream* stream);
+
+  // Causes dependent to not begin execution until other has finished its
+  // last-enqueued work.
+  bool CreateStreamDependency(Stream* dependent, Stream* other);
+
+  // Allocates a new metadata object, appropriately populated, on the heap, with
+  // ownership transfer to caller.
+  std::unique_ptr<DeviceDescription> CreateDeviceDescription() const;
+
+  // Adds a task to the tsl::thread::ThreadPool work queue. These tasks must be
+  // fire-and-forget and have no external data or timing dependencies; their
+  // execution order and completion time have no guarantees.
+  // For an example of an appropriate task, see HostBlas::DoBlasGemmInternal;
+  // there, temporary internal buffers are freed using this method.
+  void EnqueueOnBackgroundThread(std::function<void()> task);
+
+  // Calls the relevant TraceListener routine to begin tracing for the specified
+  // asynchronous method.
+  template <typename TraceCallT, typename... ArgsT>
+  void SubmitTrace(TraceCallT trace_call, ArgsT&&... args);
+
+  // Reader/writer lock for class-static StreamExecutor members.
+  static absl::Mutex static_mu_;
+
+  // Reader/writer lock for mutable data structures on this StreamExecutor.
+  //
+  // Mutable so that caching functions (like DeviceDescription, AsBlas, etc.)
+  // can acquire the lock on their first (mutating) call as well.
+  mutable absl::Mutex mu_;
+
+  // Reference to the platform that created this executor.
+  const Platform* platform_;
+
+  // Pointer to the platform-specific-interface implementation. This is
+  // delegated to by the interface routines in pointer-to-implementation
+  // fashion.
+  std::unique_ptr<internal::StreamExecutorInterface> implementation_;
+
+  // Memoized BLAS support object -- we only want to create this once when asked
+  // for a BLAS interface.
+  std::unique_ptr<blas::BlasSupport> blas_ ABSL_GUARDED_BY(mu_);
+
+  // Memoized DNN support object -- we only want to create this once when asked
+  // for an DNN interface.
+  std::unique_ptr<dnn::DnnSupport> dnn_ ABSL_GUARDED_BY(mu_);
+
+  // Memoized FFT support object -- we only want to create this once when asked
+  // for a FFT interface.
+  std::unique_ptr<fft::FftSupport> fft_;
+
+  // Slot to cache the owned DeviceDescription for the underlying device
+  // once it has been queried from DeviceDescription().
+  mutable std::unique_ptr<DeviceDescription> device_description_
+      ABSL_GUARDED_BY(mu_);
+
+  // The device ordinal that this object was initialized with.
+  //
+  // Immutable post-initialization.
+  int device_ordinal_;
+
+  // Executor for handling host callback work that cannot be performed
+  // by a host callback thread - for example, cleanup after a host BLAS routine
+  // (which may make device API calls). This work cannot block the host
+  // callback thread, will be completed asynchronously, and should be treated
+  // as fire-and-forget. Assume no ordering guarantees WRT the tasks enqueued
+  // here.
+  //
+  // Immutable post-initialization. Object is thread-safe.
+  std::unique_ptr<tsl::thread::ThreadPool> background_threads_;
+
+  // Counter for the current number of live streams. This is used to check
+  // for accidentally-outstanding streams at StreamExecutor teardown time, as
+  // well
+  // as to indicate leaks (via a large outstanding count being logged) in the
+  // case we can't allocate more streams.
+  std::atomic_int_fast32_t live_stream_count_;
+
+  // Only one worker thread is needed; little work will be done by the
+  // executor.
+  static constexpr int kNumBackgroundThreads = 1;
+
+  // Indicates if StreamExecutor operation tracing should be performed.
+  bool tracing_enabled_;
+
+  // The set of TraceListeners registered for this StreamExecutor.
+  std::set<TraceListener*> listeners_ ABSL_GUARDED_BY(mu_);
+
+  // Memory limit in bytes. Value less or equal to 0 indicates there is no
+  // limit.
+  int64_t memory_limit_bytes_;
+
+  StreamExecutorMemoryAllocator allocator_;
+
+  StreamExecutor(const StreamExecutor&) = delete;
+  void operator=(const StreamExecutor&) = delete;
+};
+
+// A wrapper around ModuleHandle that uses RAII to manage its lifetime.
+class ScopedModuleHandle {
+ public:
+  explicit ScopedModuleHandle(StreamExecutor* executor,
+                              ModuleHandle module_handle)
+      : executor_(executor), module_handle_(module_handle) {}
+
+  ScopedModuleHandle(ScopedModuleHandle&& other) {
+    executor_ = other.executor_;
+    module_handle_ = other.module_handle_;
+    other.executor_ = nullptr;
+    other.module_handle_ = ModuleHandle();
+  }
+
+  ScopedModuleHandle& operator=(ScopedModuleHandle&& other) {
+    executor_ = other.executor_;
+    module_handle_ = other.module_handle_;
+    other.executor_ = nullptr;
+    other.module_handle_ = ModuleHandle();
+    return *this;
+  }
+
+  ~ScopedModuleHandle() {
+    if (static_cast<bool>(module_handle_)) {
+      CHECK(executor_->UnloadModule(module_handle_));
+    }
+  }
+
+ private:
+  StreamExecutor* executor_;
+  ModuleHandle module_handle_;
+
+  ScopedModuleHandle(const ScopedModuleHandle&) = delete;
+  void operator=(const ScopedModuleHandle&) = delete;
+};
+
+////////////
+// Inlines
+
+template <typename... Args>
+inline tsl::StatusOr<std::unique_ptr<TypedKernel<Args...>>>
+StreamExecutor::CreateTypedKernel(absl::string_view kernel_name,
+                                  absl::string_view ptx,
+                                  absl::Span<const uint8_t> cubin_data) {
+  auto kernel_base = std::make_unique<TypedKernel<Args...>>(this);
+  MultiKernelLoaderSpec loader_spec(kernel_base->kNumberOfParameters);
+  loader_spec.AddCudaPtxInMemory(ptx, kernel_name);
+
+  if (!cubin_data.empty()) {
+    loader_spec.AddCudaCubinInMemory(
+        reinterpret_cast<const char*>(cubin_data.data()), kernel_name);
+  }
+
+  TF_RETURN_IF_ERROR(GetKernel(loader_spec, kernel_base.get()));
+  return std::move(kernel_base);
+}
+
+template <typename T>
+inline DeviceMemory<T> StreamExecutor::AllocateArray(uint64_t element_count,
+                                                     int64_t memory_space) {
+  uint64_t bytes = sizeof(T) * element_count;
+  return DeviceMemory<T>(Allocate(bytes, memory_space));
+}
+
+template <typename ElemT>
+ScopedDeviceMemory<ElemT>::ScopedDeviceMemory(StreamExecutor* parent,
+                                              DeviceMemoryBase value)
+    : wrapped_(value),
+      device_ordinal_(parent->device_ordinal()),
+      allocator_(parent->GetAllocator()) {}
+
+template <typename ElemT>
+ScopedDeviceMemory<ElemT>::ScopedDeviceMemory(
+    StreamExecutor* parent, std::initializer_list<ElemT> values)
+    : ScopedDeviceMemory(parent, parent->AllocateArray<ElemT>(values.size())) {
+  if (ptr() != nullptr) {
+    std::vector<ElemT> local(values);
+    if (!parent->SynchronousMemcpy(ptr(), const_cast<const ElemT*>(&local[0]),
+                                   ptr()->size())) {
+      TF_CHECK_OK(Free());
+    }
+  }
+}
+
+template <typename T>
+DeviceMemory<T> StreamExecutor::GetSubBuffer(DeviceMemory<T>* parent,
+                                             uint64_t element_offset,
+                                             uint64_t element_count) {
+  if (element_offset + element_count > parent->ElementCount()) {
+    LOG(ERROR) << "requested sub-buffer allocation (offset + size) is greater "
+               << "than parent allocation size: (" << element_offset << " + "
+               << element_count << ") vs. (" << parent->ElementCount() << ")";
+    return DeviceMemory<T>{};
+  }
+
+  void* opaque = GetUntypedSubBuffer(parent, sizeof(T) * element_offset,
+                                     sizeof(T) * element_count);
+  if (opaque == nullptr) {
+    return DeviceMemory<T>{};
+  }
+  return DeviceMemory<T>(DeviceMemoryBase(opaque, sizeof(T) * element_count));
+}
+
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_STREAM_EXECUTOR_PIMPL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/temporary_device_memory.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/temporary_device_memory.h
new file mode 100644
index 0000000000000000000000000000000000000000..b12fd2efceb2c49809511d7a632fbc519bcee2a4
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/temporary_device_memory.h
@@ -0,0 +1,136 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// Temporary memories are used to allocate scratch space required by an
+// operation about to be enqueued onto a stream.
+//
+//    std::unique_ptr<TemporaryDeviceMemory<float>> temporary_memory =
+//        stream.AllocateTemporaryArray<float>(1024).value();
+//    // ... enqueue stuff onto the stream using the temporary memory ...
+//    // Note that the memory is accessible via
+//    // temporary_memory->device_memory() and similar.
+//
+//    // Finalize the temporary memory. The underlying device memory may
+//    // be released any time after this program point, as another thread may
+//    // call Stream::BlockHostUntilDone, causing synchronization. This
+//    // finalization also happens automatically for the user if the unique_ptr
+//    // goes out of scope.
+//    temporary_memory.Finalize();
+//
+// WARNING: do NOT hold onto the device memory associated with temporary_memory
+// after finalization. If temporary_memory->device_memory() is used after the
+// temporary memory is finalized, it will cause a DCHECK failure.
+//
+// Note that standard usage takes advantage of the type-safe wrapper,
+// TemporaryDeviceMemory<T>, defined below.
+//
+// Also see tests for executable sample usage.
+
+#ifndef XLA_STREAM_EXECUTOR_TEMPORARY_DEVICE_MEMORY_H_
+#define XLA_STREAM_EXECUTOR_TEMPORARY_DEVICE_MEMORY_H_
+
+#include "xla/stream_executor/device_memory.h"
+
+namespace stream_executor {
+
+class Stream;
+namespace internal {
+class TemporaryMemoryManager;
+}
+
+// Untyped base class (analogous to a void*) for temporary device memory
+// allocations associated with a stream.
+class TemporaryDeviceMemoryBase {
+ public:
+  // Marks the temporary memory as finalized if it is not already marked as
+  // such.
+  ~TemporaryDeviceMemoryBase();
+
+  // Precondition: !IsFinalized()
+  DeviceMemoryBase* mutable_device_memory();
+
+  // Precondition: !IsFinalized()
+  const DeviceMemoryBase& device_memory() const;
+
+  // "Finalizes" this temporary memory, making it acceptable to release at the
+  // next stream synchronization point -- the device memory can be reclaimed at
+  // any time after the temporary memory is marked as finalized (e.g. if a
+  // separate thread is calls Stream::BlockHostUntilDone). This may only be
+  // called once -- see the precondition below.
+  //
+  // Precondition: !IsFinalized()
+  void Finalize();
+
+  // Returns true iff the temporary memory is finalized (that is, the user is
+  // done referring to the temporary device memory, and thus it can be released
+  // at the next stream synchronization point).
+  bool IsFinalized() const;
+
+  // Returns true iff the temporary memory is still allocated.
+  //
+  // Note: this is a polling call, no guarantee is made that the temporary
+  // memory is still allocated after the call has completed.
+  bool IsAllocated() const;
+
+ private:
+  friend class internal::TemporaryMemoryManager;
+  friend class TemporaryDeviceMemoryTest;
+
+  // Note: construction DCHECKs that the memory is known-allocated in the
+  // stream's temporary-allocation-manager.
+  TemporaryDeviceMemoryBase(Stream* parent, DeviceMemoryBase device_memory,
+                            uint64_t allocation_generation);
+
+  // The device memory region that has allocated.
+  DeviceMemoryBase device_memory_;
+
+  // The generation counter value for the temporary memory record in the
+  // temporary memory manager.
+  uint64_t allocation_generation_;
+
+  // The stream that this temporary memory was allocated for.
+  Stream* parent_;
+};
+
+// Type-safe wrapper around the base type (which is analogous to a void*).
+template <typename T>
+class TemporaryDeviceMemory : public TemporaryDeviceMemoryBase {
+ public:
+  // Type-safe wrapper around TemporaryDeviceMemoryBase::mutable_device_memory.
+  DeviceMemory<T>* mutable_device_memory() {
+    StaticSlicingAssertionDummy();
+    return reinterpret_cast<DeviceMemory<T>*>(
+        TemporaryDeviceMemoryBase::mutable_device_memory());
+  }
+
+  // Type-safe wrapper around TemporaryDeviceMemoryBase::device_memory.
+  const DeviceMemory<T>& device_memory() const {
+    StaticSlicingAssertionDummy();
+    return reinterpret_cast<const DeviceMemory<T>&>(
+        TemporaryDeviceMemoryBase::device_memory());
+  }
+
+ private:
+  static void StaticSlicingAssertionDummy() {
+    static_assert(
+        sizeof(TemporaryDeviceMemory) == sizeof(TemporaryDeviceMemoryBase),
+        "derived class is simply a wrapper, no members may be added due to "
+        "slicing");
+  }
+};
+
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_TEMPORARY_DEVICE_MEMORY_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/temporary_memory_manager.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/temporary_memory_manager.h
new file mode 100644
index 0000000000000000000000000000000000000000..6a82fe0667235a5b3da7fc4a8624fa3e11d96066
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/temporary_memory_manager.h
@@ -0,0 +1,153 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// The temporary-memory-manager is a helper class for a Stream to keep track of
+// temporary allocations. These allocations defer their deallocation to the next
+// Stream::BlockHostUntilDone call for efficiency purposes (as deallocation
+// itself generally forces synchronization to occur).
+
+#ifndef XLA_STREAM_EXECUTOR_TEMPORARY_MEMORY_MANAGER_H_
+#define XLA_STREAM_EXECUTOR_TEMPORARY_MEMORY_MANAGER_H_
+
+#include <map>
+#include <memory>
+#include <utility>
+
+#include "absl/base/thread_annotations.h"
+#include "absl/synchronization/mutex.h"
+#include "xla/stream_executor/device_memory.h"
+#include "xla/stream_executor/temporary_device_memory.h"
+#include "tsl/platform/status.h"
+#include "tsl/platform/statusor.h"
+
+namespace stream_executor {
+namespace internal {
+
+// Record used inside the TemporaryMemoryManager as metadata for a given device
+// memory region.
+struct TemporaryMemoryRecord {
+  // What "generation" this record was allocated in.
+  //
+  // Currently the generation counter is bumped for every allocation, but this
+  // could be made coarser if necessary.
+  uint64_t allocation_generation;
+
+  // Notes whether the temporary memory has been marked as finalized, such that
+  // we can release the DeviceMemory associated with this record at
+  // synchronization time.
+  bool finalized;
+};
+
+// Manages temporary memories associated with a stream -- keeps records of
+// outstanding temporaries and their state, and can deallocate them
+// appropriately at points in the Stream lifecycle (e.g. BlockHostUntilDone,
+// destruction).
+class TemporaryMemoryManager {
+ public:
+  explicit TemporaryMemoryManager(Stream* stream) : stream_(stream) {}
+
+  // Allocates a temporary array that is then managed by this object.
+  template <typename T>
+  tsl::StatusOr<std::unique_ptr<TemporaryDeviceMemory<T>>> AllocateArray(
+      uint64_t element_count);
+
+  // Forces deallocation of all managed temporary memory regions.
+  //
+  // Called, for example, when the Stream owning this temporary memory manager
+  // is destroyed.
+  //
+  // Note: These calls to Deallocate will likely force synchronization.
+  void ForceDeallocateAll();
+
+  // Marks the given memory region as finalized.
+  //
+  // If must_exist is set, this will check-fail if the temporary memory record
+  // is not found.
+  void MarkFinalized(const DeviceMemoryBase& device_memory, uint64_t generation,
+                     bool must_exist);
+
+  // Deallocates temporary memories that have been finalized.
+  //
+  // Note: These calls to Deallocate will likely force synchronization, so it is
+  // meant to be called before a "BlockHostUntilDone" is about to be performed.
+  void DeallocateFinalizedTemporaries();
+
+  // Returns whether the provided device_memory is finalized.
+  //
+  // In the vacuous case where the device memory doesn't appear in the temporary
+  // memory records, it is either not a temporary at all, or has already been
+  // deallocated, and thus returns true.
+  bool IsFinalized(const DeviceMemoryBase& device_memory,
+                   uint64_t allocation_generation) const;
+
+  // Returns whether the manager has a live allocation record for the given
+  // device memory pointer with the given generation counter.
+  //
+  // Note: this is a polling call -- there is no guarantee that the region is
+  // still allocated once the call has completed.
+  bool HasAllocated(const DeviceMemoryBase& device_memory,
+                    uint64_t generation) const;
+
+ private:
+  // Allocates an array without type parameterization, so that the
+  // implementation can live in the source file. Without this base allocation
+  // method, we incur a circular dependency between the StreamExecutor
+  // definition and this class' definition.
+  tsl::StatusOr<std::unique_ptr<TemporaryDeviceMemoryBase>> AllocateArrayBase(
+      uint64_t element_count, uint64 element_size);
+
+  // Mutex to guard temporary record state.
+  mutable absl::Mutex mutex_;
+
+  // Mapping from device memory to the current (live) temporary memory record.
+  //
+  // If a device memory is not in this mapping, it is not a temporary currently
+  // allocated and owned by this temporary memory manager.
+  std::map<DeviceMemoryBase, TemporaryMemoryRecord> records_
+      ABSL_GUARDED_BY(mutex_);
+
+  // Allocation generation -- we bump this counter to distinguish temporary
+  // memory handles that have been deallocated and later reallocated at the same
+  // device memory address.
+  uint64_t generation_ ABSL_GUARDED_BY(mutex_);
+
+  // The stream (parent object) for this temporary memory manager -- allocations
+  // are performed through this stream handle.
+  Stream* stream_;
+
+  TemporaryMemoryManager(const TemporaryMemoryManager&) = delete;
+  void operator=(const TemporaryMemoryManager&) = delete;
+};
+
+////////////
+// Inlines
+
+template <typename T>
+tsl::StatusOr<std::unique_ptr<TemporaryDeviceMemory<T>>>
+TemporaryMemoryManager::AllocateArray(uint64_t element_count) {
+  tsl::StatusOr<std::unique_ptr<TemporaryDeviceMemoryBase>> temporary_memory =
+      AllocateArrayBase(element_count, sizeof(T));
+  if (!temporary_memory.ok()) {
+    return temporary_memory.status();
+  }
+
+  return std::unique_ptr<TemporaryDeviceMemory<T>>(
+      reinterpret_cast<TemporaryDeviceMemory<T>*>(temporary_memory->release()));
+}
+
+}  // namespace internal
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_TEMPORARY_MEMORY_MANAGER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/tf_allocator_adapter.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/tf_allocator_adapter.h
new file mode 100644
index 0000000000000000000000000000000000000000..5293e4639dc82de48a8d730cd051c984ebb81242
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/tf_allocator_adapter.h
@@ -0,0 +1,156 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_STREAM_EXECUTOR_TF_ALLOCATOR_ADAPTER_H_
+#define XLA_STREAM_EXECUTOR_TF_ALLOCATOR_ADAPTER_H_
+
+#include <memory>
+#include <tuple>
+#include <utility>
+#include <vector>
+
+#include "xla/stream_executor/device_memory.h"
+#include "xla/stream_executor/device_memory_allocator.h"
+#include "xla/stream_executor/platform.h"
+#include "xla/stream_executor/stream.h"
+#include "xla/stream_executor/stream_executor.h"
+#include "tsl/framework/allocator.h"
+#include "tsl/platform/statusor.h"
+
+namespace stream_executor {
+
+// Adapter class that wraps a Tensorflow allocator.
+//
+// Assumes that the Tensorflow allocator permits asynchronous deallocation:
+// see comment on `AllowsAsynchronousDeallocation()`.
+class TfAllocatorAdapter : public DeviceMemoryAllocator {
+ public:
+  // stream: a Stream on which the allocator can only be used. If non-null, the
+  // allocator can not be used on any other stream.
+  TfAllocatorAdapter(tsl::Allocator *wrapped, Stream *stream);
+
+  // Constructor for the cases where `stream` can not be provided.
+  TfAllocatorAdapter(tsl::Allocator *wrapped, Platform *platform);
+
+  ~TfAllocatorAdapter() override;
+
+  tsl::StatusOr<OwningDeviceMemory> Allocate(int device_ordinal, uint64_t size,
+                                             bool retry_on_failure,
+                                             int64_t memory_space) override;
+
+  tsl::Status Deallocate(int device_ordinal, DeviceMemoryBase mem) override;
+
+  // The Tensorflow BFC allocator used on GPU allows host-side deallocation
+  // before GPU execution takes place. Tensorflow uses the ordering of the main
+  // compute stream to enforce a happens-before relationship between a memory
+  // allocation and code that reuses the same memory. If Tensorflow adds
+  // support for multiple GPU streams or allocators with different ordering
+  // requirements, this code may need to change.
+  // (This attribute has no effect on CPU.)
+  bool AllowsAsynchronousDeallocation() const override { return true; }
+
+  tsl::StatusOr<Stream *> GetStream(int device_ordinal) override;
+
+  tsl::StatusOr<tsl::Allocator *> GetAllocator(int device_ordinal);
+
+ private:
+  tsl::Allocator *wrapped_;
+  Stream *stream_;
+};
+
+// Adapter class that wraps per-device TF allocators with corresponding streams
+// as a TfAllocatorAdapter. Assumes that the Tensorflow allocator permits
+// asynchronous deallocation; see comment on `AllowsAsynchronousDeallocation()`.
+class MultiDeviceAdapter : public DeviceMemoryAllocator {
+ public:
+  using AllocatorWithStream =
+      std::pair<std::unique_ptr<tsl::Allocator>, Stream *>;
+  using AllocatorWithLogicalIdAndStream =
+      std::tuple<std::unique_ptr<tsl::Allocator>, int, Stream *>;
+
+  MultiDeviceAdapter(const Platform *platform,
+                     std::vector<AllocatorWithStream> tf_allocators)
+      : DeviceMemoryAllocator(platform) {
+    tf_allocators_.reserve(tf_allocators.size());
+    for (AllocatorWithStream &p : tf_allocators) {
+      int device_ordinal = p.second->parent()->device_ordinal();
+      if (per_device_allocators_.size() <= device_ordinal) {
+        per_device_allocators_.resize(device_ordinal + 1);
+      }
+      CHECK(!per_device_allocators_[device_ordinal]);
+      per_device_allocators_[device_ordinal] =
+          std::make_unique<TfAllocatorAdapter>(p.first.get(), p.second);
+      tf_allocators_.push_back(std::move(p.first));
+    }
+  }
+
+  MultiDeviceAdapter(const Platform *platform,
+                     std::vector<AllocatorWithLogicalIdAndStream> tf_allocators)
+      : DeviceMemoryAllocator(platform) {
+    tf_allocators_.reserve(tf_allocators.size());
+    for (AllocatorWithLogicalIdAndStream &t : tf_allocators) {
+      const int device_ordinal = std::get<1>(t);
+      Stream *stream = std::get<2>(t);
+      if (per_device_allocators_.size() <= device_ordinal) {
+        per_device_allocators_.resize(device_ordinal + 1);
+      }
+      CHECK(!per_device_allocators_[device_ordinal]);
+      per_device_allocators_[device_ordinal] =
+          std::make_unique<TfAllocatorAdapter>(std::get<0>(t).get(), stream);
+      tf_allocators_.push_back(std::move(std::get<0>(t)));
+    }
+  }
+
+  tsl::StatusOr<OwningDeviceMemory> Allocate(int device_ordinal, uint64_t size,
+                                             bool retry_on_failure,
+                                             int64_t memory_space) override {
+    CHECK_LT(device_ordinal, per_device_allocators_.size());
+    return per_device_allocators_[device_ordinal]->Allocate(
+        device_ordinal, size, retry_on_failure, memory_space);
+  }
+
+  tsl::Status Deallocate(int device_ordinal, DeviceMemoryBase mem) override {
+    CHECK_LT(device_ordinal, per_device_allocators_.size());
+    return per_device_allocators_[device_ordinal]->Deallocate(device_ordinal,
+                                                              mem);
+  }
+
+  // The Tensorflow BFC allocator used on GPU allows host-side deallocation
+  // before GPU execution takes place. Tensorflow uses the ordering of the main
+  // compute stream to enforce a happens-before relationship between a memory
+  // allocation and code that reuses the same memory. If Tensorflow adds
+  // support for multiple GPU streams or allocators with different ordering
+  // requirements, this code may need to change.
+  // (This attribute has no effect on CPU.)
+  bool AllowsAsynchronousDeallocation() const override { return true; }
+
+  tsl::StatusOr<Stream *> GetStream(int device_ordinal) override {
+    return per_device_allocators_[device_ordinal]->GetStream(device_ordinal);
+  }
+
+  tsl::StatusOr<tsl::Allocator *> GetAllocator(int device_ordinal) {
+    return per_device_allocators_[device_ordinal]->GetAllocator(device_ordinal);
+  }
+
+ private:
+  std::vector<std::unique_ptr<TfAllocatorAdapter>> per_device_allocators_;
+  // The wrapped TF allocators backing per_device_allocators_
+  // (TfAllocatorAdapter does not take ownership of its underlying Allocator).
+  std::vector<std::unique_ptr<tsl::Allocator>> tf_allocators_;
+};
+
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_TF_ALLOCATOR_ADAPTER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/tpu/c_api_conversions.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/tpu/c_api_conversions.h
new file mode 100644
index 0000000000000000000000000000000000000000..47b9f99551dcd24315bef12fee9a2655fcf722bb
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/tpu/c_api_conversions.h
@@ -0,0 +1,161 @@
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_STREAM_EXECUTOR_TPU_C_API_CONVERSIONS_H_
+#define XLA_STREAM_EXECUTOR_TPU_C_API_CONVERSIONS_H_
+
+#include <array>
+#include <memory>
+#include <vector>
+
+#include "xla/executable_run_options.h"
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/literal.h"
+#include "xla/service/hlo_module_config.h"
+#include "xla/service/maybe_owning_device_memory.h"
+#include "xla/service/shaped_buffer.h"
+#include "xla/shape.h"
+#include "xla/shape_util.h"
+#include "xla/statusor.h"
+#include "xla/stream_executor/device_memory.h"
+#include "xla/stream_executor/tpu/c_api_decl.h"
+
+// APIs for converting between internal and external versions of
+// XLA/StreamExecutor data structures.
+namespace ApiConverter {
+
+absl::Span<const float> MakeSpan(const FloatList& src_list);
+void CreateVector(absl::Span<const float> src, FloatList* dst);
+void Destroy(FloatList* float_list);
+
+absl::Span<const int64_t> MakeSpan(const Int64List& src_list);
+void CreateVector(absl::Span<const int64_t> src, Int64List* dst);
+
+absl::Span<const int> MakeSpan(const IntList& src_list);
+void CreateVector(absl::Span<const int> src, IntList* dst);
+
+absl::Span<const bool> MakeSpan(const BoolList& src_list);
+void CreateVector(absl::Span<const bool> src, BoolList* dst);
+
+void CreateVector(absl::Span<const xla::DimLevelType> src, IntList* dst);
+
+// se::DeviceMemoryBase
+SE_DeviceMemoryBase ToC(const stream_executor::DeviceMemoryBase& base);
+void ToC(const stream_executor::DeviceMemoryBase& base,
+         SE_DeviceMemoryBase* se_base);
+stream_executor::DeviceMemoryBase FromC(const SE_DeviceMemoryBase& se_base);
+void Destroy(SE_DeviceMemoryBase*);
+
+// xla::Tile
+xla::Tile FromC(const XLA_Tile* c_tile);
+void ToC(const xla::Tile& xla_tile, XLA_Tile* c_tile);
+void Destroy(XLA_Tile* c_tile);
+
+// xla::Layout
+xla::Layout FromC(const XLA_Layout* c_layout);
+void ToC(const xla::Layout& xla_layout, XLA_Layout* c_layout);
+void Destroy(XLA_Layout* c_layout);
+
+// xla::Shape
+xla::Shape FromC(const XLA_Shape* c_shape);
+void ToC(const xla::Shape& xla_shape, XLA_Shape* c_shape);
+void Destroy(XLA_Shape* c_shape);
+
+// xla::ShapeIndex
+XLA_ShapeIndex ToC(const xla::ShapeIndex& xla_shape);
+xla::ShapeIndex FromC(XLA_ShapeIndex* c_shape);
+void Destroy(XLA_ShapeIndex*);
+
+// Literal
+void ToC(const xla::LiteralSlice& literal, XLA_Literal* c_literal);
+xla::MutableBorrowingLiteral FromC(XLA_Literal* c_literal);
+void Destroy(XLA_Literal* c_literal);
+
+// ShapedBuffer
+void ToC(const xla::ShapedBuffer& buffer, XLA_ShapedBuffer* c_device_buffer);
+xla::ShapedBuffer FromC(XLA_ShapedBuffer* c_buffer);
+void Destroy(XLA_ShapedBuffer* c_buffer);
+
+// se::DeviceMemoryBase
+SE_DeviceMemoryBase ToC(const stream_executor::DeviceMemoryBase& base);
+stream_executor::DeviceMemoryBase FromC(const SE_DeviceMemoryBase& se_base);
+void Destroy(SE_DeviceMemoryBase*);
+
+// Literal
+void ToC(const xla::LiteralSlice& literal, XLA_Literal* c_literal);
+xla::MutableBorrowingLiteral FromC(XLA_Literal* c_literal);
+void Destroy(XLA_Literal* c_literal);
+
+// ShapedBuffer
+void ToC(const xla::ShapedBuffer& buffer, XLA_ShapedBuffer* c_device_buffer);
+xla::ShapedBuffer FromC(XLA_ShapedBuffer* c_buffer);
+void Destroy(XLA_ShapedBuffer* c_buffer);
+
+// TpuEmbeddingEngineParametersData
+struct TpuEmbeddingEngineParametersData {
+  // Backing vector for struct
+  std::array<std::vector<FloatListRef*>, 8> vectors;
+  TpuEmbeddingEngineParameters c_params;
+};
+
+std::unique_ptr<TpuEmbeddingEngineParametersData> Create(int num_tables);
+
+xla::MaybeOwningDeviceMemory FromC(
+    SE_MaybeOwningDeviceMemory* se_mem,
+    stream_executor::DeviceMemoryAllocator* allocator);
+
+// DeviceMemoryAllocator
+SE_DeviceMemoryAllocator ToC(stream_executor::DeviceMemoryAllocator* allocator);
+
+// OwningDeviceMemory
+SE_MaybeOwningDeviceMemory ToC(stream_executor::OwningDeviceMemory* mem);
+// mem.HasOwnership() may be true if the buffer is aliased and shouldn't be
+// released. 'aliased' should be true in this case. 'aliased' has no effect if
+// 'mem' is unowned.
+SE_MaybeOwningDeviceMemory ToC(xla::MaybeOwningDeviceMemory& mem, bool aliased);
+
+// HloModule
+XLA_HloModule ToC(const xla::HloModule& module);
+xla::StatusOr<std::unique_ptr<xla::HloModule>> FromC(
+    const XLA_HloModule& c_module);
+void Destroy(XLA_HloModule* c_module);
+
+// HloModuleConfig
+XLA_HloModuleConfig ToC(const xla::HloModuleConfig& config);
+xla::HloModuleConfig FromC(const XLA_HloModuleConfig& c_config);
+void Destroy(XLA_HloModuleConfig* c_config);
+
+// Helper for managing stack based C -> C++ conversions.
+template <class CType>
+struct StackHelper {
+  explicit StackHelper() {}
+
+  template <class CppType>
+  explicit StackHelper(const CppType& t) {
+    ::ApiConverter::ToC(t, &value);
+  }
+  ~StackHelper() { ::ApiConverter::Destroy(&value); }
+
+  template <class CppType>
+  CppType AsCpp() const {
+    return ::ApiConverter::FromC(&value);
+  }
+
+  mutable CType value;
+};
+
+}  // namespace ApiConverter
+
+#endif  // XLA_STREAM_EXECUTOR_TPU_C_API_CONVERSIONS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/tpu/c_api_decl.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/tpu/c_api_decl.h
new file mode 100644
index 0000000000000000000000000000000000000000..bbeb12472ea8b00490928e453830d1ddb1ad4350
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/tpu/c_api_decl.h
@@ -0,0 +1,362 @@
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_STREAM_EXECUTOR_TPU_C_API_DECL_H_
+#define XLA_STREAM_EXECUTOR_TPU_C_API_DECL_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include "xla/stream_executor/tpu/libtftpu.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct TSL_Status TF_Status;
+
+// Maximum number of array elements to inline into structs for performance.
+#define TPU_C_API_MAX_INLINED 6
+
+typedef enum TpuCoreTypeEnum {
+  kTensorCore,
+  kEmbeddingV1,
+  kEmbeddingV2,
+} TpuCoreTypeEnum;
+
+typedef enum TpuVersionEnum {
+  kUnknownTpuVersion,
+  kTpuV2,
+  kTpuV3,
+  kTpuV4,
+  // BEGIN-INTERNAL
+  // reserved for internal use
+  // END-INTERNAL
+} TpuVersionEnum;
+
+typedef struct TpuRuntimeVersion {
+  // The three version numbers are: major, minor, patch
+  int version[3];
+  const char* metadata;
+  size_t metadata_size;
+} TpuRuntimeVersion;
+
+typedef struct SE_Platform SE_Platform;
+typedef struct SE_StreamExecutor SE_StreamExecutor;
+typedef struct SE_Stream SE_Stream;
+typedef struct SE_Event SE_Event;
+
+typedef struct TpuSerializedProto {
+  const char* bytes;
+  size_t size;
+} TpuSerializedProto;
+
+typedef struct SE_PlatformId {
+  void* id;  // aka stream_executor::Platform::Id
+} SE_PlatformId;
+typedef struct SE_StreamExecutorConfig SE_StreamExecutorConfig;
+typedef struct SE_DeviceOptions SE_DeviceOptions;
+typedef TF_Status* (*SE_StatusCallback)(void*);
+
+typedef struct SE_DeviceMemoryBase {
+  void* opaque;
+  uint64_t size;
+  uint64_t payload;
+} SE_DeviceMemoryBase;
+
+typedef struct SE_ScopedDeviceMemory {
+  SE_DeviceMemoryBase wrapped;
+  int device_ordinal;
+} SE_ScopedDeviceMemory;
+
+typedef struct SE_AllocatorStats {
+  int64_t num_allocs;
+  int64_t bytes_in_use;
+  int64_t peak_bytes_in_use;
+  int64_t largest_alloc_size;
+
+  bool has_bytes_limit;
+  int64_t bytes_limit;
+
+  int64_t bytes_reserved;
+  int64_t peak_bytes_reserved;
+
+  bool has_bytes_reservable_limit;
+  int64_t bytes_reservable_limit;
+
+  int64_t largest_free_block_bytes;
+} SE_AllocatorStats;
+
+// Note, due to the... odd way in which DeviceMemoryAllocator is used in TF, we
+// cannot simply wrap an underlying pointer. Instead, we reverse the call
+// direction and request memory via a callback.
+typedef void (*SE_AllocateFn)(void* ctx, int device_ordinal, uint64_t size,
+                              bool retry_on_failure, int64_t memory_space,
+                              SE_ScopedDeviceMemory* result, TF_Status* status);
+
+typedef void (*SE_DeallocateFn)(void* ctx, SE_DeviceMemoryBase* base,
+                                int device_ordinal, TF_Status* status);
+
+typedef struct SE_DeviceMemoryAllocator {
+  SE_Platform* platform;
+  void* ctx;
+  SE_AllocateFn allocate;
+  SE_DeallocateFn deallocate;
+} SE_DeviceMemoryAllocator;
+
+typedef struct SE_DeviceDescription {
+  char* device_vendor;
+  char* platform_version;
+  char* driver_version;
+  char* runtime_version;
+  char* pci_bus_id;
+  char* name;
+
+  int64_t thread_dim_limit_x;
+  int64_t thread_dim_limit_y;
+  int64_t thread_dim_limit_z;
+  int64_t block_dim_limit_x;
+  int64_t block_dim_limit_y;
+  int64_t block_dim_limit_z;
+
+  int64_t threads_per_core_limit;
+  int64_t threads_per_block_limit;
+  int64_t threads_per_warp;
+
+  int64_t registers_per_core_limit;
+  int64_t registers_per_block_limit;
+
+  int64_t device_address_bits;
+  int64_t device_memory_size;
+  int64_t memory_bandwidth;
+
+  int64_t shared_memory_per_core;
+  int64_t shared_memory_per_block;
+
+  float clock_rate_ghz;
+
+  int cuda_compute_capability_major;
+  int cuda_compute_capability_minor;
+
+  int numa_node;
+  int core_count;
+  bool ecc_enabled;
+} SE_DeviceDescription;
+
+typedef struct Tpu_Compiler Tpu_Compiler;
+typedef struct SE_Executable SE_Executable;
+
+typedef struct SE_ExecutableRunOptions {
+  SE_DeviceMemoryAllocator allocator;
+  int device_ordinal;
+  SE_Stream* stream;
+  SE_Stream* host_to_device_stream;
+  TpuSerializedProto device_assignment;
+  int rng_seed;
+  int64_t run_id;
+  int launch_id;
+} SE_ExecutableRunOptions;
+
+typedef struct SE_ExecutableSerializationHandle
+    SE_ExecutableSerializationHandle;
+
+typedef struct SE_MaybeOwningDeviceMemory {
+  SE_DeviceMemoryBase memory;
+  bool owned;
+
+  // Set if owned
+  int device_ordinal;
+  SE_DeviceMemoryAllocator allocator;
+} SE_MaybeOwningDeviceMemory;
+
+typedef struct IntList {
+  union {
+    int* heap;  // owned
+    int inlined[TPU_C_API_MAX_INLINED];
+  };
+  int64_t size;
+} IntList;
+
+typedef struct Int64List {
+  union {
+    int64_t* heap;  // owned
+    int64_t inlined[TPU_C_API_MAX_INLINED];
+  };
+  int64_t size;
+} Int64List;
+
+typedef struct FloatList {
+  union {
+    float* heap;  // owned
+    float inlined[TPU_C_API_MAX_INLINED];
+  };
+  int64_t size;
+} FloatList;
+
+typedef struct BoolList {
+  union {
+    bool* heap;  // owned
+    bool inlined[TPU_C_API_MAX_INLINED];
+  };
+  int64_t size;
+} BoolList;
+
+typedef struct FloatListRef {
+  float* ptr;  // not owned
+  int64_t size;
+} FloatListRef;
+
+typedef struct TpuEmbeddingEngineParameters {
+  FloatListRef** parameters[8];
+  size_t num_tables;
+} TpuEmbeddingEngineParameters;
+
+typedef struct XLA_Tile {
+  Int64List dimensions;
+} XLA_Tile;
+
+typedef struct TileList {
+  union {
+    XLA_Tile* heap;  // owned
+    XLA_Tile inlined[TPU_C_API_MAX_INLINED];
+  };
+  int64_t size;
+} TileList;
+
+typedef struct XLA_Layout {
+  Int64List minor_to_major;
+  IntList dim_level_types;
+  IntList dim_unique;
+  IntList dim_ordered;
+  TileList tiles;
+  int index_primitive_type;
+  int pointer_primitive_type;
+  int64_t element_size_in_bits;
+  int64_t memory_space;
+  int64_t dynamic_shape_metadata_prefix_bytes;
+} XLA_Layout;
+
+// Represents an XLA shape tree.
+typedef struct XLA_Shape {
+  int element_type;
+  Int64List dimensions;
+  BoolList dynamic_dimensions;
+  struct XLA_Shape* tuple_shapes;  // owned
+  int ntuple_shapes;
+  bool has_layout;
+  XLA_Layout layout;
+} XLA_Shape;
+
+// Represents a leaf node for a XLA shaped buffer.
+typedef struct XLA_ShapedBuffer {
+  XLA_Shape on_device_shape;
+  int device_ordinal;
+
+  SE_DeviceMemoryBase* bases;
+  size_t count;
+} XLA_ShapedBuffer;
+
+// Represents a leaf XLA literal.
+typedef struct XLA_Literal {
+  char** buffers;
+  size_t* sizes;
+  size_t count;
+  XLA_Shape shape;
+} XLA_Literal;
+
+typedef struct XLA_MaybeOwningDeviceMemoryShapeTree {
+  XLA_Shape shape;
+  SE_MaybeOwningDeviceMemory* buffers;
+} XLA_MaybeOwningDeviceMemoryShapeTree;
+
+typedef struct XLA_ShapeIndex {
+  int64_t indices[8];
+  int64_t count;
+} XLA_ShapeIndex;
+
+typedef struct SE_ExecutionInput {
+  XLA_MaybeOwningDeviceMemoryShapeTree shape_tree;
+  XLA_ShapeIndex* unowned_indices;
+  int unowned_indices_size;
+  XLA_Shape dynamic_shape;
+} SE_ExecutionInput;
+
+typedef struct SE_ExecutionOutput {
+  XLA_ShapedBuffer result;
+  SE_MaybeOwningDeviceMemory* to_be_released;
+  int to_be_released_size;
+  XLA_ShapeIndex* aliased_indices;
+  int aliased_indices_size;
+} SE_ExecutionOutput;
+
+typedef struct XLA_ComputationLayout {
+  int parameter_count;
+  XLA_Shape* parameter_layouts;
+  XLA_Shape result_layout;
+} XLA_ComputationLayout;
+
+typedef struct XLA_HloModuleConfig {
+  uint64_t seed;
+  int32_t launch_id;
+  int64_t replica_count;
+  int64_t num_partitions;
+  bool use_spmd_partitioning;
+  bool use_auto_spmd_partitioning;
+  Int64List auto_spmd_partitioning_mesh_shape;
+  Int64List auto_spmd_partitioning_mesh_ids;
+  TpuSerializedProto debug_options;
+  bool has_static_device_assignment;
+  TpuSerializedProto static_device_assignment;
+  bool has_entry_computation_layout;
+  XLA_ComputationLayout entry_computation_layout;
+  BoolList allow_spmd_sharding_propagation_to_output;
+} XLA_HloModuleConfig;
+
+typedef struct SE_HloExecutionProfile SE_HloExecutionProfile;
+
+typedef struct SE_StreamExecutorList {
+  SE_StreamExecutor** exec;
+  int count;
+} SE_StreamExecutorList;
+
+typedef struct XLA_HloModuleGroup {
+  TpuSerializedProto proto;
+  XLA_HloModuleConfig* module_config;
+} XLA_HloModuleGroup;
+
+typedef struct XLA_HloModule {
+  TpuSerializedProto proto;
+  XLA_HloModuleConfig module_config;
+} XLA_HloModule;
+
+typedef struct XLA_TransferManager XLA_TransferManager;
+typedef struct XLA_TpuMeshState XLA_TpuMeshState;
+
+typedef struct XLA_ComputationPlacer XLA_ComputationPlacer;
+
+typedef void (*XLA_CallbackFn)(void*);
+typedef void (*XLA_StatusCallbackFn)(void*, TF_Status*);
+
+typedef struct SE_TpuTopology SE_TpuTopology;
+typedef struct SE_TpuTopology_Core SE_TpuTopology_Core;
+typedef struct SE_TpuTopology_Core SE_TpuTopology_Host;
+
+typedef struct SE_OutsideCompilationParams SE_OutsideCompilationParams;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // XLA_STREAM_EXECUTOR_TPU_C_API_DECL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/tpu/c_api_defn.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/tpu/c_api_defn.h
new file mode 100644
index 0000000000000000000000000000000000000000..8e4707fcbbda044df8c5e21e103f0fdd717824b9
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/tpu/c_api_defn.h
@@ -0,0 +1,66 @@
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_STREAM_EXECUTOR_TPU_C_API_DEFN_H_
+#define XLA_STREAM_EXECUTOR_TPU_C_API_DEFN_H_
+
+#include "xla/stream_executor/device_options.h"
+#include "xla/stream_executor/event.h"
+#include "xla/stream_executor/stream.h"
+#include "xla/stream_executor/stream_executor.h"
+
+// Definitions for XLA API data structures. Any underlying C++ data structures
+// are implementation details and should only be used from within the stream
+// executor implementation.
+
+namespace stream_executor {
+class Platform;
+class StreamExecutor;
+}  // namespace stream_executor
+
+struct SE_Platform {
+  stream_executor::Platform* platform;
+};
+
+struct SE_StreamExecutor {
+  stream_executor::StreamExecutor* executor;
+};
+
+struct SE_Stream {
+  explicit SE_Stream(stream_executor::StreamExecutor* parent)
+      : stream(parent) {}
+  stream_executor::Stream stream;
+};
+
+struct SE_Event {
+  explicit SE_Event(stream_executor::StreamExecutor* parent) : event(parent) {}
+  stream_executor::Event event;
+};
+
+struct SE_StreamExecutorConfig {
+  stream_executor::StreamExecutorConfig config;
+};
+
+struct SE_DeviceOptions {
+  stream_executor::DeviceOptions options;
+};
+
+// Ignored -- these are just used to enforce the interface types
+struct XLA_TransferManager {};
+struct XLA_ComputationPlacer {};
+struct SE_TpuTopology {};
+struct SE_TpuTopology_Core {};
+
+#endif  // XLA_STREAM_EXECUTOR_TPU_C_API_DEFN_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/tpu/libtftpu.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/tpu/libtftpu.h
new file mode 100644
index 0000000000000000000000000000000000000000..c5e3fb59a4a5dfab04dcf07227e0a753433bd936
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/tpu/libtftpu.h
@@ -0,0 +1,59 @@
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#include <stdbool.h>
+
+#ifndef XLA_STREAM_EXECUTOR_TPU_LIBTFTPU_H_
+#define XLA_STREAM_EXECUTOR_TPU_LIBTFTPU_H_
+
+#ifndef __cplusplus
+#define decltype(expr) __typeof__(expr)
+#endif
+
+// Unfortunately we have to add an Fn suffix because we cannot have the same
+// name for both a function and a element within a struct in the global
+// namespace in gcc. This restriction doesn't exist in clang.
+#define TFTPU_ADD_FN_IN_STRUCT(FnName) decltype(FnName)* FnName##Fn;
+
+#ifdef SWIG
+#define TFTPU_CAPI_EXPORT
+#else
+#if defined(_WIN32)
+#ifdef TF_COMPILE_LIBRARY
+#define TFTPU_CAPI_EXPORT __declspec(dllexport)
+#else
+#define TFTPU_CAPI_EXPORT __declspec(dllimport)
+#endif  // TF_COMPILE_LIBRARY
+#else
+#define TFTPU_CAPI_EXPORT __attribute__((visibility("default")))
+#endif  // _WIN32
+#endif  // SWIG
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+TFTPU_CAPI_EXPORT void TfTpu_Initialize(bool init_library, int num_args,
+                                        const char** args);
+
+#ifdef __cplusplus
+}
+#endif
+
+struct TfTpu_BaseFn {
+  TFTPU_ADD_FN_IN_STRUCT(TfTpu_Initialize);
+};
+
+#endif  // XLA_STREAM_EXECUTOR_TPU_LIBTFTPU_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/tpu/proto_helper.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/tpu/proto_helper.h
new file mode 100644
index 0000000000000000000000000000000000000000..b4f505ed135d84a004e06c500adc66d3fcc29c73
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/tpu/proto_helper.h
@@ -0,0 +1,83 @@
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_STREAM_EXECUTOR_TPU_PROTO_HELPER_H_
+#define XLA_STREAM_EXECUTOR_TPU_PROTO_HELPER_H_
+
+#include <cstddef>
+
+#include "xla/stream_executor/tpu/c_api_decl.h"
+#include "tsl/platform/logging.h"  // IWYU pragma: keep
+
+extern "C" {
+
+void StreamExecutor_Tpu_FreeSerializedProto(const TpuSerializedProto* proto);
+
+}  // extern "C"
+
+namespace stream_executor {
+namespace tpu {
+
+using SerializedProto = TpuSerializedProto;
+
+// Serializes a `proto` and put the result in the given `SerializedProtoType*`
+// argument.
+//
+// Users should call SerializedProto_Free on `serialized_proto` afterwards.
+template <class ProtoType, class SerializedProtoType>
+inline void SerializeProto(const ProtoType& proto,
+                           SerializedProtoType* serialized_proto) {
+  auto size = proto.ByteSizeLong();
+  auto bytes = new char[size];
+  CHECK(proto.SerializeToArray(bytes, size));
+  serialized_proto->size = size;
+  serialized_proto->bytes = bytes;
+}
+
+// Serializes a proto and return the result as a SerializedProto value.
+//
+// Users should call SerializedProto_Free on the return value afterwards.
+template <class ProtoType>
+inline SerializedProto SerializeProto(const ProtoType& proto) {
+  SerializedProto serialized_proto;
+  SerializeProto(proto, &serialized_proto);
+  return serialized_proto;
+}
+
+// Deserializes a buffer and return the corresponding proto. If the buffer is
+// empty, return an empty proto.
+template <class ProtoType, class SerializedProtoType>
+inline ProtoType DeserializeProto(const SerializedProtoType& serialized_proto) {
+  ProtoType proto;
+  if (serialized_proto.bytes != nullptr) {
+    CHECK_GT(serialized_proto.size, 0);
+    CHECK(proto.ParseFromArray(serialized_proto.bytes, serialized_proto.size))
+        << "Invalid buffer, failed to deserialize buffer.";
+  }
+  return proto;
+}
+
+// Releases the memory allocated for serialized protos.
+template <class SerializedProtoType>
+inline void SerializedProto_Free(const SerializedProtoType& serialized_proto) {
+  CHECK_NE(serialized_proto.bytes, nullptr);
+  CHECK_GT(serialized_proto.size, 0);
+  delete[] serialized_proto.bytes;
+}
+
+}  // namespace tpu
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_TPU_PROTO_HELPER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/tpu/tpu_api.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/tpu/tpu_api.h
new file mode 100644
index 0000000000000000000000000000000000000000..9a3cf2b330abc9bd48cd545fc43b8ca4a3ae7397
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/tpu/tpu_api.h
@@ -0,0 +1,36 @@
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_STREAM_EXECUTOR_TPU_TPU_API_H_
+#define XLA_STREAM_EXECUTOR_TPU_TPU_API_H_
+
+#include "xla/stream_executor/tpu/libtftpu.h"
+#include "xla/stream_executor/tpu/tpu_executor_api.h"
+#include "xla/stream_executor/tpu/tpu_ops_c_api.h"
+#include "xla/stream_executor/tpu/tpu_profiler_c_api.h"
+
+namespace stream_executor {
+namespace tpu {
+
+TfTpu_BaseFn* InitializeApiFn();
+
+const TfTpu_OpsApiFn* OpsApiFn();
+
+const TfTpu_ProfilerApiFn* ProfilerApiFn();
+
+}  // namespace tpu
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_TPU_TPU_API_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/tpu/tpu_executor_api.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/tpu/tpu_executor_api.h
new file mode 100644
index 0000000000000000000000000000000000000000..34989709c31a64d09762f259539a43611fa3e602
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/tpu/tpu_executor_api.h
@@ -0,0 +1,38 @@
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_STREAM_EXECUTOR_TPU_TPU_EXECUTOR_API_H_
+#define XLA_STREAM_EXECUTOR_TPU_TPU_EXECUTOR_API_H_
+
+#include "xla/stream_executor/tpu/libtftpu.h"
+#include "xla/stream_executor/tpu/tpu_executor_c_api.h"
+
+namespace stream_executor {
+namespace tpu {
+
+TfTpu_ExecutorApiFn* ExecutorApiFn();
+
+// Returns whether function pointers in `executor_api_fn` have been set and
+// stream_executor is enabled.
+bool IsStreamExecutorEnabled(TfTpu_ExecutorApiFn* executor_api_fn);
+
+// Returns whether function pointers in `executor_api_fn` have been set.  If
+// false, it probably means an appropriate initializer needs to be linked in.
+bool IsInitialized(TfTpu_ExecutorApiFn* executor_api_fn);
+
+}  // namespace tpu
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_TPU_TPU_EXECUTOR_API_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/tpu/tpu_executor_c_api.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/tpu/tpu_executor_c_api.h
new file mode 100644
index 0000000000000000000000000000000000000000..f2dc3e3918948d90f6adae094ae838ef995bd0fd
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/tpu/tpu_executor_c_api.h
@@ -0,0 +1,532 @@
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_STREAM_EXECUTOR_TPU_TPU_EXECUTOR_C_API_H_
+#define XLA_STREAM_EXECUTOR_TPU_TPU_EXECUTOR_C_API_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include "xla/stream_executor/tpu/c_api_decl.h"
+#include "xla/stream_executor/tpu/libtftpu.h"
+
+extern "C" {
+
+SE_Platform* TpuPlatform_New();
+void TpuPlatform_Free(SE_Platform* platform);
+void TpuPlatform_Initialize(SE_Platform* platform, size_t options_size,
+                            const char** options_key,
+                            const char** options_value, TF_Status* status);
+bool TpuPlatform_Initialized(SE_Platform* platform);
+SE_StreamExecutor* TpuPlatform_GetExecutor(SE_Platform* platform,
+                                           SE_StreamExecutorConfig* config,
+                                           TF_Status* status);
+SE_PlatformId TpuPlatform_Id(SE_Platform* platform);
+int64_t TpuPlatform_VisibleDeviceCount(SE_Platform* platform);
+bool TpuPlatform_ShouldRegisterTpuDeviceToDeviceCopy(SE_Platform* platform);
+SE_TpuTopology* TpuPlatform_GetTopologyPtr(SE_Platform* platform);
+SE_TpuTopology_Host* TpuPlatform_GetHostLocation(SE_Platform* platform);
+TpuRuntimeVersion TpuPlatform_GetRuntimeVersion(SE_Platform* platform);
+
+void TpuExecutor_Init(SE_StreamExecutor* executor, int device_ordinal,
+                      SE_DeviceOptions* device_options, TF_Status* status);
+void TpuExecutor_Free(SE_StreamExecutor* executor);
+
+SE_DeviceMemoryBase TpuExecutor_Allocate(SE_StreamExecutor* executor,
+                                         uint64_t size, int64_t memory_space);
+void TpuExecutor_Deallocate(SE_StreamExecutor* executor,
+                            SE_DeviceMemoryBase* memory);
+bool TpuExecutor_GetAllocatorStats(SE_StreamExecutor* executor,
+                                   SE_AllocatorStats* stats);
+bool TpuExecutor_DeviceMemoryUsage(SE_StreamExecutor* executor, int64_t* free,
+                                   int64_t* total);
+
+bool TpuExecutor_AllocateStream(SE_StreamExecutor* executor, SE_Stream* stream);
+void TpuExecutor_DeallocateStream(SE_StreamExecutor* executor,
+                                  SE_Stream* stream);
+bool TpuExecutor_CreateStreamDependency(SE_StreamExecutor* executor,
+                                        SE_Stream* dependent, SE_Stream* other);
+void TpuExecutor_GetStatus(SE_StreamExecutor* executor, SE_Stream* stream,
+                           TF_Status* status);
+
+SE_TpuTopology_Core* TpuExecutor_GetCoreLocation(SE_StreamExecutor* executor);
+
+void TpuExecutor_AllocateEvent(SE_StreamExecutor* executor, SE_Event* event,
+                               TF_Status* status);
+void TpuExecutor_DeallocateEvent(SE_StreamExecutor* executor, SE_Event* event,
+                                 TF_Status* status);
+int TpuExecutor_PollForEventStatus(SE_StreamExecutor* executor,
+                                   SE_Event* event);
+void TpuExecutor_RecordEvent(SE_StreamExecutor* executor, SE_Stream* stream,
+                             SE_Event* event, TF_Status* status);
+void TpuExecutor_WaitForEvent(SE_StreamExecutor* executor, SE_Stream* stream,
+                              SE_Event* event, TF_Status* status);
+
+void TpuExecutor_SynchronousMemcpyToHost(SE_StreamExecutor* executor,
+                                         void* host_dst,
+                                         const SE_DeviceMemoryBase* device_src,
+                                         uint64_t size, TF_Status* status);
+void TpuExecutor_SynchronousMemcpyFromHost(SE_StreamExecutor* executor,
+                                           SE_DeviceMemoryBase* device_dst,
+                                           const void* host_src, uint64_t size,
+                                           TF_Status* status);
+bool TpuExecutor_MemcpyToHost(SE_StreamExecutor* executor, SE_Stream* stream,
+                              void* host_dst,
+                              const SE_DeviceMemoryBase* device_src,
+                              uint64_t size);
+
+bool TpuExecutor_MemcpyFromHost(SE_StreamExecutor* executor, SE_Stream* stream,
+                                SE_DeviceMemoryBase* device_dst,
+                                const void* host_src, uint64_t size);
+
+void TpuExecutor_EnqueueInfeed(SE_StreamExecutor* executor,
+                               int32_t infeed_queue_index, const uint8_t* data,
+                               int64_t size, TF_Status* status);
+void TpuExecutor_DequeueOutfeed(SE_StreamExecutor* executor,
+                                int32_t outfeed_queue_index, uint8_t* data,
+                                int64_t size, TF_Status* status);
+void TpuExecutor_WaitForInfeedReady(SE_StreamExecutor* executor,
+                                    int32_t infeed_queue_index,
+                                    TF_Status* status);
+void TpuExecutor_WaitForOutfeedReady(SE_StreamExecutor* executor,
+                                     int32_t outfeed_queue_index,
+                                     TF_Status* status);
+
+void TpuExecutor_BlockHostUntilDone(SE_StreamExecutor* executor,
+                                    SE_Stream* stream, TF_Status* status);
+void TpuExecutor_BlockUntilDoneOrFailed(SE_StreamExecutor* executor,
+                                        TF_Status* status);
+void TpuExecutor_SyncAndForgetFailedStreams(SE_StreamExecutor* executor);
+bool TpuExecutor_SynchronizeAllActivity(SE_StreamExecutor* executor);
+
+void TpuExecutor_UnloadAllPrograms(SE_StreamExecutor* executor,
+                                   TF_Status* status);
+void TpuExecutor_EnqueueCompactionOnStreamForHbm(SE_StreamExecutor* executor,
+                                                 SE_Stream* compaction_stream,
+                                                 TF_Status* status);
+
+SE_Stream* TpuStream_New(SE_StreamExecutor* parent);
+void TpuStream_Free(SE_Stream*);
+void* TpuStream_Stream(SE_Stream*);
+bool TpuStream_Status(SE_Stream*);
+bool TpuStream_IsSameSharedMemoryLocation(SE_Stream*, SE_Stream*);
+void TpuStream_EnqueueTransferHostToDevice(SE_Stream* stream,
+                                           SE_DeviceMemoryBase device_dst,
+                                           void* host_src, uint64_t size,
+                                           TF_Status* status);
+void TpuStream_EnqueueTransferDeviceToHost(SE_Stream* stream,
+                                           SE_DeviceMemoryBase device_src,
+                                           void* host_dst, uint64_t size,
+                                           TF_Status* status);
+void TpuStream_TpuEnqueueOnDeviceSendRecvLocal(SE_Stream* stream,
+                                               SE_DeviceMemoryBase send_buffer,
+                                               SE_DeviceMemoryBase recv_buffer,
+                                               TF_Status* status);
+
+SE_Event* TpuEvent_New(SE_StreamExecutor* parent);
+void TpuEvent_Free(SE_Event*);
+
+TF_Status* TpuStatus_New();
+TF_Status* TpuStatus_Create(int32_t code, const char* msg);
+void TpuStatus_Set(TF_Status* status, int32_t code, const char* msg,
+                   int32_t len);
+void TpuStatus_Free(TF_Status* status);
+const char* TpuStatus_Message(TF_Status* status);
+int TpuStatus_Code(TF_Status* status);
+bool TpuStatus_Ok(TF_Status* status);
+
+SE_StreamExecutorConfig* TpuStreamExecutorConfig_Default();
+void TpuStreamExecutorConfig_SetOrdinal(SE_StreamExecutorConfig*, int ordinal);
+void TpuStreamExecutorConfig_Free(SE_StreamExecutorConfig*);
+
+SE_DeviceDescription* TpuDeviceDescription_New();
+void TpuDeviceDescription_Free(SE_DeviceDescription* description);
+void TpuExecutor_CreateDeviceDescription(SE_StreamExecutor* executor,
+                                         SE_DeviceDescription* description,
+                                         TF_Status* status);
+
+SE_DeviceOptions* TpuExecutor_NewDeviceOptions(unsigned flags);
+void TpuExecutor_FreeDeviceOptions(SE_DeviceOptions* options);
+
+bool TpuExecutor_HostCallback(SE_StreamExecutor* executor, SE_Stream* stream,
+                              SE_StatusCallback callback_fn, void* ctx);
+
+XLA_TransferManager* TpuTransferManager_New();
+void TpuTransferManager_Free(XLA_TransferManager* manager);
+SE_PlatformId TpuTransferManager_PlatformId(XLA_TransferManager* manager);
+void TpuTransferManager_HostShapeToDeviceShape(XLA_TransferManager* manager,
+                                               XLA_Shape* host_shape,
+                                               XLA_Shape* device_shape);
+void TpuTransferManager_TransferLiteralToDeviceAsync(
+    XLA_TransferManager* manager, SE_Stream* stream, XLA_Literal* literal,
+    XLA_ShapedBuffer* device_buffer, TF_Status* status);
+void TpuTransferManager_TransferLiteralFromDevice(
+    XLA_TransferManager* manager, SE_Stream* stream,
+    XLA_ShapedBuffer* device_buffer, XLA_Literal* literal,
+    XLA_StatusCallbackFn callback, void* ctx);
+int64_t TpuTransferManager_GetByteSizeRequirement(XLA_TransferManager* manager,
+                                                  XLA_Shape* shape);
+void TpuTransferManager_ChooseCompactLayoutForShape(
+    XLA_TransferManager* manager, XLA_Shape* host_shape, XLA_Shape* output,
+    TF_Status* status);
+bool TpuTransferManager_CanShapedBufferBeAccessedNow(
+    XLA_TransferManager* manager, SE_StreamExecutor* executor,
+    XLA_ShapedBuffer* device_buffer);
+bool TpuTransferManager_CanBufferBeAccessedNow(
+    XLA_TransferManager* manager, SE_StreamExecutor* executor,
+    SE_DeviceMemoryBase* device_buffer);
+void TpuTransferManager_WriteSingleTupleIndexTable(
+    XLA_TransferManager* manager, SE_Stream* stream,
+    SE_DeviceMemoryBase* elements, size_t elements_len, XLA_Shape* shape,
+    SE_DeviceMemoryBase* region, TF_Status* status);
+void TpuTransferManager_GetInfeedLayout(XLA_Shape* shape,
+                                        XLA_Shape* infeed_shape);
+void TpuTransferManager_LinearizeToBuffers(
+    XLA_TransferManager* manager, XLA_Literal* c_literal,
+    XLA_Shape* c_device_shape, char*** buffers_array, int64_t** buffers_size,
+    int64_t* buffers_array_size, TF_Status* status);
+void TpuTransferManager_FreeBuffers(char** buffers_array, int64_t* buffers_size,
+                                    int64_t buffers_array_size);
+void TpuTransferManager_TransferLiteralToInfeed(XLA_TransferManager* manager,
+                                                SE_StreamExecutor* executor,
+                                                XLA_Literal* c_literal,
+                                                TF_Status* status);
+void TpuTransferManager_TransferBuffersToInfeed(XLA_TransferManager* manager,
+                                                SE_StreamExecutor* executor,
+                                                uint32_t** buffers_array,
+                                                int64_t* buffers_size_in_uint32,
+                                                int64_t buffers_array_size,
+                                                TF_Status* status);
+void TpuTransferManager_TransferLiteralFromOutfeed(
+    XLA_TransferManager* manager, SE_StreamExecutor* executor,
+    XLA_Shape* shape /*deprecated*/, XLA_Literal* c_literal, TF_Status* status);
+void TpuTransferManager_ResetDevices(XLA_TransferManager* manager,
+                                     SE_StreamExecutor** executors,
+                                     int64_t num_executors, TF_Status* status);
+void TpuTransferManager_ReadDynamicShapes(SE_Stream* stream,
+                                          XLA_ShapedBuffer* buffer,
+                                          const XLA_Shape& original_shape,
+                                          XLA_Shape* updated_shape,
+                                          TF_Status* status);
+
+XLA_ComputationPlacer* TpuComputationPlacer_New();
+void TpuComputationPlacer_Free(XLA_ComputationPlacer* placer);
+// `assignment` should be a preallocated array of size `replicate_count` *
+// `computation_count`. The assignment will be constructed as a 2D array where
+// assignment[replica][computation] = device_id.
+void TpuComputationPlacer_AssignDevices(XLA_ComputationPlacer* placer,
+                                        int replica_count,
+                                        int computation_count, int* assignment,
+                                        TF_Status* status);
+void TpuComputationPlacer_AssignLocalDevices(SE_TpuTopology_Host* host,
+                                             int replica_count,
+                                             int computation_count,
+                                             int* assignment,
+                                             TF_Status* status);
+
+int TpuTopology_LogicalDevicesPerHost(SE_TpuTopology* tpu_topology,
+                                      TpuCoreTypeEnum tpu_core_type);
+int TpuTopology_LogicalDevicesPerChip(SE_TpuTopology* tpu_topology,
+                                      TpuCoreTypeEnum tpu_core_type);
+int TpuTopology_HostCount(SE_TpuTopology* tpu_topology);
+int TpuTopology_ChipsPerHost(SE_TpuTopology* tpu_topology);
+
+int TpuTopology_ChipBounds_X(SE_TpuTopology* tpu_topology);
+int TpuTopology_ChipBounds_Y(SE_TpuTopology* tpu_topology);
+int TpuTopology_ChipBounds_Z(SE_TpuTopology* tpu_topology);
+bool TpuTopology_HasChip(SE_TpuTopology* tpu_topology, int x, int y, int z);
+SE_TpuTopology_Core* TpuTopology_CoreForId(SE_TpuTopology* tpu_topology,
+                                           TpuCoreTypeEnum tpu_core_type,
+                                           int id);
+SE_TpuTopology_Core* TpuTopology_Core(SE_TpuTopology* tpu_topology,
+                                      TpuCoreTypeEnum tpu_core_type, int x,
+                                      int y, int z, int index);
+int TpuTopology_NumCores(SE_TpuTopology* tpu_topology,
+                         TpuCoreTypeEnum tpu_core_type);
+// 'cores' should be a preallocated array of size TpuTopology_NumCores.
+void TpuTopology_Cores(SE_TpuTopology* tpu_topology,
+                       TpuCoreTypeEnum tpu_core_type,
+                       SE_TpuTopology_Core** cores);
+int TpuTopology_IdForHost(SE_TpuTopology* tpu_topology, int x, int y, int z);
+TpuVersionEnum TpuTopology_Version(SE_TpuTopology* tpu_topology);
+void TpuCoreLocation_ChipCoordinates(SE_TpuTopology_Core* tpu_core_location,
+                                     int* x, int* y, int* z);
+void TpuCoreLocation_HostCoordinates(SE_TpuTopology_Core* tpu_core_location,
+                                     int* x, int* y, int* z);
+int TpuCoreLocation_Index(SE_TpuTopology_Core* tpu_core_location);
+int TpuCoreLocation_Id(SE_TpuTopology_Core* tpu_core_location);
+
+int TpuHostLocation_Id(SE_TpuTopology_Host* tpu_host_location);
+int TpuHostLocation_NumCores(SE_TpuTopology_Host* tpu_host_location,
+                             TpuCoreTypeEnum tpu_core_type);
+// 'cores' should be a preallocated array of size TpuHostLocation_NumCores.
+void TpuHostLocation_Cores(SE_TpuTopology_Host* tpu_host_location,
+                           TpuCoreTypeEnum tpu_core_type,
+                           SE_TpuTopology_Core** cores);
+
+// Async collective offloading.
+// Safe to call multiple times.
+void TpuAsyncCollectiveOffloadHelper_Init();
+// Must be called after TpuAsyncCollectiveOffloadHelper_Init.
+void TpuAsyncCollectiveOffloadHelper_Shutdown();
+
+// C API for XLA::Compiler interface
+
+TFTPU_CAPI_EXPORT Tpu_Compiler* TpuCompiler_New();
+TFTPU_CAPI_EXPORT void TpuCompiler_Free(Tpu_Compiler* compiler);
+
+TFTPU_CAPI_EXPORT void TpuCompiler_RunHloPasses(
+    Tpu_Compiler* compiler, XLA_HloModule* se_hlo_module,
+    SE_StreamExecutor* stream_executor, SE_DeviceMemoryAllocator* allocator,
+    XLA_HloModule* result, TF_Status* status);
+
+TFTPU_CAPI_EXPORT void TpuCompiler_RunBackend(
+    Tpu_Compiler* compiler, XLA_HloModule* se_hlo_module,
+    SE_StreamExecutor* stream_executor, SE_DeviceMemoryAllocator* allocator,
+    SE_Executable** result, TF_Status* status);
+
+TFTPU_CAPI_EXPORT void TpuCompiler_Compile(
+    Tpu_Compiler* compiler, XLA_HloModuleGroup* se_hlo_module_group,
+    SE_StreamExecutorList* stream_exec_lists, int num_lists,
+    SE_DeviceMemoryAllocator* allocator, SE_Executable** executables,
+    TF_Status* status);
+
+TFTPU_CAPI_EXPORT int64_t TpuCompiler_ShapeSize(Tpu_Compiler* compiler,
+                                                XLA_Shape* c_shape);
+
+TFTPU_CAPI_EXPORT void TpuCompiler_DefaultDeviceShapeRepresentation(
+    Tpu_Compiler* compiler, XLA_Shape* host_shape, XLA_Shape* device_shape);
+
+TFTPU_CAPI_EXPORT void TpuExecutable_ExecuteAsyncOnStream(
+    SE_Executable* executable, SE_ExecutableRunOptions* se_options,
+    SE_ExecutionInput** se_arguments, int se_arguments_size,
+    SE_HloExecutionProfile* hlo_execution_profile,
+    SE_ExecutionOutput* se_output, TF_Status* status);
+
+// This frees the XLA_ShapeIndex* array allocated when se_output is returned by
+// TpuExecutable_ExecuteAsyncOnStream.
+TFTPU_CAPI_EXPORT void TpuExecutable_FreeXlaShapeIndexArray(
+    XLA_ShapeIndex* array);
+
+// This frees the SE_MaybeOwningDeviceMemory* array allocated when se_output is
+// returned by TpuExecutable_ExecuteAsyncOnStream.
+// Note that this only frees the heap-allocated array itself, and does not
+// free any of the underlying device memory.
+TFTPU_CAPI_EXPORT void TpuExecutable_FreeMaybeOwningDeviceMemoryArray(
+    SE_MaybeOwningDeviceMemory* array);
+
+TFTPU_CAPI_EXPORT void TpuExecutable_Fingerprint(SE_Executable* executable,
+                                                 const char** fingerprint,
+                                                 size_t* size);
+
+// The serialization format is not guaranteed to be stable over time and has no
+// compatibility guarantees (i.e. this is not a suitable long-term storage
+// format). TpuExecutableSerialize_FreeHandle should be called after 'handle' is
+// no longer needed. 'handle' is set to nullptr on error.
+TFTPU_CAPI_EXPORT void TpuExecutable_Serialize(
+    SE_Executable* executable, SE_ExecutableSerializationHandle** handle,
+    TF_Status* status);
+
+// Returns the size of the serialized executable in bytes, i.e. the size of the
+// array that should be passed to TpuExecutableSerialize_WriteToArray. `handle`
+// must be non-null.
+TFTPU_CAPI_EXPORT size_t
+TpuExecutableSerialize_GetByteSize(SE_ExecutableSerializationHandle* handle);
+
+// Writes the serialized executable to `serialized`, which must be of size
+// `serialized_size`. `serialized_size` should must be at least
+// `TpuExecutableSerialize_GetByteSize(handle)`. `handle` must be non-null.
+TFTPU_CAPI_EXPORT void TpuExecutableSerialize_WriteToArray(
+    SE_ExecutableSerializationHandle* handle, int serialized_size,
+    uint8_t* serialized, TF_Status* status);
+
+// Safe to call if 'handle' is null.
+TFTPU_CAPI_EXPORT void TpuExecutableSerialize_FreeHandle(
+    SE_ExecutableSerializationHandle* handle);
+
+TFTPU_CAPI_EXPORT void TpuExecutable_Deserialize(int serialized_size,
+                                                 const uint8_t* serialized,
+                                                 SE_Executable** executable,
+                                                 TF_Status* status);
+
+// Caller is responsible for freeing the returned module's proto and its
+// config's proto.
+TFTPU_CAPI_EXPORT XLA_HloModule
+TpuExecutable_HloModule(SE_Executable* executable);
+
+TFTPU_CAPI_EXPORT void TpuExecutable_Free(SE_Executable*);
+
+// Converts an XLA `Shape` into its equivalent TPU `Shape` representation.
+TFTPU_CAPI_EXPORT void XlaShapeToTpuShapeRepresentation(
+    XLA_Shape* serialized_xla_shape, int data_type, bool use_fast_memory,
+    XLA_Shape* serialized_tpu_shape, TF_Status* status);
+
+TFTPU_CAPI_EXPORT void XlaShapeToTpuPaddedShape(XLA_Shape* serialized_xla_shape,
+                                                XLA_Shape* padded_shape,
+                                                TF_Status* status);
+
+struct TfTpu_ExecutorApiFn {
+  TFTPU_ADD_FN_IN_STRUCT(TpuPlatform_New);
+  TFTPU_ADD_FN_IN_STRUCT(TpuPlatform_Free);
+  TFTPU_ADD_FN_IN_STRUCT(TpuPlatform_Initialize);
+  TFTPU_ADD_FN_IN_STRUCT(TpuPlatform_Initialized);
+  TFTPU_ADD_FN_IN_STRUCT(TpuPlatform_GetExecutor);
+  TFTPU_ADD_FN_IN_STRUCT(TpuPlatform_Id);
+  TFTPU_ADD_FN_IN_STRUCT(TpuPlatform_VisibleDeviceCount);
+  TFTPU_ADD_FN_IN_STRUCT(TpuPlatform_ShouldRegisterTpuDeviceToDeviceCopy);
+  TFTPU_ADD_FN_IN_STRUCT(TpuPlatform_GetTopologyPtr);
+  TFTPU_ADD_FN_IN_STRUCT(TpuPlatform_GetHostLocation);
+  TFTPU_ADD_FN_IN_STRUCT(TpuPlatform_GetRuntimeVersion);
+
+  TFTPU_ADD_FN_IN_STRUCT(TpuExecutor_Init);
+  TFTPU_ADD_FN_IN_STRUCT(TpuExecutor_Free);
+  TFTPU_ADD_FN_IN_STRUCT(TpuExecutor_Allocate);
+  TFTPU_ADD_FN_IN_STRUCT(TpuExecutor_Deallocate);
+  TFTPU_ADD_FN_IN_STRUCT(TpuExecutor_GetAllocatorStats);
+  TFTPU_ADD_FN_IN_STRUCT(TpuExecutor_DeviceMemoryUsage);
+  TFTPU_ADD_FN_IN_STRUCT(TpuExecutor_AllocateStream);
+  TFTPU_ADD_FN_IN_STRUCT(TpuExecutor_DeallocateStream);
+  TFTPU_ADD_FN_IN_STRUCT(TpuExecutor_CreateStreamDependency);
+  TFTPU_ADD_FN_IN_STRUCT(TpuExecutor_GetStatus);
+  TFTPU_ADD_FN_IN_STRUCT(TpuExecutor_GetCoreLocation);
+  TFTPU_ADD_FN_IN_STRUCT(TpuExecutor_AllocateEvent);
+  TFTPU_ADD_FN_IN_STRUCT(TpuExecutor_DeallocateEvent);
+  TFTPU_ADD_FN_IN_STRUCT(TpuExecutor_PollForEventStatus);
+  TFTPU_ADD_FN_IN_STRUCT(TpuExecutor_RecordEvent);
+  TFTPU_ADD_FN_IN_STRUCT(TpuExecutor_WaitForEvent);
+  TFTPU_ADD_FN_IN_STRUCT(TpuExecutor_SynchronousMemcpyToHost);
+  TFTPU_ADD_FN_IN_STRUCT(TpuExecutor_SynchronousMemcpyFromHost);
+  TFTPU_ADD_FN_IN_STRUCT(TpuExecutor_MemcpyToHost);
+  TFTPU_ADD_FN_IN_STRUCT(TpuExecutor_MemcpyFromHost);
+  TFTPU_ADD_FN_IN_STRUCT(TpuExecutor_EnqueueInfeed);
+  TFTPU_ADD_FN_IN_STRUCT(TpuExecutor_DequeueOutfeed);
+  TFTPU_ADD_FN_IN_STRUCT(TpuExecutor_BlockHostUntilDone);
+  TFTPU_ADD_FN_IN_STRUCT(TpuExecutor_SynchronizeAllActivity);
+  TFTPU_ADD_FN_IN_STRUCT(TpuExecutor_UnloadAllPrograms);
+  TFTPU_ADD_FN_IN_STRUCT(TpuExecutor_EnqueueCompactionOnStreamForHbm);
+
+  TFTPU_ADD_FN_IN_STRUCT(TpuStream_New);
+  TFTPU_ADD_FN_IN_STRUCT(TpuStream_Free);
+  TFTPU_ADD_FN_IN_STRUCT(TpuStream_Stream);
+  TFTPU_ADD_FN_IN_STRUCT(TpuStream_Status);
+  TFTPU_ADD_FN_IN_STRUCT(TpuStream_IsSameSharedMemoryLocation);
+  TFTPU_ADD_FN_IN_STRUCT(TpuStream_EnqueueTransferHostToDevice);
+  TFTPU_ADD_FN_IN_STRUCT(TpuStream_EnqueueTransferDeviceToHost);
+  TFTPU_ADD_FN_IN_STRUCT(TpuStream_TpuEnqueueOnDeviceSendRecvLocal);
+
+  TFTPU_ADD_FN_IN_STRUCT(TpuEvent_New);
+  TFTPU_ADD_FN_IN_STRUCT(TpuEvent_Free);
+
+  TFTPU_ADD_FN_IN_STRUCT(TpuStatus_New);
+  TFTPU_ADD_FN_IN_STRUCT(TpuStatus_Create);
+  TFTPU_ADD_FN_IN_STRUCT(TpuStatus_Set);
+  TFTPU_ADD_FN_IN_STRUCT(TpuStatus_Free);
+  TFTPU_ADD_FN_IN_STRUCT(TpuStatus_Message);
+  TFTPU_ADD_FN_IN_STRUCT(TpuStatus_Code);
+  TFTPU_ADD_FN_IN_STRUCT(TpuStatus_Ok);
+
+  TFTPU_ADD_FN_IN_STRUCT(TpuStreamExecutorConfig_Default);
+  TFTPU_ADD_FN_IN_STRUCT(TpuStreamExecutorConfig_SetOrdinal);
+  TFTPU_ADD_FN_IN_STRUCT(TpuStreamExecutorConfig_Free);
+
+  TFTPU_ADD_FN_IN_STRUCT(TpuDeviceDescription_New);
+  TFTPU_ADD_FN_IN_STRUCT(TpuDeviceDescription_Free);
+
+  TFTPU_ADD_FN_IN_STRUCT(TpuExecutor_CreateDeviceDescription);
+  TFTPU_ADD_FN_IN_STRUCT(TpuExecutor_NewDeviceOptions);
+  TFTPU_ADD_FN_IN_STRUCT(TpuExecutor_FreeDeviceOptions);
+  TFTPU_ADD_FN_IN_STRUCT(TpuExecutor_HostCallback);
+
+  TFTPU_ADD_FN_IN_STRUCT(TpuTransferManager_New);
+  TFTPU_ADD_FN_IN_STRUCT(TpuTransferManager_Free);
+  TFTPU_ADD_FN_IN_STRUCT(TpuTransferManager_PlatformId);
+  TFTPU_ADD_FN_IN_STRUCT(TpuTransferManager_HostShapeToDeviceShape);
+  TFTPU_ADD_FN_IN_STRUCT(TpuTransferManager_TransferLiteralToDeviceAsync);
+  TFTPU_ADD_FN_IN_STRUCT(TpuTransferManager_TransferLiteralFromDevice);
+  TFTPU_ADD_FN_IN_STRUCT(TpuTransferManager_GetByteSizeRequirement);
+  TFTPU_ADD_FN_IN_STRUCT(TpuTransferManager_ChooseCompactLayoutForShape);
+  TFTPU_ADD_FN_IN_STRUCT(TpuTransferManager_CanShapedBufferBeAccessedNow);
+  TFTPU_ADD_FN_IN_STRUCT(TpuTransferManager_CanBufferBeAccessedNow);
+  TFTPU_ADD_FN_IN_STRUCT(TpuTransferManager_WriteSingleTupleIndexTable);
+  TFTPU_ADD_FN_IN_STRUCT(TpuTransferManager_GetInfeedLayout);
+  TFTPU_ADD_FN_IN_STRUCT(TpuTransferManager_LinearizeToBuffers);
+  TFTPU_ADD_FN_IN_STRUCT(TpuTransferManager_FreeBuffers);
+  TFTPU_ADD_FN_IN_STRUCT(TpuTransferManager_TransferLiteralToInfeed);
+  TFTPU_ADD_FN_IN_STRUCT(TpuTransferManager_TransferBuffersToInfeed);
+  TFTPU_ADD_FN_IN_STRUCT(TpuTransferManager_TransferLiteralFromOutfeed);
+  TFTPU_ADD_FN_IN_STRUCT(TpuTransferManager_ResetDevices);
+  TFTPU_ADD_FN_IN_STRUCT(TpuTransferManager_ReadDynamicShapes);
+
+  TFTPU_ADD_FN_IN_STRUCT(TpuComputationPlacer_New);
+  TFTPU_ADD_FN_IN_STRUCT(TpuComputationPlacer_Free);
+  TFTPU_ADD_FN_IN_STRUCT(TpuComputationPlacer_AssignDevices);
+  TFTPU_ADD_FN_IN_STRUCT(TpuComputationPlacer_AssignLocalDevices);
+
+  TFTPU_ADD_FN_IN_STRUCT(TpuTopology_LogicalDevicesPerHost);
+  TFTPU_ADD_FN_IN_STRUCT(TpuTopology_LogicalDevicesPerChip);
+  TFTPU_ADD_FN_IN_STRUCT(TpuTopology_HostCount);
+  TFTPU_ADD_FN_IN_STRUCT(TpuTopology_ChipsPerHost);
+
+  TFTPU_ADD_FN_IN_STRUCT(TpuTopology_ChipBounds_X);
+  TFTPU_ADD_FN_IN_STRUCT(TpuTopology_ChipBounds_Y);
+  TFTPU_ADD_FN_IN_STRUCT(TpuTopology_ChipBounds_Z);
+  TFTPU_ADD_FN_IN_STRUCT(TpuTopology_HasChip);
+  TFTPU_ADD_FN_IN_STRUCT(TpuTopology_CoreForId);
+  TFTPU_ADD_FN_IN_STRUCT(TpuTopology_Core);
+  TFTPU_ADD_FN_IN_STRUCT(TpuTopology_NumCores);
+  TFTPU_ADD_FN_IN_STRUCT(TpuTopology_Cores);
+  TFTPU_ADD_FN_IN_STRUCT(TpuTopology_IdForHost);
+  TFTPU_ADD_FN_IN_STRUCT(TpuTopology_Version);
+
+  TFTPU_ADD_FN_IN_STRUCT(TpuCoreLocation_ChipCoordinates);
+  TFTPU_ADD_FN_IN_STRUCT(TpuCoreLocation_HostCoordinates);
+  TFTPU_ADD_FN_IN_STRUCT(TpuCoreLocation_Index);
+  TFTPU_ADD_FN_IN_STRUCT(TpuCoreLocation_Id);
+
+  TFTPU_ADD_FN_IN_STRUCT(TpuHostLocation_Id);
+  TFTPU_ADD_FN_IN_STRUCT(TpuHostLocation_NumCores);
+  TFTPU_ADD_FN_IN_STRUCT(TpuHostLocation_Cores);
+
+  TFTPU_ADD_FN_IN_STRUCT(TpuCompiler_New);
+  TFTPU_ADD_FN_IN_STRUCT(TpuCompiler_Free);
+  TFTPU_ADD_FN_IN_STRUCT(TpuCompiler_RunHloPasses);
+  TFTPU_ADD_FN_IN_STRUCT(TpuCompiler_RunBackend);
+  TFTPU_ADD_FN_IN_STRUCT(TpuCompiler_Compile);
+  TFTPU_ADD_FN_IN_STRUCT(TpuCompiler_ShapeSize);
+  TFTPU_ADD_FN_IN_STRUCT(TpuCompiler_DefaultDeviceShapeRepresentation);
+
+  TFTPU_ADD_FN_IN_STRUCT(TpuExecutable_ExecuteAsyncOnStream);
+  TFTPU_ADD_FN_IN_STRUCT(TpuExecutable_FreeXlaShapeIndexArray);
+  TFTPU_ADD_FN_IN_STRUCT(TpuExecutable_FreeMaybeOwningDeviceMemoryArray);
+  TFTPU_ADD_FN_IN_STRUCT(TpuExecutable_Fingerprint);
+  TFTPU_ADD_FN_IN_STRUCT(TpuExecutable_Serialize);
+  TFTPU_ADD_FN_IN_STRUCT(TpuExecutableSerialize_GetByteSize);
+  TFTPU_ADD_FN_IN_STRUCT(TpuExecutableSerialize_WriteToArray);
+  TFTPU_ADD_FN_IN_STRUCT(TpuExecutableSerialize_FreeHandle);
+  TFTPU_ADD_FN_IN_STRUCT(TpuExecutable_Deserialize);
+  TFTPU_ADD_FN_IN_STRUCT(TpuExecutable_HloModule);
+  TFTPU_ADD_FN_IN_STRUCT(TpuExecutable_Free);
+
+  TFTPU_ADD_FN_IN_STRUCT(XlaShapeToTpuShapeRepresentation);
+  TFTPU_ADD_FN_IN_STRUCT(XlaShapeToTpuPaddedShape);
+
+  TFTPU_ADD_FN_IN_STRUCT(TpuAsyncCollectiveOffloadHelper_Init);
+  TFTPU_ADD_FN_IN_STRUCT(TpuAsyncCollectiveOffloadHelper_Shutdown);
+};
+}
+
+// extern "C"
+
+#endif  // XLA_STREAM_EXECUTOR_TPU_TPU_EXECUTOR_C_API_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/tpu/tpu_ops_c_api.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/tpu/tpu_ops_c_api.h
new file mode 100644
index 0000000000000000000000000000000000000000..65bfbabeb15f7641dba58616fd6c463a10ee10b8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/tpu/tpu_ops_c_api.h
@@ -0,0 +1,828 @@
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef XLA_STREAM_EXECUTOR_TPU_TPU_OPS_C_API_H_
+#define XLA_STREAM_EXECUTOR_TPU_TPU_OPS_C_API_H_
+
+#include <stddef.h>
+
+#include <cstdint>
+#include <optional>
+
+#include "xla/stream_executor/tpu/c_api_decl.h"
+#include "xla/stream_executor/tpu/libtftpu.h"
+
+typedef struct TpuSerializedProto TpuSerializedProto;
+
+namespace tensorflow {
+
+class TpuMeshCommonState;
+class TpuEmbeddingEngineState;
+class ResourceMgr;
+
+}  // namespace tensorflow
+
+extern "C" {
+
+typedef struct XLA_TpuProgram XLA_TpuProgram;
+
+// Enum for choosing sharding/unsharding program from a `XLA_TpuProgram` obj.
+enum TpuProgramShardingType { kInvalid = 0, kMain, kSharding, kUnsharding };
+
+struct TpuProgramFingerprint {
+  const char* bytes;
+  size_t size;
+};
+
+struct TpuExecutableSerializedProto {
+  const char* bytes;
+  size_t size;
+};
+
+struct CompilerMetadataSerializedProto {
+  const char* bytes;
+  size_t size;
+};
+
+struct HostComputeMetadataSerializedProto {
+  const char* bytes;
+  size_t size;
+};
+
+typedef struct XLA_TpuMeshState XLA_TpuMeshState;
+
+typedef struct XLA_TpuEmbeddingEngineState XLA_TpuEmbeddingEngineState;
+
+typedef struct TpuEmbedding_TensorBatchFixedState
+    TpuEmbedding_TensorBatchFixedState;
+
+typedef struct XLA_DeviceAssignment {
+  const char* bytes;
+  size_t size;
+} XLA_DeviceAssignment;
+
+// Property for creating compilation cache key.
+struct CompilationCacheKeyProperty {
+  const char* config_prefix;
+  const char* shapes_prefix;
+  const char* function_name;
+  uint64_t mlir_module_fingerprint;
+  const int32_t* device_ids;
+  size_t device_ids_size;
+  int32_t guaranteed_constants_size;
+  uint64_t function_library_fingerprint;
+  int32_t num_cores_per_replica;
+  int32_t num_replicas;
+  const XLA_TpuMeshState* mesh_state;
+  uint64_t session_id;
+  tensorflow::ResourceMgr* resource_mgr;
+};
+
+// Compilation cache key result returning both the key and a more verbose debug
+// version.
+struct CompilationCacheKeyResult {
+  const char* key;
+  const char* debug_string;
+};
+
+typedef struct XLA_TpuNodeContext XLA_TpuNodeContext;
+
+typedef struct TfTpu_OrdinalSelector TfTpuOrdinalSelector;
+
+struct TpuPartitionedCall_Params {
+  bool input_shape_opt;
+  bool group_tensors_for_packing;
+  int32_t minimum_input_tensors_packing;
+  int32_t minimum_output_tensors_packing;
+
+  // Whether to attempt to automatically shard inputs by adding an
+  // XlaSharding op after each input.
+  bool enable_auto_xla_input_sharding;
+
+  // The dimension of each input to shard if
+  // enable_auto_xla_input_sharding is set to true. Negative numbers are
+  // allowed and refers to dimensions starting from the end.
+  int32_t auto_xla_input_sharding_dim;
+
+  // If true, only create one variable on the TPU for each variable on the CPU.
+  bool enable_variable_deduplication;
+};
+
+// Compiles Mlir or TF function computation by lowering into HLO IR and returns
+// `count` number of TPU programs ready for execution.
+// The API allocates the `XLA_TpuProgram*[]` array `tpu_programs` and creates
+// `XLA_TpuProgram` object(s) using the `TpuProgram_New` API. The caller is
+// responsible to deallocate both the `XLA_TpuProgram*[]` array and the
+// `XLA_TpuProgram` object(s) using `TpuProgram_FreeArray` and `TpuProgram_Free`
+// API respectively.
+TFTPU_CAPI_EXPORT void TpuCompile_CompileAndBuild(
+    TpuSerializedProto compilation_request, const XLA_TpuMeshState* mesh_state,
+    XLA_TpuProgram** tpu_programs[], size_t* count, TF_Status* status);
+
+// Compiles a HLO IR and returns `count` number of TPU programs ready for
+// execution. The API allocates the `XLA_TpuProgram*[]` array `tpu_programs` and
+// creates `XLA_TpuProgram` object(s) using the `TpuProgram_New` API. The caller
+// is responsible to deallocate both the `XLA_TpuProgram*[]` array and the
+// `XLA_TpuProgram` object(s) using `TpuProgram_FreeArray` and `TpuProgram_Free`
+// API respectively.
+TFTPU_CAPI_EXPORT void TpuCompile_XrtCompileAndBuild(
+    TpuSerializedProto xrt_computation, const XLA_TpuMeshState* mesh_state,
+    XLA_TpuProgram** tpu_programs[], size_t* count, TF_Status* status);
+
+// Creates a new TPU mesh state object.
+TFTPU_CAPI_EXPORT XLA_TpuMeshState* TpuMeshState_Create();
+
+// Deletes the given TPU `mesh_state` object. Once deleted the object is
+// unusable.
+TFTPU_CAPI_EXPORT void TpuMeshState_Free(XLA_TpuMeshState* mesh_state);
+
+// Returns a pointer to an opaque mesh data structure used internally.
+TFTPU_CAPI_EXPORT void* TpuMeshState_MeshCommonState(
+    XLA_TpuMeshState* mesh_state);
+
+// Creates a new TPU embedding engine state object.
+TFTPU_CAPI_EXPORT XLA_TpuEmbeddingEngineState* TpuEmbeddingEngineState_Create();
+
+// Delete the given TPU embedding engine state object. Once deleted the object
+// is unusable.
+TFTPU_CAPI_EXPORT void TpuEmbeddingEngineState_Free(
+    XLA_TpuEmbeddingEngineState* engine_state);
+
+// Returns a pointer to an opaque embedding engine state data structure used
+// internally.
+TFTPU_CAPI_EXPORT void* TpuEmbeddingEngineState_GetState(
+    XLA_TpuEmbeddingEngineState* engine_state);
+
+TFTPU_CAPI_EXPORT void TfTpuOrdinalSelector_Create(
+    TfTpuOrdinalSelector** ordinal_selector, int num_cores_per_replica);
+
+TFTPU_CAPI_EXPORT void TfTpuOrdinalSelector_Destroy(
+    TfTpuOrdinalSelector* ordinal_selector);
+
+TFTPU_CAPI_EXPORT void TfTpuOrdinalSelector_GetOrdinal(
+    TfTpuOrdinalSelector* ordinal_selector, std::optional<uint64_t> key,
+    int64_t* req_id, int64_t* ordinal);
+
+TFTPU_CAPI_EXPORT void TfTpuOrdinalSelector_DequeueFromCoreSelector(
+    TfTpuOrdinalSelector* ordinal_selector, int32_t device_ordinal,
+    int64_t req_id);
+
+TFTPU_CAPI_EXPORT void TfTpu_GetTpuPartitionedCallParams(
+    TpuPartitionedCall_Params* params);
+
+typedef struct TpuExecutable_LoadProgramAndEnqueueToStream_Params {
+  int32_t struct_size;
+  void* priv;
+
+  const XLA_TpuProgram* program;
+  SE_DeviceMemoryBase* arguments;
+  size_t arguments_len;
+  SE_DeviceMemoryBase* result;
+  size_t cross_program_prefetch_addrs_len;
+  SE_DeviceMemoryBase* cross_program_prefetch_addrs;
+  size_t cross_program_prefetch_offsets_len;
+  const uint32_t* cross_program_prefetch_offsets;
+  int32_t rng_seed;
+  XLA_DeviceAssignment* device_assignment;
+  SE_Stream* stream;
+  SE_OutsideCompilationParams* outside_compilation_params;
+
+  TF_Status* status;  // out
+} TpuExecutable_LoadProgramAndEnqueueToStream_Params;
+
+#define TpuExecutable_LoadProgramAndEnqueueToStream_Params_SIZE \
+  (sizeof(struct TpuExecutable_LoadProgramAndEnqueueToStream_Params))
+
+TFTPU_CAPI_EXPORT void TpuExecutable_LoadProgramAndEnqueueToStream(
+    TpuExecutable_LoadProgramAndEnqueueToStream_Params* params);
+
+TFTPU_CAPI_EXPORT void HardwareLayout_HostShapeToDeviceShape(
+    XLA_Shape* host_shape, XLA_Shape* device_shape);
+TFTPU_CAPI_EXPORT int64_t HardwareLayout_ShapeSize(XLA_Shape* shape);
+TFTPU_CAPI_EXPORT int64_t HardwareLayout_ShapeSizeCompact(XLA_Shape* shape);
+TFTPU_CAPI_EXPORT int64_t HardwareLayout_ShapeSizeCompactRaw(XLA_Shape* shape);
+
+typedef struct TpuExecute_RuntimeInputToPaddedData_Params {
+  int32_t struct_size;
+  void* priv;
+
+  uint32_t* runtime_input_ptr;
+  size_t runtime_input_size;
+  int8_t* padded_data_ptr;
+  size_t padded_data_size;
+  XLA_Shape* runtime_shape;
+  XLA_Shape* compile_time_shape;
+
+  TF_Status* status;  // out
+} TpuExecute_RuntimeInputToPaddedData_Params;
+
+#define TpuExecute_RuntimeInputToPaddedData_Params_SIZE \
+  (sizeof(struct TpuExecute_RuntimeInputToPaddedData_Params))
+
+TFTPU_CAPI_EXPORT void TpuExecute_RuntimeInputToPaddedData(
+    TpuExecute_RuntimeInputToPaddedData_Params* params);
+
+TFTPU_CAPI_EXPORT void TpuExecute_GetTpuEmbeddingMemoryAllocations(
+    int device_ordinal, SE_DeviceMemoryBase** addrs, size_t* addrs_count,
+    TF_Status* status);
+
+TFTPU_CAPI_EXPORT void TpuExecute_FreeTpuEmbeddingMemoryAllocations(
+    int device_ordinal, SE_DeviceMemoryBase* addrs);
+
+typedef struct ConfigureDistributedTpuOp_DoWork_Params {
+  int32_t struct_size;
+  void* priv;
+
+  size_t num_cores_per_host_size;
+  const int32_t* num_cores_per_host;
+  size_t server_address_size;
+  const char* server_address;
+
+  size_t* host_config_output_size;  // out
+  char** host_config_output;        // out
+  TF_Status* status;                // out
+} ConfigureDistributedTpuOp_DoWork_Params;
+
+#define ConfigureDistributedTpuOp_DoWork_Params_SIZE \
+  (sizeof(struct ConfigureDistributedTpuOp_DoWork_Params))
+
+TFTPU_CAPI_EXPORT void ConfigureDistributedTpuOp_DoWork(
+    ConfigureDistributedTpuOp_DoWork_Params* params);
+
+typedef struct WaitForDistributedTpuOp_DoWork_Params {
+  int32_t struct_size;
+  void* priv;
+
+  size_t num_hosts;
+  size_t num_cores_per_host;
+  const int32_t** host_ordinal_to_global_core_id_map;
+  tensorflow::TpuMeshCommonState* tpu_mesh_common_state;
+
+  size_t* tpu_topology_output_size;  // out
+  char** tpu_topology_output;        // out
+  TF_Status* status;                 // out
+} WaitForDistributedTpuOp_DoWork_Params;
+
+#define WaitForDistributedTpuOp_DoWork_Params_SIZE \
+  (sizeof(struct WaitForDistributedTpuOp_DoWork_Params))
+
+TFTPU_CAPI_EXPORT void WaitForDistributedTpuOp_DoWork(
+    WaitForDistributedTpuOp_DoWork_Params* params);
+
+typedef struct InitializeHostForDistributedTpuOp_DoWork_Params {
+  int32_t struct_size;
+  void* priv;
+
+  size_t tpu_host_config_size;
+  const char* tpu_host_config;
+  bool enable_whole_mesh_compilations;
+  bool is_master_worker;
+
+  size_t* core_id_output_size;  // out
+  int32_t** core_id_output;     // out
+  TF_Status* status;            // out
+} InitializeHostForDistributedTpuOp_DoWork_Params;
+
+#define InitializeHostForDistributedTpuOp_DoWork_Params_SIZE \
+  (sizeof(struct InitializeHostForDistributedTpuOp_DoWork_Params))
+
+TFTPU_CAPI_EXPORT void InitializeHostForDistributedTpuOp_DoWork(
+    InitializeHostForDistributedTpuOp_DoWork_Params* params);
+
+TFTPU_CAPI_EXPORT void SetGlobalTPUArrayOp_DoWork(
+    const size_t tpu_topology_size, const char* tpu_topology,
+    TF_Status* status);
+
+TFTPU_CAPI_EXPORT void DisconnectDistributedTpuChipsOp_DoWork(
+    int32_t* number_of_chips_output, TF_Status* status);
+
+TFTPU_CAPI_EXPORT void TpuConfigurationApi_FreeCharArray(char* output);
+TFTPU_CAPI_EXPORT void TpuConfigurationApi_FreeInt32Array(int32_t* output);
+
+TFTPU_CAPI_EXPORT bool TpuConfigurationApi_HasTPUPodState();
+
+TFTPU_CAPI_EXPORT void TpuConfigurationApi_TpusPerHost(int32_t* tpus,
+                                                       TF_Status* status);
+TFTPU_CAPI_EXPORT void TpuConfigurationApi_TpuMemoryLimit(int64_t* memory_limit,
+                                                          TF_Status* status);
+TFTPU_CAPI_EXPORT void TpuConfigurationApi_RemoteCompilationCacheSizeInBytes(
+    int64_t* cache_size_in_bytes);
+
+typedef struct TpuConfigurationApi_CompilationCacheServerAddrFromConfig_Params {
+  int32_t struct_size;
+  void* priv;
+
+  size_t tpu_host_config_size;
+  const char* tpu_host_config;
+
+  size_t* server_address_output_size;  // out
+  char** server_address_output;        // out
+  TF_Status* status;                   // out
+} TpuConfigurationApi_CompilationCacheServerAddressFromConfig_Params;
+
+#define TpuConfigurationApi_CompilationCacheServerAddrFromConfig_Params_SIZE \
+  (sizeof(                                                                   \
+      struct TpuConfigurationApi_CompilationCacheServerAddrFromConfig_Params))
+
+TFTPU_CAPI_EXPORT
+void TpuConfigurationApi_CompilationCacheServerAddressFromConfig(
+    TpuConfigurationApi_CompilationCacheServerAddrFromConfig_Params* params);
+
+typedef struct TpuConfigurationApi_GetServerAddressAndPort_Params {
+  int32_t struct_size;
+  void* priv;
+
+  size_t* server_address_output_size;  // out
+  char** server_address_output;        // out
+  int* port_output;                    // out
+  TF_Status* status;                   // out
+} TpuConfigurationApi_GetServerAddressAndPort_Params;
+
+#define TpuConfigurationApi_GetServerAddressAndPort_Params_SIZE \
+  (sizeof(struct TpuConfigurationApi_GetServerAddressAndPort_Params))
+
+TFTPU_CAPI_EXPORT void TpuConfigurationApi_GetServerAddressAndPort(
+    TpuConfigurationApi_GetServerAddressAndPort_Params* params);
+
+// Creates a new TPU program.
+TFTPU_CAPI_EXPORT XLA_TpuProgram* TpuProgram_New();
+
+// Destroys the `tpu_program`.
+TFTPU_CAPI_EXPORT void TpuProgram_Free(XLA_TpuProgram* tpu_program);
+
+// Creates an array of `XLA_TpuProgram*`.
+TFTPU_CAPI_EXPORT XLA_TpuProgram** TpuProgram_NewArray(size_t count);
+
+// Destroys an array of `XLA_TpuProgram*`.
+TFTPU_CAPI_EXPORT void TpuProgram_FreeArray(XLA_TpuProgram* tpu_program[]);
+
+// Unloads and destroys the `tpu_program`. Once the TPU program is unloaded and
+// destroyed, it is in an unusable state.
+TFTPU_CAPI_EXPORT void TpuProgram_UnloadAndDestroy(XLA_TpuProgram* tpu_program,
+                                                   TF_Status* status);
+
+// Gets TPU program size in bytes from the `tpu_program`.
+TFTPU_CAPI_EXPORT int64_t
+TpuProgram_GetProgramSize(const XLA_TpuProgram* tpu_program);
+
+// Logs the summary of current memory state snapshot of the `tpu_program`.
+TFTPU_CAPI_EXPORT bool TpuProgram_LogProgramMemorySummary(
+    const XLA_TpuProgram* tpu_program);
+
+// Gets TPU program executable info from the `tpu_program`.
+TFTPU_CAPI_EXPORT void TpuProgram_GetExecutableInfo(
+    const XLA_TpuProgram* tpu_program, TpuSerializedProto* executable_info,
+    TF_Status* status);
+
+// Gets host transfer info proto.
+TFTPU_CAPI_EXPORT void TpuProgram_GetHostTransferInfo(
+    const XLA_TpuProgram* tpu_program, TpuSerializedProto* host_transfer_info,
+    TF_Status* status);
+
+// Gets HLO metadata proto.
+TFTPU_CAPI_EXPORT void TpuProgram_GetHloMetadata(
+    const XLA_TpuProgram* tpu_program, TpuSerializedProto* hlo_metadata,
+    TF_Status* status);
+
+// Gets may modify variables boolean value.
+TFTPU_CAPI_EXPORT void TpuProgram_GetMayModifyVariables(
+    const XLA_TpuProgram* tpu_program, bool* may_modify_variables);
+
+// Checks if TPU program has sharding.
+TFTPU_CAPI_EXPORT bool TpuProgram_HasSharding(
+    const XLA_TpuProgram* tpu_program);
+
+// Gets TPU program by sharding type. Return value is valid only when the
+// `status.status()` returns `OK`.
+TFTPU_CAPI_EXPORT XLA_TpuProgram* TpuProgram_GetTpuProgram(
+    XLA_TpuProgram* tpu_program, TpuProgramShardingType type);
+
+// Gets TPU executable proto from a `tpu_program`.
+TFTPU_CAPI_EXPORT void TpuProgram_SerializeTpuExecutable(
+    const XLA_TpuProgram* tpu_program, TpuExecutableSerializedProto* executable,
+    TF_Status* status);
+
+// Gets compilation metadata proto from a `tpu_program`.
+TFTPU_CAPI_EXPORT void TpuProgram_SerializeCompilerMetadata(
+    const XLA_TpuProgram* tpu_program,
+    CompilerMetadataSerializedProto* compiler_metadata, TF_Status* status);
+
+// Deserializes the `GetTpuProgramResponse` proto into an `XLA_TpuProgram`.
+TFTPU_CAPI_EXPORT void TpuProgram_DeserializeFromGetTpuProgramResponseProto(
+    TpuSerializedProto get_tpu_program_response, XLA_TpuProgram* tpu_program,
+    TF_Status* status);
+
+TFTPU_CAPI_EXPORT TpuProgramFingerprint
+TpuProgram_GetFingerprint(const XLA_TpuProgram* tpu_program);
+
+TFTPU_CAPI_EXPORT void TpuProgram_DestroyFingerprint(
+    TpuProgramFingerprint fingerprint);
+
+// Checks if whether a TPU compilation is enabled.
+TFTPU_CAPI_EXPORT bool TpuCompile_IsTpuCompilationEnabled();
+
+// XLA compilation cannot be cancelled. To avoid hanging the TF worker will exit
+// when cancellation is requested for an XLA compile op. Some tests require this
+// behavior to be disabled, and we test for this condition with the following
+// flag function.
+TFTPU_CAPI_EXPORT bool TpuCompile_ShouldTpuCompileOpIgnoreCancellation();
+
+// Returns the number of available TPU core count.
+TFTPU_CAPI_EXPORT int TpuTopology_AvailableCoreCount(
+    const XLA_TpuMeshState* mesh_state, TpuCoreTypeEnum tpu_core_type);
+
+// Recycle unused service port.
+TFTPU_CAPI_EXPORT void TpuNetUtil_RecycleUnusedPort(int port);
+
+// Creates a unique compilation cache `key` used for `put` and `get` operations.
+// Returned buffers are heap-allocated and must be owned.
+TFTPU_CAPI_EXPORT CompilationCacheKeyResult
+TpuCompile_CreateCompilationCacheKey(CompilationCacheKeyProperty property);
+
+// Destroys the CompilationCacheKeyResult returned by calling the
+// `TpuCompile_CreateCompilationCacheKey` API.
+TFTPU_CAPI_EXPORT void TpuCompile_DestroyCompilationCacheKey(
+    CompilationCacheKeyResult result);
+
+// Creates a guaranteed const fingerprint. Guarantee const is normally used in
+// TPU inference to avoid re-copying unchanged variables onto the TPU device.
+// It promises the value is identical for every execution in the same session
+// even if the actual value changes in later executions.
+TFTPU_CAPI_EXPORT uint64_t TpuCompile_CreateGuaranteedConstFingerprint(
+    uint64_t fingerprint, const char* data, size_t size);
+
+// Returns a pointer to the TPU topology struct.
+TFTPU_CAPI_EXPORT SE_TpuTopology* TpuUtil_GetTopologyPtr();
+
+// Returns XLA pad size from TPU topology.
+TFTPU_CAPI_EXPORT size_t TpuUtil_GetXlaPadSizeFromTpuTopology();
+
+XLA_TpuNodeContext* TpuNodeContext_Create(int device_ordinal,
+                                          TF_Status* status);
+void TpuNodeContext_Free(XLA_TpuNodeContext* node_context);
+
+void TpuNodeContext_CloseTpuHost(TF_Status* status);
+
+void TpuNodeContext_Initialize(int device_ordinal, TF_Status* status);
+
+bool TpuNodeContext_CompactionSupported(int device_ordinal);
+
+// Globally initialize the TPU system for inference.
+TFTPU_CAPI_EXPORT void TfTpu_InitializeTpuModelServer();
+
+typedef struct TpuEmbeddingEngine_ExecutePartitioner_Params {
+  int32_t struct_size;
+  void* priv;
+  TpuSerializedProto tpu_embedding_config;
+
+  // out
+  size_t* common_config_size;
+  char** common_config;
+  TF_Status* status;
+} TpuEmbeddingEngine_ExecutePartitioner_Params;
+
+TFTPU_CAPI_EXPORT void TpuEmbeddingEngine_ExecutePartitioner(
+    TpuEmbeddingEngine_ExecutePartitioner_Params* params);
+
+typedef struct TpuEmbeddingEngine_ConfigureMemory_Params {
+  int32_t struct_size;
+  void* priv;
+
+  int num_inputs;
+  size_t common_config_size;
+  const char* common_config;
+
+  // out
+  size_t* memory_config_size;
+  char** memory_config;
+  TF_Status* status;
+} TpuEmbeddingEngine_ConfigureMemory_Params;
+
+TFTPU_CAPI_EXPORT void TpuEmbeddingEngine_ConfigureMemory(
+    TpuEmbeddingEngine_ConfigureMemory_Params* params);
+
+typedef struct TpuEmbeddingEngine_CollateMemory_Params {
+  int32_t struct_size;
+  void* priv;
+
+  size_t memory_configs_size;
+  const TpuSerializedProto* memory_configs;
+
+  // out
+  size_t* merged_memory_config_size;
+  char** merged_memory_config;
+  TF_Status* status;
+} TpuEmbeddingEngine_CollateMemory_Params;
+
+TFTPU_CAPI_EXPORT void TpuEmbeddingEngine_CollateMemory(
+    TpuEmbeddingEngine_CollateMemory_Params* params);
+
+typedef struct TpuEmbeddingEngine_ConfigureHost_Params {
+  int32_t struct_size;
+  void* priv;
+
+  int num_inputs;
+  size_t common_config_size;
+  const char* common_config;
+  size_t memory_config_size;
+  const char* memory_config;
+  TpuSerializedProto tpu_embedding_config;
+
+  // out
+  size_t* network_config_size;
+  char** network_config;
+  TF_Status* status;
+} TpuEmbeddingEngine_ConfigureHost_Params;
+
+TFTPU_CAPI_EXPORT void TpuEmbeddingEngine_ConfigureHost(
+    TpuEmbeddingEngine_ConfigureHost_Params* params);
+
+typedef struct TpuEmbeddingEngine_ConnectHosts_Params {
+  int32_t struct_size;
+  void* priv;
+
+  size_t network_configs_size;
+  const TpuSerializedProto* network_configs;
+
+  // out
+  TF_Status* status;
+} TpuEmbeddingEngine_ConnectHosts_Params;
+
+TFTPU_CAPI_EXPORT void TpuEmbeddingEngine_ConnectHosts(
+    TpuEmbeddingEngine_ConnectHosts_Params* params);
+
+typedef struct TpuEmbeddingEngine_Finalize_Params {
+  int32_t struct_size;
+  void* priv;
+  const XLA_TpuMeshState* tpu_mesh_state;
+
+  size_t common_config_size;
+  const char* common_config;
+  size_t memory_config_size;
+  const char* memory_config;
+
+  // out
+  TF_Status* status;
+} TpuEmbeddingEngine_Finalize_Params;
+
+TFTPU_CAPI_EXPORT void TpuEmbeddingEngine_Finalize(
+    TpuEmbeddingEngine_Finalize_Params* params);
+
+typedef struct TpuEmbeddingEngine_IsInitialized_Params {
+  int32_t struct_size;
+  void* priv;
+
+  size_t config_string_size;
+  const char* config_string;
+
+  // out
+  bool* is_tpu_embedding_initialized;
+  TF_Status* status;
+} TpuEmbeddingEngine_IsInitialized_Params;
+
+TFTPU_CAPI_EXPORT void TpuEmbeddingEngine_IsInitialized(
+    TpuEmbeddingEngine_IsInitialized_Params* params);
+
+TFTPU_CAPI_EXPORT void TpuEmbeddingEngine_WriteParameters(
+    TpuEmbeddingEngineParameters* params, TF_Status* status);
+
+TFTPU_CAPI_EXPORT void TpuEmbeddingEngine_ReadParameters(
+    TpuEmbeddingEngineParameters* params, TF_Status* status);
+
+typedef struct TF_Tensor TF_Tensor;
+
+typedef struct TpuEmbeddingEngine_EnqueueTensorBatch_Params {
+  int32_t struct_size;
+  void* priv;
+
+  int32_t mode;
+  int32_t local_device_ordinal;
+  TpuEmbedding_TensorBatchFixedState* fixed_state;
+
+  TF_Tensor** sample_indices_tensors;
+  size_t sample_indices_tensors_size;
+  TF_Tensor** embedding_indices_tensors;
+  size_t embedding_indices_tensors_size;
+  TF_Tensor** aggregation_weights_tensors;
+  size_t aggregation_weights_tensors_size;
+  TF_Status* status;
+} TpuEmbeddingEngine_EnqueueTensorBatch_Params;
+
+TFTPU_CAPI_EXPORT void TpuEmbeddingEngine_EnqueueTensorBatch(
+    TpuEmbeddingEngine_EnqueueTensorBatch_Params* params);
+
+typedef struct TpuEmbedding_TensorBatchFixedState_Create_Params {
+  int32_t struct_size;
+  void* priv;
+
+  size_t combiners_size;
+  char** combiners;
+
+  // out
+  TF_Status* status;
+} TpuEmbedding_TensorBatchFixedState_Create_Params;
+
+TFTPU_CAPI_EXPORT TpuEmbedding_TensorBatchFixedState*
+TpuEmbeddingTensorBatchFixedState_Create(
+    TpuEmbedding_TensorBatchFixedState_Create_Params* params);
+TFTPU_CAPI_EXPORT void TpuEmbeddingTensorBatchFixedState_Destroy(
+    TpuEmbedding_TensorBatchFixedState* fixed_state);
+
+typedef struct TpuEmbeddingEngine_RecvActivationsComputation_Params {
+  int32_t struct_size;
+  void* priv;
+
+  TpuSerializedProto tpu_embedding_config;
+  XLA_Shape* deduplication_data_shape;
+  TpuSerializedProto* op_sharding;
+
+  // out
+  TpuSerializedProto* xla_computation;
+  TF_Status* status;
+} TpuEmbeddingEngine_RecvActivationsComputation_Params;
+
+TFTPU_CAPI_EXPORT void TpuEmbeddingEngine_RecvActivationsComputation(
+    TpuEmbeddingEngine_RecvActivationsComputation_Params* params);
+
+typedef struct
+    TpuEmbeddingEngine_RecvTPUEmbeddingDeduplicationDataComputation_Params {
+  int32_t struct_size;
+  void* priv;
+
+  TpuSerializedProto tpu_embedding_config;
+  TpuSerializedProto* op_sharding;
+  // out
+  TpuSerializedProto* xla_computation;
+  TF_Status* status;
+} TpuEmbeddingEngine_RecvTPUEmbeddingDeduplicationDataComputation_Params;
+
+TFTPU_CAPI_EXPORT void
+TpuEmbeddingEngine_RecvTPUEmbeddingDeduplicationDataComputation(
+    TpuEmbeddingEngine_RecvTPUEmbeddingDeduplicationDataComputation_Params*
+        params);
+
+typedef struct TpuEmbeddingEngine_SendTPUEmbeddingGradientsComputation_Params {
+  int32_t struct_size;
+  void* priv;
+
+  int32_t num_inputs;
+  TpuSerializedProto tpu_embedding_config;
+  XLA_Shape* learning_rate_tuple_shape;
+  XLA_Shape* deduplication_data_shape;
+  XLA_Shape* gradient_tuple_shape;
+  TpuSerializedProto* op_sharding;
+  // out
+  TpuSerializedProto* xla_computation;
+  TF_Status* status;
+} TpuEmbeddingEngine_SendTPUEmbeddingGradientsComputation_Params;
+
+TFTPU_CAPI_EXPORT void TpuEmbeddingEngine_SendTPUEmbeddingGradientsComputation(
+    TpuEmbeddingEngine_SendTPUEmbeddingGradientsComputation_Params* params);
+
+typedef struct TpuEmbeddingEngine_DedupDataTupleMaskComputation_Params {
+  int32_t struct_size;
+  void* priv;
+
+  TpuSerializedProto tpu_embedding_config;
+  // out
+  TpuSerializedProto* xla_computation;
+  TF_Status* status;
+} TpuEmbeddingEngine_DedupDataTupleMaskComputation_Params;
+
+TFTPU_CAPI_EXPORT void TpuEmbeddingEngine_DedupDataTupleMaskComputation(
+    TpuEmbeddingEngine_DedupDataTupleMaskComputation_Params* params);
+
+typedef struct SparseCore_GetMaxIdsAndUniques_Params {
+  size_t struct_size;
+  void* priv;
+  const char* program_key;
+  const char* table_name;
+  int64_t num_samples_per_sparse_core;
+  int64_t feature_width;
+  // out
+  TF_Status* status;
+  int64_t max_ids_per_partition;
+  int64_t max_unique_ids_per_partition;
+} SparseCore_GetMaxIdsAndUniques_Params;
+
+TFTPU_CAPI_EXPORT void SparseCore_GetMaxIdsAndUniques(
+    SparseCore_GetMaxIdsAndUniques_Params* params);
+
+struct TfTpu_OpsApiFn {
+  TFTPU_ADD_FN_IN_STRUCT(TpuCompile_CompileAndBuild);
+  TFTPU_ADD_FN_IN_STRUCT(TpuCompile_XrtCompileAndBuild);
+
+  TFTPU_ADD_FN_IN_STRUCT(TpuMeshState_Create);
+  TFTPU_ADD_FN_IN_STRUCT(TpuMeshState_Free);
+  TFTPU_ADD_FN_IN_STRUCT(TpuMeshState_MeshCommonState);
+
+  TFTPU_ADD_FN_IN_STRUCT(TpuEmbeddingEngineState_Create);
+  TFTPU_ADD_FN_IN_STRUCT(TpuEmbeddingEngineState_Free);
+  TFTPU_ADD_FN_IN_STRUCT(TpuEmbeddingEngineState_GetState);
+
+  TFTPU_ADD_FN_IN_STRUCT(TpuExecutable_LoadProgramAndEnqueueToStream);
+
+  TFTPU_ADD_FN_IN_STRUCT(HardwareLayout_HostShapeToDeviceShape);
+  TFTPU_ADD_FN_IN_STRUCT(HardwareLayout_ShapeSize);
+  TFTPU_ADD_FN_IN_STRUCT(HardwareLayout_ShapeSizeCompact);
+  TFTPU_ADD_FN_IN_STRUCT(HardwareLayout_ShapeSizeCompactRaw);
+
+  TFTPU_ADD_FN_IN_STRUCT(TpuExecute_RuntimeInputToPaddedData);
+
+  TFTPU_ADD_FN_IN_STRUCT(TpuExecute_GetTpuEmbeddingMemoryAllocations);
+  TFTPU_ADD_FN_IN_STRUCT(TpuExecute_FreeTpuEmbeddingMemoryAllocations);
+
+  TFTPU_ADD_FN_IN_STRUCT(ConfigureDistributedTpuOp_DoWork);
+  TFTPU_ADD_FN_IN_STRUCT(WaitForDistributedTpuOp_DoWork);
+  TFTPU_ADD_FN_IN_STRUCT(InitializeHostForDistributedTpuOp_DoWork);
+  TFTPU_ADD_FN_IN_STRUCT(SetGlobalTPUArrayOp_DoWork);
+  TFTPU_ADD_FN_IN_STRUCT(DisconnectDistributedTpuChipsOp_DoWork);
+  TFTPU_ADD_FN_IN_STRUCT(TpuConfigurationApi_FreeCharArray);
+  TFTPU_ADD_FN_IN_STRUCT(TpuConfigurationApi_FreeInt32Array);
+  TFTPU_ADD_FN_IN_STRUCT(TpuConfigurationApi_HasTPUPodState);
+  TFTPU_ADD_FN_IN_STRUCT(TpuConfigurationApi_TpusPerHost);
+  TFTPU_ADD_FN_IN_STRUCT(TpuConfigurationApi_TpuMemoryLimit);
+  TFTPU_ADD_FN_IN_STRUCT(TpuConfigurationApi_RemoteCompilationCacheSizeInBytes);
+  TFTPU_ADD_FN_IN_STRUCT(
+      TpuConfigurationApi_CompilationCacheServerAddressFromConfig);
+  TFTPU_ADD_FN_IN_STRUCT(TpuConfigurationApi_GetServerAddressAndPort);
+
+  TFTPU_ADD_FN_IN_STRUCT(TpuProgram_New);
+  TFTPU_ADD_FN_IN_STRUCT(TpuProgram_Free);
+  TFTPU_ADD_FN_IN_STRUCT(TpuProgram_NewArray);
+  TFTPU_ADD_FN_IN_STRUCT(TpuProgram_FreeArray);
+  TFTPU_ADD_FN_IN_STRUCT(TpuProgram_UnloadAndDestroy);
+  TFTPU_ADD_FN_IN_STRUCT(TpuProgram_GetProgramSize);
+  TFTPU_ADD_FN_IN_STRUCT(TpuProgram_LogProgramMemorySummary);
+  TFTPU_ADD_FN_IN_STRUCT(TpuProgram_GetExecutableInfo);
+  TFTPU_ADD_FN_IN_STRUCT(TpuProgram_GetHostTransferInfo);
+  TFTPU_ADD_FN_IN_STRUCT(TpuProgram_GetHloMetadata);
+  TFTPU_ADD_FN_IN_STRUCT(TpuProgram_GetMayModifyVariables);
+  TFTPU_ADD_FN_IN_STRUCT(TpuProgram_HasSharding);
+  TFTPU_ADD_FN_IN_STRUCT(TpuProgram_GetTpuProgram);
+  TFTPU_ADD_FN_IN_STRUCT(TpuProgram_SerializeTpuExecutable);
+  TFTPU_ADD_FN_IN_STRUCT(TpuProgram_SerializeCompilerMetadata);
+  TFTPU_ADD_FN_IN_STRUCT(TpuProgram_DeserializeFromGetTpuProgramResponseProto);
+  TFTPU_ADD_FN_IN_STRUCT(TpuProgram_GetFingerprint);
+  TFTPU_ADD_FN_IN_STRUCT(TpuProgram_DestroyFingerprint);
+
+  TFTPU_ADD_FN_IN_STRUCT(TpuCompile_IsTpuCompilationEnabled);
+  TFTPU_ADD_FN_IN_STRUCT(TpuCompile_ShouldTpuCompileOpIgnoreCancellation);
+  TFTPU_ADD_FN_IN_STRUCT(TpuTopology_AvailableCoreCount);
+  TFTPU_ADD_FN_IN_STRUCT(TpuNetUtil_RecycleUnusedPort);
+  TFTPU_ADD_FN_IN_STRUCT(TpuCompile_CreateCompilationCacheKey);
+  TFTPU_ADD_FN_IN_STRUCT(TpuCompile_DestroyCompilationCacheKey);
+  TFTPU_ADD_FN_IN_STRUCT(TpuCompile_CreateGuaranteedConstFingerprint);
+  TFTPU_ADD_FN_IN_STRUCT(TpuUtil_GetTopologyPtr);
+  TFTPU_ADD_FN_IN_STRUCT(TpuUtil_GetXlaPadSizeFromTpuTopology);
+
+  TFTPU_ADD_FN_IN_STRUCT(TpuNodeContext_Create);
+  TFTPU_ADD_FN_IN_STRUCT(TpuNodeContext_Free);
+  TFTPU_ADD_FN_IN_STRUCT(TpuNodeContext_CloseTpuHost);
+  TFTPU_ADD_FN_IN_STRUCT(TpuNodeContext_Initialize);
+  TFTPU_ADD_FN_IN_STRUCT(TpuNodeContext_CompactionSupported);
+
+  TFTPU_ADD_FN_IN_STRUCT(TfTpu_InitializeTpuModelServer);
+
+  TFTPU_ADD_FN_IN_STRUCT(TfTpuOrdinalSelector_Create);
+  TFTPU_ADD_FN_IN_STRUCT(TfTpuOrdinalSelector_Destroy);
+  TFTPU_ADD_FN_IN_STRUCT(TfTpuOrdinalSelector_GetOrdinal);
+  TFTPU_ADD_FN_IN_STRUCT(TfTpuOrdinalSelector_DequeueFromCoreSelector);
+  TFTPU_ADD_FN_IN_STRUCT(TfTpu_GetTpuPartitionedCallParams);
+
+  TFTPU_ADD_FN_IN_STRUCT(TpuEmbeddingEngine_ExecutePartitioner);
+  TFTPU_ADD_FN_IN_STRUCT(TpuEmbeddingEngine_ConfigureMemory);
+  TFTPU_ADD_FN_IN_STRUCT(TpuEmbeddingEngine_CollateMemory);
+  TFTPU_ADD_FN_IN_STRUCT(TpuEmbeddingEngine_ConfigureHost);
+  TFTPU_ADD_FN_IN_STRUCT(TpuEmbeddingEngine_ConnectHosts);
+  TFTPU_ADD_FN_IN_STRUCT(TpuEmbeddingEngine_Finalize);
+  TFTPU_ADD_FN_IN_STRUCT(TpuEmbeddingEngine_IsInitialized);
+  TFTPU_ADD_FN_IN_STRUCT(TpuEmbeddingEngine_WriteParameters);
+  TFTPU_ADD_FN_IN_STRUCT(TpuEmbeddingEngine_ReadParameters);
+  TFTPU_ADD_FN_IN_STRUCT(TpuEmbeddingTensorBatchFixedState_Create);
+  TFTPU_ADD_FN_IN_STRUCT(TpuEmbeddingTensorBatchFixedState_Destroy);
+  TFTPU_ADD_FN_IN_STRUCT(TpuEmbeddingEngine_EnqueueTensorBatch);
+  TFTPU_ADD_FN_IN_STRUCT(TpuEmbeddingEngine_RecvActivationsComputation);
+  TFTPU_ADD_FN_IN_STRUCT(
+      TpuEmbeddingEngine_RecvTPUEmbeddingDeduplicationDataComputation);
+  TFTPU_ADD_FN_IN_STRUCT(
+      TpuEmbeddingEngine_SendTPUEmbeddingGradientsComputation);
+  TFTPU_ADD_FN_IN_STRUCT(TpuEmbeddingEngine_DedupDataTupleMaskComputation);
+
+  TFTPU_ADD_FN_IN_STRUCT(SparseCore_GetMaxIdsAndUniques);
+};
+
+}  // extern "C"
+
+#endif  // XLA_STREAM_EXECUTOR_TPU_TPU_OPS_C_API_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/tpu/tpu_profiler_c_api.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/tpu/tpu_profiler_c_api.h
new file mode 100644
index 0000000000000000000000000000000000000000..efb81d37acc14b5ac22f4147d11e4e4186dbdf08
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/tpu/tpu_profiler_c_api.h
@@ -0,0 +1,84 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef XLA_STREAM_EXECUTOR_TPU_TPU_PROFILER_C_API_H_
+#define XLA_STREAM_EXECUTOR_TPU_TPU_PROFILER_C_API_H_
+
+#include <stddef.h>
+
+#include <cstdint>
+
+#include "xla/stream_executor/tpu/c_api_decl.h"
+#include "xla/stream_executor/tpu/libtftpu.h"
+
+extern "C" {
+
+typedef struct TpuProfiler TpuProfiler;
+
+// Creates a TPU profiler that is ready to start profiling.
+TFTPU_CAPI_EXPORT void TpuProfiler_Create(TpuProfiler** tpu_profiler,
+                                          TF_Status* status);
+// Destroys the given TPU profiler.
+TFTPU_CAPI_EXPORT void TpuProfiler_Destroy(TpuProfiler* tpu_profiler);
+// Starts profiling if not already started, returns an error otherwise.
+TFTPU_CAPI_EXPORT void TpuProfiler_Start(TpuProfiler* tpu_profiler,
+                                         TF_Status* status);
+// Stops profiling if not already stopped, returns an error otherwise.
+TFTPU_CAPI_EXPORT void TpuProfiler_Stop(TpuProfiler* tpu_profiler,
+                                        TF_Status* status);
+// Serializes profiled data into `buffer` and returns the size of `buffer`. The
+// profile data held by the TPU driver will be cleared after retrieval.
+//
+// Step 1. Query the size of buffer required into `size_in_bytes`.
+//
+//   size_t size_in_bytes;
+//   TpuProfiler_CollectData(profiler, status, nullptr, &size_in_bytes);
+//
+// Step 2. Retrieve the data into a `buffer` of size `size_in_bytes`.
+//         Subsequently,The TPU driver clears its copy of the profile data.
+//
+//   uint8_t buffer = new uint8_t[size_in_bytes];
+//   TpuProfiler_CollectData(profiler, status, buffer, size_in_bytes);
+//
+// Step 3. Unpack the data into an XSpace.
+//
+//   tensorflow::profiler::XSpace space;
+//   space.ParseFromArray(buffer, size_in_bytes);
+//
+TFTPU_CAPI_EXPORT void TpuProfiler_CollectData(TpuProfiler* tpu_profiler,
+                                               TF_Status* status,
+                                               uint8_t* buffer,
+                                               size_t* size_in_bytes);
+
+// Status helpers to create TFStatus for Profiler.
+TF_Status* TpuStatus_New();
+void TpuStatus_Free(TF_Status* status);
+const char* TpuStatus_Message(TF_Status* status);
+int TpuStatus_Code(TF_Status* status);
+
+struct TfTpu_ProfilerApiFn {
+  TFTPU_ADD_FN_IN_STRUCT(TpuProfiler_Create);
+  TFTPU_ADD_FN_IN_STRUCT(TpuProfiler_Destroy);
+  TFTPU_ADD_FN_IN_STRUCT(TpuProfiler_Start);
+  TFTPU_ADD_FN_IN_STRUCT(TpuProfiler_Stop);
+  TFTPU_ADD_FN_IN_STRUCT(TpuProfiler_CollectData);
+  TFTPU_ADD_FN_IN_STRUCT(TpuStatus_New);
+  TFTPU_ADD_FN_IN_STRUCT(TpuStatus_Free);
+  TFTPU_ADD_FN_IN_STRUCT(TpuStatus_Message);
+  TFTPU_ADD_FN_IN_STRUCT(TpuStatus_Code);
+};
+
+}  // extern "C"
+
+#endif  // XLA_STREAM_EXECUTOR_TPU_TPU_PROFILER_C_API_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/trace_listener.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/trace_listener.h
new file mode 100644
index 0000000000000000000000000000000000000000..5b1340dc7cfbb89f4b725f789e23db9a48e0d77c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/stream_executor/trace_listener.h
@@ -0,0 +1,74 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// This file defines the StreamExecutor trace listener, used for inserting
+// non-device-specific instrumentation into the StreamExecutor.
+#ifndef XLA_STREAM_EXECUTOR_TRACE_LISTENER_H_
+#define XLA_STREAM_EXECUTOR_TRACE_LISTENER_H_
+
+#include "xla/stream_executor/device_memory.h"
+#include "xla/stream_executor/kernel.h"
+#include "xla/stream_executor/launch_dim.h"
+#include "tsl/platform/status.h"
+
+namespace stream_executor {
+
+class Stream;
+
+// Traces StreamExecutor PIMPL-level events.
+// The few StreamExecutor interfaces that are synchronous have both Begin and
+// Complete versions of their trace calls. Asynchronous operations only have
+// Submit calls, as execution of the underlying operations is device-specific.
+// As all tracing calls mirror StreamExecutor routines, documentation here is
+// minimal.
+//
+// All calls have default implementations that perform no work; subclasses
+// should override functionality of interest. Keep in mind that these routines
+// are not called on a dedicated thread, so callbacks should execute quickly.
+//
+// Note: This API is constructed on an as-needed basis. Users should add
+// support for further StreamExecutor operations as required. By enforced
+// convention (see SCOPED_TRACE in stream_executor_pimpl.cc), synchronous
+// tracepoints should be named NameBegin and NameComplete.
+class TraceListener {
+ public:
+  virtual ~TraceListener() {}
+
+  virtual void LaunchSubmit(Stream* stream, const ThreadDim& thread_dims,
+                            const BlockDim& block_dims,
+                            const KernelBase& kernel,
+                            const KernelArgsArrayBase& args) {}
+
+  virtual void SynchronousMemcpyH2DBegin(int64_t correlation_id,
+                                         const void* host_src, int64_t size,
+                                         DeviceMemoryBase* gpu_dst) {}
+  virtual void SynchronousMemcpyH2DComplete(int64_t correlation_id,
+                                            const tsl::Status* result) {}
+
+  virtual void SynchronousMemcpyD2HBegin(int64_t correlation_id,
+                                         const DeviceMemoryBase& gpu_src,
+                                         int64_t size, void* host_dst) {}
+  virtual void SynchronousMemcpyD2HComplete(int64_t correlation_id,
+                                            const tsl::Status* result) {}
+
+  virtual void BlockHostUntilDoneBegin(int64_t correlation_id, Stream* stream) {
+  }
+  virtual void BlockHostUntilDoneComplete(int64_t correlation_id,
+                                          const tsl::Status* result) {}
+};
+
+}  // namespace stream_executor
+
+#endif  // XLA_STREAM_EXECUTOR_TRACE_LISTENER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/translate/hlo_to_mhlo/attribute_importer.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/translate/hlo_to_mhlo/attribute_importer.h
new file mode 100644
index 0000000000000000000000000000000000000000..cd88cd95010e43805796fa47f6ceb08cefeadc17
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/translate/hlo_to_mhlo/attribute_importer.h
@@ -0,0 +1,79 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_TRANSLATE_HLO_TO_MHLO_ATTRIBUTE_IMPORTER_H_
+#define XLA_TRANSLATE_HLO_TO_MHLO_ATTRIBUTE_IMPORTER_H_
+
+#include <utility>
+#include <vector>
+
+#include "mlir/IR/Attributes.h"  // from @llvm-project
+#include "mlir/IR/Builders.h"  // from @llvm-project
+#include "xla/mlir_hlo/mhlo/IR/hlo_ops.h"
+#include "xla/service/hlo.pb.h"
+#include "xla/shape.h"
+#include "xla/shape_util.h"
+#include "xla/statusor.h"
+#include "xla/xla_data.pb.h"
+
+namespace xla {
+
+// Converts an XLA PrecisionConfig to the corresponding MLIR attribute.
+mlir::ArrayAttr ConvertPrecisionConfig(const PrecisionConfig* config,
+                                       mlir::Builder* builder);
+
+// Converts the gather dimensions to attributes.
+mlir::mhlo::GatherDimensionNumbersAttr ConvertGatherDimensionNumbers(
+    const xla::GatherDimensionNumbers& dnums, mlir::Builder* builder);
+
+// Converts the scatter dimensions to attributes.
+mlir::mhlo::ScatterDimensionNumbersAttr ConvertScatterDimensionNumbers(
+    const xla::ScatterDimensionNumbers& dnums, mlir::Builder* builder);
+
+// Converts the dot dimensions to attributes.
+mlir::mhlo::DotDimensionNumbersAttr ConvertDotDimensionNumbers(
+    const DotDimensionNumbers& dnums, mlir::Builder* builder);
+
+// Converts the conv dimensions to attributes.
+mlir::mhlo::ConvDimensionNumbersAttr ConvertConvDimensionNumbers(
+    const xla::ConvolutionDimensionNumbers& dnums, mlir::Builder* builder);
+
+// Converts the output operand aliasing to attributes.
+mlir::ArrayAttr ConvertOutputOperandAliasing(
+    const std::vector<std::pair<xla::ShapeIndex,
+                                std::pair<int64_t, xla::ShapeIndex>>>& aliaInfo,
+    mlir::Builder* builder);
+
+StatusOr<mlir::mhlo::FftType> ConvertFftType(FftType type);
+StatusOr<mlir::mhlo::Transpose> ConvertTranspose(
+    TriangularSolveOptions_Transpose transpose);
+
+StatusOr<mlir::mhlo::CustomCallApiVersion> ConvertCustomCallApiVersion(
+    xla::CustomCallApiVersion api_version);
+
+// Extracts layouts from shapes and converts it into layout attributes (array of
+// rank-1 index tensors). Returns an error if any of the shapes is a tuple.
+StatusOr<mlir::ArrayAttr> ExtractLayoutsFromShapes(
+    const absl::Span<const Shape> shapes_with_layouts, mlir::Builder* builder);
+
+// Extracts the layouts of each element from a tuple shape and returns them as
+// an array of rank-1 index tensors. Returns an error in presence of nested
+// tuple shapes.
+StatusOr<mlir::ArrayAttr> ExtractLayoutsFromTuple(const xla::Shape shape,
+                                                  mlir::Builder* builder);
+
+}  // namespace xla
+
+#endif  // XLA_TRANSLATE_HLO_TO_MHLO_ATTRIBUTE_IMPORTER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/translate/hlo_to_mhlo/hlo_function_importer.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/translate/hlo_to_mhlo/hlo_function_importer.h
new file mode 100644
index 0000000000000000000000000000000000000000..66794a4bf80480637a12005e9c2e71e6ad5c8e74
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/translate/hlo_to_mhlo/hlo_function_importer.h
@@ -0,0 +1,301 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_TRANSLATE_HLO_TO_MHLO_HLO_FUNCTION_IMPORTER_H_
+#define XLA_TRANSLATE_HLO_TO_MHLO_HLO_FUNCTION_IMPORTER_H_
+
+#include <string>
+#include <unordered_map>
+
+#include "absl/types/optional.h"
+#include "mlir/Dialect/Arith/IR/Arith.h"  // from @llvm-project
+#include "mlir/Dialect/Func/IR/FuncOps.h"  // from @llvm-project
+#include "mlir/Dialect/SparseTensor/IR/SparseTensor.h"  // from @llvm-project
+#include "mlir/IR/Attributes.h"  // from @llvm-project
+#include "mlir/IR/Builders.h"  // from @llvm-project
+#include "mlir/IR/BuiltinOps.h"  // from @llvm-project
+#include "mlir/IR/BuiltinTypes.h"  // from @llvm-project
+#include "mlir/IR/MLIRContext.h"  // from @llvm-project
+#include "xla/comparison_util.h"
+#include "xla/hlo/ir/hlo_sharding.h"
+#include "xla/mlir_hlo/mhlo/IR/hlo_ops.h"
+#include "xla/service/hlo.pb.h"
+#include "xla/status.h"
+#include "xla/statusor.h"
+#include "xla/xla_data.pb.h"
+
+namespace xla {
+
+class HloModule;
+class HloComputation;
+class HloInstruction;
+class Shape;
+
+// HLO bounded dynamic shapes can be converted to either MLIR dynamic shapes
+// (which lose the bound information) or casted to static shape using the
+// bounds.
+enum class DynamicShapeHandlingMode { kDynamic, kConvertToStatic };
+
+// Helper class for importing HloComputations.
+class HloFunctionImporter {
+ public:
+  // Imports the given computation as a function in the given symbol table and
+  // returns the FuncOp. This also imports any computations referred by
+  // instructions in this computation.
+  static StatusOr<mlir::func::FuncOp> ImportAsFunc(
+      const xla::HloComputation& computation, mlir::SymbolTable& symbol_table,
+      std::unordered_map<const xla::HloComputation*, mlir::func::FuncOp>*
+          function_map,
+      mlir::Builder* builder, bool is_main);
+
+  // Imports the given hlo computation to the specified region. If
+  // 'flatten_region_arg_tuple' is true, then flatten the tuple-typed region
+  // argument(s) and return value(s).
+  static Status ImportAsRegion(const xla::HloComputation& computation,
+                               mlir::SymbolTable& symbol_table,
+                               mlir::Region* region, mlir::Builder* builder,
+                               bool flatten_region_arg_tuple = false);
+
+  // Imports the given computation to the given place specified by `builder`.
+  // `arguments` contains values for all parameters.
+  static StatusOr<mlir::Value> ImportInstructions(
+      const xla::HloComputation& computation,
+      const llvm::SmallVectorImpl<mlir::Value>& arguments,
+      mlir::SymbolTable& symbol_table, mlir::OpBuilder* builder);
+
+  static StatusOr<mlir::Operation*> ImportInstruction(
+      const xla::HloInstruction* instr,
+      const llvm::SmallVectorImpl<mlir::Value>& operands,
+      mlir::SymbolTable& symbol_table, mlir::OpBuilder* builder,
+      DynamicShapeHandlingMode mode = DynamicShapeHandlingMode::kDynamic);
+
+  static void SetLayoutForMlir(mlir::Operation* op, const Shape& shape,
+                               llvm::StringRef attr_name);
+
+  // TODO(b/179166199): move this to attribute_importer.h.
+  // Converts XLA instruction source target pairs to MLIR attribute.
+  static mlir::NamedAttribute ConvertSourceTargetPairs(
+      const std::vector<std::pair<int64_t, int64_t>>& source_target_pairs,
+      mlir::Builder* builder);
+
+  // TODO(b/179166199): move this to attribute_importer.h.
+  // Converts replica groups to attribute
+  static mlir::NamedAttribute ConvertReplicaGroups(
+      absl::Span<const ReplicaGroup> replica_groups, mlir::Builder* builder);
+
+  // For mlir::IfOp or mlir::CaseOp, replace the uses of their region's block
+  // arguments with 'implicit_operands'. Here | implicit_operands | == sum of
+  // the number of arguments in all the regions in IfOp or CaseOp.
+  void ReplaceBlockArgumentsWithImplicitOperands(
+      mlir::Operation* op, llvm::ArrayRef<mlir::Value> implicit_operands);
+
+  // Create a TupleOp using the results of 'op' if 'type' is a mlir::TupleType.
+  // Otherwise, return 'op'.
+  mlir::Operation* CreateTupleFromOpResults(mlir::OpBuilder* func_builder,
+                                            mlir::Location loc,
+                                            mlir::Operation* op,
+                                            mlir::Type type);
+
+  // FlattenTupleType flattens the types in (nested) tuple-type 'type' and
+  // stores them in 'types'.
+  static void FlattenTupleType(
+      mlir::Type type, llvm::SmallVectorImpl<mlir::Type>& flattened_types);
+
+  // FlattenTupleValue flattens the values in (nested) tuple-typed 'value' and
+  // stores them in 'flattened_values'.
+  static void FlattenTupleValue(
+      mlir::OpBuilder* func_builder, mlir::Location loc, mlir::Value value,
+      llvm::SmallVectorImpl<mlir::Value>& flattened_values);
+
+  // CreateTupleValue creates a root TupleOp of (nested) tuple-type 'type' using
+  // the non-tuple-typed values in 'flatten_values'.
+  //
+  // e.g., Given 'flatten_values': [V1, V2, V3] &'type': tuple<T1,tuple<T1,T2>>,
+  //      The function returns %t2 such that:
+  //       %t1 = mhlo.tuple(V2,V3) : (T2,T3) -> tuple<T2,T3>
+  //       %t2 = mhlo.tuple(V1,%t1): (T1,tuple<T2,T3>) -> tuple<T1,tuple<T1,T2>>
+  //
+  // Note: 1. FlattenTupleValue and CreateTupleValue is a pair of functions to
+  //          resp. flatten and create tuples in the exact same order.
+  //       2. `flatten_values`, initially storing the flattened values, will be
+  //          mutated to a 0-length array by the end of function invocation.
+  static mlir::Value CreateTupleValue(
+      mlir::OpBuilder* func_builder, mlir::Location loc,
+      llvm::MutableArrayRef<mlir::Value>& flatten_values, mlir::Type type);
+
+ private:
+  HloFunctionImporter(mlir::SymbolTable& symbol_table,
+                      std::unordered_map<const xla::HloComputation*,
+                                         mlir::func::FuncOp>* function_map,
+                      mlir::Builder* builder)
+      : context_(symbol_table.getOp()->getContext()),
+        symbol_table_(symbol_table),
+        builder_(builder),
+        function_map_(function_map) {
+    context_->loadDialect<mlir::arith::ArithDialect>();
+    context_->loadDialect<mlir::func::FuncDialect>();
+    context_->loadDialect<mlir::mhlo::MhloDialect>();
+    context_->loadDialect<mlir::sparse_tensor::SparseTensorDialect>();
+  }
+
+  // Imports the given computation as a new function, if it hasn't been already
+  // imported.
+  StatusOr<mlir::func::FuncOp> ImportAsFunc(
+      const xla::HloComputation& computation, bool is_main);
+
+  // Imports the given computation in the specified region.
+  Status ImportAsRegion(const HloComputation& computation, mlir::Region* region,
+                        bool flatten_region_arg_tuple = false);
+
+  // Imports instructions from the given computation in the specified block.
+  // Assumes that the block already has correct arguments populated.
+  Status ImportInstructions(const HloComputation& computation,
+                            mlir::Block* block, bool flatten_region_arg_tuple);
+  StatusOr<mlir::Value> ImportInstructionsImpl(
+      const xla::HloComputation& computation,
+      const llvm::SmallVectorImpl<mlir::Value>& arguments,
+      mlir::OpBuilder* builder);
+
+  // Imports an instruction.
+  StatusOr<mlir::Operation*> ImportInstructionWithLayout(
+      const xla::HloInstruction* instruction,
+      const llvm::SmallVectorImpl<mlir::Value>& operands,
+      mlir::OpBuilder* func_builder,
+      DynamicShapeHandlingMode mode = DynamicShapeHandlingMode::kDynamic);
+
+  StatusOr<mlir::Operation*> ImportInstructionImpl(
+      const HloInstruction* instruction,
+      const llvm::SmallVectorImpl<mlir::Value>& operands,
+      mlir::OpBuilder* func_builder,
+      DynamicShapeHandlingMode mode = DynamicShapeHandlingMode::kDynamic);
+
+  // Gets the MLIR operand values from an HLO Instruction.
+  StatusOr<llvm::SmallVector<mlir::Value, 4>> GetOperands(
+      const xla::HloInstruction* instruction);
+
+  // Converts xla Tensor type to the corresponding MLIR type.
+  StatusOr<mlir::RankedTensorType> ConvertTensorType(const xla::Shape& shape);
+
+  // Converts an XLA shape/layout to the corresponding MLIR layout, in
+  // flattened_attr, while flattening the tuple layout.
+  Status ConvertShapeToMlirLayout(
+      const xla::Shape& shape,
+      llvm::SmallVectorImpl<mlir::Attribute>& flattened_attr);
+
+  // Returns the output type of an HloInstruction.
+  StatusOr<mlir::Type> GetReturnType(const xla::HloInstruction* instruction);
+
+  // Takes a list of HloInstructions and generates the list of types used for
+  // input, bypassing tuples to subsets.
+  Status GetMlirTypes(absl::Span<const HloInstruction* const> instructions,
+                      llvm::SmallVectorImpl<mlir::Type>* types);
+
+  // Returns the Mlir Value for the corresponding HloInstruction.
+  StatusOr<mlir::Value> GetMlirValue(const xla::HloInstruction* instruction);
+
+  // Converts an XLA ComparisonDirection to the corresponding MLIR attribute.
+  mlir::NamedAttribute ConvertComparisonDirection(
+      ComparisonDirection direction);
+
+  // Converts an XLA Comparison::Type to the corresponding MLIR attribute.
+  mlir::NamedAttribute ConvertComparisonType(Comparison::Type type);
+
+  // Converts an XLA CustomCallSchedule to the corresponding MLIR attribute.
+  mlir::NamedAttribute ConvertCustomCallSchedule(
+      xla::CustomCallSchedule schedule);
+
+  // Converts the dimensions of an HLO instruction into an MLIR attribute.
+  mlir::DenseIntElementsAttr ConvertDimensions(
+      absl::Span<const int64_t> op_dimensions);
+
+  // Converts Array ref to an DenseIntElementsAttr.
+  mlir::DenseIntElementsAttr Convert(llvm::ArrayRef<int64_t> elements);
+
+  // Converts Array ref of bools to a DenseIntElementsAttr of I1 type.
+  mlir::DenseIntElementsAttr Convert(llvm::ArrayRef<bool> elements);
+
+  // Converts Array ref to padding attribute. Input is a flattened list of
+  // padding low and padding high for each of the spatial dimensions.
+  mlir::NamedAttribute ConvertPadding(llvm::ArrayRef<int64_t> padding);
+
+  // Converts channel id to attribute
+  mlir::NamedAttribute ConvertChannelHandle(std::optional<int64_t> channel_id);
+
+  // Convert use global device ids flag to attribute
+  mlir::NamedAttribute ConvertUseGlobalDeviceIds();
+
+  // Converts channel handle to attribute
+  mlir::NamedAttribute ConvertChannelHandle(const xla::ChannelHandle& channel);
+
+  // ============
+  // Imports an old-style async start op. E.g. an HLO all-gather-start
+  // instruction is imported as an async-start associated with an all-gather
+  // computation.
+  //
+  // Eventually, old-style async ops (e.g. all-gather-start) and new-style async
+  // ops (i.e. async-start, async-update and async-done) will converge on the
+  // HLO side, so we decided to not introduce new MHLO ops for all-gather-start
+  // and friends.
+  //
+  // In the end, there may be new ops added in the old-style because they're not
+  // compatible with the new-style async semantics, but those should be handled
+  // on their own, rather than this function which "upgrades" ops to the
+  // new-style async API.
+  // ============
+  template <typename SyncOp>
+  StatusOr<mlir::Operation*> ImportOldStyleAsyncStart(
+      llvm::SmallVectorImpl<mlir::NamedAttribute>& attributes,
+      const llvm::SmallVectorImpl<mlir::Value>& operands, mlir::Location loc,
+      mlir::Type result_type, mlir::OpBuilder* func_builder,
+      std::string func_name, std::function<Status(SyncOp)> mutate_op);
+
+  // Imports an old-style async done op
+  StatusOr<mlir::Operation*> ImportOldStyleAsyncDone(
+      llvm::SmallVectorImpl<mlir::NamedAttribute>& attributes,
+      const llvm::SmallVectorImpl<mlir::Value>& operands, mlir::Location loc,
+      mlir::Type result_type, mlir::OpBuilder* func_builder);
+
+  mlir::MLIRContext* context_;
+
+  // SymbolTable to which new functions should be inserted.
+  mlir::SymbolTable& symbol_table_;
+
+  mlir::Builder* builder_;
+
+  // Mapping from HloComputation to the created MLIR function.
+  std::unordered_map<const xla::HloComputation*, mlir::func::FuncOp>*
+      function_map_;
+
+  // Mapping from HloInstructions to the associative MLIR values.
+  std::unordered_map<const xla::HloInstruction*, mlir::Value>
+      instruction_value_map_;
+};
+
+// Returns a StringAttr that carries a prettyprinted representation of the
+// given HLO C++ sharding.
+// Always succeeds and returns a non-empty attribute.
+mlir::Attribute ConvertSharding(const xla::HloSharding& sharding,
+                                mlir::Builder* builder);
+
+// Returns a StringAttr that carries a prettyprinted representation of the
+// given HLO proto sharding.
+// Will fail and return an empty attribute if the proto sharding cannot be
+// converted to the C++ sharding.
+mlir::Attribute ConvertSharding(const xla::OpSharding& sharding,
+                                mlir::Builder* builder);
+
+}  // namespace xla
+
+#endif  // XLA_TRANSLATE_HLO_TO_MHLO_HLO_FUNCTION_IMPORTER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/translate/hlo_to_mhlo/hlo_module_importer.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/translate/hlo_to_mhlo/hlo_module_importer.h
new file mode 100644
index 0000000000000000000000000000000000000000..ac42e28f3f2123d946ce40d09011158a6dc72e20
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/translate/hlo_to_mhlo/hlo_module_importer.h
@@ -0,0 +1,67 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_TRANSLATE_HLO_TO_MHLO_HLO_MODULE_IMPORTER_H_
+#define XLA_TRANSLATE_HLO_TO_MHLO_HLO_MODULE_IMPORTER_H_
+
+#include <unordered_map>
+
+#include "mlir/Dialect/Func/IR/FuncOps.h"  // from @llvm-project
+#include "mlir/IR/Builders.h"  // from @llvm-project
+#include "mlir/IR/BuiltinOps.h"  // from @llvm-project
+#include "mlir/IR/MLIRContext.h"  // from @llvm-project
+#include "mlir/IR/SymbolTable.h"  // from @llvm-project
+#include "xla/mlir_hlo/mhlo/IR/hlo_ops.h"
+#include "xla/status.h"
+#include "xla/xla_data.pb.h"
+
+namespace xla {
+class HloModule;
+class HloModuleProto;
+class HloComputation;
+class HloInstruction;
+class Shape;
+
+// Importer that takes an HloModule and imports it as an MLIR module in the XLA
+// dialect. HloModuleImporter does not take ownership.
+class HloModuleImporter {
+ public:
+  explicit HloModuleImporter(mlir::ModuleOp module,
+                             bool import_all_computation = false);
+
+  // Import the HloModule into the MLIR Module.
+  Status Import(const xla::HloModule& module);
+
+  // Import the HloModuleProto into the MLIR Module.
+  Status Import(const xla::HloModuleProto& module);
+
+ private:
+  void ImportFrontendAttributes(const xla::HloModule& hlo_module,
+                                mlir::ModuleOp module);
+
+  bool import_all_computation_;
+  mlir::SymbolTable symbol_table_;
+  mlir::Builder builder_;
+
+  // Map for tracking which MLIR function map to which HLO Computation. This
+  // tracks functions as they are imported and provides a quick lookup for
+  // functions invoked by control flow related operations (e.g. while, call).
+  std::unordered_map<const xla::HloComputation*, mlir::func::FuncOp>
+      function_map_;
+};
+
+}  // namespace xla
+
+#endif  // XLA_TRANSLATE_HLO_TO_MHLO_HLO_MODULE_IMPORTER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/translate/hlo_to_mhlo/hlo_to_mlir_hlo.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/translate/hlo_to_mhlo/hlo_to_mlir_hlo.h
new file mode 100644
index 0000000000000000000000000000000000000000..21b3c1589c0bd7384baa2262f66abb4b719fc320
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/translate/hlo_to_mhlo/hlo_to_mlir_hlo.h
@@ -0,0 +1,44 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_TRANSLATE_HLO_TO_MHLO_HLO_TO_MLIR_HLO_H_
+#define XLA_TRANSLATE_HLO_TO_MHLO_HLO_TO_MLIR_HLO_H_
+
+#include "xla/status.h"
+
+namespace mlir {
+class ModuleOp;
+}  // namespace mlir
+
+namespace xla {
+class HloModule;
+class HloModuleProto;
+
+// Converts an HLO module proto to a MLIR module in HLO dialect.
+// If import_all_computation is set to true, imports all computations
+// irrespective if transitively called from entry computation.
+Status ConvertHloToMlirHlo(mlir::ModuleOp module,
+                           xla::HloModuleProto const* hlo_module,
+                           bool import_all_computations = false);
+
+// Converts an HLO module to a MLIR module in HLO dialect.
+// If import_all_computation is set to true, imports all computations
+// irrespective if transitively called from entry computation.
+Status ConvertHloToMlirHlo(mlir::ModuleOp module, xla::HloModule* hlo_module,
+                           bool import_all_computations = false);
+
+}  // namespace xla
+
+#endif  // XLA_TRANSLATE_HLO_TO_MHLO_HLO_TO_MLIR_HLO_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/translate/hlo_to_mhlo/hlo_utils.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/translate/hlo_to_mhlo/hlo_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..42682a251385aeb82b97bb3f64378f1dfc377539
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/translate/hlo_to_mhlo/hlo_utils.h
@@ -0,0 +1,174 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// This file defines helpers useful when creating or manipulating lhlo/hlo.
+
+#ifndef XLA_TRANSLATE_HLO_TO_MHLO_HLO_UTILS_H_
+#define XLA_TRANSLATE_HLO_TO_MHLO_HLO_UTILS_H_
+
+#include "llvm/ADT/STLExtras.h"
+#include "mlir/Dialect/SparseTensor/IR/Enums.h"  // from @llvm-project
+#include "mlir/Dialect/SparseTensor/IR/SparseTensor.h"  // from @llvm-project
+#include "mlir/IR/Attributes.h"  // from @llvm-project
+#include "mlir/IR/Builders.h"  // from @llvm-project
+#include "mlir/IR/BuiltinTypes.h"  // from @llvm-project
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/mlir_hlo/mhlo/IR/hlo_ops.h"
+#include "xla/mlir_hlo/utils/convert_op_folder.h"
+#include "xla/util.h"
+
+namespace xla {
+
+StatusOr<mlir::DenseElementsAttr> CreateDenseElementsAttrFromLiteral(
+    const LiteralBase& literal, mlir::Builder builder);
+
+Status CopyDenseElementsDataToXlaFormat(mlir::DenseElementsAttr data,
+                                        std::vector<uint8_t>* output);
+
+StatusOr<int> GetElementTypeBytes(mlir::Type type);
+
+// Creates an DenseIntElementsAttr using the elements of the vector and the
+// optional shape.
+mlir::DenseIntElementsAttr CreateDenseIntElementsAttrFromVector(
+    const llvm::ArrayRef<int64_t> vector, mlir::Builder builder,
+    llvm::ArrayRef<int64_t> shape = {});
+
+StatusOr<mlir::Type> ConvertPrimitiveTypeToMLIRType(PrimitiveType element_type,
+                                                    mlir::Builder builder);
+
+mlir::mhlo::GatherDimensionNumbersAttr CreateGatherDimensionNumbers(
+    const GatherDimensionNumbers& input, mlir::Builder builder);
+
+// Converts the given XLA shape for tensors to the template MLIR type.
+template <typename TypeT>
+static StatusOr<TypeT> ConvertTensorShapeToType(const Shape& xla_ty,
+                                                mlir::Builder builder) {
+  auto element_type_or =
+      ConvertPrimitiveTypeToMLIRType(xla_ty.element_type(), builder);
+  if (!element_type_or.ok()) return element_type_or.status();
+
+  bool is_dynamic = false;
+  int64_t rank = xla_ty.rank();
+  llvm::SmallVector<int64_t, 4> shape(rank, mlir::ShapedType::kDynamic);
+  llvm::SmallVector<int64_t, 4> bounds(rank, mlir::ShapedType::kDynamic);
+  for (int64_t dim = 0; dim < rank; ++dim) {
+    int64_t dim_size = xla_ty.dimensions(dim);
+    if (xla_ty.is_dynamic_dimension(dim)) {
+      bounds[dim] = dim_size;
+      is_dynamic = true;
+    } else {
+      shape[dim] = dim_size;
+    }
+  }
+  using mlir::mhlo::TypeExtensionsAttr;
+  mlir::Attribute encoding;
+  if (is_dynamic) {
+    encoding = TypeExtensionsAttr::get(builder.getContext(), bounds);
+  }
+
+  using mlir::sparse_tensor::SparseTensorEncodingAttr;
+  // TODO(b/238903065): We don't yet support bounded dynamism shapes and
+  // sparsity at the same time, as we can currently only have one `encoding` on
+  // a RankedTensorType, and we don't currently have a meet of
+  // SparseTensorEncodingAttr and TypeExtensionsAttr (which holds bounds).
+  //
+  // For example, we wouldn't be able to represent the xla type
+  // `f32[4,<=4]{1,0:D(D,C)}`.
+  if (xla_ty.has_layout()) {
+    auto layout = xla_ty.layout();
+    if (LayoutUtil::IsSparse(layout)) {
+      if (is_dynamic)
+        return Unimplemented(
+            "MHLO doesn't support bounded dynamic shapes for sparse tensors");
+      llvm::SmallVector<mlir::sparse_tensor::DimLevelType> dlts;
+      for (size_t i = 0, e = layout.dim_level_types().size(); i < e; ++i) {
+        auto dlt = layout.dim_level_types()[i];
+        bool ordered =
+            i < layout.dim_ordered().size() ? layout.dim_ordered()[i] : true;
+        bool unique =
+            i < layout.dim_unique().size() ? layout.dim_unique()[i] : true;
+        switch (dlt) {
+          case DimLevelType::DIM_DENSE:
+            dlts.push_back(*mlir::sparse_tensor::buildLevelType(
+                mlir::sparse_tensor::LevelFormat::Dense, ordered, unique));
+            break;
+          case DimLevelType::DIM_COMPRESSED:
+            dlts.push_back(*mlir::sparse_tensor::buildLevelType(
+                mlir::sparse_tensor::LevelFormat::Compressed, ordered, unique));
+            break;
+          case DimLevelType::DIM_SINGLETON:
+            dlts.push_back(*mlir::sparse_tensor::buildLevelType(
+                mlir::sparse_tensor::LevelFormat::Singleton, ordered, unique));
+            break;
+          case DimLevelType::DIM_LOOSE_COMPRESSED:
+            dlts.push_back(*mlir::sparse_tensor::buildLevelType(
+                mlir::sparse_tensor::LevelFormat::LooseCompressed, ordered,
+                unique));
+            break;
+          default:
+            return InvalidArgument("Unknown DimLevelType from HLO");
+        }
+      }
+      auto ordering = layout.minor_to_major();
+      llvm::SmallVector<uint32_t> major_to_minor = {ordering.rbegin(),
+                                                    ordering.rend()};
+      auto id_map = mlir::AffineMap::getPermutationMap(major_to_minor,
+                                                       builder.getContext());
+      // TODO(atondwal): support sizes other than 32 when XLA does
+      encoding = SparseTensorEncodingAttr::get(
+          builder.getContext(), dlts, id_map, mlir::AffineMap(), 32, 32);
+    }
+  }
+  return TypeT::get(shape, element_type_or.value(), encoding);
+}
+
+StatusOr<mlir::MemRefType> ConvertTensorShapeToMemRefType(
+    const Shape& shape, mlir::Builder builder);
+
+template <>
+inline StatusOr<mlir::MemRefType> ConvertTensorShapeToType(
+    const Shape& shape, mlir::Builder builder) {
+  if (shape.is_dynamic()) {
+    return FailedPrecondition(  // NOLINT
+        "MemRefType don't support dynamic shapes");
+  }
+  return ConvertTensorShapeToMemRefType(shape, builder);
+}
+
+// Converts the given XLA shape to the template MLIR type.
+template <typename TypeT>
+static StatusOr<mlir::Type> ConvertShapeToType(const Shape& shape,
+                                               mlir::Builder builder) {
+  if (shape.IsTuple()) {
+    llvm::SmallVector<mlir::Type, 4> contents;
+    contents.reserve(shape.tuple_shapes_size());
+    for (const auto& subtype : shape.tuple_shapes()) {
+      TF_ASSIGN_OR_RETURN(auto mlir_subtype,
+                          ConvertShapeToType<TypeT>(subtype, builder));
+      contents.push_back(mlir_subtype);
+    }
+    return builder.getTupleType(contents);
+  }
+  if (shape.IsToken()) {
+    return mlir::mhlo::TokenType::get(builder.getContext());
+  }
+  return ConvertTensorShapeToType<TypeT>(shape, builder);
+}
+
+::xla::StatusOr<::xla::HloOpcode> MhloToHloOpcode(mlir::Operation* op);
+
+}  // namespace xla
+
+#endif  // XLA_TRANSLATE_HLO_TO_MHLO_HLO_UTILS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/translate/hlo_to_mhlo/location_importer.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/translate/hlo_to_mhlo/location_importer.h
new file mode 100644
index 0000000000000000000000000000000000000000..1cfc4ab39bfde89d19fbcb28de3a4fc3b785d442
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/translate/hlo_to_mhlo/location_importer.h
@@ -0,0 +1,33 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_TRANSLATE_HLO_TO_MHLO_LOCATION_IMPORTER_H_
+#define XLA_TRANSLATE_HLO_TO_MHLO_LOCATION_IMPORTER_H_
+
+#include "mlir/IR/Location.h"  // from @llvm-project
+#include "xla/hlo/ir/hlo_instruction.h"
+
+namespace mlir {
+namespace mhlo {
+
+// Returns an MLIR Location generated from HLO Instruction. Uses instruction
+// metadata if present or instruction name.
+mlir::Location GenerateInstructionLocation(
+    const xla::HloInstruction* instruction, mlir::MLIRContext* context);
+
+}  // namespace mhlo
+}  // namespace mlir
+
+#endif  // XLA_TRANSLATE_HLO_TO_MHLO_LOCATION_IMPORTER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/translate/hlo_to_mhlo/stack_location_utils.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/translate/hlo_to_mhlo/stack_location_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..298f651ad86531da732e9c0ab252d11f8c4cecde
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/translate/hlo_to_mhlo/stack_location_utils.h
@@ -0,0 +1,34 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_TRANSLATE_HLO_TO_MHLO_STACK_LOCATION_UTILS_H_
+#define XLA_TRANSLATE_HLO_TO_MHLO_STACK_LOCATION_UTILS_H_
+
+#include "mlir/IR/Builders.h"  // from @llvm-project
+#include "mlir/IR/Location.h"  // from @llvm-project
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/service/hlo.pb.h"
+
+namespace mlir {
+namespace mhlo {
+// Construct MLIR location from frame index.
+// Returns unknown location if frame is not presented.
+mlir::Location GetLocationFromFrameIndex(int frame_id, mlir::Builder &builder,
+                                         const xla::HloModule *hlo_module);
+
+}  // namespace mhlo
+}  // namespace mlir
+
+#endif  // XLA_TRANSLATE_HLO_TO_MHLO_STACK_LOCATION_UTILS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/translate/mhlo_to_hlo/attribute_exporter.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/translate/mhlo_to_hlo/attribute_exporter.h
new file mode 100644
index 0000000000000000000000000000000000000000..3d58247b6d631807c76dbb810eecb8535df18298
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/translate/mhlo_to_hlo/attribute_exporter.h
@@ -0,0 +1,77 @@
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_TRANSLATE_MHLO_TO_HLO_ATTRIBUTE_EXPORTER_H_
+#define XLA_TRANSLATE_MHLO_TO_HLO_ATTRIBUTE_EXPORTER_H_
+
+#include <utility>
+
+#include "mlir/IR/Attributes.h"  // from @llvm-project
+#include "xla/mlir_hlo/lhlo_gpu/IR/lhlo_gpu_ops.h"
+#include "xla/mlir_hlo/mhlo/IR/hlo_ops.h"
+#include "xla/service/hlo.pb.h"
+#include "xla/shape_util.h"
+#include "xla/statusor.h"
+#include "xla/stream_executor/dnn.h"
+#include "xla/types.h"
+#include "xla/xla_data.pb.h"
+
+namespace xla {
+
+// Converts the conv dimensions attribute to XLA HLO.
+ConvolutionDimensionNumbers ConvertConvDimensionNumbers(
+    mlir::mhlo::ConvDimensionNumbersAttr input);
+
+StatusOr<stream_executor::dnn::ActivationMode> ConvertConvActivationMode(
+    mlir::lmhlo_gpu::Activation input);
+
+StatusOr<std::vector<ReplicaGroup>> ConvertReplicaGroups(
+    mlir::DenseIntElementsAttr input);
+
+// Convert a (N, 2) dense attribute to a list of tuples. This is the way padding
+// and source-target pairs are defined in HLO.
+StatusOr<std::vector<std::pair<int64_t, int64_t>>> ConvertNx2Attribute(
+    std::optional<mlir::DenseIntElementsAttr> optional_attr);
+
+StatusOr<FftType> ConvertFftType(llvm::StringRef type_string);
+StatusOr<TriangularSolveOptions::Transpose> ConvertTranspose(
+    llvm::StringRef transpose_string);
+
+StatusOr<xla::CustomCallSchedule> ConvertCustomCallSchedule(
+    mlir::mhlo::CustomCallSchedule schedule);
+
+StatusOr<xla::CustomCallApiVersion> ConvertCustomCallApiVersion(
+    mlir::mhlo::CustomCallApiVersion api_version);
+
+StatusOr<std::vector<std::pair<ShapeIndex, std::pair<int64_t, ShapeIndex>>>>
+ConvertOutputOperandAliasing(mlir::ArrayAttr aliasArrayAttr);
+
+// Returns an OpSharding that represents the result of parsing the given string:
+// first, as serialized protobuf, and then as prettyprinted representation.
+// Will fail if both attempts at parsing failed.
+std::optional<xla::OpSharding> ConvertSharding(mlir::StringRef sharding);
+
+DotDimensionNumbers ConvertDotDimensionNumbers(
+    mlir::mhlo::DotDimensionNumbersAttr input);
+
+DotDimensionNumbers ConvertDotDimensionNumbers(
+    absl::Span<const int64_t> lhs_batch, absl::Span<const int64_t> lhs_contract,
+    absl::Span<const int64_t> rhs_batch,
+    absl::Span<const int64_t> rhs_contract);
+
+StatusOr<std::vector<int64_t>> ConvertMlirArrayAttrToInt64Array(
+    const mlir::ArrayAttr& array);
+}  // namespace xla
+#endif  // XLA_TRANSLATE_MHLO_TO_HLO_ATTRIBUTE_EXPORTER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/translate/mhlo_to_hlo/layout_util.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/translate/mhlo_to_hlo/layout_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..f8f175ba282c476251b8c1d7873897fd0fcc2937
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/translate/mhlo_to_hlo/layout_util.h
@@ -0,0 +1,84 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// Utilities for working with XLA layout and shapes.
+
+#ifndef XLA_TRANSLATE_MHLO_TO_HLO_LAYOUT_UTIL_H_
+#define XLA_TRANSLATE_MHLO_TO_HLO_LAYOUT_UTIL_H_
+
+#include <functional>
+#include <vector>
+
+#include "xla/client/xla_builder.h"
+#include "xla/hlo/ir/hlo_sharding.h"
+#include "xla/shape.h"
+#include "xla/statusor.h"
+#include "xla/xla_data.pb.h"
+
+namespace mlir {
+
+// XLA Layout preferences. Currently, when it comes to TPU, there are two
+// primary layout choices for any XLA argumetns (parameter or resource): (1)
+// CompactChunkPadded and (2) Linear. CompactChunkPadded is the native TPU
+// layout while Linear is native host (CPU) layout.
+// This enum allows the caller of XLA to progogate layout preference to the XLA
+// compiler.
+//   kNoPreference: the generic layout where the XLA compiler has the freedom
+//                  to assign any layout.
+//   kTpuPreferCompactChunkPaddedLayout: use native TPU layout on TPU.
+//   kTpuPreferLinearLayout: use native CPU layout on TPU. The compiler may
+//                           insert transformation TPU kernels.
+// As the layout of any argument will change from a native host layout to a
+// native TPU layout either on host or on device, XLA compiler and TPU runtime
+// must be in coordination to transform the parameters in a consistent way.
+enum class XlaLayoutPreference {
+  kNoPreference = 0,
+  kTpuPreferCompactChunkPaddedLayout = 1,
+  kTpuPreferLinearLayout = 2
+};
+
+// The following defines the layout preference of an xla tensor.
+// The return value of LayoutPreferenceFn can be used in
+// ShapeRepresentationFn.
+typedef std::function<xla::StatusOr<XlaLayoutPreference>(
+    const xla::Shape& shape)>
+    LayoutPreferenceFn;
+
+typedef std::function<xla::StatusOr<xla::Shape>(
+    const xla::Shape& shape, bool fast_mem,
+    XlaLayoutPreference layout_preference)>
+    ShapeRepresentationFn;
+
+// Return a LayoutPreferenceFn that always uses kNoPreference layout.
+LayoutPreferenceFn UseNoPreferenceLayoutFn();
+
+// Rewrites the layout of xla_shape if there is tiled sharding.
+xla::Status RewriteLayoutWithShardedShape(
+    const std::optional<xla::HloSharding>& sharding, bool use_fast_memory,
+    const LayoutPreferenceFn& layout_preference_fn,
+    const ShapeRepresentationFn& shape_representation_fn,
+    xla::Shape* xla_shape);
+
+// Adds reshapes to fix the layout of an output, if a shape_representation_fn or
+// sharding is present.
+xla::StatusOr<xla::XlaOp> ReshapeWithCorrectRepresentationAndSharding(
+    xla::XlaBuilder* builder, xla::XlaOp original, xla::Shape original_shape,
+    const LayoutPreferenceFn& layout_preference_fn,
+    const ShapeRepresentationFn& shape_representation_fn,
+    std::optional<xla::OpSharding> sharding, bool fast_mem);
+
+}  // namespace mlir
+
+#endif  // XLA_TRANSLATE_MHLO_TO_HLO_LAYOUT_UTIL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/translate/mhlo_to_hlo/location_exporter.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/translate/mhlo_to_hlo/location_exporter.h
new file mode 100644
index 0000000000000000000000000000000000000000..69efa6dbc4f477d705b34f9b2a581cc55237cfd3
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/translate/mhlo_to_hlo/location_exporter.h
@@ -0,0 +1,44 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_TRANSLATE_MHLO_TO_HLO_LOCATION_EXPORTER_H_
+#define XLA_TRANSLATE_MHLO_TO_HLO_LOCATION_EXPORTER_H_
+
+#include <string>
+
+#include "mlir/IR/Location.h"  // from @llvm-project
+#include "mlir/IR/Operation.h"  // from @llvm-project
+#include "xla/translate/mhlo_to_hlo/stack_frame_index_builder.h"
+#include "xla/xla_data.pb.h"
+
+namespace mlir {
+namespace mhlo {
+
+// Returns a OpMetadata proto based on the location of the op. If the location
+// is unknown, an empty proto is returned. `op_name` are populated with the op
+// location (converted). FileLineColLoc locations are populated by taking the
+// file name and line number, and populating `source_file` and `source_line`
+// respectively.
+xla::OpMetadata CreateOpMetadataFromLocation(
+    Operation* op, StackFrameIndexBuilder* frame_index_builder);
+
+// Returns a name that can be used for debugging purposes, e.g., naming
+// variable names in generated IR or producing logging output.
+std::string GetDebugNameFromLocation(Location location);
+
+}  // namespace mhlo
+}  // namespace mlir
+
+#endif  // XLA_TRANSLATE_MHLO_TO_HLO_LOCATION_EXPORTER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/translate/mhlo_to_hlo/mlir_hlo_to_hlo.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/translate/mhlo_to_hlo/mlir_hlo_to_hlo.h
new file mode 100644
index 0000000000000000000000000000000000000000..5cbdfdd398dabc4e46fe51d67d55bf45f874d773
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/translate/mhlo_to_hlo/mlir_hlo_to_hlo.h
@@ -0,0 +1,72 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_TRANSLATE_MHLO_TO_HLO_MLIR_HLO_TO_HLO_H_
+#define XLA_TRANSLATE_MHLO_TO_HLO_MLIR_HLO_TO_HLO_H_
+
+#include <optional>
+#include <vector>
+
+#include "mlir/Dialect/Func/IR/FuncOps.h"  // from @llvm-project
+#include "mlir/IR/BuiltinOps.h"  // from @llvm-project
+#include "xla/client/xla_builder.h"
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/translate/mhlo_to_hlo/layout_util.h"
+
+namespace mlir {
+
+struct MlirToHloConversionOptions {
+  // Best-effort propagation of the layouts. These layouts serve as performance
+  // hints to the backend.
+  //
+  // Note that non-array shapes are not carrying layouts, and users have to
+  // figure out the proper layouts of them through context. This is one of the
+  // reasons why the attribute-based solution is temporary.
+  //
+  // TODO(timshen): Investigate the necessity of having layouts in MHLO.
+  bool propagate_layouts = false;
+
+  // Propagate the source and result layouts from mhlo bitcast op into the
+  // backend config for the bitcast. This is required for XLA:GPU backend to
+  // use elemental IR emitters for fused bitcasts without propagating layouts.
+  bool propagate_bitcast_layouts_to_backend_config = false;
+
+  LayoutPreferenceFn layout_preference_fn;
+  ShapeRepresentationFn shape_representation_fn;
+};
+
+// Converts a MLIR module in HLO dialect into a HloModuleProto. If
+// use_tuple_args is set, then the entry computations's arguments are converted
+// to a tuple and passed as a single parameter.
+// Similarly, if return tuple is true, then the entry function's return values
+// are converted to a tuple even when there is only a single return value.
+// Multiple return values are always converted to a tuple and returned as a
+// single value.
+xla::Status ConvertMlirHloToHlo(mlir::ModuleOp module,
+                                ::xla::HloProto* hlo_proto, bool use_tuple_args,
+                                bool return_tuple,
+                                MlirToHloConversionOptions options = {});
+
+// Transforms a Block into HLO, where the HLO is represented as calls into an
+// XlaBuilder. Callee functions are allowed in the Block's ancestor ModuleOp.
+// xla_params are inputs to block. returns are the returned XlaOps.
+xla::Status BuildHloFromMlirHlo(mlir::Block& block, xla::XlaBuilder& builder,
+                                llvm::ArrayRef<xla::XlaOp> xla_params,
+                                std::vector<xla::XlaOp>& returns,
+                                MlirToHloConversionOptions options = {});
+
+}  // namespace mlir
+
+#endif  // XLA_TRANSLATE_MHLO_TO_HLO_MLIR_HLO_TO_HLO_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/translate/mhlo_to_hlo/stack_frame_index_builder.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/translate/mhlo_to_hlo/stack_frame_index_builder.h
new file mode 100644
index 0000000000000000000000000000000000000000..804795eb83f62e5725a863076646136749820df6
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/translate/mhlo_to_hlo/stack_frame_index_builder.h
@@ -0,0 +1,48 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_TRANSLATE_MHLO_TO_HLO_STACK_FRAME_INDEX_BUILDER_H_
+#define XLA_TRANSLATE_MHLO_TO_HLO_STACK_FRAME_INDEX_BUILDER_H_
+
+#include <map>
+#include <string_view>
+#include <tuple>
+
+#include "mlir/IR/Location.h"  // from @llvm-project
+#include "xla/service/hlo.pb.h"
+
+namespace mlir {
+class StackFrameIndexBuilder {
+ public:
+  constexpr static int kInvalidIndex = 0;
+
+  xla::StackFrameIndexProto Build() const;
+
+  int AddCallStackAndGetFirstFrameId(const mlir::Location &root_loc);
+
+ private:
+  int AddStackFrameLocation(const mlir::NameLoc &name_location,
+                            int parent_frame_id);
+
+  xla::StackFrameIndexProto indexes_;
+
+  std::map<std::string_view, int> function_name_to_id_;
+  std::map<std::string_view, int> file_name_to_id_;
+  std::map<std::tuple<int, int, int, int>, int> file_location_to_id_;
+  std::map<std::tuple<int, int>, int> frame_to_id_;
+};
+}  // namespace mlir
+
+#endif  // XLA_TRANSLATE_MHLO_TO_HLO_STACK_FRAME_INDEX_BUILDER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/translate/mhlo_to_hlo/type_to_shape.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/translate/mhlo_to_hlo/type_to_shape.h
new file mode 100644
index 0000000000000000000000000000000000000000..39bfb6c5b409185a0a3a198f1c8052b99d97573c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/translate/mhlo_to_hlo/type_to_shape.h
@@ -0,0 +1,35 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_TRANSLATE_MHLO_TO_HLO_TYPE_TO_SHAPE_H_
+#define XLA_TRANSLATE_MHLO_TO_HLO_TYPE_TO_SHAPE_H_
+
+#include "llvm/ADT/STLExtras.h"
+#include "mlir/IR/Types.h"  // from @llvm-project
+#include "xla/shape.h"
+#include "xla/xla_data.pb.h"
+
+namespace xla {
+
+// Returns a XLA Shape equivalent of a MLIR Type, else returns empty shape.
+Shape TypeToShape(mlir::Type type);
+
+// Returns a XLA PrimitiveType equivalent of a MLIR Type that represents a
+// primitive type (e.g., i8, f32), else returns PRIMITIVE_TYPE_INVALID.
+PrimitiveType TypeToPrimitiveType(mlir::Type type);
+
+}  // namespace xla
+
+#endif  // XLA_TRANSLATE_MHLO_TO_HLO_TYPE_TO_SHAPE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/translate/mhlo_to_lhlo_with_xla/mhlo_to_lhlo_with_xla.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/translate/mhlo_to_lhlo_with_xla/mhlo_to_lhlo_with_xla.h
new file mode 100644
index 0000000000000000000000000000000000000000..c355cb132fa63d0af79cc3e5fedc5de0f226bc61
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/translate/mhlo_to_lhlo_with_xla/mhlo_to_lhlo_with_xla.h
@@ -0,0 +1,337 @@
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_TRANSLATE_MHLO_TO_LHLO_WITH_XLA_MHLO_TO_LHLO_WITH_XLA_H_
+#define XLA_TRANSLATE_MHLO_TO_LHLO_WITH_XLA_MHLO_TO_LHLO_WITH_XLA_H_
+
+#include <functional>
+#include <memory>
+#include <optional>
+#include <utility>
+
+#include "absl/types/optional.h"
+#include "mlir/Dialect/MemRef/IR/MemRef.h"  // from @llvm-project
+#include "mlir/IR/Builders.h"  // from @llvm-project
+#include "mlir/IR/BuiltinOps.h"  // from @llvm-project
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/hlo/ir/hlo_instructions.h"
+#include "xla/mlir_hlo/lhlo/IR/lhlo_ops.h"
+#include "xla/mlir_hlo/lhlo_gpu/IR/lhlo_gpu_ops.h"
+#include "xla/service/buffer_assignment.h"
+#include "xla/shape_util.h"
+#include "tsl/platform/status.h"
+#include "tsl/platform/statusor.h"
+
+namespace mlir {
+
+// This class will process an HloModule with the supplied BufferAssignment and
+// populate the MLIR ModuleOp with the computation converted in the LHLO
+// dialect.
+class LhloDialectEmitter : public xla::ConstDfsHloVisitorWithDefault {
+ public:
+  // Initializes internal data structures. It must be called before calling any
+  // of the visitors.
+  tsl::Status Initialize();
+
+  LhloDialectEmitter(const xla::BufferAssignment& assignment,
+                     const xla::HloComputation& computation, ModuleOp module)
+      : assignment_(assignment),
+        computation_(computation),
+        module_(module),
+        symbol_table_(module),
+        builder_(module.getContext()),
+        i8_type_(builder_.getIntegerType(8)) {}
+
+  tsl::StatusOr<mlir::Operation*> EmitOp(const xla::HloInstruction* instr);
+
+  static tsl::StatusOr<mhlo::ScatterDimensionNumbersAttr>
+  GetScatterDimensionNumbers(const xla::HloInstruction* instr,
+                             mlir::MLIRContext* context);
+
+  absl::flat_hash_map<const mlir::Operation*, const xla::HloInstruction*>
+  ConsumeLhloToHloMap() {
+    return std::move(lhlo_to_hlo_);
+  }
+
+ private:
+  tsl::StatusOr<lmhlo::SortOp> EmitSortOp(const xla::HloInstruction* instr);
+  tsl::StatusOr<lmhlo::FusionOp> EmitFusionOp(const xla::HloInstruction* instr);
+  tsl::StatusOr<lmhlo::ScatterOp> EmitScatterOp(
+      const xla::HloInstruction* instr);
+  tsl::StatusOr<lmhlo::SelectAndScatterOp> EmitSelectAndScatterOp(
+      const xla::HloInstruction* instr);
+
+  tsl::StatusOr<Operation*> EmitCustomCallOp(const xla::HloInstruction* instr);
+  tsl::StatusOr<lmhlo_gpu::CholeskyOp> EmitCholesky(
+      const xla::HloCustomCallInstruction* custom_call);
+  tsl::StatusOr<Operation*> EmitGemm(
+      const xla::HloCustomCallInstruction* custom_call);
+  tsl::StatusOr<Operation*> EmitCublasLtMatmul(
+      const xla::HloCustomCallInstruction* custom_call);
+  tsl::StatusOr<Operation*> EmitCublasLtMatmulF8(
+      const xla::HloCustomCallInstruction* custom_call);
+  tsl::StatusOr<Operation*> EmitDnnConvolution(
+      const xla::HloCustomCallInstruction* custom_call);
+  tsl::StatusOr<Operation*> EmitDnnConvolutionReorderVectorized(
+      const xla::HloCustomCallInstruction* custom_call);
+  tsl::StatusOr<Operation*> EmitDnnBatchNorm(
+      const xla::HloCustomCallInstruction* custom_call);
+  xla::StatusOr<Operation*> EmitDnnfMHA(
+      const xla::HloCustomCallInstruction* custom_call);
+  xla::StatusOr<Operation*> EmitDnnfMHABackward(
+      const xla::HloCustomCallInstruction* custom_call);
+  tsl::StatusOr<memref::GetGlobalOp> EmitConstant(
+      const xla::HloInstruction* instr);
+
+  tsl::StatusOr<lmhlo::InfeedOp> EmitInfeedOp(const xla::HloInstruction* instr);
+  tsl::StatusOr<lmhlo::OutfeedOp> EmitOutfeedOp(
+      const xla::HloInstruction* instr);
+
+  template <typename OpT>
+  tsl::StatusOr<OpT> EmitDoneOp(const xla::HloInstruction* instr);
+
+  tsl::StatusOr<lmhlo_gpu::AllToAllStartOp> EmitAllToAllStartOp(
+      const xla::HloInstruction* instr);
+  tsl::StatusOr<lmhlo_gpu::AllToAllDoneOp> EmitAllToAllDoneOp(
+      const xla::HloInstruction* instr);
+  tsl::StatusOr<lmhlo_gpu::AllGatherStartOp> EmitAllGatherStartOp(
+      const xla::HloInstruction* instr);
+  tsl::StatusOr<lmhlo_gpu::AllGatherDoneOp> EmitAllGatherDoneOp(
+      const xla::HloInstruction* instr);
+  tsl::StatusOr<lmhlo_gpu::AllReduceStartOp> EmitAllReduceStartOp(
+      const xla::HloInstruction* instr);
+  tsl::StatusOr<lmhlo_gpu::AllReduceDoneOp> EmitAllReduceDoneOp(
+      const xla::HloInstruction* instr);
+  tsl::StatusOr<mlir::Operation*> EmitAsyncStartOp(
+      const xla::HloInstruction* instr);
+  tsl::StatusOr<mlir::Operation*> EmitAsyncDoneOp(
+      const xla::HloInstruction* instr);
+  tsl::StatusOr<lmhlo_gpu::ReduceScatterStartOp> EmitReduceScatterStartOp(
+      const xla::HloInstruction* instr);
+  tsl::StatusOr<lmhlo_gpu::ReduceScatterDoneOp> EmitReduceScatterDoneOp(
+      const xla::HloInstruction* instr);
+  tsl::StatusOr<lmhlo_gpu::CollectivePermuteStartOp>
+  EmitCollectivePermuteStartOp(const xla::HloInstruction* instr);
+  tsl::StatusOr<lmhlo_gpu::CollectivePermuteDoneOp> EmitCollectivePermuteDoneOp(
+      const xla::HloInstruction* instr);
+
+  tsl::StatusOr<lmhlo::RngGetAndUpdateStateOp> EmitRngGetAndUpdateStateOp(
+      const xla::HloInstruction* instr);
+  tsl::StatusOr<lmhlo::FftOp> EmitFftOp(const xla::HloInstruction* instr);
+  tsl::StatusOr<lmhlo::TriangularSolveOp> EmitTriangularSolveOp(
+      const xla::HloInstruction* instr);
+  tsl::StatusOr<Operation*> EmitBitcast(const xla::HloInstruction* instr);
+
+  tsl::StatusOr<lmhlo::CaseOp> EmitCaseOp(const xla::HloInstruction* instr);
+
+  tsl::StatusOr<lmhlo::WhileOp> EmitWhileOp(const xla::HloInstruction* instr);
+
+  tsl::StatusOr<lmhlo::SendOp> EmitSendOp(const xla::HloInstruction* instr);
+  tsl::StatusOr<lmhlo::SendDoneOp> EmitSendDoneOp(
+      const xla::HloInstruction* instr);
+
+  tsl::StatusOr<lmhlo::RecvOp> EmitRecvOp(const xla::HloInstruction* instr);
+  tsl::StatusOr<lmhlo::RecvDoneOp> EmitRecvDoneOp(
+      const xla::HloInstruction* instr);
+
+  tsl::Status ImportAsLmhloRegion(xla::HloComputation* computation,
+                                  mlir::Region* region);
+
+  // Since LMHLO dialect does not define token types, this enum controls how
+  // token operand/results from XLA:HLO are lowered to MLIR.
+  enum class TokenLoweringMode {
+    kFailToLower,  // Fail lowering if token inputs are encountered.
+    kUseNull,      // Use a null Value in the operand list for each token.
+    // kSkip,        // Skip any token inputs or outputs (not yet needed)
+  };
+
+  // Create LHLO operation operands given an XLA HLO instruction. By default,
+  // all XLA HLO operands and results are converted to MLIR and appended to
+  // `operands`. If `num_operands` is specified, only the first `num_operand`
+  // operands of the instruction are converted to MLIR. The function returns the
+  // actual number of operands and results generated for MLIR in `num_arguments`
+  // and `num_results`.
+  tsl::Status CreateOperands(const xla::HloInstruction* instr,
+                             std::optional<int64_t> num_operands,
+                             TokenLoweringMode token_mode,
+                             SmallVectorImpl<Value>& operands,
+                             size_t& num_arguments, size_t& num_results);
+
+  template <typename OpType>
+  tsl::StatusOr<OpType> CreateOpWithoutAttrs(
+      const xla::HloInstruction* instr,
+      std::optional<int64_t> num_operands = std::nullopt) {
+    size_t unused;
+    return CreateOpWithoutAttrs<OpType>(instr, unused, unused, num_operands);
+  }
+
+  template <typename OpType>
+  tsl::StatusOr<OpType> CreateOpWithoutAttrs(
+      const xla::HloInstruction* instr, size_t& num_arguments,
+      size_t& num_results, std::optional<int64_t> num_operands = std::nullopt);
+
+  template <typename OpType>
+  OpType CreateOpWithoutAttrs(const xla::HloInstruction* instr,
+                              ValueRange operands);
+
+  template <typename T>
+  DenseIntElementsAttr GetI64DenseElementsAttr(const T& container) {
+    return builder_.getI64TensorAttr(
+        {container.data(), static_cast<size_t>(container.size())});
+  }
+
+  DenseIntElementsAttr GetWindowElements(
+      const xla::Window& window,
+      std::function<int64_t(const xla::WindowDimension& dim)> getter) {
+    llvm::SmallVector<int64_t, 4> elements;
+    elements.reserve(window.dimensions_size());
+    for (const xla::WindowDimension& dim : window.dimensions()) {
+      elements.push_back(getter(dim));
+    }
+    return GetI64DenseElementsAttr(elements);
+  }
+
+  static mlir::DenseIntElementsAttr GetLayoutAttribute(
+      const xla::Layout& layout, Builder* builder);
+
+  tsl::Status DefaultAction(const xla::HloInstruction* instr) final;
+
+  // Computation parameters don't need any specific handling when they are
+  // visited, they are already processed when we enter a new computation.
+  tsl::Status HandleParameter(const xla::HloInstruction* instr) final {
+    return ::tsl::OkStatus();
+  }
+
+  // Helper function that recursively visits the tuple structure in
+  // `current_shape`, and reconstruct a matching lmhlo::TupleOp.
+  // Each leaf node is converted to an std.view op with corresponding offsets.
+  // If no tuple presents, it simply returns a view of the buffer.
+  tsl::Status GetOrCreateViewImpl(const xla::HloInstruction* instr,
+                                  const xla::Shape& current_shape,
+                                  xla::ShapeIndex* current_shape_index,
+                                  SmallVectorImpl<Value>* values,
+                                  TokenLoweringMode token_mode);
+
+  // Helper function to create view/tuple of views to a buffer for a given
+  // instruction result. `result_subset` can be used to for instructions that
+  // have a tuple result and MLIR conversion needs to convert only one of the
+  // tuple elements. Note that if needed, this can be extended to take a list of
+  // ShapeIndex values in case we need finer control on what elements of the
+  // output tuple to be converted to MLIR.
+  tsl::Status GetOrCreateView(
+      const xla::HloInstruction* instr, SmallVectorImpl<Value>* values,
+      const xla::ShapeIndex& result_subset = {},
+      TokenLoweringMode token_mode = TokenLoweringMode::kFailToLower);
+
+  tsl::StatusOr<Value> GetOrCreateArrayView(
+      const xla::HloInstruction* instr, const xla::Shape& current_shape,
+      const xla::ShapeIndex& current_shape_index);
+
+  tsl::StatusOr<Value> RewriteFusionOperand(const xla::HloInstruction* root,
+                                            const xla::Shape& shape,
+                                            xla::ShapeIndex* shape_index,
+                                            OpBuilder* b, Location loc);
+
+  // Return an MLIR location for an HLO instruction.
+  Location getLocation(const xla::HloInstruction* inst) {
+    return NameLoc::get(builder_.getStringAttr(inst->name()));
+  }
+
+  // This map provides access to MLIR buffers for each HLO buffer allocation.
+  // The MLIR buffers are all `memref<{size}xi8>` and correspond to function
+  // parameters. It is populated at the beginning of the processing with all
+  // the buffer allocations and is unchanged afterward. Every HLOInstruction
+  // is using a "slice" of the buffer allocation and providing shape, layout,
+  // and Dtype. An MLIR view is used separately to model slices into the
+  // allocations (see below).
+  llvm::DenseMap<const xla::BufferAllocation*, Value> allocations_;
+
+  // This map provides access to MLIR buffers constructed from memref arguments
+  // (allocations) using memref.view operation at the given offset (defined by
+  // slice) and result type (defined by shape). By using this cache we guarantee
+  // that we have a unique memref.view operation corresponding to each
+  // allocation slice.
+  absl::flat_hash_map<std::pair<xla::BufferAllocation::Slice, xla::Shape>,
+                      Value>
+      allocation_slices_;
+
+  // This map provides access to MLIR buffers for each HLO instruction, keyed
+  // instruction identity. A slice is contained in a BufferAllocation, and has
+  // an offset and a size.
+  //
+  // As for why we don't use HloInstruction*, see GetOrCreateView(), but
+  // mostly we want to leverage better of the aliased buffers.
+  //
+  // If the HloInstruction is a tuple, all leaf nodes are stored flattened.
+  // Otherwise, there will be a single buffer.
+  //
+  // An MLIR buffer is either an input parameter, or a ViewOp in the case
+  // where the slice is only part of its allocation.
+  //
+  // `instr_slices_` is populated lazily in the `GetOrCreateView()` helper as we
+  // process every instruction.
+  absl::flat_hash_map<std::pair<const xla::HloInstruction*, xla::ShapeIndex>,
+                      Value>
+      instr_slices_;
+
+  // The BufferAssignment computed by XLA ahead of time.
+  const xla::BufferAssignment& assignment_;
+
+  // The HLO module that will be converted.
+  const xla::HloComputation& computation_;
+
+  // This is the MLIR module in which a function will be created for every HLO
+  // computation.
+  ModuleOp module_;
+
+  // SymbolTable associated with the module. New functions should be added using
+  // this to avoid name conflicts.
+  mlir::SymbolTable symbol_table_;
+
+  // The builder keeps track of the current insertion point in the MLIR
+  // module.
+  OpBuilder builder_;
+  // Convenient "cached" access to this widely used MLIR type (i8).
+  Type i8_type_;
+
+  // Map ops returning tokens to their output (async collectives start ops, and
+  // point-to-point communication ops), to connect the correct done op.
+  absl::flat_hash_map<const xla::HloInstruction*, mlir::Value> ret_tokens_;
+
+  // Maps each LHLO op created directly by this emitter to the corresponding HLO
+  // instruction.
+  // Note: this does not contain ops that are inside the bodies of fusions.
+  absl::flat_hash_map<const mlir::Operation*, const xla::HloInstruction*>
+      lhlo_to_hlo_;
+};
+
+// Populate the MLIR `module` with the computation from the `hlo_module` using
+// the provided buffer `assignment`. The returned `Status` indicates success
+// or failure in the conversion.
+// `lhlo_to_hlo_map`, if non-null, is populated with a mapping from generated
+// top-level MLIR operations to the original HLO instructions. "top-level" means
+// that ops inside the bodies of fusions are not included (but all fusions are).
+tsl::Status HloToLhloModule(
+    const xla::BufferAssignment& assignment, const xla::HloModule& hlo_module,
+    ModuleOp module,
+    absl::flat_hash_map<const mlir::Operation*, const xla::HloInstruction*>*
+        lhlo_to_hlo_map = nullptr);
+
+OwningOpRef<mlir::ModuleOp> HloTextToLhloTranslateFunction(
+    llvm::StringRef input, MLIRContext* context);
+
+}  // namespace mlir
+
+#endif  // XLA_TRANSLATE_MHLO_TO_LHLO_WITH_XLA_MHLO_TO_LHLO_WITH_XLA_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/activity_watcher/activity.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/activity_watcher/activity.h
new file mode 100644
index 0000000000000000000000000000000000000000..334a58d45190baf7d659b6809a8a2a6562b57401
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/activity_watcher/activity.h
@@ -0,0 +1,186 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_ACTIVITY_WATCHER_ACTIVITY_H_
+#define TENSORFLOW_CORE_ACTIVITY_WATCHER_ACTIVITY_H_
+
+#include <atomic>
+#include <functional>
+#include <memory>
+#include <utility>
+
+#include "absl/container/flat_hash_map.h"
+#include "tsl/platform/macros.h"
+#include "tsl/platform/types.h"
+
+namespace tsl {
+class CoordinationServiceAgent;
+}
+
+namespace tensorflow {
+
+namespace activity_watcher {
+
+using ActivityId = tsl::uint64;
+constexpr ActivityId kActivityNotRecorded = 0;
+constexpr int kWatcherDisabled = 0;
+
+enum ActivityCategory {
+  kCollective = 0,
+  kRemoteFunction = 1,
+  kMisc = 2,
+  kDatasetOp = 3,
+  kTpuOp = 4,
+  kRendezvous = 5,
+};
+
+static tsl::string ToString(ActivityCategory category) {
+  switch (category) {
+    case ActivityCategory::kCollective:
+      return "Collective";
+    case ActivityCategory::kRemoteFunction:
+      return "Remote Function";
+    case ActivityCategory::kMisc:
+      return "Miscellaneous";
+    case ActivityCategory::kDatasetOp:
+      return "Dataset Op";
+    case ActivityCategory::kTpuOp:
+      return "TPU Op";
+    case ActivityCategory::kRendezvous:
+      return "Rendezvous";
+  }
+}
+
+// An activity to be recorded.
+struct Activity {
+  using Attributes = absl::flat_hash_map<tsl::string, tsl::string>;
+  // A human readable title of the activity.
+  tsl::string title;
+  // The category of the activity.
+  ActivityCategory category = ActivityCategory::kMisc;
+  // Key/value pairs that are attached to the activity.
+  Attributes attributes;
+  Activity() = default;
+  Activity(tsl::string title, ActivityCategory category)
+      : title(std::move(title)), category(category) {}
+  Activity(tsl::string title, ActivityCategory category, Attributes attributes)
+      : title(std::move(title)),
+        category(category),
+        attributes(std::move(attributes)) {}
+};
+
+// Enable activity wathcer to send own workers activities to coordination
+// service and also fetch all workers' activities.
+void MaybeEnableMultiWorkersWatching(tsl::CoordinationServiceAgent* agent);
+
+namespace tfw_internal {
+
+#if defined(TF_ENABLE_ACTIVITY_WATCHER)
+
+// Records an activity start without checking whether the watcher is enabled.
+ActivityId RecordActivityStart(std::unique_ptr<Activity> activity);
+// Records an activity end without checking whether the activity_id is valid.
+void RecordActivityEnd(ActivityId activity_id);
+
+TF_EXPORT extern std::atomic<int> g_watcher_level;
+
+// Returns whether the activitity watcher is enabled.
+inline bool WatcherEnabled(int level = 1) {
+  return g_watcher_level.load(std::memory_order_acquire) >= level;
+}
+
+#endif
+
+// NOTE: Borrowed from boost C++ libraries because std::is_invocable_r is not
+// available in Android NDK.
+template <typename R, typename F, typename... Args>
+struct is_invocable_r
+    : std::is_constructible<
+          std::function<R(Args...)>,
+          std::reference_wrapper<typename std::remove_reference<F>::type>> {};
+
+}  // namespace tfw_internal
+
+template <typename F>
+constexpr bool is_activity_generator =
+    tfw_internal::is_invocable_r<std::unique_ptr<Activity>, F>::value;
+
+// Records an activity explicitly. Useful when the start and end of an activity
+// happen in different threads. Generates the Activity only if activity
+// watching is enabled, useful for avoiding expensive operations when activity
+// watching is disabled.
+// Example Usage:
+//   auto aid = ActivityStart([&]() {
+//     return std::make_unique<Activity>(
+//         op_name, category,
+//         Activity::Attributes{{"key1", value1}, {"key2", value2}});
+//   }, /*level=*/2);
+//   DoSomething();
+//   ActivityEnd(aid);
+template <
+    typename ActivityGenerator,
+    std::enable_if_t<is_activity_generator<ActivityGenerator>, bool> = true>
+inline ActivityId ActivityStart(ActivityGenerator&& gen, int level = 1) {
+#if defined(TF_ENABLE_ACTIVITY_WATCHER)
+  if (TF_PREDICT_FALSE(tfw_internal::WatcherEnabled(level))) {
+    return tfw_internal::RecordActivityStart(
+        std::forward<ActivityGenerator>(gen)());
+  }
+#endif
+  return kActivityNotRecorded;
+}
+
+inline void ActivityEnd(ActivityId id) {
+#if defined(TF_ENABLE_ACTIVITY_WATCHER)
+  if (TF_PREDICT_FALSE(id != kActivityNotRecorded)) {
+    tfw_internal::RecordActivityEnd(id);
+  }
+#endif
+}
+
+// ActivityScope marks a scope as an activity and record it with a global
+// ActivityRecorder.
+// Example Usage:
+//   {
+//     ActivityScope activity_scope([&]() {
+//       return std::make_unique<Activity>(
+//           op_name, ActivityCategory::kMisc,
+//           Activity::Attributes{{"key1", value1}, {"key2", value2}});
+//     }, /*level=*/2);
+//     DoSomething();
+//   }
+class ActivityScope {
+ public:
+  template <
+      typename ActivityGenerator,
+      std::enable_if_t<is_activity_generator<ActivityGenerator>, bool> = true>
+  explicit ActivityScope(ActivityGenerator&& gen, int level = 1) {
+    activity_id_ = ActivityStart(std::forward<ActivityGenerator>(gen), level);
+  }
+  ActivityScope(ActivityScope&& activity) {
+    activity_id_ = activity.activity_id_;
+    activity.activity_id_ = kActivityNotRecorded;
+  }
+  ~ActivityScope() { ActivityEnd(activity_id_); }
+
+ private:
+  ActivityId activity_id_;
+  ActivityScope(const ActivityScope&) = delete;
+  void operator=(const ActivityScope&) = delete;
+};
+
+}  // namespace activity_watcher
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_ACTIVITY_WATCHER_ACTIVITY_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/activity_watcher/activity_utils.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/activity_watcher/activity_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..745b1c88565ed5e6a8dbb2a7410693b3986cca0e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/activity_watcher/activity_utils.h
@@ -0,0 +1,37 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_ACTIVITY_WATCHER_ACTIVITY_UTILS_H_
+#define TENSORFLOW_CORE_ACTIVITY_WATCHER_ACTIVITY_UTILS_H_
+
+#include <memory>
+
+#include "tensorflow/core/activity_watcher/activity.h"
+
+namespace tensorflow {
+
+class OpKernelContext;
+
+namespace activity_watcher {
+
+// A convenient way to create an activity. Writes OpKernelContext information
+// and given attributes to a new activity and returns.
+std::unique_ptr<Activity> ActivityFromContext(
+    OpKernelContext* context, tsl::string name, ActivityCategory category,
+    Activity::Attributes additional_attributes = Activity::Attributes());
+
+}  // namespace activity_watcher
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_ACTIVITY_WATCHER_ACTIVITY_UTILS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/all_to_all.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/all_to_all.h
new file mode 100644
index 0000000000000000000000000000000000000000..0c9716da6a108b876fd5fd619b9eddbafc593bce
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/all_to_all.h
@@ -0,0 +1,69 @@
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_ALL_TO_ALL_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_ALL_TO_ALL_H_
+
+#include <deque>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "tensorflow/core/common_runtime/base_collective_executor.h"
+#include "tensorflow/core/framework/collective.h"
+#include "tensorflow/core/framework/device.h"
+
+namespace tensorflow {
+
+// Implementation of collective all-to-all.
+class AllToAll : public CollectiveImplementationInterface {
+ public:
+  AllToAll();
+
+  void Run(StatusCallback done) override;
+
+  Status InitializeCollectiveParams(CollectiveParams* col_params) override {
+    return OkStatus();
+  }
+
+  // Initializes members of CollectiveContext not yet initialized, i.e. device
+  // and device_locality.  Also saves the CollectiveContext in this object.
+  Status InitializeCollectiveContext(
+      std::shared_ptr<CollectiveContext> col_ctx) override;
+
+ private:
+  std::shared_ptr<CollectiveContext> col_ctx_;
+  const CollectiveParams* col_params_;  // Not owned
+  std::vector<Tensor> input_chunks_;
+  Tensor output_buffer_;
+  std::vector<Tensor> output_chunks_;
+  StatusCallback done_;
+  mutex mu_;
+  Status status_ TF_GUARDED_BY(mu_);
+  int counter_ TF_GUARDED_BY(mu_);
+
+  void DispatchSend(int src_rank, int target_rank, const Tensor* tensor,
+                    const StatusCallback& done);
+
+  void DispatchRecv(int src_rank, int target_rank, Tensor* tensor,
+                    const StatusCallback& done);
+
+  // Atomically increments counter_ by one for sending, one for receiving.
+  // Invokes done when counter_ reaches 2.
+  // The purpose of checking counter_ is to ensure that done_ is called once.
+  StatusCallback CheckCounterAndCallDone();
+};
+
+}  // namespace tensorflow
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_ALL_TO_ALL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/allocator_retry.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/allocator_retry.h
new file mode 100644
index 0000000000000000000000000000000000000000..44ff25aee27aa44ed41a52b0d68335d5016992f5
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/allocator_retry.h
@@ -0,0 +1,28 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_ALLOCATOR_RETRY_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_ALLOCATOR_RETRY_H_
+
+#include "tensorflow/core/platform/env.h"
+#include "tensorflow/core/platform/mutex.h"
+#include "tensorflow/core/platform/types.h"
+#include "tsl/framework/allocator_retry.h"
+
+namespace tensorflow {
+using tsl::AllocatorRetry;  // NOLINT
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_ALLOCATOR_RETRY_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/arg_ret_placement.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/arg_ret_placement.h
new file mode 100644
index 0000000000000000000000000000000000000000..4f00d18e3bb6ca801e7281d85c74d53efd009f6f
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/arg_ret_placement.h
@@ -0,0 +1,158 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_ARG_RET_PLACEMENT_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_ARG_RET_PLACEMENT_H_
+
+#include <utility>
+#include <vector>
+
+#include "tensorflow/core/framework/allocator.h"
+#include "tensorflow/core/framework/function.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/platform/status.h"
+
+namespace tensorflow::full_type {
+
+// Set the contents of memory_types for args (inputs to functions, "_Arg" ops)
+// based on dtype. Raises an error if an int32 arg does not have
+// expected full_type information. If an error raised about bad full
+// time information causes a breakage, changing `SetMemoryTypeForArgs` to
+// `WeakSetMemoryTypeForArgs` is a possible work around.
+Status SetMemoryTypeForArgs(const gtl::InlinedVector<Node*, 4>& nodes,
+                            const DataTypeVector& dtypes,
+                            MemoryTypeVector& memory_types);
+
+// TODO(b/258849883) Delete the `Weak...` versions of these functions once
+// everything is working with the version without `Weak`.
+
+// Set the contents of memory_types for args (inputs to functions, "_Arg" ops)
+// based on dtype. Logging of warnings if an int32 arg does not have
+// expected full_type information can be enabled.
+Status WeakSetMemoryTypeForArgs(const gtl::InlinedVector<Node*, 4>& nodes,
+                                const DataTypeVector& dtypes,
+                                MemoryTypeVector& memory_types);
+
+// Set the contents of memory_types for rets (outputs from functions, "_Retval"
+// ops) based on dtype. Raises an error if an int32 ret does not have
+// expected full_type information (i.e. if the source of the input to the ret
+// does not have expected full type information). If an error raised about bad
+// full time information causes a breakage, changing `SetMemoryTypeForRets` to
+// `WeakSetMemoryTypeForRets` is a possible work around.
+Status SetMemoryTypeForRets(const gtl::InlinedVector<Node*, 4>& nodes,
+                            const DataTypeVector& dtypes,
+                            MemoryTypeVector& memory_types);
+
+// Set the contents of memory_types for rets (outputs from functions, "_Retval"
+// ops) based on dtype. Logging of warnings if an int32 ret does not have
+// expected full_type information (i.e. if the source of the input to the ret
+// does not have expected full type information) can be enabled.
+Status WeakSetMemoryTypeForRets(const gtl::InlinedVector<Node*, 4>& nodes,
+                                const DataTypeVector& dtypes,
+                                MemoryTypeVector& memory_types);
+
+// Set the contents of alloc_attrs for args (inputs to functions, "_Arg" ops)
+// based on dtype. Raises an error if an int32 arg does not have
+// expected full_type information. If an error raised about bad full
+// time information causes a breakage, changing `SetAllocAttrsForArgs` to
+// `WeakSetAllocAttrsForArgs` is a possible work around.
+Status SetAllocAttrsForArgs(const gtl::InlinedVector<Node*, 4>& nodes,
+                            const DataTypeVector& dtypes,
+                            std::vector<AllocatorAttributes>& alloc_attrs);
+
+// Set the contents of alloc_attrs for args (inputs to functions, "_Arg" ops)
+// based on dtype. Logging of warnings if an int32 arg does not have
+// expected full_type information can be enabled.
+Status WeakSetAllocAttrsForArgs(const gtl::InlinedVector<Node*, 4>& nodes,
+                                const DataTypeVector& dtypes,
+                                std::vector<AllocatorAttributes>& alloc_attrs);
+
+// Set the contents of alloc_attrs for rets (outputs from functions, "_Retval"
+// ops) based on dtype. Raises an error if an int32 ret does not have
+// expected full_type information (i.e. if the source of the input to the ret
+// does not have expected full type information). If an error raised about bad
+// full time information causes a breakage, changing `SetAllocAttrsForRets` to
+// `WeakSetAllocAttrsForRets` is a possible work around.
+Status SetAllocAttrsForRets(const gtl::InlinedVector<Node*, 4>& nodes,
+                            const DataTypeVector& dtypes,
+                            std::vector<AllocatorAttributes>& alloc_attrs);
+
+// Set the contents of alloc_attrs for rets (outputs from functions, "_Retval"
+// ops) based on dtype. Logging of warnings if an int32 ret does not have
+// expected full_type information (i.e. if the source of the input to the ret
+// does not have expected full type information) can be enabled.
+Status WeakSetAllocAttrsForRets(const gtl::InlinedVector<Node*, 4>& nodes,
+                                const DataTypeVector& dtypes,
+                                std::vector<AllocatorAttributes>& alloc_attrs);
+
+// Set the contents of alloc_attrs for args (inputs to functions, "_Arg" ops)
+// for a single device funtion based on dtype. Raises an error if an int32 arg
+// does not have expected full_type information. If an error raised about bad
+// full time information causes a breakage, changing
+// `SingleDeviceSetAllocAttrsForArgs` to `WeakSingleDeviceSetAllocAttrsForArgs`
+// is a possible work around. The DataType specified by the "T" attr of input
+// nodes is used.
+Status SingleDeviceSetAllocAttrsForArgs(
+    std::vector<std::pair<Node*, FunctionArgIndex>> arg_nodes,
+    bool ints_on_device, std::vector<AllocatorAttributes>& alloc_attrs);
+
+// Set the contents of alloc_attrs for args (inputs to functions, "_Arg" ops)
+// for a single device based on dtype. Logging of warnings if an int32 arg does
+// not have expected full_type information can be enabled. The DataType
+// specified by the "T" attr of input nodes is used.
+Status WeakSingleDeviceSetAllocAttrsForArgs(
+    std::vector<std::pair<Node*, FunctionArgIndex>> arg_nodes,
+    bool ints_on_device, std::vector<AllocatorAttributes>& alloc_attrs);
+
+// Set the contents of alloc_attrs for rets (outputs from functions, "_Retval"
+// ops) for a single device based on dtype. Raises an error if an int32 ret does
+// not have expected full_type information (i.e. if the source of the input to
+// the ret does not have expected full type information). If an error raised
+// about bad full time information causes a breakage, changing
+// `SingleDeviceSetAllocAttrsForRets` to `WeakSingleDeviceSetAllocAttrsForRets`
+// is a possible work around. The DataType specified by the "T" attr of input
+// nodes is used.
+Status SingleDeviceSetAllocAttrsForRets(
+    std::vector<std::pair<Node*, int>> ret_nodes, bool ints_on_device,
+    std::vector<AllocatorAttributes>& alloc_attrs);
+
+// Set the contents of alloc_attrs for rets (outputs from functions, "_Retval"
+// ops) for a single device based on dtype. Logging of warnings if an int32 ret
+// does not have expected full_type information (i.e. if the source of the input
+// to the ret does not have expected full type information) can be enabled. The
+// DataType specified by the "T" attr of input nodes is used.
+Status WeakSingleDeviceSetAllocAttrsForRets(
+    std::vector<std::pair<Node*, int>> ret_nodes, bool ints_on_device,
+    std::vector<AllocatorAttributes>& alloc_attrs);
+
+// Given a FullTypeId, return the corresponding MemoryTypes (i.e. return
+// HOST_MEMORY for TFT_SHAPE_TENSOR, DEVICE_MEMORY othersize).
+MemoryType MemoryTypeFromFullTypeId(FullTypeId id);
+
+// Check that use_host_memory is true iff FT has type_id TFT_SHAPE_TENSOR
+// and logging of a warning if not can be enabled. Returns true if check passes.
+// Note the FT is expected to be the full type information for a tensor, not for
+// the whole ouput of an op, i.e. it should not have an outer TFT_PRODUCT.
+bool LogMemoryTypeMismatch(bool use_host_memory, const FullTypeDef& ft);
+
+// Check that use_host_memory is true iff FT has type_id TFT_SHAPE_TENSOR
+// and raise an error if not. Note the FT is expected to be the full type
+// information for a tensor, not for the whole ouput of an op, i.e. it should
+// not have an outer TFT_PRODUCT.
+Status CheckMemoryType(bool use_host_memory, const FullTypeDef& ft);
+
+}  // namespace tensorflow::full_type
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_ARG_RET_PLACEMENT_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/base_collective_executor.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/base_collective_executor.h
new file mode 100644
index 0000000000000000000000000000000000000000..242b92b2e749f74a0223ff87e7058866d7b226b2
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/base_collective_executor.h
@@ -0,0 +1,164 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_BASE_COLLECTIVE_EXECUTOR_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_BASE_COLLECTIVE_EXECUTOR_H_
+
+#include <memory>
+#include <string>
+
+#include "tensorflow/core/common_runtime/buf_rendezvous.h"
+#include "tensorflow/core/framework/collective.h"
+#include "tensorflow/core/framework/device_attributes.pb.h"
+#include "tensorflow/core/platform/unbounded_work_queue.h"
+
+namespace tensorflow {
+class CollectiveImplementation;
+class DeviceMgr;
+class Device;
+
+// Helper interface that aliases regular subfields of a Tensor as separate
+// Tensors for in-place update.
+class CollectiveAdapter {
+ public:
+  virtual ~CollectiveAdapter() {}
+
+  // Move the backing tensor to 'output' with its original storage and
+  // shape. After this call this CollectiveAdapter object should be
+  // deleted immediately without calling any of its other methods.
+  virtual void ConsumeFinalValue(Tensor* output) = 0;
+
+  // const access to entire intermediate value for debugging
+  virtual const Tensor& Value() const = 0;
+
+  // Returns tensor for chunk i which aliases the backing buffer.
+  virtual Tensor ChunkAlias(int i) = 0;
+
+  // Returns tensor allocated on the same device but with its own
+  // separate backing buffer.  Will have same type and size as
+  // chunk i.
+  virtual Tensor TempChunk(int i) const = 0;
+
+  // Bytes in chunk i
+  virtual int64_t ChunkBytes(int i) const = 0;
+
+  // Generate a CPU RAM scalar tensor of the same DataType as the
+  // backing tensor with the given integer value.
+  virtual Tensor Scalar(int v) const = 0;
+
+  // Generate a scalar tensor of same DataType and on the same device
+  // as the backing tensor.
+  virtual Tensor Scalar(Allocator* a,
+                        const AllocationAttributes& attr) const = 0;
+
+  // Debugging string describing buffer location
+  virtual string TBounds(const Tensor& t) const = 0;
+
+  virtual string DebugString() const = 0;
+
+  // Computes the number of elements per alias chunk tensor.
+  //
+  // A CHECK in tensor.cc expects that the memory buffer backing a
+  // Tensor will be aligned according to EIGEN_MAX_ALIGN_BYTES.  To
+  // ensure that all chunk aliasing Tensors maintain this alignment we
+  // need to pick a chunk size that preserves it.  Note than in extreme
+  // cases (impractical, but possible with very small tensors) one or
+  // more tail chunks can end up emptby.
+  static int64_t AlignedChunkElts(int64_t elt_bytes, int64_t total_elts,
+                                  int64_t num_chunks);
+};
+
+// Create a CollectiveAdaptor wrapping 'output', specialized to its
+// data-type and shape.  If align_chunks == true then chunk size may
+// be larger than output->NumElements() / num_chunks and one or more
+// of the suffix chunks may be empty.  Chunks will be arranged to start
+// and end on alignment boundaries.  If align_chunks == false then
+// output->NumElements() % num_chunks must be 0 and all chunks will
+// have exactly the same size, ignoring alignment issues.
+CollectiveAdapter* MakeCollectiveAdapter(Tensor* output, int num_chunks,
+                                         Allocator* allocator,
+                                         bool align_chunks = true);
+
+// Default implementation of CollectiveExecutor.  Delegates the actual
+// work of moving data to a class specialized for the operation type,
+// arguments and device+interconnect topology.
+class BaseCollectiveExecutor : public CollectiveExecutor {
+ public:
+  BaseCollectiveExecutor(CollectiveExecutorMgrInterface* cem,
+                         CollectiveRemoteAccess* remote_access, int64_t step_id,
+                         const DeviceMgr* dev_mgr,
+                         std::shared_ptr<UnboundedWorkQueue> work_queue)
+      : CollectiveExecutor(cem),
+        step_id_(step_id),
+        dev_mgr_(dev_mgr),
+        remote_access_(remote_access),
+        work_queue_(std::move(work_queue)) {}
+
+  ~BaseCollectiveExecutor() override;
+
+  void StartAbort(const Status& s) override TF_LOCKS_EXCLUDED(status_mu_);
+
+  void ExecuteAsync(OpKernelContext* ctx, const CollectiveParams* col_params,
+                    const string& exec_key, StatusCallback done) override;
+
+  void CompleteParamsAsync(const DeviceAttributes& device, CollectiveParams* cp,
+                           CancellationManager* cancel_mgr,
+                           StatusCallback done) override;
+
+  CollectiveRemoteAccess* remote_access() override {
+    return remote_access_.get();
+  }
+
+  void RunClosure(std::function<void()> closure) override {
+    work_queue_->Schedule(std::move(closure));
+  }
+
+  // If we need to enforce an ordering on any portion of collective
+  // implementation, and the ordering is encoded via attribute on the collective
+  // op, this function will block until all dependencies for this collective
+  // have completed.
+  void WaitForDependencies(const CollectiveParams& col_params) override;
+  // Record that this collective has completed the portion of the implementation
+  // that needs to be ordered wrt other collectives, to unblock any of its
+  // dependent ops.
+  void UnblockDependencies(const CollectiveParams& col_params) override;
+
+ protected:
+  const int64_t step_id_;
+  const DeviceMgr* dev_mgr_;  // Not owned.
+  std::unique_ptr<CollectiveRemoteAccess> remote_access_;
+  // Ownership of `work_queue_` is shared between `this` and
+  // `CollectiveExecutorMgr`.
+  std::shared_ptr<UnboundedWorkQueue> work_queue_;
+  mutex launch_mu_;
+  condition_variable launch_cv_;
+  // collective instance key -> number of local devices for which NCCL ops have
+  // been launched.
+  std::unordered_map<int32, int32> launched_ TF_GUARDED_BY(launch_mu_);
+  mutex status_mu_;
+  Status status_ TF_GUARDED_BY(status_mu_);
+
+ private:
+  Status CreateCollective(const CollectiveParams& col_params,
+                          CollectiveImplementationInterface** col_impl);
+  // Check if all ops on which this collective depends on have launched.
+  bool CheckDependencies(const CollectiveParams& col_params)
+      TF_EXCLUSIVE_LOCKS_REQUIRED(launch_mu_);
+  // Tries to return the status that is the original error. It returns the
+  // aborted status if the collective executor is aborted.
+  Status GetStatus(const Status& s) TF_LOCKS_EXCLUDED(status_mu_);
+};
+
+}  // namespace tensorflow
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_BASE_COLLECTIVE_EXECUTOR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/bfc_allocator.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/bfc_allocator.h
new file mode 100644
index 0000000000000000000000000000000000000000..efd2a0c7480d8448b395477a7fc39263cc3ecff0
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/bfc_allocator.h
@@ -0,0 +1,45 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_BFC_ALLOCATOR_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_BFC_ALLOCATOR_H_
+
+#include <array>
+#include <deque>
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include "absl/container/flat_hash_set.h"
+#include "tensorflow/core/common_runtime/allocator_retry.h"
+#include "tensorflow/core/common_runtime/shared_counter.h"
+#include "tensorflow/core/framework/allocator.h"
+#include "tensorflow/core/lib/strings/numbers.h"
+#include "tensorflow/core/lib/strings/strcat.h"
+#include "tensorflow/core/platform/macros.h"
+#include "tensorflow/core/platform/mutex.h"
+#include "tensorflow/core/platform/thread_annotations.h"
+#include "tensorflow/core/platform/types.h"
+#include "tsl/framework/bfc_allocator.h"
+
+namespace tensorflow {
+
+class MemoryDump;         // NOLINT
+using tsl::BFCAllocator;  // NOLINT
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_BFC_ALLOCATOR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/buf_rendezvous.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/buf_rendezvous.h
new file mode 100644
index 0000000000000000000000000000000000000000..0ee6099eea54943cd44f66a54bf4be101d1d04a7
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/buf_rendezvous.h
@@ -0,0 +1,134 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_BUF_RENDEZVOUS_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_BUF_RENDEZVOUS_H_
+
+#include <functional>
+#include <string>
+
+#include "absl/container/flat_hash_map.h"
+#include "absl/strings/string_view.h"
+#include "tensorflow/core/framework/allocator.h"
+#include "tensorflow/core/framework/cancellation.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/platform/mutex.h"
+
+namespace tensorflow {
+class Device;
+class DeviceContext;
+class DeviceMgr;
+class Tensor;
+
+// EXPERIMENTAL: RDMA oriented producer/consumer rendezvous on a local
+// Tensor value for which DMAHelper::CanUseDMA() is true, i.e. dense
+// numeric types.  Similar to Rendezvous but never owns a Ref on the
+// tensor, instead it uses an explicit callback to the producer when
+// the consumer side is finished with the value.  This allows the
+// producer to perform in-place updates on the source buffer or to take
+// other actions that depend on knowing the consumer has passed a certain
+// execution point.
+class BufRendezvous {
+ public:
+  explicit BufRendezvous(uint64 step_id, const DeviceMgr* dev_mgr)
+      : step_id_(step_id), dev_mgr_(dev_mgr) {}
+
+  virtual ~BufRendezvous();
+
+  // Inform all waiting parties that this BufRendezvous is defunct because of
+  // an error Status interrupting the Step.
+  void StartAbort(const Status& s);
+
+  struct Hook;
+  // Provided by the consumer to be called when access to the buffer
+  // is available.  If the Status arg is not OK, then hook will not
+  // be populated.  Ownership of Hook passes to consumer with the
+  // callback.
+  typedef std::function<void(const Status&, Hook*)> ConsumerCallback;
+  // Provided by the producer to be called when the consumer has finished
+  // reading the buffer and will no longer access it.
+  typedef std::function<void(const Status&)> ProducerCallback;
+
+  struct Hook {
+    Device* prod_dev;
+    DeviceContext* prod_ctx;
+    const Tensor* prod_value;
+    AllocatorAttributes prod_attr;
+    ProducerCallback prod_cb;
+    ConsumerCallback cons_cb;
+    CancellationManager* cancellation_manager;
+    CancellationToken cancellation_token;
+    explicit Hook(CancellationManager* cancellation_manager,
+                  CancellationToken cancellation_token)
+        : prod_dev(nullptr),
+          prod_ctx(nullptr),
+          prod_value(nullptr),
+          prod_cb(nullptr),
+          cons_cb(nullptr),
+          cancellation_manager(cancellation_manager),
+          cancellation_token(cancellation_token) {}
+    string DebugString() const;
+  };
+
+  // Called to advertise availability of a Tensor value corresponding
+  // to key.  That value must stay valid until done is called.
+  //
+  // If a non-null cancellation manager is provided, this function registers a
+  // callback to delete the hook and invoke provider/consumer callbacks with
+  // cancelled error.
+  void ProvideBuf(const string& key, Device* dev, DeviceContext* dev_ctx,
+                  const Tensor* v, const AllocatorAttributes& attr,
+                  const ProducerCallback& done,
+                  CancellationManager* cancellation_manager);
+
+  // Called to request access to a Tensor value corresponding to key.
+  // Consumer is provided with a Hook as soon as available.
+  //
+  // This function also checks that the current incarnation number of the
+  // `device` that produced this value matches the `incarnation` expected by the
+  // consumer, and invokes `done` with `FailedPrecondition` status and
+  // `nullptr` hook if it does not match.
+  //
+  // If a non-null cancellation manager is provided, this function registers a
+  // callback to delete the hook and invoke provider/consumer callbacks with
+  // cancelled error.
+  virtual void ConsumeBuf(const string& key, const string& device,
+                          const uint64 incarnation,
+                          const ConsumerCallback& done,
+                          CancellationManager* cancellation_manager);
+
+  // Cancel the rendezvous entry corresponding to `key`.  Triggered by the
+  // cancellation manager. No-op if the rendezvous was already successful.
+  void CancelHook(const string& key);
+
+  // Consumer must call this function when it's done reading the Hook provided
+  // by the ConsumerCallback.  This function will invoke the producer callback
+  // and then delete h.
+  static void DoneWithHook(Hook* h);
+
+  // Write the current contents of the table to the INFO log.
+  void LogContents();
+
+ protected:
+  const uint64 step_id_;
+  const DeviceMgr* const dev_mgr_;  // Not owned.
+  mutex mu_;
+  Status status_ TF_GUARDED_BY(mu_);
+  typedef absl::flat_hash_map<string, Hook*> HookTable;
+  HookTable hook_table_ TF_GUARDED_BY(mu_);
+
+  void PurgeTable(const Status& s, HookTable* table);
+};
+}  // namespace tensorflow
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_BUF_RENDEZVOUS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/build_graph_options.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/build_graph_options.h
new file mode 100644
index 0000000000000000000000000000000000000000..f33d43fbc3cfd6f1f6deffc94cc606502c377e44
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/build_graph_options.h
@@ -0,0 +1,48 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_BUILD_GRAPH_OPTIONS_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_BUILD_GRAPH_OPTIONS_H_
+
+#include <vector>
+
+#include "tensorflow/core/graph/collective_order.h"
+#include "tensorflow/core/platform/types.h"
+#include "tensorflow/core/protobuf/config.pb.h"
+
+namespace tensorflow {
+
+struct BuildGraphOptions {
+  CallableOptions callable_options;
+
+  // If `true`, uses Arg/Retval to implement feeds/fetches; otherwise
+  // uses Recv/Send to implement feeds/fetches.
+  // TODO(mrry): Remove this when the distributed runtime supports Arg/Retval.
+  bool use_function_convention = false;
+
+  static constexpr int64_t kNoCollectiveGraphKey = 0;
+  int64_t collective_graph_key = kNoCollectiveGraphKey;
+
+  // If not `kNone`, order all CollectiveReduce operations statically and
+  // deterministically.  If `kEdges`, encode dependencies as explicit control
+  // edges, if `kAttrs` encode as attribute on collective op.
+  GraphCollectiveOrder collective_order = GraphCollectiveOrder::kNone;
+
+  string DebugString() const;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_BUILD_GRAPH_OPTIONS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/collective_executor_mgr.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/collective_executor_mgr.h
new file mode 100644
index 0000000000000000000000000000000000000000..d480db03a466094f83764b9f88700b2d371aa5fa
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/collective_executor_mgr.h
@@ -0,0 +1,96 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_COLLECTIVE_EXECUTOR_MGR_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_COLLECTIVE_EXECUTOR_MGR_H_
+
+#include "tensorflow/core/framework/collective.h"
+#include "tensorflow/core/lib/gtl/flatmap.h"
+#include "tensorflow/core/platform/unbounded_work_queue.h"
+
+namespace tensorflow {
+class ConfigProto;
+class DeviceMgr;
+
+class CollectiveExecutorMgr : public CollectiveExecutorMgrInterface {
+ public:
+  CollectiveExecutorMgr(
+      const ConfigProto& config, const DeviceMgr* dev_mgr,
+      std::unique_ptr<DeviceResolverInterface> dev_resolver,
+      std::unique_ptr<ParamResolverInterface> param_resolver,
+      std::unique_ptr<NcclCommunicatorInterface> nccl_communicator);
+
+  virtual ~CollectiveExecutorMgr();
+
+  CollectiveExecutor* FindOrCreate(int64_t step_id) override;
+
+  void Cleanup(int64_t step_id) override;
+
+  ParamResolverInterface* GetParamResolver() const override {
+    return param_resolver_.get();
+  }
+
+  DeviceResolverInterface* GetDeviceResolver() const override {
+    return dev_resolver_.get();
+  }
+
+  NcclCommunicatorInterface* GetNcclCommunicator() const override {
+    return nccl_communicator_.get();
+  }
+
+  void GetStepSequenceAsync(const GetStepSequenceRequest* request,
+                            GetStepSequenceResponse* response,
+                            const StatusCallback& done) override;
+
+  void RefreshStepIdSequenceAsync(int64_t graph_key,
+                                  const StatusCallback& done) override;
+
+  int64_t NextStepId(int64_t graph_key) override {
+    return CollectiveExecutor::kInvalidId;
+  }
+
+  void RetireStepId(int64_t graph_key, int64_t step_id) override {}
+
+ protected:
+  // Called by FindOrCreate when table entry does not yet exist.
+  virtual CollectiveExecutor* Create(int64_t step_id);
+
+  const DeviceMgr* dev_mgr_;
+  std::unique_ptr<DeviceResolverInterface> dev_resolver_;
+  std::unique_ptr<ParamResolverInterface> param_resolver_;
+  string gpu_ring_order_;
+  std::unique_ptr<NcclCommunicatorInterface> nccl_communicator_;
+  // Unbounded work queue for scheduling potentially-blocking work during
+  // collective op execution.  Ownership is shared between `this` and
+  // `CollectiveRemoteAccessLocal`.
+  std::shared_ptr<UnboundedWorkQueue> work_queue_;
+
+ private:
+  mutex exec_mu_;
+  // Map from step_id to CollectiveExecutor
+  gtl::FlatMap<int64_t, CollectiveExecutor*> executor_table_
+      TF_GUARDED_BY(exec_mu_);
+};
+
+// Creates a local CollectiveExecutorMgr with production implementations of each
+// components. Cases that need to inject other implementations of these
+// components should call CollectiveExecutorMgr constructor directly. This only
+// supports a single host. For distributed use case, use
+// CreateProdRpcCollectiveExecutorMgr() instead.
+std::unique_ptr<CollectiveExecutorMgr> CreateProdLocalCollectiveExecutorMgr(
+    const ConfigProto& config, const DeviceMgr* device_mgr,
+    std::unique_ptr<NcclCommunicatorInterface> nccl_communicator);
+
+}  // namespace tensorflow
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_COLLECTIVE_EXECUTOR_MGR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/collective_param_resolver_local.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/collective_param_resolver_local.h
new file mode 100644
index 0000000000000000000000000000000000000000..6a702e237c171c4a128e5cf230f9fea1a262baff
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/collective_param_resolver_local.h
@@ -0,0 +1,215 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_COLLECTIVE_PARAM_RESOLVER_LOCAL_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_COLLECTIVE_PARAM_RESOLVER_LOCAL_H_
+
+#include <functional>
+#include <memory>
+#include <set>
+#include <string>
+#include <tuple>
+#include <unordered_map>
+#include <vector>
+
+#include "tensorflow/core/framework/collective.h"
+#include "tensorflow/core/framework/device_attributes.pb.h"
+#include "tensorflow/core/lib/gtl/flatmap.h"
+#include "tensorflow/core/platform/thread_annotations.h"
+
+namespace tensorflow {
+class CompleteGroupRequest;
+class CompleteGroupResponse;
+class CompleteInstanceRequest;
+class CompleteInstanceResponse;
+class ConfigProto;
+class DeviceMgr;
+
+// Implements ParamResolverInterface for a single-task context.
+// It also implements the functionality necessary to serve as the
+// group leader for param resolution in a multi-task context.
+class CollectiveParamResolverLocal : public ParamResolverInterface {
+ public:
+  CollectiveParamResolverLocal(const ConfigProto& config,
+                               const DeviceMgr* dev_mgr,
+                               DeviceResolverInterface* dev_resolver,
+                               NcclCommunicatorInterface* nccl_communicator,
+                               const string& task_name);
+
+  ~CollectiveParamResolverLocal() override {}
+
+  void CompleteParamsAsync(const DeviceAttributes& device, CollectiveParams* cp,
+                           CancellationManager* cancel_mgr,
+                           const StatusCallback& done) override;
+
+  void CompleteGroupAsync(const DeviceAttributes& device,
+                          CollGroupParams* group_params,
+                          CancellationManager* cancel_mgr,
+                          const StatusCallback& done) override;
+
+  void CompleteInstanceAsync(const CompleteInstanceRequest* request,
+                             CompleteInstanceResponse* response,
+                             CancellationManager* cancel_mgr,
+                             const StatusCallback& done) override;
+
+  Status LookupGroup(int32_t group_key, CollGroupParams* group) override;
+
+  void StartAbort(const Status& s) override;
+
+ protected:
+  // For access to InstanceRec and CompleteDefaultRanking.
+  friend class CollectiveParamResolverLocalTest;
+
+  // Used to complete/verify CollGroup.
+  struct GroupRec {
+    mutable mutex mu;
+    CollGroupParams group TF_GUARDED_BY(mu);
+    Status status TF_GUARDED_BY(mu);
+    std::unordered_map<string, int64_t> incarnations_by_device_name
+        TF_GUARDED_BY(mu);
+    std::vector<CollGroupParams*> pending_params TF_GUARDED_BY(mu);
+    std::vector<StatusCallback> pending_done TF_GUARDED_BY(mu);
+  };
+
+  // Finds the GroupRec that corresponds to group_params->group_key.
+  // Also populates group_params from that group_rec.
+  // Will wait until GroupRec is fully populated or an error arises before
+  // calling done.  Callback GroupRec* arg is only valid if status is ok.
+  // Ownership of GroupRec stays with this object and does not pass to the
+  // callback.
+  void CompleteGroupLocal(const DeviceAttributes& device,
+                          CollGroupParams* group_params,
+                          CancellationManager* cancel_mgr, StatusCallback done)
+      TF_LOCKS_EXCLUDED(group_mu_);
+
+  // Finishes the group parameters once all members of the group are there.
+  void FinishGroup(GroupRec* gr) TF_EXCLUSIVE_LOCKS_REQUIRED(gr->mu);
+
+  // Cancels the group if it's still pending.
+  void CancelGroup(int32 group_key) TF_LOCKS_EXCLUDED(group_mu_);
+
+  // Lookup and populate parameters from an already initialized group.
+  Status LookupAndPopulateGroupParams(CollGroupParams* group_params);
+
+  // Used to complete/verify CollInstance.
+  struct InstanceRec;
+
+  typedef std::function<void(InstanceRec*)> IRConsumer;
+  struct InstanceRec {
+    mutex mu;
+    // Values to be shared by all instances, constant after initialization.
+    CollectiveParams* shared;
+    // If an error occurs during initialization this structure stays in the
+    // table with a non-OK status. Purging the table and restarting needs to be
+    // done at a higher level.
+    Status status TF_GUARDED_BY(mu);
+
+    // These fields are used to count the instances that have called
+    // in and become known while resolving broadcast source identity and
+    // communicator key.
+    int source_rank TF_GUARDED_BY(mu);
+    string communicator_key TF_GUARDED_BY(mu);
+    int known_count TF_GUARDED_BY(mu);
+    std::vector<bool> known TF_GUARDED_BY(mu);
+    std::vector<IRConsumer> known_waiters TF_GUARDED_BY(mu);
+
+    InstanceRec()
+        : shared(new CollectiveParams()), source_rank(-1), known_count(0) {}
+    ~InstanceRec() { shared->Unref(); }
+  };
+
+  // Find the InstanceRec with the same instance_key as cp.  If it doesn't
+  // already exist, create and initialize from gr and cp.
+  // created is set to true if a new IRec is created, false otherwise.
+  //
+  // Precondition: *gr must be a complete GroupRec, i.e. the value set
+  // by CompleteGroupLocal. *cp must be populated with all the fields
+  // required by InitInstanceSharedParams.  Ownership of InstanceRec stays
+  // with this object and does not pass to the callback.
+  InstanceRec* GetOrCreateInstanceRec(CollectiveParams* cp, bool* created)
+      TF_LOCKS_EXCLUDED(instance_mu_, group_mu_);
+
+  // Populate *ir with device membership from gr, then initialize to be specific
+  // to cp->instance_key, i.e. order the devices and tasks.
+  //
+  // Preconditions:
+  //  cp is populated with all DeviceLocalities
+  void InitInstanceSharedParams(const CollectiveParams* cp, InstanceRec* ir);
+
+  // Establishes the final order of gp->device_names and gp->task_names by
+  // considering localities of all devices.
+  void CompleteDefaultRanking(CollGroupParams* gp);
+
+  // Finish populating *cp.
+  // Precondition: *gr has been fully populated by CompleteGroupLocal.
+  void CompleteInstanceLocal(const string& device, CollectiveParams* cp,
+                             const StatusCallback& done)
+      TF_LOCKS_EXCLUDED(instance_mu_, group_mu_);
+
+  // Finish populating *cp from fully initialized *ir.
+  // Precondition: *gr and *ir are fully populated.
+  void CompleteInstanceFromInitializedIRec(const string& device,
+                                           CollectiveParams* cp,
+                                           InstanceRec* ir,
+                                           const StatusCallback& done)
+      TF_LOCKS_EXCLUDED(ir->mu);
+
+  // Complete instance params after waiting for group.
+  // Precondition: *cp has complete group data and default_rank.
+  void WaitForGroup(InstanceRec* ir, CollectiveParams* cp, const IRConsumer& f)
+      TF_LOCKS_EXCLUDED(ir->mu);
+
+  // If cp.device_names contains only devices local to this process
+  // populates *localities, else returns an error.
+  Status GetLocalDeviceLocalities(const CollectiveParams& cp,
+                                  std::vector<DeviceLocality>* localities);
+
+  // Sets cp->instance_default_rank according to location of device in
+  // current ordering of cp->instance.device_names.
+  void SetDefaultRank(const string& device, CollectiveParams* cp);
+
+  // Sets cp->instance.type based on collective op type, and attempts to assign
+  // best implementation.
+  void AssignCollectiveType(CollectiveParams* cp);
+
+  void StartAbortLocal(const Status& s)
+      TF_LOCKS_EXCLUDED(status_mu_, group_mu_, instance_mu_);
+
+  const bool nccl_;
+  const DeviceMgr* dev_mgr_;
+  DeviceResolverInterface* dev_resolver_;  // Not owned.
+  NcclCommunicatorInterface* nccl_communicator_;  // Not owned.
+  string task_name_;
+  string gpu_ring_order_;
+  mutex group_mu_;
+  gtl::FlatMap<int32, std::unique_ptr<GroupRec>> group_table_
+      TF_GUARDED_BY(group_mu_);
+  struct TupleHash {
+    std::size_t operator()(const std::tuple<int64_t, int32_t> x) const {
+      // The hash does not need to be unique and a value of 20 is picked
+      // arbitrarily as an effort to reduce probability of conflicts.
+      return (std::get<0>(x) << 20) + std::get<1>(x);
+    }
+  };
+  mutex instance_mu_;
+  gtl::FlatMap<int32_t, gtl::FlatMap<std::tuple<int64_t, int32_t>,
+                                     std::unique_ptr<InstanceRec>, TupleHash>>
+      instance_table_ TF_GUARDED_BY(instance_mu_);
+  mutex status_mu_;
+  Status status_ TF_GUARDED_BY(status_mu_);
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_COLLECTIVE_PARAM_RESOLVER_LOCAL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/collective_rma_local.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/collective_rma_local.h
new file mode 100644
index 0000000000000000000000000000000000000000..5c12ed413d9594361ec02dbb06623c5e206d73cc
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/collective_rma_local.h
@@ -0,0 +1,82 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_COLLECTIVE_RMA_LOCAL_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_COLLECTIVE_RMA_LOCAL_H_
+
+#include "tensorflow/core/common_runtime/buf_rendezvous.h"
+#include "tensorflow/core/common_runtime/device_mgr.h"
+#include "tensorflow/core/framework/collective.h"
+#include "tensorflow/core/framework/rendezvous.h"
+
+namespace tensorflow {
+
+// Basic implementation of PerStepCollectiveRemoteAccess.
+class CollectiveRemoteAccessLocal : public CollectiveRemoteAccess {
+ public:
+  CollectiveRemoteAccessLocal(const DeviceMgr* dev_mgr,
+                              DeviceResolverInterface* dev_resolver,
+                              int64_t step_id)
+      : dev_mgr_(dev_mgr),
+        dev_resolver_(dev_resolver),
+        buf_rendezvous_(step_id, dev_mgr),
+        step_id_(step_id) {}
+
+  ~CollectiveRemoteAccessLocal() override = default;
+
+  void StartAbort(const Status& s) override;
+
+  void RecvFromPeer(const string& peer_device, const string& peer_task,
+                    bool peer_is_local, const string& key, Device* to_device,
+                    DeviceContext* to_device_ctx,
+                    const AllocatorAttributes& to_alloc_attr, Tensor* to_tensor,
+                    const DeviceLocality& client_locality,
+                    int dev_to_dev_stream_index,
+                    CancellationManager* cancellation_manager,
+                    const StatusCallback& done) override;
+
+  void PostToPeer(const string& peer_device, const string& peer_task,
+                  const string& key, Device* from_device,
+                  DeviceContext* from_device_ctx,
+                  const AllocatorAttributes& from_alloc_attr,
+                  const Tensor* from_tensor,
+                  const DeviceLocality& client_locality,
+                  CancellationManager* cancellation_manager,
+                  const StatusCallback& done) override;
+
+  void CheckPeerHealth(const string& peer_task, int64_t timeout_in_ms,
+                       const StatusCallback& done) override;
+
+  BufRendezvous* buf_rendezvous() override { return &buf_rendezvous_; }
+
+  // Copy utility that always copies bytes from src to dst even if
+  // they are on the same device, unlike CopyTensor::ViaDMA which will
+  // just change the dst buffer pointer in that case.
+  static void MemCpyAsync(DeviceContext* src_dev_ctx,
+                          DeviceContext* dst_dev_ctx, Device* src_dev,
+                          Device* dst_dev, const AllocatorAttributes& src_attr,
+                          const AllocatorAttributes& dst_attr,
+                          const Tensor* src, Tensor* dst,
+                          int dev_to_dev_stream_index,
+                          const StatusCallback& done);
+
+ protected:
+  const DeviceMgr* dev_mgr_;               // not owned
+  DeviceResolverInterface* dev_resolver_;  // not owned
+  BufRendezvous buf_rendezvous_;
+  int64_t step_id_;
+};
+
+}  // namespace tensorflow
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_COLLECTIVE_RMA_LOCAL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/collective_util.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/collective_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..01fb8b8c81cd2f4dc390c2b6467d7c54c7753bf0
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/collective_util.h
@@ -0,0 +1,59 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_COLLECTIVE_UTIL_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_COLLECTIVE_UTIL_H_
+
+#include <string>
+
+#include "tensorflow/core/common_runtime/device.h"
+#include "tensorflow/core/common_runtime/device_mgr.h"
+#include "tensorflow/core/framework/collective.h"
+#include "tensorflow/core/framework/device_attributes.pb.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/lib/core/status.h"
+
+namespace tensorflow {
+namespace collective_util {
+
+Status InitializeDeviceAndLocality(const DeviceMgr* dev_mgr,
+                                   const string& device_name, Device** device,
+                                   DeviceLocality* device_locality);
+string SubdivPermDebugString(const CollectiveParams& col_params);
+
+// Used for executing a sub-operation, e.g. a merge_op instance, with
+// an OpKernelContext based on the one passed into this Op.
+class SubContext {
+ public:
+  OpKernelContext::Params sub_params_;
+  gtl::InlinedVector<TensorValue, 4> sub_inputs_;
+  gtl::InlinedVector<AllocatorAttributes, 4> sub_input_attr_;
+  gtl::InlinedVector<DeviceContext*, 4> sub_input_dc_;
+  // Used only for Binary and Unary Ops for which we require
+  // the calculation to be in-place on the first input.
+  int forward_from_ = 0;
+  std::unique_ptr<OpKernelContext> sub_ctx_;
+  SubContext(OpKernelContext* ctx, OpKernelContext::Params* params,
+             OpKernel* op, Tensor* output, Tensor* input);
+  ~SubContext() = default;
+};
+
+Status ComputeBinOp(OpKernelContext* op_ctx, OpKernelContext::Params* params,
+                    Device* device, OpKernel* op, Tensor* output,
+                    Tensor* input);
+
+}  // namespace collective_util
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_COLLECTIVE_UTIL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/colocation_graph.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/colocation_graph.h
new file mode 100644
index 0000000000000000000000000000000000000000..e6362b47334949c12f5a070c6e1d6b33a6215f2b
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/colocation_graph.h
@@ -0,0 +1,393 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_COLOCATION_GRAPH_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_COLOCATION_GRAPH_H_
+
+#include <unordered_map>
+#include <vector>
+
+#include "absl/strings/str_join.h"
+#include "tensorflow/core/common_runtime/device.h"
+#include "tensorflow/core/common_runtime/inspecting_placer.h"
+#include "tensorflow/core/common_runtime/placer_inspection_required_ops_utils.h"
+#include "tensorflow/core/framework/function.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/lib/core/stringpiece.h"
+#include "tensorflow/core/util/device_name_utils.h"
+#include "tensorflow/core/util/port.h"
+
+namespace tensorflow {
+
+// Represents a node in the disjoint node forest and the
+// accumulated constraints on the device used by that node.
+class Member {
+ public:
+  Member() = default;
+
+  Status SetParentAndSupportedDevices(
+      const Node& node, const std::vector<DeviceType>& types,
+      const DeviceNameUtils::ParsedName* local_address_spec);
+
+  const DeviceNameUtils::ParsedName& requested_device_name() const {
+    return requested_device_name_;
+  }
+
+  Status SetAssignedDeviceName(const string& device_name);
+  Status SetResourceDeviceName(const Node& node);
+  Status SetRequestedDeviceName(const Node& node);
+
+  Status FillPossibleDevices(PossibleDevices* possible_device) const;
+
+  // Returns whether `src_root` is assigned to a CompositeDevice and `this` is
+  // assigned to a physical device.
+  bool IsEdgeFromCompositeDeviceToPhysicalDevice(const Member& src_root) const;
+
+  Status EnsureCompatibilityAcrossResourceEdge(
+      const Node& src, const Member& src_root,
+      const Node& dst, /*dst_root is this*/
+      bool log_device_placement);
+
+  const PrioritizedDeviceTypeVector& supported_device_types() const {
+    return supported_device_types_;
+  }
+
+  // If `dry_run` is true, just sets `new_root` and `old_root` and does not
+  // actually modify anything in the `tree`.
+  static void Merge(std::vector<Member>* tree, int x_root, int y_root,
+                    Member** new_root, Member** old_root, bool dry_run);
+
+  // Returns the root node of the disjoint tree to which the node with the
+  // given id is connected.
+  // FindRoot should be called only for debugging or after the members have
+  // been updated with direct root pointers because it does not update
+  // root pointers and can traverse many links. It exists to have
+  // a const version of FindAndUpdateRoot
+  static int FindRoot(const std::vector<Member>& tree, int node_id);
+  static int FindAndUpdateRoot(std::vector<Member>* tree, int node_id);
+
+  Status MergeDeviceNames(const Member& other, bool allow_soft_placement);
+
+  // Updates this to contain the intersection of the device types in
+  // this and "other". If the intersection is empty, returns false and does
+  // not update this. Else returns true and updates this.
+  bool MergeSupportedDevices(const Member& other);
+
+  Status AssignDevice(const Node& node);
+
+  // If user does not explicitly request XLA device and non-XLA device is
+  // supported for this node, use only the non-XLA device. See b/140896502.
+  void MaybeExcludeXlaDevices();
+
+  // Limit the possible devices of this (should be a root) to the device
+  // specifications in `devices`.
+  Status LimitToPossibleDevices(const PossibleDevices& devices,
+                                bool allow_soft_placement);
+
+  void set_possible_devices(std::vector<Device*>&& devices) {
+    possible_devices_ = devices;
+  }
+  const std::vector<Device*>& possible_devices() { return possible_devices_; }
+
+  // Returns a (parsed) device name that is based on requested_device_name()
+  // but with potentially cleared device type and ID fields. A field is cleared
+  // if the assigned_device_name does not specify it. If it does, the field
+  // is not cleared because soft placement cannot violate assigned device names.
+  DeviceNameUtils::ParsedName GetSoftDeviceName() const;
+
+  // Same as GetSoftDeviceName but device type and device ID fields are not
+  // cleared if resource device has them set.
+  DeviceNameUtils::ParsedName GetPreferredSoftDeviceName() const;
+
+  string DebugString() const;
+
+  bool has_assigned_device_name() const { return assigned_device_name_.has_id; }
+
+ private:
+  // Updates this to contain the intersection of the device types in
+  // this and `other_devices`.
+  bool MergeSupportedDevices(const PrioritizedDeviceTypeVector& other_devices);
+
+  // The id of the node that is the parent of this one, or its own
+  // id if it is a root. parent <= 0 indicates that this member is invalid.
+  int parent_ = -1;
+
+  // A proxy for the depth of the tree that is used to prefer
+  // connecting smaller trees to larger trees when merging disjoint
+  // sets.
+  int rank_ = 0;
+
+  // Once colocation groups have been formed, the Placer starts actually
+  // choosing devices. All nodes in a group must be assigned to the same
+  // device. Once we assigned the first device to some node in this group,
+  // we set assigned_device_name_index to this device name's index in the
+  // graph.
+  // The `*_device_name_` fields will contain the parsed name of this device
+  // and `possible_devices`, if computed, will contain just this device.
+  // `assigned_device_name_index` is an optimization to avoid parsing and
+  // comparing device names. The value of -1 signals that a single device
+  // has not been chosen yet.
+  int assigned_device_name_index_ = -1;
+
+  // The merged form of the device requested for this node, with those of all of
+  // its children. requested_device_name_ is always kept a specialization (i.e.
+  // DeviceNameUtils::IsSpecification) of assigned_device_name_. When no device
+  // is requested, this field is set to assigned_device_name_.  As a
+  // specialization of assigned_device_name_, requested_device_name_ represents
+  // the most specific form of all assigned and requested devices of this node
+  // and its children, if this node is a root. requested_device_name_ is used
+  // to finally select devices for nodes.  We can override requested devices due
+  // to resource colocation constraints but not assigned devices (unless soft
+  // placement is on).
+  // INVARIANT: requested_device_name_ is always kept a
+  // DeviceNameUtils::IsSpecification of assigned_device_name_ and
+  // resource_device_name_. This makes requested_device_name_ the "accumulation
+  // of all wishes" about the device.
+  DeviceNameUtils::ParsedName requested_device_name_;
+
+  // The merged form of the device assigned for this node, with
+  // those of all of its children.
+  // This field is used to raise errors due to unsatisfiable constraints.
+  // Can be a partial specification.
+  DeviceNameUtils::ParsedName assigned_device_name_;
+
+  // The merged form of the requested resource device assigned for this node,
+  // with those of all of its children.
+  // This field is used to raise errors due to unsatisfiable constraints.
+  // Can be a partial specification.
+  // resource_device_name_ is initialized with user-requested device on nodes
+  // producing resources, e.g. VarHandleOp.
+  // For historical reasons, with soft placement enabled, Placer can "move"
+  // resources (place resource producing ops on a device different from what
+  // the user explicitly requested) when the colocation group of a resource
+  // producing op contains ops that are not supported on the user-requested
+  // resource device. A classic example of this is a sparse optimizer (only
+  // supported on CPU) used on a GPU variable. In this case, the whole group
+  // will be assigned to some device supported by all ops in the colocation
+  // group. This is a surprising and unfortunate behavior because:
+  //   1. Since soft_placement is on by default, users don't know that their
+  //   variables are created on a different device than what they requested.
+  //   Among other things, this can lead to surprising poor performance.
+  //   2. Eager runtime cannot "move" resources. The same code can "work" when
+  //   wrapped in tf.function but will fail when run eagerly.
+  //   3. Extra complexity here to preserve these resource moving capabilities.
+  DeviceNameUtils::ParsedName resource_device_name_;
+
+  // The intersection of all device types supported by this node,
+  // and those of all of its children, in priority order
+  // of the preferred device.
+  // It is possible that supported_device_types_ has an empty intersection with
+  // requested/assigned/resource devices. We could have detected such cases
+  // as soon as they happen and raise an error. Instead, for historical reasons,
+  // we leave such error detection to the final device picking stage.
+  PrioritizedDeviceTypeVector supported_device_types_;
+
+  // If this node is a root, stores a list of Devices to which this node
+  // and all of its children can be assigned.
+  // `possible_devices` is empty if they have not yet been computed.
+  std::vector<Device*> possible_devices_;
+};
+
+// This class maintains the connected components of a colocation
+// constraint graph, and uses this information to assign a satisfying
+// device placement to the nodes of the graph.
+//
+// This implementation uses the Union-Find algorithm to efficiently maintain the
+// connected components and incrementally adds edges via
+// ColocationGraph::ColocateNodes() invocations.
+//
+// ColocationGraph does not assign any devices to graph nodes. The
+// `log_device_placement` argument is used to log messages when requested
+// device is ignored.
+class ColocationGraph {
+ public:
+  // graph, flib_def, and device_set must not be null and must outlive
+  // this ColocationGraph. default_local_device can be null. If not, must
+  // outlive this.
+  ColocationGraph(const Graph* graph, const FunctionStack& stack,
+                  const FunctionLibraryDefinition* flib_def,
+                  const DeviceSet* device_set,
+                  const Device* default_local_device, bool allow_soft_placement,
+                  bool log_device_placement);
+
+  Status Initialize();
+
+  const std::vector<Member>& members() const { return members_; }
+
+  // Limit the group containing `node` to the device specifications in
+  // `devices`.
+  Status LimitToPossibleDevices(const Node& node,
+                                const PossibleDevices& devices);
+
+  // Limits the possible devices of `node`'s colocation group to the device
+  // to which `node` is assigned. This makes sure that all nodes in this
+  // colocation group will be assigned to the same device. Without this
+  // explicit restriction, heuristics can choose a different possible device
+  // for other nodes in the group.
+  Status LimitToAssignedDevice(const Node& node);
+
+  // Returns the root node of the disjoint tree to which the node with the
+  // given id is connected.
+  // Updates the internal pointers so that future calls will returns faster.
+  int FindAndUpdateRoot(int node_id) {
+    return Member::FindAndUpdateRoot(&members_, node_id);
+  }
+
+  // For the given node, subject to the constraints previously given
+  // to this ColocationGraph, set its assigned_device_name. Returns OK
+  // if a satisfying device can be found, otherwise an error.
+  //
+  // Note: This method returns a pointer to a field within members_.
+  // The caller must not use the returned pointer after there is any possibility
+  // that the members_[i].possible_devices field has been modified.
+  Status GetDevicesForNode(Node* node,
+                           const std::vector<Device*>** possible_devices);
+
+  // Returns debugging info for the node referred to by 'node_root'.
+  string DebugInfo(const int node_root) const;
+
+  string DebugString() const;
+
+  // Returns a list of devices having type in supported_device_types.  The
+  // returned list is sorted by preferred type (higher numeric type is
+  // preferred).
+  static std::vector<Device*> FilterSupportedDevices(
+      const std::vector<Device*>& devices,
+      const PrioritizedDeviceTypeVector& supported_device_types,
+      const Device* default_local_device);
+
+ private:
+  // Adds each node of the Graph to this ColocationGraph as a singleton.
+  //
+  // NOTE: The implementation assumes that the ids of nodes passed to
+  // this method are dense and zero-based; the memory used will be linear in
+  // the largest node ID.
+  // NOTE: If this method returns an error, *this is left in an undefined
+  // state.
+  Status ColocateAllNodes();
+
+  Status ColocateResourceOrRefEdge(const Node* src, const Node* dst);
+
+  // Adds colocation constraints to data types known not to support copying.
+  Status ColocateUncopiableTypeEdges(
+      std::unordered_set<Node*>* inspection_required);
+
+  // Updates this ColocationGraph by making sure that all nodes
+  // touching resource and/or ref tensors are colocated.
+  // As it iterates over the edges, fills the `inspection_required` set with
+  // the nodes that
+  // PlacerInspectionRequiredOpChecker::IsPlacerInspectionRequired
+  // deems as requiring deep inspection by placer. This is an optimization.
+  // TODO(mdan): Deprecate in favor of ColocateUncopiableTypeEdges.
+  Status ColocateResourceAndRefEdges(
+      std::unordered_set<Node*>* inspection_required);
+
+  // Updates this ColocationGraph by making sure that all nodes having inputs of
+  // a DT_VARIANT data type with a host-only underlying types (e.g. strings) can
+  // be placed only on CPU device. We do that by reverse-DFS traversal from all
+  // nodes that take variant inputs to the node that produces that variant.
+  // TODO(ezhulenev): This function does not yet support "deep op" inspection,
+  // that we have for DT_RESOURCE edges.
+  Status AddHostOnlyDataTypesConstraints();
+
+  Status AddInspectionConstraints(
+      const std::unordered_set<Node*>& inspection_required);
+
+  // Applies colocation groups for `node`'s inputs and outputs to this
+  // ColocationGraph.
+  // `groups` are the colocation groups to which `nodes`'s inputs and outputs
+  // belong.
+  // `node` is a node requiring deep inspection (e.g. a node calling
+  // a function)
+  //
+  // For example, consider a `node` taking two inputs and producing one output
+  //    a  b
+  //    |  |
+  //    v  v
+  //    node
+  //     |
+  //     v
+  //     c
+  //
+  // `groups` can tell us that `a` and `c` must be colocated and their device
+  // must be a GPU. `b` might be in a group by itself without any device
+  // restrictions.
+  //
+  // ApplyIOColocationGroups will have an effect of calling
+  // ColocateNodes(a, c) and LimitToPossibleDevices(`a`, "GPU"). The colocation
+  // group of the `node` itself is not directly impacted.
+  //
+  Status ApplyIOColocationGroups(const IOColocationGroups& groups,
+                                 const Node& node);
+
+  Status ColocateNodeToGroup(
+      std::unordered_map<StringPiece, const Node*, StringPieceHasher>*
+          colocation_group_root,
+      const Node* node, StringPiece colocation_group);
+
+  // Merge the (possibly disjoint) sets containing nodes "x" and
+  // "y". Returns OK if the all nodes in the union of these sets can
+  // be placed on the same device type.
+  //
+  // If this method returns an error, *this is unchanged.
+  Status ColocateNodes(const Node& x, const Node& y);
+
+  // This overload of ColocateNodes() allows a caller to provide the root node
+  // ids for the two nodes. For large graphs, this noticeably reduces the
+  // graph load time.
+  // If this method returns an error, *this is unchanged.
+  Status ColocateNodes(const Node& x, int x_root, const Node& y, int y_root);
+
+  void GetSoftDeviceCandidates(const Node& node, const Member& root_member,
+                               int root_id,
+                               std::vector<Device*>* possible_devices);
+
+  Status InitializeMembers();
+
+  Status InitializeMemberWithAssignedDevice(const string& assigned_device_name,
+                                            const string& node_type,
+                                            Member* member);
+
+  Status InitializeMember(const Node& node, Member* member);
+
+  // Returns the root node of the disjoint tree to which the node with the
+  // given id is connected.
+  // FindRoot should be called only for debugging or after the members have
+  // been updated with direct root pointers because it does not update
+  // root pointers and can traverse many links. It exists to have
+  // a const version of FindAndUpdateRoot
+  int FindRoot(int node_id) const {
+    return Member::FindRoot(members_, node_id);
+  }
+
+  const Graph& graph_;
+  const FunctionStack stack_;
+  std::vector<Member> members_;
+  InspectingPlacer inspecting_placer_;
+  PlacerInspectionRequiredOpChecker inspection_required_checker_;
+  const DeviceSet& device_set_;
+  const std::vector<DeviceType> device_types_;
+  const DeviceNameUtils::ParsedName local_address_spec_;
+  const Device* default_local_device_;
+  const bool allow_soft_placement_;
+  const bool log_device_placement_;
+
+  ColocationGraph(const ColocationGraph&) = delete;
+  void operator=(const ColocationGraph&) = delete;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_COLOCATION_GRAPH_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/composite_device.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/composite_device.h
new file mode 100644
index 0000000000000000000000000000000000000000..800a24f34117d709e8db455fd0fbb8e93b44e169
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/composite_device.h
@@ -0,0 +1,72 @@
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_COMPOSITE_DEVICE_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_COMPOSITE_DEVICE_H_
+
+#include "absl/strings/string_view.h"
+#include "tensorflow/core/common_runtime/device.h"
+#include "tensorflow/core/framework/allocator.h"
+#include "tensorflow/core/framework/device_attributes.pb.h"
+#include "tensorflow/core/lib/core/errors.h"
+#include "tensorflow/core/lib/core/status.h"
+
+namespace tensorflow {
+
+extern const char* const kCompositeDeviceType;
+
+// A virtual device which represents a set of devices. We don't execute any
+// op on this virtial device.
+class CompositeDevice : public Device {
+ public:
+  Status Sync() override {
+    return errors::Internal(
+        "Sync() should never been invoked on CompositeDevice.");
+  }
+
+  Allocator* GetAllocator(AllocatorAttributes) override { return nullptr; }
+
+  const std::vector<string>* underlying_devices() const {
+    return &underlying_devices_;
+  }
+
+  // Helper for creating a CompositeDevice on the same task as the given host
+  // CPU.
+  static std::unique_ptr<CompositeDevice> MakeDevice(
+      const std::vector<string>& underlying_devices, const int unique_device_id,
+      const DeviceNameUtils::ParsedName& host_name, Status* status);
+
+  // Helper for creating a CompositeDevice with the given device name.
+  static std::unique_ptr<CompositeDevice> MakeDevice(
+      const std::vector<string>& underlying_devices, const string& device_name,
+      Status* status);
+
+  bool IsRemoteCallAllowed() const override { return false; }
+
+ private:
+  CompositeDevice(const DeviceAttributes& device_attributes,
+                  const std::vector<string>& underlying_devices)
+      : Device(/*env=*/nullptr, device_attributes),
+        underlying_devices_(underlying_devices) {}
+
+  const std::vector<string> underlying_devices_;
+
+  CompositeDevice(const CompositeDevice&) = delete;
+  void operator=(const CompositeDevice&) = delete;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_COMPOSITE_DEVICE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/constant_folding.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/constant_folding.h
new file mode 100644
index 0000000000000000000000000000000000000000..64441f73db4b868f23805739e3b1170083fffb3a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/constant_folding.h
@@ -0,0 +1,70 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_CONSTANT_FOLDING_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_CONSTANT_FOLDING_H_
+
+#include "tensorflow/core/common_runtime/device.h"
+#include "tensorflow/core/framework/function.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/graph/graph.h"
+#include "tensorflow/core/platform/env.h"
+
+// TODO(skyewm): can this be combined with EvaluateConstantTensor?
+
+namespace tensorflow {
+
+// This generator type is used to generate a name for the newly folded node
+// based on the node's old name.
+using ConstantFoldNameGenerator =
+    std::function<string(Graph* graph, string old_name)>;
+
+// Options specific to constant folding optimizations.
+struct ConstantFoldingOptions {
+  // If "consider" is not a nullptr, then only constant fold a node "n" if
+  // consider(n) returns true.
+  std::function<bool(const Node*)> consider = nullptr;
+  // If shape_map is not a nullptr, it is a map from node n to a
+  // vector of the (potentially partially-known) shapes of its
+  // outputs.
+  const std::unordered_map<string, std::vector<PartialTensorShape>>* shape_map =
+      nullptr;  // not owned
+  // The maximum size of each constant created during constant folding
+  // optimization.
+  int64_t max_constant_size_in_bytes = 10 * 1024 * 1024;
+
+  // A generator for the name suffix of constant folded nodes. A
+  // default id generator that monotonically increases is used if nullptr is
+  // passed.
+  ConstantFoldNameGenerator generate_new_name = nullptr;
+};
+
+// Perform constant folding optimization on "graph".
+// Looks for nodes in "graph" that can be completely evaluated statically, i.e.,
+// that are only dependent on constants. Evaluates those nodes on a CPU device
+// and replaces those nodes with the result of the evaluation.
+// "partition_device", if non-null, is the device where all the graph nodes are
+// assumed to execute.
+// Sets `was_mutated` to true if and only if "graph" has been mutated.
+// The status is only set to a non-OK state if an unexpected error is hit
+// running the graph.
+Status ConstantFold(const ConstantFoldingOptions& opts,
+                    FunctionLibraryRuntime* function_library, Env* env,
+                    const Device* partition_device, Graph* graph,
+                    bool* was_mutated);
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_CONSTANT_FOLDING_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/copy_tensor.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/copy_tensor.h
new file mode 100644
index 0000000000000000000000000000000000000000..0bbbee2421b284b6181a0c1b8f4c4f178651e142
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/copy_tensor.h
@@ -0,0 +1,78 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_COPY_TENSOR_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_COPY_TENSOR_H_
+
+#include "tensorflow/core/common_runtime/device.h"
+#include "tensorflow/core/framework/allocator.h"
+#include "tensorflow/core/framework/device_base.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+
+class CopyTensor {
+ public:
+  typedef void (*CopyFunction)(
+      DeviceContext* send_dev_context, DeviceContext* recv_dev_context,
+      Device* src, Device* dst, const AllocatorAttributes src_alloc_attr,
+      const AllocatorAttributes dst_alloc_attr, const Tensor* input,
+      Tensor* output, int dev_to_dev_stream_index, StatusCallback done);
+
+  // Copies "input" to "output" between devices accessible to the
+  // local process via some DMA-like method.  "edge_name" is the name
+  // of the tensor being copied, for debugging purposes. Depending on
+  // the type of devices and memory in use, the copy may be performed
+  // synchronously or asynchronously.  'done' will be invoked only
+  // after the copy is actually complete.
+  static void ViaDMA(StringPiece edge_name, DeviceContext* send_dev_context,
+                     DeviceContext* recv_dev_context, Device* src, Device* dst,
+                     const AllocatorAttributes src_alloc_attr,
+                     const AllocatorAttributes dst_alloc_attr,
+                     const Tensor* input, Tensor* output,
+                     int dev_to_dev_stream_index, StatusCallback done,
+                     bool sync_dst_compute = true);
+
+  // Object used to call Register() at static-initialization time.
+  // Note: This should only ever be used as a global-static object; no stack
+  // or heap instances.
+  class Registration {
+   public:
+    Registration(DeviceType sender_device_type, DeviceType receiver_device_type,
+                 CopyFunction copy_function) {
+      TF_QCHECK_OK(Register(sender_device_type, receiver_device_type,
+                            copy_function, /*is_pluggable_device=*/false));
+    }
+  };
+
+  // Register a function for copying between two specific DeviceTypes.
+  // Note: This should only be called via the constructor of
+  // CopyTensor::Registration or from PluggableDevice implementation.
+  static Status Register(DeviceType sender_device_type,
+                         DeviceType receiver_device_type,
+                         CopyFunction copy_function, bool is_pluggable_device);
+};
+
+void CopyDeviceToHost(const Tensor* input, Allocator* cpu_allocator,
+                      Allocator* out_allocator, StringPiece edge_name,
+                      Device* src, Tensor* output,
+                      DeviceContext* send_dev_context, StatusCallback done);
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_COPY_TENSOR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/cost_constants.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/cost_constants.h
new file mode 100644
index 0000000000000000000000000000000000000000..d580a95370bfd7cf3f069bf6db9e6716b18a23e2
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/cost_constants.h
@@ -0,0 +1,42 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_COST_CONSTANTS_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_COST_CONSTANTS_H_
+
+namespace tensorflow {
+
+// Types of per-request cost.
+inline constexpr char kTpuCostName[] = "tpu";
+inline constexpr char kGcuCostName[] = "gcu";
+inline constexpr char kNoOpCostName[] = "no_op";
+
+// Each type of per-request cost could have the following versions.
+//
+// A server may have costs that cannot be directly attributed to a specific
+// query. Each request will be assigned a portion of it, and the cost ends with
+// '_with_smear" includes this part.
+inline constexpr char kWithSmearSuffix[] = "_with_smear";
+inline constexpr char kNoSmearSuffix[] = "_no_smear";
+
+// Full names of per-request cost.
+inline constexpr char kTpuWithSmearCostName[] = "tpu_with_smear";
+inline constexpr char kTpuNoSmearCostName[] = "tpu_no_smear";
+inline constexpr char kGcuWithSmearCostName[] = "gcu_with_smear";
+inline constexpr char kGcuNoSmearCostName[] = "gcu_no_smear";
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_COST_CONSTANTS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/cost_measurement.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/cost_measurement.h
new file mode 100644
index 0000000000000000000000000000000000000000..3da322e5dbcba91fb4bcbeae76d9ccea36bb52a6
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/cost_measurement.h
@@ -0,0 +1,45 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_COST_MEASUREMENT_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_COST_MEASUREMENT_H_
+
+#include "absl/strings/string_view.h"
+#include "absl/time/time.h"
+
+namespace tensorflow {
+
+// An interface for cost measurement.
+class CostMeasurement {
+ public:
+  // Context of the CostMeasurement.
+  struct Context {
+    // Whether this CostMeasurement is running within a per-query context (e.g.
+    // rpc handler) or not (e.g. batching).
+    bool is_per_query = false;
+  };
+
+  explicit CostMeasurement(const Context& context) {}
+
+  virtual ~CostMeasurement() {}
+
+  virtual absl::Duration GetTotalCost() = 0;
+
+  virtual absl::string_view GetCostType() const = 0;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_COST_MEASUREMENT_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/cost_measurement_registry.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/cost_measurement_registry.h
new file mode 100644
index 0000000000000000000000000000000000000000..b2f1727325235ee24afdd3c3c89dfecfc56282b1
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/cost_measurement_registry.h
@@ -0,0 +1,72 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_COST_MEASUREMENT_REGISTRY_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_COST_MEASUREMENT_REGISTRY_H_
+
+#include <functional>
+#include <memory>
+#include <string>
+#include <utility>
+
+#include "absl/memory/memory.h"
+#include "absl/strings/string_view.h"
+#include "tensorflow/core/common_runtime/cost_measurement.h"
+
+namespace tensorflow {
+
+// CostMeasurementRegistry allows to
+// - register a CostMeasurement type to the global map
+// - create an instance of registered CostMeasurement.
+class CostMeasurementRegistry {
+ public:
+  // Creates an instance of registered CostMeasurement by name. If the named
+  // CostMeasurement is not registered yet, returns nullptr. Any returned
+  // std::unique_ptr<CostMeasurement> should not be moved.
+  // TODO(b/185852990): create a non-moveable wrapper class for the returned
+  // unique_ptr<CostMeasurement>.
+  static std::unique_ptr<CostMeasurement> CreateByNameOrNull(
+      const std::string& name, const CostMeasurement::Context& context);
+
+  using Creator = std::function<std::unique_ptr<CostMeasurement>(
+      const CostMeasurement::Context&)>;
+
+  // Registers a CostMeasurement type to the global map. Registering different
+  // types of CostMeasurement with the same name is prohibited.
+  static void RegisterCostMeasurement(absl::string_view name, Creator creator);
+};
+
+// Registers a CostMeasurement type to the global map. Registering different
+// types of CostMeasurement with the same name is prohibited.
+class CostMeasurementRegistrar {
+ public:
+  explicit CostMeasurementRegistrar(absl::string_view name,
+                                    CostMeasurementRegistry::Creator creator) {
+    CostMeasurementRegistry::RegisterCostMeasurement(name, std::move(creator));
+  }
+};
+
+#define REGISTER_COST_MEASUREMENT(name, MyCostMeasurementClass)        \
+  namespace {                                                          \
+  static ::tensorflow::CostMeasurementRegistrar                        \
+      MyCostMeasurementClass##_registrar(                              \
+          (name), [](const CostMeasurement::Context& context) {        \
+            return std::make_unique<MyCostMeasurementClass>(context); \
+          });                                                          \
+  }  // namespace
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_COST_MEASUREMENT_REGISTRY_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/cost_util.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/cost_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..aa1102c1c43e96451bf91df266c7872c456b6397
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/cost_util.h
@@ -0,0 +1,39 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_COST_UTIL_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_COST_UTIL_H_
+
+#include <memory>
+#include <vector>
+
+#include "tensorflow/core/common_runtime/cost_measurement.h"
+#include "tensorflow/core/common_runtime/request_cost_accessor.h"
+
+namespace tensorflow {
+
+// Creates instances of CostMeasurement. The types to create are determined by
+// env.
+std::vector<std::unique_ptr<CostMeasurement>> CreateCostMeasurements(
+    const CostMeasurement::Context& context);
+
+// Creates an instance of RequestCostAccessor. The type to create is determined
+// by env. Returns nullptr if the type is not specified in env, or the type of
+// CostMeasurement is unregistered..
+std::unique_ptr<RequestCostAccessor> CreateRequestCostAccessor();
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_COST_UTIL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/costmodel_manager.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/costmodel_manager.h
new file mode 100644
index 0000000000000000000000000000000000000000..770d44287269da27130cacd0c8a9c8946fd48040
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/costmodel_manager.h
@@ -0,0 +1,55 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_COSTMODEL_MANAGER_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_COSTMODEL_MANAGER_H_
+
+#include <unordered_map>
+
+#include "tensorflow/core/framework/cost_graph.pb.h"
+#include "tensorflow/core/graph/costmodel.h"
+#include "tensorflow/core/graph/graph.h"
+#include "tensorflow/core/lib/core/errors.h"
+#include "tensorflow/core/lib/gtl/iterator_range.h"
+
+namespace tensorflow {
+
+// Used to manage all the cost models for a session.
+class CostModelManager {
+ public:
+  ~CostModelManager();
+
+  typedef std::unordered_map<const Graph*, CostModel*> CostModelMap;
+  typedef CostModelMap::iterator CostModelMapIter;
+
+  void ExportCostModels(CostModelMap* cost_models) {
+    mutex_lock l(mu_);
+    *cost_models = cost_models_;
+  }
+
+  CostModel* FindOrCreateCostModel(const Graph* graph);
+
+  bool RemoveCostModelForGraph(const Graph* graph);
+
+  Status AddToCostGraphDef(const Graph* graph, CostGraphDef* cost_graph);
+
+ private:
+  mutex mu_;
+  CostModelMap cost_models_ TF_GUARDED_BY(mu_);
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_COSTMODEL_MANAGER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/debugger_state_interface.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/debugger_state_interface.h
new file mode 100644
index 0000000000000000000000000000000000000000..e4815cca4f3c597dce273500c6527f71aceac344
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/debugger_state_interface.h
@@ -0,0 +1,122 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_DEBUGGER_STATE_INTERFACE_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_DEBUGGER_STATE_INTERFACE_H_
+
+#include <memory>
+
+#include "tensorflow/core/common_runtime/device.h"
+#include "tensorflow/core/graph/graph.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/platform/macros.h"
+#include "tensorflow/core/platform/protobuf.h"
+#include "tensorflow/core/protobuf/debug.pb.h"
+
+namespace tensorflow {
+
+// Returns a summary string for the list of debug tensor watches.
+const string SummarizeDebugTensorWatches(
+    const protobuf::RepeatedPtrField<DebugTensorWatch>& watches);
+
+// An abstract interface for storing and retrieving debugging information.
+class DebuggerStateInterface {
+ public:
+  virtual ~DebuggerStateInterface() {}
+
+  // Publish metadata about the debugged Session::Run() call.
+  //
+  // Args:
+  //   global_step: A global step count supplied by the caller of
+  //     Session::Run().
+  //   session_run_index: A chronologically sorted index for calls to the Run()
+  //     method of the Session object.
+  //   executor_step_index: A chronologically sorted index of invocations of the
+  //     executor charged to serve this Session::Run() call.
+  //   input_names: Name of the input Tensors (feed keys).
+  //   output_names: Names of the fetched Tensors.
+  //   target_names: Names of the target nodes.
+  virtual Status PublishDebugMetadata(
+      const int64_t global_step, const int64_t session_run_index,
+      const int64_t executor_step_index, const std::vector<string>& input_names,
+      const std::vector<string>& output_names,
+      const std::vector<string>& target_nodes) = 0;
+};
+
+class DebugGraphDecoratorInterface {
+ public:
+  virtual ~DebugGraphDecoratorInterface() {}
+
+  // Insert special-purpose debug nodes to graph and dump the graph for
+  // record. See the documentation of DebugNodeInserter::InsertNodes() for
+  // details.
+  virtual Status DecorateGraph(Graph* graph, Device* device) = 0;
+
+  // Publish Graph to debug URLs.
+  virtual Status PublishGraph(const Graph& graph,
+                              const string& device_name) = 0;
+};
+
+typedef std::function<std::unique_ptr<DebuggerStateInterface>(
+    const DebugOptions& options)>
+    DebuggerStateFactory;
+
+// Contains only static methods for registering DebuggerStateFactory.
+// We don't expect to create any instances of this class.
+// Call DebuggerStateRegistry::RegisterFactory() at initialization time to
+// define a global factory that creates instances of DebuggerState, then call
+// DebuggerStateRegistry::CreateState() to create a single instance.
+class DebuggerStateRegistry {
+ public:
+  // Registers a function that creates a concrete DebuggerStateInterface
+  // implementation based on DebugOptions.
+  static void RegisterFactory(const DebuggerStateFactory& factory);
+
+  // If RegisterFactory() has been called, creates and supplies a concrete
+  // DebuggerStateInterface implementation using the registered factory,
+  // owned by the caller and return an OK Status. Otherwise returns an error
+  // Status.
+  static Status CreateState(const DebugOptions& debug_options,
+                            std::unique_ptr<DebuggerStateInterface>* state);
+
+ private:
+  static DebuggerStateFactory* factory_;
+
+  DebuggerStateRegistry(const DebuggerStateRegistry&) = delete;
+  void operator=(const DebuggerStateRegistry&) = delete;
+};
+
+typedef std::function<std::unique_ptr<DebugGraphDecoratorInterface>(
+    const DebugOptions& options)>
+    DebugGraphDecoratorFactory;
+
+class DebugGraphDecoratorRegistry {
+ public:
+  static void RegisterFactory(const DebugGraphDecoratorFactory& factory);
+
+  static Status CreateDecorator(
+      const DebugOptions& options,
+      std::unique_ptr<DebugGraphDecoratorInterface>* decorator);
+
+ private:
+  static DebugGraphDecoratorFactory* factory_;
+
+  DebugGraphDecoratorRegistry(const DebugGraphDecoratorRegistry&) = delete;
+  void operator=(const DebugGraphDecoratorRegistry&) = delete;
+};
+
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_DEBUGGER_STATE_INTERFACE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/device.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/device.h
new file mode 100644
index 0000000000000000000000000000000000000000..83785e3341be5980f989a2db554beb496b747823
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/device.h
@@ -0,0 +1,20 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_DEVICE_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_DEVICE_H_
+
+#include "tensorflow/core/framework/device.h"
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_DEVICE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/device/device_event_mgr.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/device/device_event_mgr.h
new file mode 100644
index 0000000000000000000000000000000000000000..00b300466805b69fef87ad9dcde7c5f6546362ae
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/device/device_event_mgr.h
@@ -0,0 +1,142 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_DEVICE_DEVICE_EVENT_MGR_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_DEVICE_DEVICE_EVENT_MGR_H_
+
+#include <deque>
+#include <functional>
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include "absl/container/flat_hash_map.h"
+#include "tensorflow/core/lib/core/notification.h"
+#include "tensorflow/core/lib/core/threadpool.h"
+#include "tensorflow/core/lib/gtl/inlined_vector.h"
+#include "tensorflow/core/platform/mutex.h"
+#include "tensorflow/core/platform/stream_executor.h"
+#include "tensorflow/core/platform/thread_annotations.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+
+// TODO(annarev): Check if we can use a more general option representation here
+// that could work for other device types as well.
+class GPUOptions;
+
+// The callback provided to EventMgr::ThenExecute must not block or take a long
+// time.  If it does, performance may be impacted and device memory may be
+// exhausted.  This macro is for checking that an EventMgr thread is not
+// accidentally entering blocking parts of the code, e.g. the RPC subsystem.
+//
+// Intended use is something like
+//
+//   void RespondToAnRPC(Params* params) {
+//      WARN_IF_IN_EVENT_MGR_THREAD;
+//      if (params->status.ok()) { ...
+//
+namespace device_event_mgr {
+// Logs a stack trace if current execution thread belongs to this EventMgr
+// object.  If f is not nullptr, executes instead of  logging the stack trace.
+// trace.
+void WarnIfInCallback(std::function<void()> f);
+}  // namespace device_event_mgr
+#define WARN_IF_IN_EVENT_MGR_THREAD \
+  ::tensorflow::device_event_mgr::WarnIfInCallback(nullptr)
+
+// EventMgr lets you register a callback to be executed when a given
+// StreamExecutor stream completes all the work that's thus-far been enqueued on
+// the stream.
+class EventMgr {
+ public:
+  virtual ~EventMgr();
+
+  // Execute `func` when all pending stream actions have completed.  func must
+  // be brief and non-blocking since it executes in the one thread used for all
+  // such callbacks and also buffer deletions.
+  void ThenExecute(se::Stream* stream, std::function<void()> func) {
+    mutex_lock l(mu_);
+    EnqueueCallback(stream, std::move(func));
+    PollEvents(stream);
+  }
+
+ private:
+  friend class TEST_EventMgr;
+  friend class TEST_EventMgrHelper;
+  friend class EventMgrFactory;
+
+  se::StreamExecutor* const exec_;
+  const int32 polling_active_delay_usecs_;
+  mutex mu_;
+  condition_variable events_pending_ TF_GUARDED_BY(mu_);
+
+  EventMgr(se::StreamExecutor* se, const GPUOptions& gpu_options);
+
+  // Set up `func` to be called once `stream` completes all its outstanding
+  // work.
+  void EnqueueCallback(se::Stream* stream, std::function<void()> func)
+      TF_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+
+  // This function should be called at roughly the same tempo as QueueTensors()
+  // to check whether pending events have recorded, and then retire them.
+  //
+  // If `stream` is not null, we only poll events for that stream.  Otherwise we
+  // poll events for all streams.
+  void PollEvents(se::Stream* stream = nullptr)
+      TF_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+
+  // An internal polling loop that runs at a low frequency to clear straggler
+  // Events.
+  void PollLoop();
+
+  // Setup/Teardown functions for the polling loop.
+  void StartPollingLoop();
+  void StopPollingLoop();
+
+  // A stack of unused events
+  std::vector<std::unique_ptr<se::Event>> free_events_ TF_GUARDED_BY(mu_);
+
+  // Callbacks waiting on their events to complete.
+  absl::flat_hash_map<
+      se::Stream*,
+      std::deque<std::pair<std::unique_ptr<se::Event>, std::function<void()>>>>
+      callbacks_ TF_GUARDED_BY(mu_);
+
+  bool stop_polling_ TF_GUARDED_BY(mu_);
+  std::unique_ptr<Notification> polling_stopped_;
+
+  // The main PollLoop for the event manager runs in this threadpool.
+  thread::ThreadPool threadpool_;
+};
+
+// Manages all the EventMgr instances.
+class EventMgrFactory {
+ public:
+  static EventMgrFactory* Singleton();
+
+  EventMgr* GetEventMgr(se::StreamExecutor* se, const GPUOptions& gpu_options);
+
+ private:
+  mutex mu_;
+
+  // Maintain one EventMgr per physical device (StreamExecutor is
+  // per-physical-device).
+  absl::flat_hash_map<se::StreamExecutor*, EventMgr*> event_mgr_map_
+      TF_GUARDED_BY(mu_);
+};
+
+}  // namespace tensorflow
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_DEVICE_DEVICE_EVENT_MGR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/device/device_host_allocator.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/device/device_host_allocator.h
new file mode 100644
index 0000000000000000000000000000000000000000..4111fc909631cea0b57a95396d0555bcd24aebf6
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/device/device_host_allocator.h
@@ -0,0 +1,28 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_DEVICE_DEVICE_HOST_ALLOCATOR_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_DEVICE_DEVICE_HOST_ALLOCATOR_H_
+
+#include "xla/stream_executor/device_host_allocator.h"
+#include "tensorflow/core/framework/allocator.h"
+#include "tensorflow/core/platform/macros.h"
+#include "tensorflow/core/platform/stream_executor.h"
+
+namespace tensorflow {
+using stream_executor::DeviceHostAllocator;  // NOLINT
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_DEVICE_DEVICE_HOST_ALLOCATOR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/device/device_id.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/device/device_id.h
new file mode 100644
index 0000000000000000000000000000000000000000..382c40aacfacdb5e4999ec1f9461735f47a65ae4
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/device/device_id.h
@@ -0,0 +1,91 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_DEVICE_DEVICE_ID_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_DEVICE_DEVICE_ID_H_
+
+#include "tensorflow/core/lib/gtl/int_type.h"
+#include "tensorflow/core/platform/types.h"
+#include "tsl/framework/device_id.h"
+
+namespace tensorflow {
+
+// There are three types of device ids:
+// - *physical* device id: this is the integer index of a device in the
+//   physical machine, it can be filtered (for e.g. using environment variable
+//   CUDA_VISIBLE_DEVICES when using CUDA). Note that this id is not visible to
+//   Tensorflow, but result after filtering is visible to TF and is called
+//   platform device id as below.
+//   For CUDA, see
+//   http://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#env-vars
+//   for more details.
+// - *platform* device id (also called *visible* device id in
+//   third_party/tensorflow/core/protobuf/config.proto): this is the id that is
+//   visible to Tensorflow after filtering (for e.g. by CUDA_VISIBLE_DEVICES).
+//   For CUDA, this id is generated by the CUDA GPU driver. It starts from 0
+//   and is used for CUDA API calls like cuDeviceGet().
+// - TF device id (also called *virtual* device id in
+//   third_party/tensorflow/core/protobuf/config.proto): this is the id that
+//   Tensorflow generates and exposes to its users. It is the id in the <id>
+//   field of the device name "/device:GPU:<id>", and is also the identifier of
+//   a BaseGPUDevice. Note that the configuration allows us to create multiple
+//   BaseGPUDevice per GPU hardware in order to use multi CUDA streams on the
+//   hardware, so the mapping between TF GPU id and platform GPU id is not a 1:1
+//   mapping, see the example below.
+//
+// For example, assuming that in the machine we have GPU device with index 0, 1,
+// 2 and 3 (physical GPU id). Setting "CUDA_VISIBLE_DEVICES=1,2,3" will create
+// the following mapping between platform GPU id and physical GPU id:
+//
+//        platform GPU id ->  physical GPU id
+//                 0  ->  1
+//                 1  ->  2
+//                 2  ->  3
+//
+// Note that physical GPU id 0 is invisible to TF so there is no mapping entry
+// for it.
+//
+// Assuming we configure the Session to create one BaseGPUDevice per GPU
+// hardware, then setting GPUOptions::visible_device_list to "2,0" will create
+// the following mapping between TF device id and platform device id:
+//
+//                  TF GPU id  ->  platform GPU ID
+//      0 (i.e. /device:GPU:0) ->  2
+//      1 (i.e. /device:GPU:1) ->  0
+//
+// Note that platform device id 1 is filtered out by
+// GPUOptions::visible_device_list, so it won't be used by the TF process.
+//
+// On the other hand, if we configure it to create 2 BaseGPUDevice per GPU
+// hardware, then setting GPUOptions::visible_device_list to "2,0" will create
+// the following mapping between TF device id and platform device id:
+//
+//                  TF GPU id  ->  platform GPU ID
+//      0 (i.e. /device:GPU:0) ->  2
+//      1 (i.e. /device:GPU:1) ->  2
+//      2 (i.e. /device:GPU:2) ->  0
+//      3 (i.e. /device:GPU:3) ->  0
+//
+// We create strong-typed integer classes for both TF device id and platform
+// device id to minimize programming errors and improve code readability. Except
+// for the StreamExecutor interface (as we don't change its API), whenever we
+// need a TF device id (or platform device id) we should use TfDeviceId (or
+// PlatformDeviceId) instead of a raw integer.
+using tsl::PlatformDeviceId;  // NOLINT
+using tsl::TfDeviceId;        // NOLINT
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_DEVICE_DEVICE_ID_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/device/device_id_manager.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/device/device_id_manager.h
new file mode 100644
index 0000000000000000000000000000000000000000..1e9232c270f18726a08e0a189dcfdad7f6f5b023
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/device/device_id_manager.h
@@ -0,0 +1,28 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_DEVICE_DEVICE_ID_MANAGER_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_DEVICE_DEVICE_ID_MANAGER_H_
+
+#include "tensorflow/core/common_runtime/device/device_id.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tsl/framework/device_id_manager.h"
+
+namespace tensorflow {
+using tsl::DeviceIdManager;  // NOLINT
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_DEVICE_DEVICE_ID_MANAGER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/device/device_mem_allocator.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/device/device_mem_allocator.h
new file mode 100644
index 0000000000000000000000000000000000000000..4ba97a5b68cfbe8a5fdd168be696eec433b99f1b
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/device/device_mem_allocator.h
@@ -0,0 +1,28 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_DEVICE_DEVICE_MEM_ALLOCATOR_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_DEVICE_DEVICE_MEM_ALLOCATOR_H_
+
+#include "xla/stream_executor/device_mem_allocator.h"
+#include "tensorflow/core/common_runtime/device/device_id.h"
+#include "tensorflow/core/framework/allocator.h"
+#include "tensorflow/core/platform/stream_executor.h"
+
+namespace tensorflow {
+using stream_executor::DeviceMemAllocator;  // NOLINT
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_DEVICE_DEVICE_MEM_ALLOCATOR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/device/device_utils.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/device/device_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..91c93a64e46b6621e086059ef9d23a8c36172842
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/device/device_utils.h
@@ -0,0 +1,41 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_DEVICE_DEVICE_UTILS_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_DEVICE_DEVICE_UTILS_H_
+
+#include "tensorflow/core/platform/status.h"
+#include "tensorflow/core/platform/stringpiece.h"
+
+namespace tensorflow {
+namespace device_utils {
+
+// Validate device type. Device type must start with a capital letter and
+// consist of capital letters and underscores. Reasoning behind this decision:
+// * At the minimum we want to disallow '/' and ':' since
+//   these characters are used in device spec, for e.g.
+//   /job:foo/replica:12/device:GPU:1.
+// * Underscores seem useful, for e.g. XLA_GPU uses underscores.
+// * Allowing lowercase might get confusing. For example, say someone
+//   registers a new type called "Gpu". It might be confusing for users that
+//   "Gpu" is not the same device type as "GPU".
+//   Note that lowercase "cpu" and "gpu" are currently supported only for
+//   legacy reasons:
+//   https://cs.opensource.google/tensorflow/tensorflow/+/master:tensorflow/python/framework/device_spec.py;l=46;drc=d3a378f9665d8eee827c74cb9ecbee81e4c288dd
+Status ValidateDeviceType(StringPiece type);
+
+}  // namespace device_utils
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_DEVICE_DEVICE_UTILS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/device_factory.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/device_factory.h
new file mode 100644
index 0000000000000000000000000000000000000000..1b5a662639acbf2fbb249a675807fd2c82d3d943
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/device_factory.h
@@ -0,0 +1,20 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_DEVICE_FACTORY_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_DEVICE_FACTORY_H_
+
+#include "tensorflow/core/framework/device_factory.h"
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_DEVICE_FACTORY_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/device_mgr.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/device_mgr.h
new file mode 100644
index 0000000000000000000000000000000000000000..6e8420de1733cbe085fa25f8d1d84f925b57bb36
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/device_mgr.h
@@ -0,0 +1,178 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_DEVICE_MGR_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_DEVICE_MGR_H_
+
+#include <map>
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+#include "absl/container/flat_hash_set.h"
+#include "tensorflow/core/common_runtime/device.h"
+#include "tensorflow/core/lib/core/arena.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/lib/core/stringpiece.h"
+#include "tensorflow/core/lib/gtl/inlined_vector.h"
+#include "tensorflow/core/platform/macros.h"
+
+namespace tensorflow {
+
+class DeviceAttributes;
+
+// Represents a set of devices.
+class DeviceMgr {
+ public:
+  DeviceMgr() = default;
+  virtual ~DeviceMgr();
+
+  // Returns attributes of all devices.
+  virtual void ListDeviceAttributes(
+      std::vector<DeviceAttributes>* devices) const = 0;
+
+  // Returns raw pointers to the underlying devices.
+  virtual std::vector<Device*> ListDevices() const = 0;
+
+  // Returns a string listing all devices.
+  virtual string DebugString() const = 0;
+
+  // Returns a string of all the device mapping.
+  virtual string DeviceMappingString() const = 0;
+
+  // Assigns *device with pointer to Device of the given name.
+  // Accepts either a full device name, or just the replica-local suffix.
+  virtual Status LookupDevice(StringPiece name, Device** device) const = 0;
+
+  // Check if the current device manager contains device with the given
+  // incarnation ID. Looking up by incarnation IDs because they are randomly
+  // generated and not intentionally reused (unlike device pointers).
+  virtual bool ContainsDevice(int64_t device_incarnation) const = 0;
+
+  // Clears given containers of all devices if 'container' is
+  // non-empty. Otherwise, clears default containers of all devices.
+  virtual void ClearContainers(gtl::ArraySlice<string> containers) const = 0;
+
+  virtual int NumDeviceType(const string& type) const = 0;
+
+  virtual int NumDevices() const = 0;
+
+  // Returns an arbitrary CPU device if one is present, otherwise return
+  // nullptr.
+  virtual Device* HostCPU() const = 0;
+
+  DeviceMgr(const DeviceMgr&) = delete;
+  void operator=(const DeviceMgr&) = delete;
+};
+
+
+// Size of stale device buffer for temporary storage of removed devices.
+static const size_t kStaleDeviceBufferSize = 8192;
+
+// Represents a dynamic set of devices
+class DynamicDeviceMgr : public DeviceMgr {
+ public:
+  // Constructs an empty DynamicDeviceMgr.
+  DynamicDeviceMgr();
+
+  // Constructs a DynamicDeviceMgr from a list of devices.
+  explicit DynamicDeviceMgr(std::vector<std::unique_ptr<Device>>&& devices);
+  explicit DynamicDeviceMgr(std::unique_ptr<Device>&& device);
+
+  ~DynamicDeviceMgr() override;
+
+  void ListDeviceAttributes(
+      std::vector<DeviceAttributes>* devices) const override;
+  std::vector<Device*> ListDevices() const override;
+  string DebugString() const override;
+  string DeviceMappingString() const override;
+  Status LookupDevice(StringPiece name, Device** device) const override;
+  bool ContainsDevice(int64_t device_incarnation) const override;
+  void ClearContainers(gtl::ArraySlice<string> containers) const override;
+  int NumDeviceType(const string& type) const override;
+  int NumDevices() const override;
+  Device* HostCPU() const override;
+
+  // Add devices to device manager. Returns error for repeated device names.
+  Status AddDevices(std::vector<std::unique_ptr<Device>> devices);
+
+  // Remove devices from device manager.
+  // Returns error for non-existing devices or if the HostCPU() device is in the
+  // input list. If an error is returned, the device list is not modified.
+  Status RemoveDevices(const std::vector<Device*>& devices);
+
+  // Remove devices from device manager by their names. Returns error for
+  // non-existing devices or if the HostCPU() device is given in the input list.
+  // If an error is returned, the device list is not modified.
+  Status RemoveDevicesByName(const std::vector<string>& device_names);
+
+ private:
+  mutable mutex devices_mu_;
+
+  // Using an ordered map to ensure deterministic ordering of devices.
+  // Not a set, because we need to do find(Device*) and own the devices
+  // at the same time.
+  // We still have to override C++'s default pointer ordering.
+  struct DereferenceDevicePtrLess {
+    bool operator()(const Device* a, const Device* b) const {
+      return Device::LessByParsedName(*a, *b);
+    }
+  };
+  std::map<Device*, std::unique_ptr<Device>, DereferenceDevicePtrLess>
+      dynamic_devices_ TF_GUARDED_BY(devices_mu_);
+
+  absl::flat_hash_set<int64_t> device_incarnation_set_
+      TF_GUARDED_BY(devices_mu_);
+  std::unordered_map<string, Device*> device_map_ TF_GUARDED_BY(devices_mu_);
+
+  std::unordered_map<string, int> device_type_counts_
+      TF_GUARDED_BY(devices_mu_);
+
+  mutable std::atomic<Device*> cpu_device_;  // memoize `HostCPU` result
+
+  class DeviceCircularBuffer {
+   public:
+    DeviceCircularBuffer() : index_(0) {
+      devices_.resize(kStaleDeviceBufferSize);
+    }
+    void add(std::unique_ptr<Device> device) {
+      devices_[index_] = std::move(device);
+      index_ = (index_ + 1) % kStaleDeviceBufferSize;
+    }
+
+   private:
+    int index_;
+    std::vector<std::unique_ptr<Device>> devices_;
+  };
+
+  // Buffer to temporarily store the removed devices. Raw device pointers are
+  // accessible to DeviceSet, and if the function instantiation process directly
+  // access fields through the device set, the underlying device object must
+  // still be available to avoid segmentation fault. We keep the devices in this
+  // buffer only for that purpose.
+  DeviceCircularBuffer stale_devices_ TF_GUARDED_BY(devices_mu_);
+
+  DynamicDeviceMgr(const DynamicDeviceMgr&) = delete;
+  void operator=(const DynamicDeviceMgr&) = delete;
+};
+
+// TODO(b/183966398): Remove StaticDeviceMgr since there's no usage.
+using StaticDeviceMgr = DynamicDeviceMgr;
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_DEVICE_MGR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/device_resolver_local.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/device_resolver_local.h
new file mode 100644
index 0000000000000000000000000000000000000000..adb859abc1fd9e3450cb546af53fa26d1d591802
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/device_resolver_local.h
@@ -0,0 +1,47 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_DEVICE_RESOLVER_LOCAL_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_DEVICE_RESOLVER_LOCAL_H_
+
+#include <string>
+#include <vector>
+
+#include "tensorflow/core/framework/collective.h"
+#include "tensorflow/core/framework/device_attributes.pb.h"
+#include "tensorflow/core/platform/status.h"
+
+namespace tensorflow {
+class DeviceMgr;
+
+// Implements DeviceResolverInterface in a single-task context.
+class DeviceResolverLocal : public DeviceResolverInterface {
+ public:
+  explicit DeviceResolverLocal(const DeviceMgr* dev_mgr) : dev_mgr_(dev_mgr) {}
+
+  Status GetDeviceAttributes(const string& device,
+                             DeviceAttributes* attributes) override;
+
+  Status GetAllDeviceAttributes(
+      const string& task, std::vector<DeviceAttributes>* attributes) override;
+
+  Status UpdateDeviceAttributes(
+      const std::vector<DeviceAttributes>& attributes) override;
+
+ protected:
+  const DeviceMgr* dev_mgr_;
+};
+
+}  // namespace tensorflow
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_DEVICE_RESOLVER_LOCAL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/device_set.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/device_set.h
new file mode 100644
index 0000000000000000000000000000000000000000..16dcd0ad6e5a442c2687522c3a2e97a02cf30000
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/device_set.h
@@ -0,0 +1,139 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_DEVICE_SET_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_DEVICE_SET_H_
+
+#include <memory>
+#include <unordered_map>
+#include <vector>
+
+#include "absl/container/flat_hash_map.h"
+#include "tensorflow/core/common_runtime/device.h"
+#include "tensorflow/core/platform/macros.h"
+#include "tensorflow/core/platform/types.h"
+#include "tensorflow/core/util/device_name_utils.h"
+
+namespace tensorflow {
+
+typedef std::vector<std::pair<Device*, int32>> PrioritizedDeviceVector;
+
+// DeviceSet is a container class for managing the various types of
+// devices used by a model.
+class DeviceSet {
+ public:
+  DeviceSet();
+  ~DeviceSet();
+
+  // Does not take ownership of 'device'.
+  void AddDevice(Device* device) TF_LOCKS_EXCLUDED(devices_mu_);
+
+  // Set the device designated as the "client".  This device
+  // must also be registered via AddDevice().
+  void set_client_device(Device* device) {
+    DCHECK(client_device_ == nullptr);
+    client_device_ = device;
+  }
+
+  // Returns a pointer to the device designated as the "client".
+  Device* client_device() const { return client_device_; }
+
+  // Return the list of devices in this set.
+  const std::vector<Device*>& devices() const { return devices_; }
+
+  // Given a DeviceNameUtils::ParsedName (which may have some
+  // wildcards for different components), fills "*devices" with all
+  // devices in "*this" that match "spec".
+  void FindMatchingDevices(const DeviceNameUtils::ParsedName& spec,
+                           std::vector<Device*>* devices) const;
+
+  // Finds the device with the given "fullname". Returns nullptr if
+  // not found.
+  Device* FindDeviceByName(const string& fullname) const;
+
+  // Return the list of unique device types in this set, ordered
+  // with more preferable devices earlier.
+  std::vector<DeviceType> PrioritizedDeviceTypeList() const;
+
+  // Return the prioritized list of devices in this set.
+  // Devices are prioritized first by `DeviceTypeOrder`, then by name.
+  const PrioritizedDeviceVector& prioritized_devices() const
+      TF_LOCKS_EXCLUDED(devices_mu_);
+
+  // Return the prioritized list of unique device types in this set.
+  //
+  // The list will be ordered by decreasing priority. The priorities (the second
+  // element in the list's `std::pair<DeviceType, int32>`) will be initialized
+  // to the value of `DeviceTypeOrder` for the device types.
+  const PrioritizedDeviceTypeVector& prioritized_device_types() const
+      TF_LOCKS_EXCLUDED(devices_mu_);
+
+  // An order to sort by device types according to system-determined
+  // priority.
+  //
+  // Higher result implies higher priority.
+  static int DeviceTypeOrder(const DeviceType& d);
+
+  // Sorts a PrioritizedDeviceVector according to devices and explicit
+  // priorities.
+  //
+  // After a call to this function, the argument vector will be sorted by
+  // explicit priority (the second element in the `std::pair<DeviceType,
+  // int32>`), then by `DeviceTypeOrder` of the device type, then by device
+  // locality, and lastly by device name.
+  static void SortPrioritizedDeviceVector(PrioritizedDeviceVector* vector);
+
+  // Sorts a PrioritizedDeviceTypeVector according to types and explicit
+  // priorities.
+  //
+  // After a call to this function, the argument vector will be sorted by
+  // explicit priority (the second element in the `std::pair<DeviceType,
+  // int32>`), then by `DeviceTypeOrder` of the device type.
+  static void SortPrioritizedDeviceTypeVector(
+      PrioritizedDeviceTypeVector* vector);
+
+ private:
+  mutable mutex devices_mu_;
+
+  mutable absl::flat_hash_map<DeviceNameUtils::ParsedName, std::vector<Device*>>
+      matching_device_cache_;
+
+  // Not owned.
+  std::vector<Device*> devices_;
+
+  // Cached prioritized vector, created on-the-fly when
+  // prioritized_devices() is called.
+  mutable PrioritizedDeviceVector prioritized_devices_
+      TF_GUARDED_BY(devices_mu_);
+
+  // Cached prioritized vector, created on-the-fly when
+  // prioritized_device_types() is called.
+  mutable PrioritizedDeviceTypeVector prioritized_device_types_
+      TF_GUARDED_BY(devices_mu_);
+
+  // Fullname -> device* for device in devices_.
+  std::unordered_map<string, Device*> device_by_name_;
+
+  // client_device_ points to an element of devices_ that we consider
+  // to be the client device (in this local process).
+  Device* client_device_ = nullptr;
+
+  DeviceSet(const DeviceSet&) = delete;
+  void operator=(const DeviceSet&) = delete;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_DEVICE_SET_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/direct_session.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/direct_session.h
new file mode 100644
index 0000000000000000000000000000000000000000..a81a3079345117ee1b0c8b8e1588ccfed9e307d9
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/direct_session.h
@@ -0,0 +1,450 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_DIRECT_SESSION_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_DIRECT_SESSION_H_
+
+#include <atomic>
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+#include "tensorflow/core/common_runtime/costmodel_manager.h"
+#include "tensorflow/core/common_runtime/debugger_state_interface.h"
+#include "tensorflow/core/common_runtime/device_mgr.h"
+#include "tensorflow/core/common_runtime/device_set.h"
+#include "tensorflow/core/common_runtime/executor.h"
+#include "tensorflow/core/common_runtime/graph_execution_state.h"
+#include "tensorflow/core/common_runtime/process_function_library_runtime.h"
+#include "tensorflow/core/common_runtime/rendezvous_mgr.h"
+#include "tensorflow/core/common_runtime/session_factory.h"
+#include "tensorflow/core/framework/cancellation.h"
+#include "tensorflow/core/framework/collective.h"
+#include "tensorflow/core/framework/graph.pb.h"
+#include "tensorflow/core/framework/session_state.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/lib/core/errors.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/platform/macros.h"
+#include "tensorflow/core/platform/mutex.h"
+#include "tensorflow/core/platform/thread_annotations.h"
+#include "tensorflow/core/platform/types.h"
+#include "tensorflow/core/public/session.h"
+
+namespace tensorflow {
+
+class CostModel;
+class DebugGateway;
+class Device;
+class DirectSessionFactory;
+
+class DirectSession : public Session {
+ public:
+  typedef std::function<void(Session*)> CloseCallback;
+
+  // Takes ownership of 'device_mgr'.
+  // 'factory' is used to unregister the DirectSession with 'factory' when its
+  // closed. This ensures that Reset requests from the 'factory' don't get sent
+  // to sessions that are already closed.
+  DirectSession(const SessionOptions& options, const DeviceMgr* device_mgr,
+                DirectSessionFactory* factory);
+  ~DirectSession() override;
+
+  typedef std::vector<std::pair<string, Tensor>> NamedTensorList;
+  typedef std::unordered_map<StringPiece, Node*, StringPieceHasher> NameNodeMap;
+
+  ::tensorflow::Status Create(const GraphDef& graph) override;
+  ::tensorflow::Status Create(GraphDef&& graph) override;
+  ::tensorflow::Status Extend(const GraphDef& graph) override;
+  ::tensorflow::Status Extend(GraphDef&& graph) override;
+  ::tensorflow::Status Run(const NamedTensorList& inputs,
+                           const std::vector<string>& output_names,
+                           const std::vector<string>& target_nodes,
+                           std::vector<Tensor>* outputs) override;
+
+  // NOTE: Experimental and subject to change.
+  ::tensorflow::Status Run(const ::tensorflow::RunOptions& run_options,
+                           const NamedTensorList& inputs,
+                           const std::vector<string>& output_names,
+                           const std::vector<string>& target_nodes,
+                           std::vector<Tensor>* outputs,
+                           RunMetadata* run_metadata) override;
+
+  // NOTE: Experimental and subject to change.
+  ::tensorflow::Status Run(
+      const ::tensorflow::RunOptions& run_options,
+      const NamedTensorList& inputs, const std::vector<string>& output_names,
+      const std::vector<string>& target_nodes, std::vector<Tensor>* outputs,
+      RunMetadata* run_metadata,
+      const thread::ThreadPoolOptions& threadpool_options) override;
+
+  // NOTE: PRunSetup and PRun are added to support partial execution. This
+  // feature is experimental and subject to change.
+  ::tensorflow::Status PRunSetup(const std::vector<string>& input_names,
+                                 const std::vector<string>& output_names,
+                                 const std::vector<string>& target_nodes,
+                                 string* handle) override;
+  ::tensorflow::Status PRun(const string& handle, const NamedTensorList& inputs,
+                            const std::vector<string>& output_names,
+                            std::vector<Tensor>* outputs) override;
+
+  // Reset clears 'containers' from the device_mgr of the DirectSession.
+  // If 'containers' is empty, then Reset clears the default container.
+  ::tensorflow::Status Reset(const std::vector<string>& containers);
+
+  ::tensorflow::Status ListDevices(
+      std::vector<DeviceAttributes>* response) override;
+  ::tensorflow::Status Close() override;
+  ::tensorflow::Status LocalDeviceManager(const DeviceMgr** output) override {
+    *output = device_mgr_.get();
+    return OkStatus();
+  }
+
+  void ExportCostModels(CostModelManager::CostModelMap* cost_models) {
+    cost_model_manager_.ExportCostModels(cost_models);
+  }
+
+  ::tensorflow::Status MakeCallable(const CallableOptions& callable_options,
+                                    CallableHandle* out_handle) override;
+
+  ::tensorflow::Status RunCallable(CallableHandle handle,
+                                   const std::vector<Tensor>& feed_tensors,
+                                   std::vector<Tensor>* fetch_tensors,
+                                   RunMetadata* run_metadata) override;
+
+  ::tensorflow::Status RunCallable(
+      CallableHandle handle, const std::vector<Tensor>& feed_tensors,
+      std::vector<Tensor>* fetch_tensors, RunMetadata* run_metadata,
+      const thread::ThreadPoolOptions& threadpool_options) override;
+
+  ::tensorflow::Status ReleaseCallable(CallableHandle handle) override;
+
+  ::tensorflow::Status Finalize() override;
+
+  const SessionOptions& options() const { return options_; }
+
+ private:
+  // For access to collective_graph_key_.
+  friend class DirectSessionCollectiveTest;
+
+  // We create one executor and its dependent library runtime for
+  // every partition.
+  struct PerPartitionExecutorsAndLib {
+    std::unique_ptr<Graph> graph = nullptr;
+    Device* device = nullptr;                // not owned.
+    FunctionLibraryRuntime* flib = nullptr;  // not owned.
+    std::unique_ptr<Executor> executor;
+  };
+
+  // An ExecutorsAndKeys is created for a given set of feeds/fetches.
+  // 'step_count' is the number of times this graph is executed.
+  // 'graph' is the entire graph being executed. 'name_to_node'
+  // maps node name to node. We keep 'graph' and 'name_to_node' only in
+  // the case of partial runs. Each item in 'items' is the executor for
+  // a partition of the graph bundled with its dependent library runtime.
+  // 'input_keys' are the rendezvous keys for the feeds and 'output_keys'
+  // are rendezvous keys for the fetches.
+  struct ExecutorsAndKeys {
+    ExecutorsAndKeys() : step_count(0) {}
+
+    std::atomic_int_fast64_t step_count;
+    std::unique_ptr<Graph> graph;
+    NameNodeMap name_to_node;
+    std::vector<PerPartitionExecutorsAndLib> items;
+    std::unordered_map<string, size_t> input_name_to_index;
+    std::unordered_map<string, string> input_name_to_rendezvous_key;
+    std::unordered_map<string, size_t> output_name_to_index;
+    std::unordered_map<string, string> output_name_to_rendezvous_key;
+
+    DataTypeVector input_types;
+    DataTypeVector output_types;
+
+    CallableOptions callable_options;
+
+    int64_t collective_graph_key = BuildGraphOptions::kNoCollectiveGraphKey;
+  };
+
+  // A FunctionInfo object is created for every unique set of feeds/fetches.
+  // This info could be folded into the ExecutorsAndKeys object but we would
+  // like to maintain a deletion order in which the OpKernels (owned by the
+  // executor) should be destroyed first, followed by the resources in the
+  // device and then followed by the function stuff.
+  // TODO(rohanj): Consolidate function library definitions so that we can
+  // instantiate only one ProcFLR and lib_def and make this just a member
+  // variable and not a vector.
+  // 'flib_def' is the function library used.
+  // 'proc_flr' is the collection of FunctionLibraryRuntime objects, one per
+  // device.
+  struct FunctionInfo {
+    std::unique_ptr<FunctionLibraryDefinition> flib_def;
+    std::unique_ptr<ProcessFunctionLibraryRuntime> proc_flr;
+  };
+
+  // For each live Run() call, the session maintains a RunState.
+  // 'status' is the current status of the execution.
+  struct RunState {
+    mutex mu;
+    Status status TF_GUARDED_BY(mu);
+    std::unique_ptr<CollectiveExecutor::Handle> collective_executor;
+    std::unique_ptr<StepStatsCollector> collector;
+    TensorStore tensor_store;
+    ScopedStepContainer step_container;
+
+    RunState(int64_t step_id, const std::vector<Device*>* devices);
+  };
+
+  // For each live partial execution, the session maintains a PartialRunState.
+  // 'executor_done' is "notified" when all executors are done. 'pending_inputs'
+  // are the set of pending feeds and 'pending_outputs' are the set of pending
+  // fetches.
+  struct PartialRunState : public RunState {
+    Notification executors_done;
+    std::unordered_map<string, bool> pending_inputs;   // true if fed
+    std::unordered_map<string, bool> pending_outputs;  // true if fetched
+    core::RefCountPtr<IntraProcessRendezvous> rendez = nullptr;
+
+    PartialRunState(const std::vector<string>& pending_input_names,
+                    const std::vector<string>& pending_output_names,
+                    int64_t step_id, const std::vector<Device*>* devices);
+
+    // Returns true if all pending inputs and outputs have been completed.
+    bool PendingDone() const;
+
+    ~PartialRunState();
+  };
+
+  struct RunStateArgs {
+    explicit RunStateArgs(const DebugOptions& options)
+        : debug_options(options) {}
+
+    bool is_partial_run = false;
+    string handle;
+    std::unique_ptr<Graph> graph;
+    const DebugOptions& debug_options;
+    int64_t collective_graph_key = BuildGraphOptions::kNoCollectiveGraphKey;
+  };
+
+  // Retrieves an already existing set of executors to run 'inputs' and
+  // 'outputs', or creates and caches them for future use.
+  ::tensorflow::Status GetOrCreateExecutors(
+      gtl::ArraySlice<string> inputs, gtl::ArraySlice<string> outputs,
+      gtl::ArraySlice<string> target_nodes,
+      ExecutorsAndKeys** executors_and_keys, RunStateArgs* run_state_args);
+
+  // Creates a set of executors to run the subgraph defined by
+  // `callable_options`.
+  ::tensorflow::Status CreateExecutors(
+      const CallableOptions& callable_options,
+      std::unique_ptr<ExecutorsAndKeys>* out_executors_and_keys,
+      std::unique_ptr<FunctionInfo>* out_func_info,
+      RunStateArgs* run_state_args);
+
+  // Creates several graphs given the existing graph_def_ and the
+  // input feeds and fetches, given 'devices'. The graphs share a common
+  // function library 'flib_def'.
+  ::tensorflow::Status CreateGraphs(
+      const BuildGraphOptions& options,
+      std::unordered_map<string, std::unique_ptr<Graph>>* outputs,
+      std::unique_ptr<FunctionLibraryDefinition>* flib_def,
+      RunStateArgs* run_state_args, DataTypeVector* input_types,
+      DataTypeVector* output_types, int64_t* collective_graph_key);
+
+  ::tensorflow::Status RunInternal(
+      int64_t step_id, const RunOptions& run_options,
+      CallFrameInterface* call_frame, ExecutorsAndKeys* executors_and_keys,
+      RunMetadata* run_metadata,
+      const thread::ThreadPoolOptions& threadpool_options);
+
+  // Returns whether inter-op execution uses a global pool or the input
+  // `run_options` requests being run on inter_op_thread_pool = 0 in case
+  // multiple pools are configured.
+  bool ShouldUseRunHandlerPool(const RunOptions& run_options) const;
+
+  ::tensorflow::Status ExtendLocked(GraphDef&& graph)
+      TF_EXCLUSIVE_LOCKS_REQUIRED(graph_state_lock_);
+
+  ::tensorflow::Status ResourceHandleToInputTensor(
+      const Tensor& resource_tensor, Tensor* retrieved_tensor);
+
+  // Feeds more inputs to the executors, triggering further execution.
+  ::tensorflow::Status SendPRunInputs(
+      const std::vector<std::pair<string, Tensor>>& inputs,
+      const ExecutorsAndKeys* executors_and_keys,
+      IntraProcessRendezvous* rendez);
+
+  // Fetches more outputs from the executors. It waits until the output
+  // tensors are computed.
+  ::tensorflow::Status RecvPRunOutputs(
+      const std::vector<string>& output_names,
+      const ExecutorsAndKeys* executors_and_keys, PartialRunState* run_state,
+      std::vector<Tensor>* outputs);
+
+  // Check if the specified fetches can be computed from the feeds
+  // that we have already provided.
+  ::tensorflow::Status CheckFetch(
+      const std::vector<std::pair<string, Tensor>>& feeds,
+      const std::vector<string>& fetches,
+      const ExecutorsAndKeys* executors_and_keys,
+      const PartialRunState* run_state);
+
+  // Use the appropriate WaitForNotification function based on whether
+  // operation_timeout_in_ms is greater than 0.
+  //
+  // If the timeout expires, the `cm->StartCancel()` will be called.
+  ::tensorflow::Status WaitForNotification(Notification* n,
+                                           int64_t timeout_in_ms);
+  void WaitForNotification(Notification* n, RunState* run_state,
+                           CancellationManager* cm, int64_t timeout_in_ms);
+
+  ::tensorflow::Status CheckNotClosed() {
+    mutex_lock l(closed_lock_);
+    if (closed_) return errors::Cancelled("Session has been closed.");
+    return OkStatus();
+  }
+
+  ::tensorflow::Status CheckGraphCreated(const char* method) {
+    mutex_lock l(graph_state_lock_);
+    if (!graph_created_) {
+      return errors::InvalidArgument(
+          "Session was not created with a graph before ", method, "!");
+    }
+    return OkStatus();
+  }
+
+  ::tensorflow::Status CreateDebuggerState(
+      const CallableOptions& options, int64_t global_step,
+      int64_t session_run_index, int64_t executor_step_index,
+      std::unique_ptr<DebuggerStateInterface>* debugger_state);
+
+  ::tensorflow::Status DecorateAndPublishGraphForDebug(
+      const DebugOptions& debug_options, Graph* graph, Device* device);
+
+  const SessionOptions options_;
+
+  // Device structures.
+  const std::unique_ptr<const DeviceMgr> device_mgr_;
+  std::vector<Device*> devices_;  // not owned
+  DeviceSet device_set_;
+
+  // Unique session identifier.
+  string session_handle_;
+  mutex graph_state_lock_;
+  bool graph_created_ TF_GUARDED_BY(graph_state_lock_) = false;
+  bool finalized_ TF_GUARDED_BY(graph_state_lock_) = false;
+
+  // The thread-pools to use for running ops, with a bool indicating if the pool
+  // is owned.
+  std::vector<std::pair<thread::ThreadPool*, bool>> thread_pools_;
+
+  Status init_error_;  // Set to an error if construction failed.
+
+  // If true, blocks until device has finished all queued operations in a step.
+  bool sync_on_finish_ = true;
+
+  std::vector<std::unique_ptr<FunctionInfo>> functions_
+      TF_GUARDED_BY(executor_lock_);
+
+  mutex executor_lock_;  // protects executors_
+  // Holds mappings from signature to the executors that process
+  // it. The reason for a level of indirection around mapped_type is
+  // to guarantee address stability.
+  // The map value is a shared_ptr since multiple map keys can point to the
+  // same ExecutorsAndKey object.
+  std::unordered_map<string, std::shared_ptr<ExecutorsAndKeys>> executors_
+      TF_GUARDED_BY(executor_lock_);
+
+  class RunCallableCallFrame;
+  struct Callable {
+    std::shared_ptr<ExecutorsAndKeys> executors_and_keys;
+    std::shared_ptr<FunctionInfo> function_info;
+    ~Callable();
+  };
+  mutex callables_lock_;
+  int64_t next_callable_handle_ TF_GUARDED_BY(callables_lock_) = 0;
+  std::unordered_map<int64_t, Callable> callables_
+      TF_GUARDED_BY(callables_lock_);
+
+  // Holds mappings from handle to partial run state.
+  std::unordered_map<string, std::unique_ptr<PartialRunState>> partial_runs_
+      TF_GUARDED_BY(executor_lock_);
+
+  // This holds all the tensors that are currently alive in the session.
+  SessionState session_state_;
+
+  DirectSessionFactory* const factory_;  // not owned
+  CancellationManager* cancellation_manager_;
+  std::unique_ptr<CollectiveExecutorMgrInterface> collective_executor_mgr_;
+
+  // Map of placed stateful nodes, i.e. nodes for which is_stateful()
+  // is true, such as "params" and "queue" nodes.  Once placed these
+  // nodes can not be moved to a different device.  Maps node names to
+  // device names.
+  std::unordered_map<string, string> stateful_placements_
+      TF_GUARDED_BY(graph_state_lock_);
+
+  // Execution_state; used when placing the entire graph.
+  std::unique_ptr<GraphExecutionState> execution_state_
+      TF_GUARDED_BY(graph_state_lock_);
+
+  // The function library, before any rewrites or optimizations have been
+  // performed. In particular, CreateGraphs() may need to modify the function
+  // library; it copies and modifies the function library.
+  std::unique_ptr<FunctionLibraryDefinition> flib_def_;
+
+  // true if the Session has been Closed.
+  mutex closed_lock_;
+  bool closed_ TF_GUARDED_BY(closed_lock_) = false;
+
+  // For generating unique names for this session instance.
+  std::atomic<int64_t> edge_name_counter_ = {0};
+  std::atomic<int64_t> handle_name_counter_ = {0};
+
+  // For generating step ids that are unique among all sessions.
+  static std::atomic_int_fast64_t step_id_counter_;
+
+  // Global timeout for all blocking operations in this session.
+  const int64_t operation_timeout_in_ms_ = 0;
+
+  // Manages all the cost models for the graphs executed in this session.
+  CostModelManager cost_model_manager_;
+
+  // For testing collective graph key generation.
+  mutex collective_graph_key_lock_;
+  int64_t collective_graph_key_ TF_GUARDED_BY(collective_graph_key_lock_) = -1;
+
+  // Run in caller's thread if RunOptions.inter_op_thread_pool is negative or
+  // all of following conditions are met:
+  // 1. This session doesn't own any thread pool.
+  // 2. RunOptions.inter_op_thread_pool is unspecified or 0.
+  // 3. This session has a single executor.
+  // 4. config.inter_op_parallelism_threads is specified to negative explicitly
+  //    or through environment variable TF_NUM_INTEROP_THREADS.
+  // 5. RunOptions.experimental.use_run_handler_pool is unspecified or false.
+  // Otherwise run in global thread pool, session owned thread pool or handler
+  // pool according to other specifications of RunOptions and ConfigProto.
+  bool run_in_caller_thread_ = false;
+
+  DirectSession(const DirectSession&) = delete;
+  void operator=(const DirectSession&) = delete;
+
+  // EXPERIMENTAL: debugger (tfdbg) related
+  friend class DebugGateway;
+};
+
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_DIRECT_SESSION_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/dma_helper.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/dma_helper.h
new file mode 100644
index 0000000000000000000000000000000000000000..4a76cff1e340b6386b7455b7a3288faa2e341984
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/dma_helper.h
@@ -0,0 +1,38 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_DMA_HELPER_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_DMA_HELPER_H_
+
+#include "tensorflow/core/framework/tensor.h"
+
+namespace tensorflow {
+
+// For TensorFlow internal use only.
+class DMAHelper {
+ public:
+  static bool CanUseDMA(const Tensor* t) { return t->CanUseDMA(); }
+  static const void* base(const Tensor* t) { return t->base<const void>(); }
+  static void* base(Tensor* t) { return t->base<void>(); }
+  static TensorBuffer* buffer(Tensor* t) { return t->buf_; }
+  static const TensorBuffer* buffer(const Tensor* t) { return t->buf_; }
+  static void UnsafeSetShape(Tensor* t, const TensorShape& s) {
+    t->set_shape(s);
+  }
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_DMA_HELPER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/eager/attr_builder.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/eager/attr_builder.h
new file mode 100644
index 0000000000000000000000000000000000000000..6fc817039cc214df4d6d56ccc8e5787d85e805a7
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/eager/attr_builder.h
@@ -0,0 +1,223 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_EAGER_ATTR_BUILDER_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_EAGER_ATTR_BUILDER_H_
+
+// Support for eager execution of TensorFlow kernels.
+
+#include <memory>
+#include <optional>
+#include <unordered_map>
+
+#include "tensorflow/c/eager/abstract_op_attrs.h"
+#include "tensorflow/c/tf_attrtype.h"
+#include "tensorflow/core/common_runtime/device.h"
+#include "tensorflow/core/framework/node_def.pb.h"
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/lib/core/errors.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/lib/gtl/inlined_vector.h"
+#include "tensorflow/core/platform/fingerprint.h"
+#include "tensorflow/core/util/tensor_slice_reader_cache.h"
+
+namespace tensorflow {
+
+// Maps attribute name to an encoding of the type of the attribute value.
+// If the type is not a list type, the value is the same as the TF_AttrType type
+// of the value. Else, the highest order bit is on, and the rest of the bits
+// represent the TF_AttrType type of the values in the list.
+typedef std::unordered_map<string, uint32> AttrTypeMap;
+
+// Look up OpDef for `op_name`.
+Status OpDefForOp(const string& op_name, const OpDef** op_def);
+
+// Returns the AttrTypeMap for the TensorFlow operation named op_name.
+// If op_name is not registered in global op registry, AttrTypeMapForOp assumes
+// the op to be a function and returns the default attributes for a function.
+// `is_function` is set to true in this case.
+Status AttrTypeMapForOp(const char* op_name, const AttrTypeMap** out,
+                        bool* is_function);
+
+// Looks for 'attr_name' in 'm' and sets 'out' and 'is_list'.
+Status AttrTypeByName(const AttrTypeMap& m, const string& attr_name,
+                      TF_AttrType* out, unsigned char* is_list);
+
+// KernelAndDevice::Init needs a NodeDef only to pass the attribute map through.
+// An AttrBuilder is a convenience class to help with that - providing a smaller
+// interface than NodeDefBuilder and avoiding expensive (unnecessary?) sanity
+// checks (like number of inputs matching the OpDef - we only care about
+// attributes here).
+//
+// TODO(ashankar): Take a closer look at checks in NodeDefBuilder and see which
+// ones make sense to replicate.
+
+// This is a helper class for creating a NodeDef. Additionally, this class
+// allows computing a cache key based on fingerprinting the attributes of this
+// NodeDef.
+//
+// Example usage:
+// AttrBuilder a;
+// a.NumInputs(2);
+// a.Set("T", TF_FLOAT);
+// tensorflow::Fprint128 cache_key = a.CacheKey("cpu:0");
+// const NodeDef& n = a.BuildNodeDef();
+//
+// Calls to NumInputs or Set between multiple invocations to CacheKey may cause
+// different values to be returned by CacheKey.
+//
+// If NumInputs or Set is called, BuildNodeDef should be called again to update
+// the NodeDef.
+//
+// For performance reasons, the class internally delays the actual construction
+// of the NodeDef till BuildNodeDef is called, or Set is called with certain
+// uncommon types (see template specializations of Set to see which types
+// trigger a NodeDef creation).
+//
+// Setting attributes via `Set` may cause arena-allocated protocol buffer
+// messages to be destructed, which is not thread safe. This means that it is
+// currently not safe to set attributes on *different* AttrBuilder objects from
+// multiple threads. This does not apply to `CopyAttributes`.
+class AttrBuilder : public AbstractOpAttrs {
+ public:
+  AttrBuilder()
+      : AbstractOpAttrs(AbstractOpAttrs::AbstractOpAttrsKind::kEager) {}
+
+  ~AttrBuilder() override = default;
+  explicit AttrBuilder(const char* op)
+      : AbstractOpAttrs(AbstractOpAttrs::AbstractOpAttrsKind::kEager) {
+    Reset(op);
+  }
+
+  void Reset(const char* op) {
+    op_name_ = op;
+    num_inputs_ = 0;
+    encoded_attrs_.clear();
+    node_def_finalized_ = false;
+    cached_cache_key_ = std::nullopt;
+    device_for_cached_cache_key_.clear();
+  }
+
+  const string& op_name() const { return op_name_; }
+  void set_op_name(const string& name) { op_name_ = name; }
+
+  // Needed to work around call to ValidateNodeDef in CreateOpKernel.
+  AttrBuilder& NumInputs(int n);
+
+  template <class T>
+  AttrBuilder& Set(StringPiece attr_name, T&& value) {
+    SetAttrValue(value, &attr_tmp_);
+    AddAttrIfNotPresent(attr_name, attr_tmp_);
+    node_def_finalized_ = false;
+    cached_cache_key_ = std::nullopt;
+    return *this;
+  }
+
+  size_t NumAttributes() const { return encoded_attrs_.size(); }
+
+  AttrBuilder& Set(StringPiece attr_name, const AttrValue& value) {
+    AddAttrIfNotPresent(attr_name, value);
+    cached_cache_key_ = std::nullopt;
+    return *this;
+  }
+
+  // Retrieves the attribute value.
+  // Note that Get() can involve a linear scan of all attributes with the same
+  // value type in this Node. This is not an issue, because Get is used rarely
+  // and nodes have a small number of attributes.
+  template <class T>
+  Status Get(StringPiece attr_name, T* value) const {
+    // Common attributes are stored in AttrVecs. This Get() template
+    // is specialized for them below. If we end up here, the type must be
+    // among those that we store in the node_def_.
+    if (!node_def_finalized_) {
+      return errors::NotFound("No attr named'", attr_name,
+                              "' found in AttrBuilder for ", op_name_);
+    }
+    return GetNodeAttr(AttrSlice(node_def_), attr_name, value);
+  }
+
+  tensorflow::Fprint128 CacheKey(StringPiece device);
+
+  // Fill `m` with the attr-value pairs set via AttrBuilder::Set() so far, as
+  // well as any default attr-value pairs from the associated op_def, if there
+  // is one.
+  void FillAttrValueMap(AttrValueMap* m) const;
+
+  // Fill `m` with the attr-value pairs set via AttrBuilder::Set() so far except
+  // when the value matches the default for this attr.
+  // More precisely, if the global op registry contains an OpDef for this op
+  // and if an attribute value is the same as the default (according to the
+  // OpDef), this attr-value pair is not added to `m`.
+  void FillAttrValueMapWithoutDefaults(AttrValueMap* m) const;
+  const NodeDef& BuildNodeDef();
+
+  // Transfers the attributes from `other` to this AttrBuilder. Does not
+  // overwrite existing attributes. Since it does not require deserializing and
+  // re-serializing attributes, it is much more efficient than going through an
+  // AttrValueMap.
+  void CopyAttributes(const AttrBuilder& other);
+
+  void GetNameAttrList(tensorflow::NameAttrList* name_and_attrs) const override;
+
+  bool GetInt(absl::string_view attr_name, int64_t* result) const override;
+  bool GetFloat(absl::string_view attr_name, float* result) const override;
+  bool GetBool(absl::string_view attr_name, bool* result) const override;
+  bool GetType(absl::string_view attr_name,
+               tensorflow::DataType* result) const override;
+  Status GetTypeList(
+      absl::string_view attr_name,
+      absl::InlinedVector<DataType, 4>* type_list) const override;
+
+ private:
+  tensorflow::Fprint128 BuildCacheKeyForDevice(StringPiece device) const;
+
+  template <class T>
+  void SetInAttrValueMap(AttrValueMap* m, const string& attr_name,
+                         T&& value) const {
+    DCHECK(!node_def_finalized_)
+        << "Calling SetInAttrValueMap after BuildNodeDef.";
+    // If attribute is set more than once, its first value prevails
+    m->insert({attr_name, value});
+  }
+
+  void AddAttrIfNotPresent(StringPiece attr_name, const AttrValue& value);
+
+  gtl::FlatMap<string, string> encoded_attrs_;
+  mutable AttrValue attr_tmp_;  // For encoding
+
+  string op_name_;
+  int num_inputs_;
+  NodeDef node_def_;
+  bool node_def_initialized_;
+  bool node_def_finalized_;
+
+  std::optional<tensorflow::Fprint128> cached_cache_key_;
+  string device_for_cached_cache_key_;
+};
+
+template <>
+Status AttrBuilder::Get(StringPiece attr_name, int* value) const;
+template <>
+Status AttrBuilder::Get(StringPiece attr_name, float* value) const;
+template <>
+Status AttrBuilder::Get(StringPiece attr_name, bool* value) const;
+template <>
+Status AttrBuilder::Get(StringPiece attr_name,
+                        tensorflow::DataType* value) const;
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_EAGER_ATTR_BUILDER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/eager/context.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/eager/context.h
new file mode 100644
index 0000000000000000000000000000000000000000..e45ce40735506c7ec06a49535a2badebaa629068
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/eager/context.h
@@ -0,0 +1,914 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_EAGER_CONTEXT_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_EAGER_CONTEXT_H_
+
+#include <algorithm>
+#include <atomic>
+#include <cstddef>
+#include <functional>
+#include <map>
+#include <memory>
+#include <queue>
+#include <string>
+#include <thread>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+#include "absl/container/flat_hash_map.h"
+#include "absl/container/flat_hash_set.h"
+#include "absl/types/optional.h"
+#include "tensorflow/c/eager/immediate_execution_context.h"
+#include "tensorflow/core/common_runtime/composite_device.h"
+#include "tensorflow/core/common_runtime/device_factory.h"
+#include "tensorflow/core/common_runtime/device_mgr.h"
+#include "tensorflow/core/common_runtime/eager/custom_device.h"
+#include "tensorflow/core/common_runtime/eager/custom_device_op_handler.h"
+#include "tensorflow/core/common_runtime/eager/eager_executor.h"
+#include "tensorflow/core/common_runtime/eager/kernel_and_device.h"
+#include "tensorflow/core/common_runtime/eager/rendezvous_cache.h"
+#include "tensorflow/core/common_runtime/function.h"
+#include "tensorflow/core/common_runtime/process_function_library_runtime.h"
+#include "tensorflow/core/common_runtime/rendezvous_mgr.h"
+#include "tensorflow/core/example/example.pb.h"
+#include "tensorflow/core/framework/collective.h"
+#include "tensorflow/core/framework/function.h"
+#include "tensorflow/core/framework/log_memory.h"
+#include "tensorflow/core/framework/rendezvous.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/lib/core/stringpiece.h"
+#include "tensorflow/core/lib/core/threadpool.h"
+#include "tensorflow/core/lib/gtl/flatmap.h"
+#include "tensorflow/core/lib/gtl/flatset.h"
+#include "tensorflow/core/lib/gtl/inlined_vector.h"
+#include "tensorflow/core/lib/gtl/map_util.h"
+#include "tensorflow/core/platform/casts.h"
+#include "tensorflow/core/platform/env.h"
+#include "tensorflow/core/platform/fingerprint.h"
+#include "tensorflow/core/platform/mutex.h"
+#include "tensorflow/core/platform/platform.h"
+#include "tensorflow/core/platform/status.h"
+#include "tensorflow/core/platform/thread_annotations.h"
+#include "tensorflow/core/platform/threadpool.h"
+#include "tensorflow/core/public/session_options.h"
+#include "tensorflow/core/public/version.h"
+#include "tensorflow/core/util/device_name_utils.h"
+#include "tsl/platform/refcount.h"
+
+// "tensorflow/core/platform/platform.h" must be included first before using
+// IS_MOBILE_PLATFORM.
+#if !defined(IS_MOBILE_PLATFORM)
+#include "tensorflow/core/distributed_runtime/eager/eager_client.h"
+#include "tensorflow/core/distributed_runtime/rendezvous_mgr_interface.h"
+#include "tensorflow/core/distributed_runtime/server_lib.h"
+#include "tensorflow/core/distributed_runtime/worker_cache.h"
+#include "tensorflow/core/distributed_runtime/worker_env.h"
+#endif  // !IS_MOBILE_PLATFORM
+
+namespace tensorflow {
+
+namespace eager {
+// We need this forward declaration because we have circular dependency:
+// Context -> RemoteMgr -> TensorHandle -> Context.
+// TODO(fishx): Remove this once we remove Context dependency in TensorHandle.
+class RemoteMgr;
+}  // namespace eager
+
+class EagerContext : public ImmediateExecutionContext, public core::RefCounted {
+ public:
+  static constexpr uint64 kInvalidContextId = 0;
+
+  static uint64 NewContextId() {
+    uint64 context_id = random::New64();
+    while (context_id == kInvalidContextId) {
+      context_id = random::New64();
+    }
+    return context_id;
+  }
+
+  EagerContext(
+      const SessionOptions& opts,
+      ContextDevicePlacementPolicy default_device_placement_policy, bool async,
+      /*const*/ DeviceMgr* device_mgr, bool device_mgr_owned,
+      /*const*/ tsl::core::RefCountPtr<Rendezvous> rendezvous,
+      DistributedFunctionLibraryRuntime* cluster_flr = nullptr,
+      CollectiveExecutorMgrInterface* collective_executor_mgr = nullptr,
+      bool run_eager_op_as_function = false, bool jit_compile_rewrite = false);
+
+  void Release() override { Unref(); }
+
+  AbstractTensorInterface* CreateInt64Scalar(int64_t value) override;
+  AbstractTensorInterface* CreateUint64Scalar(uint64 value) override;
+  AbstractTensorInterface* CreateInt32Scalar(int32_t value) override;
+  AbstractTensorInterface* CreateFloatScalar(float value) override;
+  AbstractTensorInterface* CreateDoubleScalar(double value) override;
+  AbstractTensorInterface* CreateHalfScalar(Eigen::half value) override;
+  AbstractTensorInterface* CreateStringScalar(
+      tensorflow::tstring value) override;
+  AbstractTensorInterface* CreateComplex128Scalar(
+      tensorflow::complex128 value) override;
+  AbstractTensorInterface* CreateBoolScalar(bool value) override;
+
+  AbstractTensorInterface* CreateTensor(
+      DataType dtype, absl::Span<const int64_t> dim_sizes) override;
+  AbstractTensorInterface* CreateTensor(DataType dtype, const int64_t* dims,
+                                        int num_dims, void* data, size_t len,
+                                        MemoryReleaser memory_releaser,
+                                        void* memory_releaser_arg) override;
+
+  ImmediateExecutionTensorHandle* CreateLocalHandle(
+      AbstractTensorInterface* t) override;
+  // Create an abstract tensor handle from tensorflow::Tensor.
+  ImmediateExecutionTensorHandle* CreateLocalHandleFromTFTensor(
+      tensorflow::Tensor& t, const char* d_name) override;
+  ImmediateExecutionTensorHandle* CopyTensorHandleToDevice(
+      ImmediateExecutionTensorHandle* handle, const char* device_name,
+      Status* status) override;
+  ImmediateExecutionOperation* CreateOperation() override;
+
+  // This is a virtual helper function to convert TFRT TensorHandle to
+  // tensorflow::TensorHandle. In current runtime EagerContext, just forward
+  // the input since the input tensor handle is already a
+  // tensorflow::TensorHandle.
+  ImmediateExecutionTensorHandle* TFTensorHandleFromInterface(
+      ImmediateExecutionTensorHandle* handle) override;
+
+  Status RegisterFunction(AbstractFunction* f) override;
+
+  bool UsesTFRT() override;
+
+  bool RunEagerOpAsFunction() const;
+
+  void SetRunEagerOpAsFunction(bool enable) override;
+
+  bool JitCompileRewrite() const;
+
+  void SetJitCompileRewrite(bool enable) override;
+
+  void ListDevices(std::vector<DeviceAttributes>* device_attributes) override;
+
+  Status AddDevices(std::vector<std::unique_ptr<Device>> devices) override;
+
+  thread::ThreadPool* GetThreadPool() { return thread_pool_.get(); }
+
+  // Returns the function library runtime for the given device.
+  FunctionLibraryRuntime* func_lib(const Device* d) const {
+    return pflr_->GetFLR(d->name());
+  }
+
+  ProcessFunctionLibraryRuntime* pflr() const { return pflr_.get(); }
+
+  std::function<void(std::function<void()>)>* runner() { return &runner_; }
+
+  // Specify a executor for this thread.
+  void SetExecutorForThread(EagerExecutor* executor) override;
+
+  std::shared_ptr<std::vector<DeviceType>> prioritized_device_type_list()
+      const {
+    mutex_lock l(device_type_list_mu_);
+    return prioritized_device_type_list_;
+  }
+
+  // Clear pending nodes in thread executors and kernel caches.
+  void ClearCachesAndThreadExecutors() override;
+  // Clear pending nodes in default executor and kernel caches.
+  void ClearCachesAndDefaultExecutor();
+
+  // Sets the device placement policy for the current thread.
+  void SetThreadLocalDevicePlacementPolicy(
+      ContextDevicePlacementPolicy policy) override;
+
+  // Returns the device placement policy for the current thread.
+  ContextDevicePlacementPolicy GetDevicePlacementPolicy() const override;
+
+  // Select an appropriate device for an operation.
+  //
+  // Given the preferred device for the operation, and the node_def, finds the
+  // best suitable device for the operation in this context.
+  //
+  // The preferred device is specified as a `ParsedName` containing the elements
+  // (details) that the resulting device should match. If there are no such
+  // devices, and the context currently allows soft device placement, a suitable
+  // device not matching `preferred` will be chosen.
+  //
+  // The chosen device is stored in the `device` argument. The argument is not
+  // modified unless this method returns `OkStatus()`.
+  Status SelectDevice(DeviceNameUtils::ParsedName preferred,
+                      const NodeDef& ndef, Device** out) const;
+
+  // TODO(mdan): Rename to ContainsFunction.
+  bool FindFunctionByName(const string& name) const;
+
+  Status FindFunctionOpData(const string& name,
+                            const tensorflow::OpRegistrationData** op_data);
+
+  const FunctionDef* FindFunctionDef(const string& name) const override;
+  core::RefCountPtr<FunctionRecord> FindRecord(
+      const string& name) const override;
+
+  Device* HostCPU() const { return host_cpu_device_; }
+  Device* CanonicalDevice(Device* d) const {
+    return HostCPU() == d ? nullptr : d;
+  }
+  const DeviceNameUtils::ParsedName& HostCPUParsedName() const override {
+    return HostCPU()->parsed_name();
+  }
+
+  const string& HostCPUName() const override { return HostCPU()->name(); }
+
+  GraphCollector* GetGraphCollector() { return &graph_collector_; }
+
+  EagerExecutor& Executor() override;
+
+  // Add the given `fdef` to the local FunctionLibraryDefinition. And add an
+  // entry to the KernelAndDevice cache for it if it's not exist.
+  Status AddFunctionDef(const FunctionDef& fdef) override;
+
+  Status AddFunctionDefWithStackTraces(
+      const FunctionDef& fdef, const StackTracesMap& stack_traces) override;
+
+  // `library` contains all FunctionDefs and GradientDefs to expand `fdef`. Add
+  // it to the local FunctionLibraryDefinition as well, but no need to add it
+  // to the KernelAndDevice cache since they won't be executed as
+  // KernelAndDevices.
+  Status AddFunctionDef(const FunctionDef& fdef,
+                        const FunctionDefLibrary& library,
+                        bool add_to_local_only = false,
+                        const StackTracesMap& stack_traces = {});
+
+  const FunctionDef* GetFunctionDef(const string& function_name);
+
+  std::vector<string> ListFunctionNames() override;
+  tensorflow::ImmediateExecutionContext::CacheStats GetCacheStats() override;
+
+  Status RemoveFunction(const string& func) override;
+  Status AddRemoveFunctionNotifier(const string& func,
+                                   std::function<void()> notifier) override;
+
+  // Wait for pending nodes to be finished in local executors (including context
+  // default executor and thread executors) and executors on remote workers.
+  // Return combined status of remote executors. If there are multiple errors,
+  // the Status code will be the same as the first remote executor that has
+  // errors, and the error message will be combined from all executors.
+  Status SyncExecutors();
+
+  Status AsyncWait() override { return SyncExecutors(); }
+
+  core::RefCountPtr<KernelAndDevice> GetCachedKernel(Fprint128 cache_key);
+  Device* GetCachedDevice(Fprint128 device_cache_key);
+
+  void AddKernelToCache(Fprint128 cache_key, KernelAndDevice* kernel);
+  void AddDeviceToCache(Fprint128 device_cache_key, Device* device);
+
+  bool LogDevicePlacement() const { return log_device_placement_; }
+  void SetLogDevicePlacement(bool enable) override {
+    log_device_placement_ = enable;
+  }
+
+  bool AllowSoftPlacement() const { return allow_soft_placement_; }
+  void SetAllowSoftPlacement(bool enable) override {
+    allow_soft_placement_ = enable;
+  }
+  bool LogMemory() const { return log_memory_; }
+
+  // Returns a borrowed pointer to the global rendezvous. The rendezvous may
+  // become invalid if this Context is destroyed.
+  Rendezvous* GetRendezvous() const { return rendezvous_.get(); }
+
+  void ResetGlobalRendezvousForFunction() override {
+    mutex_lock l(global_rendezvous_mu_);
+    // Remove the global rendezvous instance from the local rendezvous table
+    // if it uses local rendezvous type, which forces EagerContext to create a
+    // new local rendezvous instance in the table.
+    // TODO(b/274683676) Why can't we abort the old rendezvous here?
+    local_rendezvous_cache_.Remove(-1);
+    TF_CHECK_OK(CreateRendezvousFactory()(-1, nullptr,
+                                          &global_rendezvous_for_functions_));
+  }
+
+  // Returns the global_rendezvous_for_functions' underlying LocalRendezvous'
+  // status. If the underlying Rendezvous is not in the local_rendezvous_cache_
+  // returns OK.
+  Status GetGlobalRendezvousForFunctionLocalRendezvousStatus();
+
+  // Returns a factory which maps from step_id to rendezvous.
+  //
+  // When tensor transfer across functions/eager executions using send/recv ops
+  // are required, `reuse_rendezvous_for_functions` can be set to true so that
+  // function executions and eager executions use the same rendezvous instance,
+  // instead of creating new instance per function calls.
+  //
+  // The caller of the returned function owns a reference to the resulting
+  // Rendezvous.
+  Rendezvous::Factory RendezvousFactory(
+      bool reuse_rendezvous_for_functions = false) {
+    // There is an implicit assumption that the global_rendezvous_for_functions_
+    // is always an IntraProcessRendezvous to match the behaviour of the
+    // EagerContext's rendezvous.
+    // Ref: tensorflow/c/eager/c_api.cc;l=143;rcl=396387348
+    // If a cross process kernel needs a rendezvous a new InterProcessRendezvous
+    // should be created.
+    if (reuse_rendezvous_for_functions && rendezvous_creator_ == nullptr &&
+#if !defined(IS_MOBILE_PLATFORM)
+        worker_env_ == nullptr &&
+#endif
+        remote_device_mgr() == nullptr) {
+      return Rendezvous::Factory{[this](const int64_t step_id,
+                                        const DeviceMgr* device_mgr,
+                                        tsl::core::RefCountPtr<Rendezvous>* r) {
+        mutex_lock l(global_rendezvous_mu_);
+        *r = global_rendezvous_for_functions_.GetNewRef();
+        return OkStatus();
+      }};
+    } else {
+      return CreateRendezvousFactory();
+    }
+  }
+
+  CollectiveExecutorMgrInterface* collective_executor_mgr() {
+    return collective_executor_mgr_.Get();
+  }
+  std::unique_ptr<CollectiveExecutor::Handle> GetCollectiveExecutorHandle() {
+    return std::make_unique<CollectiveExecutor::Handle>(
+
+        collective_executor_mgr()->FindOrCreate(0), true /*inherit_ref*/);
+  }
+
+  void SetCollectiveExecutorMgr(CollectiveExecutorMgrInterface* mgr) {
+    collective_executor_mgr_.Reset(mgr);
+  }
+  tensorflow::DeviceMgr* local_device_mgr() const {
+    return local_device_manager_.Get();
+  }
+  const tensorflow::DynamicDeviceMgr* remote_device_mgr() const {
+    return remote_device_manager_.Get();
+  }
+
+  tensorflow::DynamicDeviceMgr* GetOwnedRemoteDeviceMgr() {
+    return remote_device_manager_.GetOwned();
+  }
+
+  std::vector<Device*> ListLocalTfDevices() override {
+    return local_device_mgr()->ListDevices();
+  }
+
+  std::vector<Device*> ListAllTfDevices() override;
+
+  // TODO(apassos) clean up RunMetadata storage.
+  mutex* MetadataMu() TF_LOCK_RETURNED(metadata_mu_) { return &metadata_mu_; }
+  bool ShouldStoreGraphs() TF_LOCKS_EXCLUDED(metadata_mu_);
+  void SetShouldStoreGraphs(bool value) override;
+  RunMetadata* RunMetadataProto() TF_EXCLUSIVE_LOCKS_REQUIRED(metadata_mu_) {
+    return run_metadata_.get();
+  }
+  std::unique_ptr<RunMetadata> ExportRunMetadata() override
+      TF_LOCKS_EXCLUDED(metadata_mu_);
+
+  void StartStep() override;
+  void EndStep() override;
+  ScopedStepContainer* StepContainer();
+
+  FunctionLibraryDefinition* FuncLibDef() override { return &func_lib_def_; }
+
+#if !defined(IS_MOBILE_PLATFORM)
+  // Assign the EagerClient pointer to `client` based on the given device / task
+  // name, and increment the refcount of the client. The reference ownership is
+  // transferred to the caller, and the unref should automatically happen when
+  // destructing the RefCountPtr object at the caller's side.
+  // `client` must not be initialized or holding a reference of another object
+  // before calling this method.
+  Status GetClient(Device* device,
+                   core::RefCountPtr<eager::EagerClient>* client);
+  Status GetClient(const DeviceNameUtils::ParsedName& device_name,
+                   core::RefCountPtr<eager::EagerClient>* client);
+  Status GetClient(const string& remote_task,
+                   core::RefCountPtr<eager::EagerClient>* client);
+
+  uint64 GetContextId() const;
+  uint64 GetContextViewId() const;
+  void IncrementContextViewId();
+
+  Status EnableCollectiveOps(const ServerDef& server_def) override;
+
+  // TODO(nareshmodi): Encapsulate remote state into a separate
+  // class/struct.
+  //
+  // Enables the eager context to communicate with remote devices. When
+  // initializing with this method, this context will be the primary context,
+  // which will kill all its remote contexts in shutdown.
+  //
+  // - server: A ServerInterface that exports the tensorflow.WorkerService.
+  // Note that this class expects the server to already have been started.
+  // - remote_eager_workers: A cache from which we can get "EagerClient"s to
+  // communicate with remote eager services.
+  // - remote_device_mgr: A DeviceMgr* which contains all remote devices
+  // (should contain no local devices).
+  // - remote_contexts: A vector containing task names.
+  // TODO(b/184375824): clean up parameter order for better readability.
+  Status InitializeRemoteMaster(
+      std::unique_ptr<ServerInterface> server, WorkerEnv* worker_env,
+      std::shared_ptr<WorkerSession> worker_session,
+      std::unique_ptr<eager::EagerClientCache> remote_eager_workers,
+      std::unique_ptr<DynamicDeviceMgr> remote_device_manager,
+      const std::vector<string>& remote_contexts, uint64 context_id,
+      tsl::core::RefCountPtr<Rendezvous> r,
+      /*const*/ DeviceMgr* local_device_mgr, int keep_alive_secs,
+      DistributedFunctionLibraryRuntime* cluster_flr,
+      std::unique_ptr<eager::RemoteMgr, std::function<void(eager::RemoteMgr*)>>
+          remote_mgr);
+
+  // Update an existing master context with a new set of remote workers (i.e., a
+  // new "view" of cluster membership. Similar to InitializeRemoteMaster but
+  // this will keep the current context_id and increment a context_view_id, will
+  // keep the current resource manager so that resources from the previous view
+  // can still be accessed, and will automatically register existing functions
+  // if there are newly added hosts.
+  Status UpdateRemoteMaster(
+      uint64 context_id,
+      std::unique_ptr<eager::EagerClientCache> remote_eager_workers,
+      const std::vector<string>& add_remote_contexts,
+      const std::vector<string>& remove_remote_contexts);
+
+  // Similar with InitializeRemoteMaster but this context will not kill remote
+  // contexts in shutdown.
+  Status InitializeRemoteWorker(
+      std::unique_ptr<eager::EagerClientCache> remote_eager_workers,
+      DynamicDeviceMgr* remote_device_mgr,
+      const std::vector<string>& remote_contexts, uint64 context_id,
+      uint64 context_view_id,
+      std::function<tsl::core::RefCountPtr<Rendezvous>(const int64_t)>
+          rendezvous_creator,
+      DistributedFunctionLibraryRuntime* cluster_flr,
+      std::unique_ptr<eager::RemoteMgr, std::function<void(eager::RemoteMgr*)>>
+          remote_mgr,
+      std::function<void()> resource_deallocator);
+
+  // Similar with InitializeRemoteWorker but will reuse existing context and
+  // increment context_view_id.
+  Status UpdateRemoteWorker(
+      std::unique_ptr<eager::EagerClientCache> remote_eager_workers,
+      const std::vector<string>& remote_contexts, uint64 context_id);
+
+  Status StoreCollectiveOpsServer(
+      std::unique_ptr<ServerInterface> new_server, DeviceMgr* device_mgr,
+      CollectiveExecutorMgrInterface* rpc_collective_executor_mgr);
+
+  // For the specified remote worker, preprocess and set its device filters.
+  Status SetRemoteDeviceFilters(const string& remote_worker,
+                                const std::vector<string>& device_filters);
+
+  // For the specified remote worker, apply the stored device filters to the
+  // list of device attributes following these rules:
+  // (1) if the remote worker does not have device filters, all devices are
+  //     visible to the worker;
+  // (2) if the device is on the remote worker, then it is visible;
+  // (3) if the device matches at least one device filter, then it is visible.
+  // The result is saved as a boolean vector of the same length (i.e.,
+  // filtered_device_mask) indicating whether each of the devices is visible to
+  // the remote worker.
+  void FilterDevicesForRemoteWorkers(
+      const string& remote_worker,
+      const protobuf::RepeatedPtrField<DeviceAttributes>& device_attrs,
+      std::vector<bool>* filtered_device_mask);
+
+  // TODO(fishx): Remove the custom deleter once we remove forward declaration.
+  const std::unique_ptr<eager::RemoteMgr,
+                        std::function<void(eager::RemoteMgr*)>>&
+  RemoteMgr() {
+    return remote_mgr_;
+  }
+
+  // If true, then tensors should be shipped across processes via the
+  // EagerService.Enqueue(SendTensorOp). If false, _Send/_Recv ops should be
+  // used instead (which in-turn use WorkerService.RecvTensor RPCs).
+  bool UseSendTensorRPC() { return use_send_tensor_rpc_; }
+
+  tensorflow::ServerInterface* GetServer() { return server_.get(); }
+
+  // For LLVM style RTTI.
+  static bool classof(const AbstractContext* ptr) {
+    return ptr->getKind() == kEager;
+  }
+
+  // Function to support distributed C API.
+  void SetDistributedManager(
+      std::unique_ptr<ImmediateExecutionDistributedManager> distributed)
+      override {
+    distributed_manager_ = std::move(distributed);
+  }
+  ImmediateExecutionDistributedManager* GetDistributedManager() override {
+    return distributed_manager_.get();
+  }
+
+  // May only be used during multi-client setup so that a RemoteRendezvous
+  // can be initialized instead of defaulting to the IntraProcessRendezvous.
+  void SetWorkerEnv(WorkerEnv* worker_env,
+                    std::shared_ptr<WorkerSession> worker_session);
+#endif  // IS_MOBILE_PLATFORM
+
+  // Closes remote eager contexts, waits for all RPCs to finish, and
+  // destroys the EagerClientCache. No RPCs can be made through this context
+  // after this method has been called.
+  // This method exists to aid a clean shutdown. It causes all RPCs to finish
+  // and remote TensorHandles to release their references to this context.
+  // To avoid deadlocks, this method must not be called on the thread
+  // processing RPCs because it makes RPCs and waits for their completion.
+  //
+  // On mobile, it just cleans the caches.
+  void WaitForAndCloseRemoteContexts();
+
+  bool PinSmallOpsToCPU() const { return pin_small_ops_to_cpu_; }
+
+  tensorflow::Env* TFEnv() const { return env_; }
+
+  Status FindDeviceFromName(const char* device_name, Device** device) const;
+
+  Status FindCompositeDeviceFromName(StringPiece device_name,
+                                     CompositeDevice** device) const;
+
+  bool IsCustomDevice(const string& device_name) override;
+
+  Status RegisterCustomDevice(const string& name,
+                              std::unique_ptr<CustomDevice> device) override;
+
+  CustomDeviceOpHandler& GetCustomDeviceOpHandler() override {
+    return custom_device_op_handler_;
+  };
+
+  // Find or create a composite device with the given `underlying_devices` and
+  // `device_name` (if not empty).
+  Status FindOrCreateCompositeDevice(
+      const std::vector<string>& underlying_devices, const string& device_name,
+      CompositeDevice** composite_device);
+
+  bool OnSameTask(const Device* first, const Device* second) const;
+  // Gets the CPU device on the task of device.
+  Status CPUDeviceOnTask(const Device* device, Device** cpu_device) const;
+
+  const SessionOptions& session_options() const { return opts_; }
+  void InitPrioritizedDeviceTypeList();
+
+  // Re-assign cluster-FLR and re-initialize devices and FLR in process-FLR
+  void UpdateClusterFLRAndInitDevices(
+      DistributedFunctionLibraryRuntime* cluster_flr);
+
+  // A constant representing the step id used for the global rendezvous.
+  // This is used to distibguish whether a user-specified step id should be set.
+  // Step id value of kGlobalRendezvous is reserved and should not be specified
+  // by the user.
+  static const int64_t kGlobalRendezvousId;
+
+ private:
+  // The class for caching Rendezvous instances per step_id.
+  // If the Rendezvous object is destroyed for the step, a new one will be
+  // created on demand.
+  class LocalRendezvousCache {
+   public:
+    LocalRendezvousCache()
+        : cache_(new RendezvousCache<IntraProcessRendezvous>) {}
+
+    tsl::core::RefCountPtr<IntraProcessRendezvous> FindOrCreate(
+        int64_t step_id, DeviceMgr* device_mgr);
+
+    tsl::core::RefCountPtr<IntraProcessRendezvous> Find(int64_t step_id) const {
+      return cache_->Find(step_id);
+    }
+
+    std::vector<int64_t> GetActiveStepIds() const {
+      return cache_->GetActiveStepIds();
+    }
+
+    void Remove(int64_t step_id) { cache_->Remove(step_id); }
+
+   private:
+    tsl::core::RefCountPtr<RendezvousCache<IntraProcessRendezvous>> cache_;
+  };
+
+  Rendezvous::Factory CreateRendezvousFactory() {
+    if (rendezvous_creator_ != nullptr) {
+      return Rendezvous::Factory{[this](const int64_t step_id,
+                                        const DeviceMgr* device_mgr,
+                                        tsl::core::RefCountPtr<Rendezvous>* r) {
+        VLOG(6) << "Creating rendezvous using the rendezvous_creator_.";
+        *r = rendezvous_creator_(step_id);
+        return OkStatus();
+      }};
+    }
+
+#if !defined(IS_MOBILE_PLATFORM)
+    if (worker_env_ != nullptr && worker_env_->rendezvous_mgr != nullptr) {
+      return Rendezvous::Factory{[this](const int64_t step_id,
+                                        const DeviceMgr* device_mgr,
+                                        tsl::core::RefCountPtr<Rendezvous>* r) {
+        VLOG(6) << "Creating rendezvous using the worker_env's rendezvous_mgr.";
+        // TODO(hhb): Add a Create method and use it here.
+        auto remote_r = worker_env_->rendezvous_mgr->Find(step_id);
+        remote_r->Initialize(worker_session_.get()).IgnoreError();
+        *r = std::move(remote_r);
+        return OkStatus();
+      }};
+    }
+#endif
+
+    if (remote_device_mgr() == nullptr) {
+      return Rendezvous::Factory{[this](const int64_t step_id,
+                                        const DeviceMgr* device_mgr,
+                                        tsl::core::RefCountPtr<Rendezvous>* r) {
+        VLOG(6) << "Creating rendezvous using local_device_mgr.";
+        *r = local_rendezvous_cache_.FindOrCreate(step_id, local_device_mgr());
+        return OkStatus();
+      }};
+    }
+
+    return Rendezvous::Factory();
+  }
+
+  ~EagerContext() override;
+
+  Status MaybeRegisterFunctionRemotely(const FunctionDef& fdef);
+  Status MaybeRemoveFunctionRemotely(const string& function_name);
+  Status RegisterExistingFunctionsOnRemoteWorkers(
+      const std::vector<string>& remote_workers);
+
+  void ResetPFLR(const DeviceMgr* device_mgr, Env* env,
+                 const ConfigProto* config, int graph_def_version,
+                 const FunctionLibraryDefinition* lib_def,
+                 const OptimizerOptions& optimizer_options,
+                 thread::ThreadPool* thread_pool = nullptr,
+                 DistributedFunctionLibraryRuntime* cluster_flr = nullptr);
+
+  void ResetClusterFLR(DistributedFunctionLibraryRuntime* cluster_flr);
+  void UpdateGlobalRendezvousDeviceManager(tensorflow::DeviceMgr* device_mgr);
+
+  void ClearResourceContainer(const string& name);
+
+  template <typename T>
+  struct OwnedOrUnownedHelper {
+   public:
+    OwnedOrUnownedHelper() = default;
+    explicit OwnedOrUnownedHelper(T* object, const bool owned = false) {
+      Reset(object, owned);
+    }
+
+    void Reset(std::unique_ptr<T> object) {
+      owned_object = std::move(object);
+      unowned_object_ptr = nullptr;
+    }
+
+    void Reset(T* object, const bool owned = false) {
+      if (owned) {
+        owned_object.reset(object);
+        unowned_object_ptr = nullptr;
+      } else {
+        owned_object.reset(nullptr);
+        unowned_object_ptr = object;
+      }
+    }
+
+    bool Owned() const { return owned_object != nullptr; }
+
+    T* GetOwned() const { return owned_object.get(); }
+    T* Get() const {
+      return owned_object ? owned_object.get() : unowned_object_ptr;
+    }
+
+    std::unique_ptr<T> owned_object = nullptr;
+    T* unowned_object_ptr = nullptr;
+  };
+
+  SessionOptions opts_;
+  const ContextDevicePlacementPolicy default_device_placement_policy_;
+
+  // Note: we cannot use C++11 thread_local here as there is no concept of a
+  // thread-local-object-local variable in C++11.
+  mutable mutex policy_map_mu_;
+  std::unordered_map<std::thread::id, ContextDevicePlacementPolicy>
+      device_placement_policy_ TF_GUARDED_BY(policy_map_mu_);
+
+  // This device manager maintains only the local devices on this worker.
+  OwnedOrUnownedHelper<DeviceMgr> local_device_manager_;
+  // Maintain copy of all previously created local device managers.
+  std::vector<std::unique_ptr<DeviceMgr>> old_local_device_managers_;
+
+  // Unowned DynamicDeviceMgr is set on remote worker to allow running
+  // multi-device function on remote worker.
+  // This device manager maintains all the devices (including both local and
+  // remote to this worker) in the cluster.
+  OwnedOrUnownedHelper<DynamicDeviceMgr> remote_device_manager_;
+
+  Device* host_cpu_device_;  // Owned by device_manager
+  mutable mutex device_type_list_mu_;
+  std::shared_ptr<std::vector<DeviceType>> prioritized_device_type_list_
+      TF_GUARDED_BY(device_type_list_mu_);
+  tsl::core::RefCountPtr<Rendezvous> rendezvous_;
+  std::function<tsl::core::RefCountPtr<Rendezvous>(const int64_t)>
+      rendezvous_creator_;
+  CustomDeviceOpHandler custom_device_op_handler_;
+
+  mutable mutex composite_devices_mu_;
+  // Maps from the fingerprint of a set of device names to a virtual
+  // CompositeDevice.
+  // TODO(b/145922293): Consider taking device names as keys.
+  absl::flat_hash_map<uint64, std::unique_ptr<CompositeDevice>>
+      composite_devices_ ABSL_GUARDED_BY(composite_devices_mu_);
+
+  FunctionLibraryDefinition func_lib_def_{OpRegistry::Global(), {}};
+
+  std::unique_ptr<thread::ThreadPool> thread_pool_;
+
+  // EagerContext owns the DistributedFunctionLibraryRuntime(
+  // EagerClusterFunctionLibraryRuntime) if using EagerService for remote
+  // function execution (lazy_copy_function_remote_inputs_=true).
+  OwnedOrUnownedHelper<DistributedFunctionLibraryRuntime> cluster_flr_;
+  // One FunctionLibraryRuntime per device.
+  // func_libs[i] is the FunctionLibraryRuntime corresponding to
+  // session->devices[i].
+  std::unique_ptr<ProcessFunctionLibraryRuntime> pflr_;
+
+  std::function<void(std::function<void()>)> runner_;
+
+  mutex cache_mu_;
+  mutex device_cache_mu_;
+  mutex remove_function_notifiers_mu_;
+  struct RegisteredFunction : public core::RefCounted {
+    ~RegisteredFunction() override = default;
+
+    std::unique_ptr<std::vector<Fprint128>> cached_kernel_keys;
+  };
+  std::unordered_map<Fprint128, core::RefCountPtr<KernelAndDevice>,
+                     Fprint128Hasher>
+      kernel_cache_ TF_GUARDED_BY(cache_mu_);
+  std::unordered_map<string, RegisteredFunction*> registered_functions_
+      TF_GUARDED_BY(cache_mu_);
+  absl::flat_hash_map<Fprint128, Device*, Fprint128Hasher> device_cache_
+      TF_GUARDED_BY(device_cache_mu_);
+  std::unordered_map<std::string, std::vector<std::function<void()>>>
+      remove_function_notifiers_ TF_GUARDED_BY(remove_function_notifiers_mu_);
+
+  // Whether we should compute RunMetadata.
+  std::atomic<bool> should_store_graphs_{false};
+  mutex metadata_mu_;
+  std::unique_ptr<RunMetadata> run_metadata_ TF_GUARDED_BY(metadata_mu_);
+  GraphCollector graph_collector_;
+  std::atomic<bool> log_device_placement_;
+  std::atomic<bool> allow_soft_placement_;
+
+  // Information related to step containers.
+  std::atomic<int> num_active_steps_;
+  std::unique_ptr<ScopedStepContainer> step_container_
+      TF_GUARDED_BY(metadata_mu_);
+
+  EagerExecutor default_executor_;
+  mutable mutex executor_map_mu_;
+  // Not owned.
+  std::unordered_map<std::thread::id, EagerExecutor*> thread_local_executor_
+      TF_GUARDED_BY(executor_map_mu_);
+  std::unordered_map<std::thread::id, absl::flat_hash_set<EagerExecutor*>>
+      has_cleanup_ TF_GUARDED_BY(executor_map_mu_);
+
+  const bool log_memory_;
+
+  // The table of local rendezvous instances for intra-process communication.
+  // This make sures only one local rendezvous instance exists per step id.
+  LocalRendezvousCache local_rendezvous_cache_;
+
+  // Whether to use same rendezvous instance across function/eager executions.
+  std::atomic<bool> reuse_rendezvous_for_functions_{false};
+  mutable mutex global_rendezvous_mu_;
+
+  // Keeps alive the global rendezvous object.
+  core::RefCountPtr<Rendezvous> global_rendezvous_for_functions_
+      TF_GUARDED_BY(global_rendezvous_mu_);
+
+  Env* const env_;
+
+  OwnedOrUnownedHelper<CollectiveExecutorMgrInterface> collective_executor_mgr_;
+
+#if !defined(IS_MOBILE_PLATFORM)
+  std::vector<string> GetRemoteContexts() TF_LOCKS_EXCLUDED(remote_state_mu_);
+  bool IsRemoteContextsEmpty() TF_LOCKS_EXCLUDED(remote_state_mu_);
+  void CloseAndClearAllRemoteContexts();
+  void CloseRemoteContexts(const std::vector<string>& remote_contexts,
+                           uint64 context_id, uint64 context_view_id);
+
+  // TODO(b/184375824): clean up parameter order for better readability.
+  Status SetMasterContextState(
+      std::unique_ptr<ServerInterface> server, WorkerEnv* worker_env,
+      std::shared_ptr<WorkerSession> worker_session,
+      std::unique_ptr<eager::EagerClientCache> remote_eager_workers,
+      std::unique_ptr<DynamicDeviceMgr> remote_device_manager,
+      uint64 context_id, uint64 context_view_id,
+      tsl::core::RefCountPtr<Rendezvous> r,
+      /*const*/ DeviceMgr* local_device_mgr, int keep_alive_secs,
+      DistributedFunctionLibraryRuntime* cluster_flr,
+      std::unique_ptr<eager::RemoteMgr, std::function<void(eager::RemoteMgr*)>>
+          remote_mgr);
+
+  // The server_ is not const since we release it when the context is destroyed.
+  // Therefore the server_ object is not marked as const (even though it should
+  // be).
+  std::unique_ptr<ServerInterface> server_;
+  WorkerEnv* worker_env_ = nullptr;
+  std::shared_ptr<WorkerSession> worker_session_;
+
+  mutable mutex remote_state_mu_;
+
+  uint64 context_id_ TF_GUARDED_BY(remote_state_mu_);
+  // The view id of an eager context should be set to 0 when context is created,
+  // and continuously incremented when context with the same context_id gets
+  // updated. The view id should be consistent between master and workers.
+  uint64 context_view_id_ TF_GUARDED_BY(remote_state_mu_);
+  std::vector<string> remote_contexts_ TF_GUARDED_BY(remote_state_mu_);
+  std::unique_ptr<eager::EagerClientCache> remote_eager_workers_
+      TF_GUARDED_BY(remote_state_mu_);
+
+  int keep_alive_secs_ TF_GUARDED_BY(remote_state_mu_);
+  std::atomic<int> sleep_for_secs_;
+
+  std::unique_ptr<Thread> keep_alive_thread_;
+  mutex keep_alive_thread_shutdown_mu_;
+  condition_variable keep_alive_thread_cv_;
+  bool shutting_down_ TF_GUARDED_BY(keep_alive_thread_shutdown_mu_) = false;
+
+  std::unique_ptr<eager::RemoteMgr, std::function<void(eager::RemoteMgr*)>>
+      remote_mgr_;
+  bool is_master_ TF_GUARDED_BY(remote_state_mu_);
+
+  // Maps from a remote worker to a list of parsed device filters.
+  std::unordered_map<string, std::vector<DeviceNameUtils::ParsedName>>
+      cluster_device_filters_ TF_GUARDED_BY(remote_state_mu_);
+
+  // A distributed manager that helps setup, update, and check liveness of
+  // member tasks in the cluster.
+  std::unique_ptr<ImmediateExecutionDistributedManager> distributed_manager_;
+
+#endif  // IS_MOBILE_PLATFORM
+
+  // For a multi device function, the target device of each input is unknown
+  // until the function is instantiated on the default function device.
+  // If false, eagerly copy all remote inputs to the default function device;
+  // if true, lazily copy remote inputs to their target devices to avoid
+  // redundant copies.
+  bool lazy_copy_function_remote_inputs_ = false;
+  bool use_send_tensor_rpc_;
+  const bool pin_small_ops_to_cpu_;
+
+  // Function that will be invoked in destructor to deallocate resources related
+  // to this context.
+  std::function<void()> resource_deallocator_ = nullptr;
+  bool run_eager_op_as_function_;
+  bool jit_compile_rewrite_;
+};
+
+inline EagerContext* ContextFromInterface(ImmediateExecutionContext* context) {
+  return down_cast<EagerContext*>(context);
+}
+
+namespace internal {
+struct EagerContextDeleter {
+  void operator()(EagerContext* p) const {
+    if (p != nullptr) {
+      p->Release();
+    }
+  }
+};
+}  // namespace internal
+
+using EagerContextPtr =
+    std::unique_ptr<EagerContext, internal::EagerContextDeleter>;
+
+// Sets the EagerContext owned by the current Python eager Context (see
+// TFE_Py_SetEagerContext in python/eager/pywrap_tfe.h). This is always called
+// in tandem with TFE_Py_SetEagerContext (but not called by it, because its
+// py_context argument is opaque).
+//
+// Do not use this function in production. It is only intended for testing.
+// (see _reset_context in context.py).
+//
+// Not thread-safe.
+void SetCEagerContext(EagerContext* ctx);
+
+// Returns the EagerContext owned by the current Python eager Context (see
+// TFE_Py_SetEagerContext in pywrap_tfe.h).
+//
+// Not thread-safe.
+EagerContext* GetCEagerContext();
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_EAGER_CONTEXT_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/eager/context_distributed_manager.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/eager/context_distributed_manager.h
new file mode 100644
index 0000000000000000000000000000000000000000..b6344827f44ba4665d14ef21f4135e8c38b5c05d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/eager/context_distributed_manager.h
@@ -0,0 +1,79 @@
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_EAGER_CONTEXT_DISTRIBUTED_MANAGER_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_EAGER_CONTEXT_DISTRIBUTED_MANAGER_H_
+
+#include <memory>
+#include <string>
+#include <utility>
+
+#include "tensorflow/c/eager/immediate_execution_context.h"
+#include "tensorflow/c/eager/immediate_execution_distributed_manager.h"
+#include "tensorflow/core/common_runtime/eager/context.h"
+#include "tensorflow/core/platform/status.h"
+
+#if !defined(IS_MOBILE_PLATFORM)
+#include "tsl/distributed_runtime/coordination/coordination_service_agent.h"
+#include "tsl/distributed_runtime/preemption/preemption_notifier.h"
+#endif  // !IS_MOBILE_PLATFORM
+
+namespace tensorflow {
+#if !defined(IS_MOBILE_PLATFORM)
+class EagerContext;
+class ServerDef;
+
+class EagerContextDistributedManager
+    : public ImmediateExecutionDistributedManager {
+ public:
+  explicit EagerContextDistributedManager(EagerContext* context)
+      : context_(context) {}
+
+  // When running in a distributed context, `init_timeout_in_ms` requests the
+  // amount of time to wait for remote workers to respond.
+
+  Status SetOrUpdateServerDef(const ServerDef& server_def, bool reset_context,
+                              int keep_alive_secs, int64_t init_timeout_in_ms,
+                              int retries) override;
+
+  Status InitializeLocalOnlyContext(const ServerDef& server_def,
+                                    int keep_alive_secs) override;
+
+  Status EnableCollectiveOps(const ServerDef& server_def) override;
+
+  Status CheckRemoteAlive(const std::string& remote_task_name,
+                          bool* is_alive) override;
+
+  tsl::CoordinationServiceAgent* GetCoordinationServiceAgent() override {
+    return coordination_service_agent_;
+  }
+  void SetCoordinationServiceAgent(tsl::CoordinationServiceAgent* agent) {
+    coordination_service_agent_ = agent;
+  }
+  void SetPreemptionNotifier(
+      std::unique_ptr<tsl::PreemptionNotifier> notifier) {
+    preemption_notifier_ = std::move(notifier);
+  }
+
+ private:
+  EagerContext* context_;
+  // Owned by context_->GetServer()->worker_env()->session_mgr.
+  tsl::CoordinationServiceAgent* coordination_service_agent_ = nullptr;
+  std::unique_ptr<tsl::PreemptionNotifier> preemption_notifier_;
+};
+#endif  // !IS_MOBILE_PLATFORM
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_EAGER_CONTEXT_DISTRIBUTED_MANAGER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/eager/copy_to_device_node.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/eager/copy_to_device_node.h
new file mode 100644
index 0000000000000000000000000000000000000000..6cbc7b87dd41d1abcd0397d198f1094d510c4672
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/eager/copy_to_device_node.h
@@ -0,0 +1,95 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_EAGER_COPY_TO_DEVICE_NODE_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_EAGER_COPY_TO_DEVICE_NODE_H_
+
+#include <utility>
+
+#include "tensorflow/core/common_runtime/device.h"
+#include "tensorflow/core/common_runtime/eager/eager_executor.h"
+#include "tensorflow/core/common_runtime/eager/tensor_handle.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/profiler/lib/scoped_memory_debug_annotation.h"
+
+namespace tensorflow {
+
+class CopyToDeviceNode : public EagerNode {
+ public:
+  CopyToDeviceNode(TensorHandle* src, TensorHandle* dst, Device* dstd,
+                   const EagerContext& ctx, bool async, bool mirror)
+      : EagerNode(),
+        src_(src),
+        dst_(dst),
+        dstd_(dstd),
+        ctx_(ctx),
+        async_(async),
+        mirror_(mirror) {
+    if (async_) {
+      src_->Ref();
+      dst_->Ref();
+    }
+  }
+
+  ~CopyToDeviceNode() override {
+    if (async_) {
+      src_->Unref();
+      dst_->Unref();
+    }
+  }
+
+  Status Run() override {
+    tensorflow::Tensor tensor;
+    profiler::ScopedMemoryDebugAnnotation op_annotation(
+        "eager::CopyToDeviceNode", "dynamic", tensor.dtype(),
+        [&tensor]() { return tensor.shape().DebugString(); });
+    TF_RETURN_IF_ERROR(src_->CopyToDevice(ctx_, dstd_, &tensor));
+    if (!async_ && mirror_) {
+      Status s = dst_->AddLocalMirror(std::move(tensor), dstd_);
+      // If a mirror was added since we called HasLocalMirror then just return
+      // and ignore the error.
+      if (s.ok() || (s.code() == error::Code::ALREADY_EXISTS)) {
+        return OkStatus();
+      }
+      return s;
+    } else {
+      return dst_->SetTensor(std::move(tensor), dstd_);
+    }
+  }
+
+  void Abort(Status status) override { dst_->Poison(status, dstd_); }
+
+  string DebugString() const override {
+    string out = "[CopyToDeviceNode]";
+    strings::StrAppend(&out, " src_tensor: ", src_->DebugString());
+    strings::StrAppend(&out, ", dst_tensor: ", dst_->DebugString());
+    strings::StrAppend(&out, ", dst_device: ", dstd_ ? dstd_->name() : "[]");
+    return out;
+  }
+
+  TensorHandle* dst() { return dst_; }
+
+ private:
+  TensorHandle* src_;
+  TensorHandle* dst_;
+  Device* dstd_;
+  const EagerContext& ctx_;
+  bool async_;
+  bool mirror_;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_EAGER_COPY_TO_DEVICE_NODE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/eager/custom_device.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/eager/custom_device.h
new file mode 100644
index 0000000000000000000000000000000000000000..ed8716fb4b298a9005deec5a92403e37765de55a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/eager/custom_device.h
@@ -0,0 +1,134 @@
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_EAGER_CUSTOM_DEVICE_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_EAGER_CUSTOM_DEVICE_H_
+
+#include <optional>
+#include <string>
+#include <variant>
+
+#include "tensorflow/c/eager/immediate_execution_context.h"
+#include "tensorflow/c/eager/immediate_execution_operation.h"
+#include "tensorflow/c/eager/immediate_execution_tensor_handle.h"
+#include "tensorflow/core/framework/full_type.pb.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/util/device_name_utils.h"
+
+namespace tensorflow {
+
+class TensorHandle;
+class EagerOperation;
+class CustomDeviceTensorHandle;
+
+// Custom devices intercept the execution of operations (the `Execute` method),
+// typically implemented with one or more of the custom device's own executions.
+class CustomDevice {
+ public:
+  virtual ~CustomDevice() = default;
+  virtual const string& name() = 0;
+  virtual Status CopyTensorToDevice(
+      ImmediateExecutionTensorHandle* tensor,
+      ImmediateExecutionTensorHandle** result) = 0;
+
+  virtual Status CopyTensorFromDevice(
+      ImmediateExecutionTensorHandle* tensor, const string& target_device_name,
+      ImmediateExecutionTensorHandle** result) = 0;
+
+  virtual Status Execute(const ImmediateExecutionOperation* op,
+                         ImmediateExecutionTensorHandle** retvals,
+                         int* num_retvals) = 0;
+
+  // Creates a packed TensorHandle from a group of custom device TensorHandles,
+  // one of which is on this custom device.
+  virtual Status Pack(absl::Span<ImmediateExecutionTensorHandle*> handles,
+                      ImmediateExecutionTensorHandle** result) = 0;
+
+  // Returns true signifying to pin to the current custom device.
+  // Returns false to pin to the physical device.
+  virtual StatusOr<bool> ShallPinToThisDevice(
+      const ImmediateExecutionOperation* op) = 0;
+};
+
+// Custom devices do many of the same things as physical Devices, but have a
+// much more restricted interface. We pass around ambiguous pointers since
+// operations may be placed either on custom or physical devices.
+using VariantDevice = std::variant<Device*, CustomDevice*>;
+
+// Indicates either HostCPU or an unset physical device. We never set a null
+// CustomDevice*.
+const VariantDevice kVariantDeviceNull = static_cast<Device*>(nullptr);
+
+// A tensor handle produced by a custom device. Generally they can only be
+// consumed by executing an operation on the same custom device that produced it
+// originally, or by attempting to copy the handle off the custom device.
+//
+// TODO(allenl): Currently custom devices are tied to the eager C API. They
+// should be renamed op handlers and subclass AbstractTensorHandle instead so
+// they are eager/graph agnostic.
+//
+// full_type_ is not set by the constructor (because it is not currently
+// needed). If full type information is needed in the future, the constructor
+// could use map_dtype_to_child_of_tensor() from core/framework/types.h to set
+// it based on dtype. Update test CustomDevice.TestTensorHandle in
+// custom_device_test.cc if this changes.
+class CustomDeviceTensorHandle : public ImmediateExecutionTensorHandle {
+ public:
+  CustomDeviceTensorHandle(ImmediateExecutionContext* context,
+                           CustomDevice* device, tensorflow::DataType dtype)
+      : ImmediateExecutionTensorHandle(kCustomDevice),
+        context_(context),
+        device_(device),
+        dtype_(dtype) {}
+
+  // TODO(allenl): Should this be a generic method of
+  // ImmediateExecutionTensorHandle to support TFE_TensorHandleDevicePointer?
+  virtual void* DevicePointer() const = 0;
+
+  tensorflow::DataType DataType() const override { return dtype_; }
+  tensorflow::FullTypeDef FullType() const override { return full_type_; }
+  Status Shape(PartialTensorShape* shape) const override;
+  Status NumElements(int64_t* num_elements) const override;
+
+  const char* DeviceName(Status* status) const override {
+    return device_->name().c_str();
+  }
+  const char* BackingDeviceName(Status* status) const override {
+    return device_->name().c_str();
+  }
+  CustomDevice* device() const { return device_; }
+  const char* DeviceType(Status* status) const override;
+  int DeviceId(Status* status) const override;
+
+  AbstractTensorInterface* Resolve(Status* status) override;
+
+  // For LLVM style RTTI.
+  static bool classof(const AbstractTensorHandle* ptr) {
+    return ptr->getKind() == kCustomDevice;
+  }
+
+ protected:
+  const DeviceNameUtils::ParsedName* ParsedName(Status* status) const;
+
+  ImmediateExecutionContext* const context_;
+  CustomDevice* const device_;
+  const tensorflow::DataType dtype_;
+  tensorflow::FullTypeDef full_type_;
+
+  mutable std::optional<DeviceNameUtils::ParsedName> parsed_name_;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_EAGER_CUSTOM_DEVICE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/eager/custom_device_op_handler.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/eager/custom_device_op_handler.h
new file mode 100644
index 0000000000000000000000000000000000000000..2f60726566f4411c3758df0741538a0e9fa75f1c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/eager/custom_device_op_handler.h
@@ -0,0 +1,59 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_EAGER_CUSTOM_DEVICE_OP_HANDLER_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_EAGER_CUSTOM_DEVICE_OP_HANDLER_H_
+
+#include <memory>
+#include <unordered_map>
+
+#include "tensorflow/c/eager/immediate_execution_operation.h"
+#include "tensorflow/c/eager/immediate_execution_tensor_handle.h"
+#include "tensorflow/core/common_runtime/eager/custom_device.h"
+#include "tensorflow/core/lib/core/status.h"
+namespace tensorflow {
+
+// TODO(tfrt-devs): Figure out a way to unify it with OpHandler in TFRT.
+class CustomDeviceOpHandler {
+ public:
+  ~CustomDeviceOpHandler() = default;
+  // Register a new custom device.
+  Status RegisterCustomDevice(const string& device_name,
+                              std::unique_ptr<CustomDevice> device);
+
+  // Find the custom device from given name. Return true if it finds one.
+  bool FindCustomDeviceFromName(const string& name,
+                                CustomDevice** device) const;
+
+  Status Execute(ImmediateExecutionOperation* op,
+                 ImmediateExecutionTensorHandle** retvals, int* num_retvals);
+
+  ImmediateExecutionTensorHandle* CopyTensorHandleToDevice(
+      ImmediateExecutionContext* context,
+      ImmediateExecutionTensorHandle* handle, const char* device_name,
+      Status* status);
+
+  // Determine whether to place an op on a custom device. This method is
+  // exposed as public for test only.
+  Status MaybePinToCustomDevice(CustomDevice** device,
+                                const ImmediateExecutionOperation& op) const;
+
+  void Clear();
+
+ private:
+  std::unordered_map<string, std::unique_ptr<CustomDevice>> custom_devices_;
+};
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_EAGER_CUSTOM_DEVICE_OP_HANDLER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/eager/eager_executor.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/eager/eager_executor.h
new file mode 100644
index 0000000000000000000000000000000000000000..63e9dedc4fa8eca676b931e2497f0170255b9340
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/eager/eager_executor.h
@@ -0,0 +1,290 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_EAGER_EAGER_EXECUTOR_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_EAGER_EAGER_EXECUTOR_H_
+
+#include <algorithm>
+#include <atomic>
+#include <cstddef>
+#include <functional>
+#include <map>
+#include <memory>
+#include <queue>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include "absl/container/flat_hash_map.h"
+#include "tensorflow/core/common_runtime/device_factory.h"
+#include "tensorflow/core/common_runtime/function.h"
+#include "tensorflow/core/common_runtime/rendezvous_mgr.h"
+#include "tensorflow/core/framework/rendezvous.h"
+#include "tensorflow/core/lib/core/errors.h"
+#include "tensorflow/core/lib/core/refcount.h"
+#include "tensorflow/core/lib/gtl/inlined_vector.h"
+#include "tensorflow/core/lib/gtl/map_util.h"
+#include "tensorflow/core/platform/mutex.h"
+#include "tensorflow/core/platform/thread_annotations.h"
+#include "tensorflow/core/platform/types.h"
+#include "tensorflow/core/public/version.h"
+
+namespace tensorflow {
+
+class AsyncEagerNode;
+class AsyncRemoteExecuteNode;
+namespace eager {
+class EagerClient;
+}
+
+// A unit of execution for the EagerExecutor class below. Example subclasses
+// encapsulate execution of a TFE_Op, or copying a TFE_TensorHandle from one
+// device to another.
+class EagerNode {
+ public:
+  EagerNode() = default;
+
+  virtual ~EagerNode() = default;
+
+  // Prepares the node when adding it into EagerExecutor. If any errors happens,
+  // EagerExecutor will abort the node immediately.
+  virtual Status Prepare() { return OkStatus(); }
+
+  // Runs the computation corresponding to this node and blocks till the
+  // execution is done.
+  virtual Status Run() = 0;
+
+  // Called when this node will not be run due to some error contained in
+  // `status`. `status` must not be OK.
+  // For example, if the node would have computed some tensors in the Run(),
+  // it should poison the corresponding tensor handles in this method.
+  virtual void Abort(Status status) = 0;
+
+  // Returns nullptr iff this Eager node is synchronous.
+  virtual AsyncEagerNode* AsAsync() { return nullptr; }
+  virtual AsyncRemoteExecuteNode* AsAsyncRemoteExecuteNode() { return nullptr; }
+
+  virtual string DebugString() const = 0;
+
+  // Indicates whether a node failure should make the executor unusable.
+  virtual bool Fatal() const { return true; }
+};
+
+class AsyncEagerNode : public EagerNode {
+ public:
+  using EagerNode::EagerNode;  // Lift EagerNode constructors.
+
+  // This node will be cleaned up once the done callback is called.
+  virtual void RunAsync(StatusCallback done) = 0;
+
+  AsyncEagerNode* AsAsync() final { return this; }
+
+  Status Run() final {
+    return errors::Unimplemented("Don't call AsyncEagerNode::Run().");
+  }
+};
+
+class AsyncRemoteExecuteNode : public AsyncEagerNode {
+ public:
+  AsyncRemoteExecuteNode* AsAsyncRemoteExecuteNode() final { return this; }
+
+  virtual const eager::EagerClient* eager_client() const = 0;
+  virtual bool needs_remote_inputs() const = 0;
+  virtual bool allow_multiple_pending_requests() const = 0;
+  virtual Status SyncExecutors() = 0;
+};
+
+// A class for handling async execution (see TFE_ContextSetAsync).
+// Note that this class is thread-safe.
+// TODO(agarwal): TFE_OpAddInput may currently block if it tries to access the
+// device of the input handle. Fix that.
+// TODO(agarwal): Implement support for control dependencies.
+// TODO(agarwal): Support out-of-order execution and dispatching multiple
+// EagerNode in parallel.
+// TODO(agarwal): Implement optimizations over EagerNode traces.
+class EagerExecutor {
+ public:
+  explicit EagerExecutor(bool async, bool enable_streaming_enqueue = true,
+                         int in_flight_nodes_limit = 0);
+
+  ~EagerExecutor();
+
+  // Puts this in a shutdown state. In this state, AddOrExecute() will return an
+  // error and not add new EagerNodes. After putting this in the shutdown state,
+  // blocks until all pendings nodes have finished running.
+  // Returns the status of executing pending nodes.
+  // If async was not enabled, aborts and destroys all pending nodes.
+  Status ShutDown();
+
+  bool Async() const;
+
+  bool StreamingEnqueue() const;
+
+  // Inline execute node if executor is in sync mode.
+  Status SyncExecute(EagerNode* node);
+
+  // - Async Mode: schedules `node` for execution.
+  // - Sync Mode: inline execute the 'node' directly.
+  // If an error occurs (e.g. EagerExecutor has already been shut down), the
+  // `node` is not added to this executor and its Abort() method is called.
+  Status AddOrExecute(std::unique_ptr<EagerNode> node);
+
+  // Blocks till all currently pending ops are done.
+  // In particular, if EnableAsync() has not beed called, it will not return
+  // until that happens (and pendings, at the time of call, nodes finish
+  // running). If this executor has already been shut down, its final status is
+  // returned.
+  Status WaitForAllPendingNodes();
+
+  // Clears all currently set errors which re-enables async execution.
+  void ClearError();
+
+  // Returns Status based on any errors that occurred during async execution.
+  Status status() const {
+    if (ok()) return OkStatus();
+
+    tf_shared_lock l(node_queue_mutex_);
+    return status_;
+  }
+
+  bool ok() const TF_NO_THREAD_SAFETY_ANALYSIS { return ok_; }
+
+  // On destruction, runs `callback`. Used by the EagerContext for clearing
+  // thread-local executors.
+  void AddCleanup(intptr_t key, std::function<void()> callback);
+  // If `key` (e.g. a context) is destroyed before the executor, the associated
+  // callbacks are no longer safe to run.
+  void RemoveCleanups(intptr_t key);
+
+ private:
+  // Possible states for this executor.
+  // Executor starts in kActive state. When Shutdown() is called, Executor
+  // is put in the kShuttingDown state. In this state, the executor thread
+  // continues to run, but no new nodes are accepted. Finally, when all nodes
+  // are drained, the executor is put in the kShutDown state, which causes the
+  // thread to exit.
+  // If this executor is destroyed without calling shutdown first, it
+  // transitions to kShutDown state immediately which causes the thread to exit
+  // without running pending nodes.
+  enum class ExecutorState {
+    kActive,
+    kShuttingDown,
+    kShutDown,
+  };
+
+  enum class NodeState {
+    kPENDING,
+    kSCHEDULED,
+    kDONE,
+  };
+
+  struct NodeItem : core::RefCounted {
+    // Unique id generated in EagerExecutor::Add(). If item1.id < item2.id, it
+    // means item1.node is added before item2.node.
+    uint64 id;
+    std::unique_ptr<EagerNode> node;
+    NodeState state;
+  };
+
+  const char* StateStringLocked()
+      TF_EXCLUSIVE_LOCKS_REQUIRED(node_queue_mutex_);
+
+  void NodeDone(const core::RefCountPtr<NodeItem>& item, const Status& status,
+                bool from_queue);
+  void NotifyWaiters(uint64 id) TF_EXCLUSIVE_LOCKS_REQUIRED(node_queue_mutex_);
+
+  // Starts execution of pending EagerNodes. This function loops till executor
+  // state_ is set to kShutDown. If any errors are encountered, these are set
+  // inside `status_`. The loop blocks anytime there are no pending nodes, or if
+  // `status_` is not ok.
+  void Run();
+
+  Status RunItem(core::RefCountPtr<NodeItem> item, bool from_queue);
+  Status MoveToUnfinished(core::RefCountPtr<NodeItem> item, bool from_queue);
+
+  // The impl of WaitForAllPendingNodes
+  // `lock` is the lock that holds node_queue_mutex_.
+  Status WaitForAllPendingNodesLocked(mutex_lock* lock)
+      TF_EXCLUSIVE_LOCKS_REQUIRED(node_queue_mutex_);
+
+  Status WaitImpl(bool wait_all, uint64 node_id);
+
+  std::atomic<uint64> next_node_id_;
+
+  mutable mutex node_queue_mutex_;
+
+  // Used to signal that some EagerNodes are pending execution.
+  condition_variable nodes_pending_ TF_GUARDED_BY(node_queue_mutex_);
+  // Used to signal that some EagerNodes are done.
+  condition_variable nodes_done_ TF_GUARDED_BY(node_queue_mutex_);
+
+  // Queue of pending NodeItems. Ordered by NodeItem::id.
+  std::queue<core::RefCountPtr<NodeItem>> node_queue_
+      TF_GUARDED_BY(node_queue_mutex_);
+
+  // Ordered by NodeItem::id.
+  std::map<uint64, core::RefCountPtr<NodeItem>, std::less<uint64>>
+      unfinished_nodes_ TF_GUARDED_BY(node_queue_mutex_);
+
+  // `status_` is set based on any errors raised during execution of a
+  // EagerNode.  It remains set until ClearError is called.
+  Status status_ TF_GUARDED_BY(node_queue_mutex_);
+  std::atomic<bool> ok_ TF_GUARDED_BY(node_queue_mutex_);
+
+  // Map from id of a EagerNode to condition_variables (not owned by the map).
+  // These condition_variables are notified and removed when that EagerNode is
+  // done executing, or if an error is found in execution of any EagerNode.
+  // The map is ordered by id.
+  std::multimap<uint64, condition_variable*, std::less<uint64>>
+      node_done_notifications_ TF_GUARDED_BY(node_queue_mutex_);
+
+  // thread_exited_notification_ is notified by the `thread_` right before it
+  // exits.
+  Notification thread_exited_notification_;
+
+  // When state_ is set to kShutDown, it indicates that `thread_` should stop as
+  // soon as it is done executing the current EagerNode.
+  ExecutorState state_ TF_GUARDED_BY(node_queue_mutex_) =
+      ExecutorState::kActive;
+
+  // Thread object that calls the `Run` method in async mode.This thread runs
+  // until state_ is set to kShuttingDown. It is `nullptr` in sync mode.
+  const std::unique_ptr<Thread> thread_;
+
+  // Last device where remote function with remote inputs was executed.
+  const eager::EagerClient* last_eager_client_;
+
+  const bool enable_async_wait_for_remote_function_;
+
+  // Enable sending remote executions through streaming enqueue.
+  const bool enable_streaming_enqueue_;
+
+  // Callbacks to run on destruction.
+  absl::flat_hash_map<intptr_t, std::vector<std::function<void()>>> cleanups_;
+
+  // Limit the number of in-flight nodes. When the number of in-flight eager
+  // async nodes reach this number, enqueuing to the eager async queue is
+  // blocked.
+  const int64_t in_flight_nodes_limit_;
+};
+
+inline bool EagerExecutor::Async() const { return thread_ != nullptr; }
+
+inline bool EagerExecutor::StreamingEnqueue() const {
+  return enable_streaming_enqueue_;
+}
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_EAGER_EAGER_EXECUTOR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/eager/eager_op_rewrite_registry.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/eager/eager_op_rewrite_registry.h
new file mode 100644
index 0000000000000000000000000000000000000000..a70877b57114a2399ddd37d75dfe9ae978d008d3
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/eager/eager_op_rewrite_registry.h
@@ -0,0 +1,109 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_EAGER_EAGER_OP_REWRITE_REGISTRY_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_EAGER_EAGER_OP_REWRITE_REGISTRY_H_
+
+#include <array>
+#include <list>
+#include <memory>
+#include <utility>
+
+#include "tensorflow/core/common_runtime/eager/eager_operation.h"
+
+namespace tensorflow {
+
+// Eager op rewrites should inherit from this class and
+// implement the Run method.
+class EagerOpRewrite {
+ public:
+  EagerOpRewrite(string name, string file, string line) {
+    debug_info_.name = name;
+    debug_info_.file = file;
+    debug_info_.line = line;
+  }
+
+  virtual ~EagerOpRewrite() = default;
+
+  // To be implemented by an Eager op rewrite pass.
+  virtual Status Run(EagerOperation* orig_op,
+                     std::unique_ptr<tensorflow::EagerOperation>* out_op) = 0;
+
+  // Holds information about the rewrite registration.
+  struct DebugInfo {
+    string name, file, line;
+  };
+
+  // Returns information about the registered Eager op rewrite.
+  DebugInfo GetDebugInfo() const { return debug_info_; }
+
+ private:
+  DebugInfo debug_info_;
+};
+
+class EagerOpRewriteRegistry {
+ public:
+  // Phases at which the Eager op rewrite pass should run.
+  enum Phase {
+    PRE_EXECUTION = 0,  // right before executing an eager op
+    POST_PLACEMENT = 1  // after device placement
+  };
+
+  // Add a rewrite pass to the registry.
+  void Register(Phase phase, int32_t ordinal,
+                std::unique_ptr<EagerOpRewrite> pass);
+
+  // Run the rewrite pass registered for a given phase.
+  Status RunRewrite(Phase phase, EagerOperation* orig_op,
+                    std::unique_ptr<tensorflow::EagerOperation>* out_op);
+
+  // Returns the global registry of rewrite passes.
+  static EagerOpRewriteRegistry* Global();
+
+ private:
+  static constexpr int32_t kNumPhases = 2;
+  // Holds all the registered Eager op rewrites and their ordinal numbers.
+  std::array<std::list<std::pair<std::unique_ptr<EagerOpRewrite>, int32>>,
+             kNumPhases>
+      rewrites_;
+};
+
+namespace eager_rewrite_registration {
+
+// This class is used to register a new Eager Op rewrite.
+class EagerRewriteRegistration {
+ public:
+  EagerRewriteRegistration(EagerOpRewriteRegistry::Phase phase, int32_t ordinal,
+                           std::unique_ptr<EagerOpRewrite> pass) {
+    EagerOpRewriteRegistry::Global()->Register(phase, ordinal, std::move(pass));
+  }
+};
+
+}  // namespace eager_rewrite_registration
+
+#define REGISTER_REWRITE(phase, ordinal, rewrite)                      \
+  REGISTER_REWRITE_UNIQ_HELPER(__COUNTER__, __FILE__, __LINE__, phase, \
+                               ordinal, rewrite)
+
+#define REGISTER_REWRITE_UNIQ_HELPER(ctr, file, line, phase, ordinal, rewrite) \
+  REGISTER_REWRITE_UNIQ(ctr, file, line, phase, ordinal, rewrite)
+
+#define REGISTER_REWRITE_UNIQ(ctr, file, line, phase, ordinal, rewrite)       \
+  static ::tensorflow::eager_rewrite_registration::EagerRewriteRegistration   \
+      register_rewrite_##ctr(phase, ordinal,                                  \
+                             ::std::unique_ptr<::tensorflow::EagerOpRewrite>( \
+                                 new rewrite(#rewrite, file, #line)))
+
+}  // namespace tensorflow
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_EAGER_EAGER_OP_REWRITE_REGISTRY_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/eager/eager_operation.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/eager/eager_operation.h
new file mode 100644
index 0000000000000000000000000000000000000000..ccde391e8dc53da0f3a4a84c417163ebfc690e42
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/eager/eager_operation.h
@@ -0,0 +1,323 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_EAGER_EAGER_OPERATION_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_EAGER_EAGER_OPERATION_H_
+
+#include <optional>
+#include <string>
+#include <variant>
+#include <vector>
+
+#include "absl/container/inlined_vector.h"
+#include "absl/types/optional.h"
+#include "absl/types/span.h"
+#include "absl/types/variant.h"
+#include "tensorflow/c/eager/abstract_tensor_handle.h"
+#include "tensorflow/c/eager/immediate_execution_operation.h"
+#include "tensorflow/core/common_runtime/eager/attr_builder.h"
+#include "tensorflow/core/common_runtime/eager/context.h"
+#include "tensorflow/core/common_runtime/eager/eager_executor.h"
+#include "tensorflow/core/common_runtime/eager/kernel_and_device.h"
+#include "tensorflow/core/common_runtime/eager/tensor_handle.h"
+#include "tensorflow/core/framework/cancellation.h"
+#include "tensorflow/core/framework/device_attributes.pb.h"
+#include "tensorflow/core/framework/op_def.pb.h"
+#include "tensorflow/core/util/device_name_utils.h"
+#include "tensorflow/core/util/managed_stack_trace.h"
+
+namespace tensorflow {
+
+class EagerOperation : public ImmediateExecutionOperation {
+ public:
+  explicit EagerOperation(tensorflow::EagerContext* ctx)
+      : ImmediateExecutionOperation(kEager), ctx_(*ctx), is_function_(false) {}
+  ~EagerOperation() override {
+    for (ImmediateExecutionTensorHandle* h : inputs_) {
+      h->Unref();
+    }
+  }
+
+  void Release() override { delete this; }
+
+  void Clear() override;
+  Status Reset(const char* op, const char* raw_device_name) override {
+    return Reset(op, raw_device_name, false, nullptr);
+  }
+
+  const string& Name() const override { return attrs_.op_name(); }
+
+  const string& DeviceName() const override { return device_name_; }
+
+  ImmediateExecutionContext* GetContext() const override { return &ctx_; }
+
+  const DeviceNameUtils::ParsedName& GetDeviceParsedName() const {
+    return device_parsed_name_;
+  }
+
+  // Replaces the previous device name with the given one (see
+  // AbstractOperation::SetDeviceName for more details).
+  //
+  // This also resets the internal device pointer, unless the given name refers
+  // to a known custom device, in which case the internal device pointer is
+  // updated to that device.
+  Status SetDeviceName(const char* name) override;
+
+  void SetDevice(VariantDevice device) {
+    device_ = device;
+    device_name_ = std::visit(
+        [](auto* device) { return device == nullptr ? "" : device->name(); },
+        device);
+    DeviceNameUtils::ParseFullName(device_name_, &device_parsed_name_);
+    // TODO(b/154133594): Due to intricacies of external logic, we can not
+    // set this do device_name_ as it would be natural, because we need the
+    // next call to SetDeviceName to reset the device pointer.
+    last_set_device_name_ = "\177";  // DEL (an invalid value)
+  }
+
+  Status SetAttrValue(const char* attr_name, const AttrValue& value);
+
+  Status AddInput(AbstractTensorHandle* input) override;
+  Status AddInputList(absl::Span<AbstractTensorHandle* const> inputs) override;
+  Status SetInput(size_t index, ImmediateExecutionTensorHandle* input) override;
+  absl::Span<ImmediateExecutionTensorHandle* const> GetInputs() const override;
+  bool HasCustomDeviceInput() const override {
+    return custom_device_tensor_handles_count_ > 0;
+  }
+  Status Execute(absl::Span<AbstractTensorHandle*> retvals,
+                 int* num_retvals) override;
+  const tensorflow::OpDef* OpDef() const override { return op_def_; };
+
+  Status SetAttrString(const char* attr_name, const char* data,
+                       size_t length) override;
+  Status SetAttrInt(const char* attr_name, int64_t value) override;
+  Status SetAttrFloat(const char* attr_name, float value) override;
+  Status SetAttrBool(const char* attr_name, bool value) override;
+  Status SetAttrType(const char* attr_name, DataType value) override;
+  Status SetAttrShape(const char* attr_name, const int64_t* dims,
+                      int num_dims) override;
+  Status SetAttrFunction(const char* attr_name,
+                         const AbstractOperation* value) override;
+  Status SetAttrFunctionName(const char* attr_name, const char* data,
+                             size_t length) override;
+  Status SetAttrTensor(const char* attr_name,
+                       AbstractTensorInterface* tensor) override;
+  Status SetAttrStringList(const char* attr_name, const void* const* values,
+                           const size_t* lengths, int num_values) override;
+  Status SetAttrFloatList(const char* attr_name, const float* values,
+                          int num_values) override;
+  Status SetAttrIntList(const char* attr_name, const int64_t* values,
+                        int num_values) override;
+  Status SetAttrTypeList(const char* attr_name, const DataType* values,
+                         int num_values) override;
+  Status SetAttrBoolList(const char* attr_name, const unsigned char* values,
+                         int num_values) override;
+  Status SetAttrShapeList(const char* attr_name, const int64_t** dims,
+                          const int* num_dims, int num_values) override;
+  Status SetAttrFunctionList(
+      const char* attr_name,
+      absl::Span<const AbstractOperation*> values) override;
+
+  Status InputLength(const char* input_name, int* length) override;
+  Status OutputLength(const char* output_name, int* length) override;
+
+  const AbstractOpAttrs* GetOpAttrs() const override;
+  void AddAttrs(const AbstractOpAttrs* op_attrs) override;
+
+  void SetStackTrace(ManagedStackTrace stack_trace) override {
+    stack_trace_ = stack_trace;
+  }
+
+  std::optional<ManagedStackTrace> GetStackTrace() override {
+    return stack_trace_;
+  }
+
+  Status Reset(
+      const char* op, const char* device_name, bool remote,
+      EagerExecutor* executor,
+      absl::optional<EagerFunctionParams> eager_func_params = std::nullopt);
+
+  bool is_function() const { return is_function_; }
+  bool colocation_exempt() const { return colocation_exempt_; }
+
+  tensorflow::EagerContext& EagerContext() const { return ctx_; }
+
+  AttrBuilder* MutableAttrs() { return &attrs_; }
+  const AttrBuilder& Attrs() const { return attrs_; }
+
+  // TensorHandleInputs and MutableTensorHandleInputs first check that all
+  // inputs are TensorHandles, i.e. that there are no custom device inputs. They
+  // return a bad status otherwise.
+  Status TensorHandleInputs(
+      const absl::InlinedVector<TensorHandle*, 4>** inputs) const;
+  Status MutableTensorHandleInputs(
+      absl::InlinedVector<TensorHandle*, 4>** inputs);
+
+  const absl::InlinedVector<ImmediateExecutionTensorHandle*, 4>& Inputs()
+      const {
+    return inputs_;
+  }
+
+  void UpdateInput(int i, TensorHandle* h);
+
+  // This is useful if we want the EagerOperation to point to a different
+  // function.
+  void UpdateName(const string& name) {
+    op_name_ = name.c_str();
+    attrs_.set_op_name(name);
+  }
+
+  // Like TensorHandles, EagerOperations may be placed either on a virtual
+  // CustomDevice or on a physical Device.
+  VariantDevice Device() const { return device_; }
+
+  // Indicates whether the op is assigned to a device that is local to the
+  // current host.
+  bool IsLocal() const;
+
+  CancellationManager* GetCancellationManager() const {
+    return cancellation_manager_;
+  }
+  void SetCancellationManager(
+      CancellationManager* cancellation_manager) override {
+    cancellation_manager_ = cancellation_manager;
+  }
+
+  // Assign step_id value only if op has valid step id.
+  // When eager_func_params.has_value() returns true, we can directly overwrite
+  // its step id according to Op's step id (if not default value). However, when
+  // eager_func_params.has_value() returns false, we need to first create a new
+  // EagerFuncParams object for it before assigning step_id; otherwise,
+  // directly assigning step_id in this case leaves eager_func_params to be
+  // in a weird state where:
+  // (1) eager_func_params.has_value() returns false, but
+  // (2) eager_func_params->step_id.has_value() returns true.
+  void SetStepId(int64_t step_id) override {
+    assert(is_function());
+    if (step_id != EagerContext::kGlobalRendezvousId) {
+      if (eager_func_params_.has_value()) {
+        eager_func_params_->step_id = step_id;
+      } else {
+        eager_func_params_ = EagerFunctionParams{
+            kInvalidOpId, /*is_component_function=*/false, step_id};
+      }
+    } else {
+      LOG(WARNING) << "SetStepId() should not receive a gloabl rendezvous id.";
+    }
+  }
+
+  EagerExecutor& Executor() { return *executor_; }
+
+  string DebugString() const;
+
+  const absl::optional<EagerFunctionParams>& eager_func_params() const {
+    return eager_func_params_;
+  }
+
+  // Op name recorded for memory debugging purpose.
+  const char* op_name() const { return op_name_; }
+
+  // For LLVM style RTTI.
+  static bool classof(const AbstractOperation* ptr) {
+    return ptr->getKind() == kEager;
+  }
+
+ private:
+  void AddTensorHandle(ImmediateExecutionTensorHandle* h);
+
+  const tensorflow::OpDef* GetOpDef(Status* status);
+
+  void ClearInferenceState() {
+    op_def_ = nullptr;
+    inference_arg_idx_ = 0;
+    inference_attrs_.clear_no_resize();
+  }
+
+  Status MaybeInferSingleInputAttrs(ImmediateExecutionTensorHandle* handle);
+  Status InferInputListAttrs(int num_inputs);
+
+  void InferSingleTypeInputListAttrs(const OpDef::ArgDef& input_def,
+                                     DataType dtype, int num_inputs);
+  void InferMixedTypeInputListAttrs(const OpDef::ArgDef& input_def,
+                                    const std::vector<DataType>& dtypes);
+
+  tensorflow::EagerContext& ctx_;
+  const char* op_name_ = nullptr;
+  AttrBuilder attrs_;
+  const AttrTypeMap* attr_types_;
+
+  // The number of custom device TensorHandle inputs. These inputs need to be
+  // processed by CustomDeviceOpHandler first.
+  int custom_device_tensor_handles_count_ = 0;
+  absl::InlinedVector<ImmediateExecutionTensorHandle*, 4> inputs_;
+
+  // The last device name given to SetDeviceName.
+  // This is used to avoid having to re-process the same device in repeated
+  // calls to SetDeviceName.
+  string last_set_device_name_;
+
+  // The operation's device name.
+  // This contains the named passed to SetDeviceName until device_ is set,
+  // at which point it contains the device_ name.
+  string device_name_;
+
+  // The parsed device name.
+  // This will always contain the result of
+  // DeviceNameUtils::ParseFullName(device_name_).
+  DeviceNameUtils::ParsedName device_parsed_name_;
+
+  // The operation's device.
+  // This is set by the execution device placement logic, and should conform
+  // with the contents of device_name_. Once it is set, the device_name_ is
+  // updated accordingly.
+  VariantDevice device_;
+
+  std::optional<ManagedStackTrace> stack_trace_;
+  bool is_function_;  // Conceptually const, but can't be because of Reset
+  bool colocation_exempt_;
+  CancellationManager* cancellation_manager_ = nullptr;  // Not owned.
+  EagerExecutor* executor_;                              // Not owned.
+
+  std::optional<EagerFunctionParams> eager_func_params_;
+
+  // Inference information
+  const tensorflow::OpDef* op_def_;  // op definition from protobuf
+  int inference_arg_idx_;  // arg definition index for the next input to be
+                           // added
+  gtl::FlatSet<std::string> inference_attrs_;  // attributes inferred so far
+};
+
+inline void EagerOperation::UpdateInput(int i, TensorHandle* h) {
+  ImmediateExecutionTensorHandle** slot = &inputs_[i];
+  ImmediateExecutionTensorHandle* existing = *slot;
+  if (existing != h) {
+    h->Ref();
+    existing->Unref();
+    *slot = h;  // Update inputs_[i] to h
+  }
+}
+
+inline EagerOperation* OperationFromInterface(
+    ImmediateExecutionOperation* operation) {
+  return down_cast<EagerOperation*>(operation);
+}
+
+inline const EagerOperation* OperationFromInterface(
+    const ImmediateExecutionOperation* operation) {
+  return down_cast<const EagerOperation*>(operation);
+}
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_EAGER_EAGER_OPERATION_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/eager/execute.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/eager/execute.h
new file mode 100644
index 0000000000000000000000000000000000000000..5cba8cf0243207a7ae59920141dae52b4e768163
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/eager/execute.h
@@ -0,0 +1,90 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_EAGER_EXECUTE_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_EAGER_EXECUTE_H_
+
+#include "absl/container/inlined_vector.h"
+#include "absl/types/span.h"
+#include "tensorflow/core/common_runtime/device.h"
+#include "tensorflow/core/common_runtime/eager/context.h"
+#include "tensorflow/core/common_runtime/eager/eager_operation.h"
+#include "tensorflow/core/common_runtime/eager/kernel_and_device.h"
+#include "tensorflow/core/common_runtime/eager/tensor_handle.h"
+#include "tensorflow/core/framework/step_stats.pb.h"
+#include "tensorflow/core/lib/core/status.h"
+
+namespace tensorflow {
+
+// Utility function that executes a fully constructed EagerOperation.
+// There are a few possible different combinations of how things can be
+// executed:
+//  - Async (the op context is configured to schedule asynchronously)
+//    Eager execute should return quickly after scheduling this operation to
+//    execute.
+//  - Remote (the op device is on a remote task)
+//    Eager execute will send an RPC to execute the op on a remote device.
+//  Note that in the Async + Remote case, EagerExecute should still return
+//  quickly, but it will schedule the op to be executed remotely.
+//
+// 'retvals' must point to a pre-allocated array of TensorHandle* and
+// '*num_retvals' should be set to the size of this array. It is an error if
+// the size of 'retvals' is less than the number of outputs. This call sets
+// *num_retvals to the number of outputs.
+Status EagerExecute(EagerOperation* op, TensorHandle** retvals,
+                    int* num_retvals);
+
+// Low-level utility to execute the kernel specified by `kernel` on
+// `kernel->device()`, with the inputs op_inputs, in the context 'ctx'.
+Status EagerKernelExecute(
+    EagerContext* ctx, const absl::InlinedVector<TensorHandle*, 4>& op_inputs,
+    const absl::optional<EagerFunctionParams>& eager_func_params,
+    const core::RefCountPtr<KernelAndDevice>& kernel,
+    GraphCollector* graph_collector, CancellationManager* cancellation_manager,
+    absl::Span<TensorHandle*> retvals,
+    const absl::optional<ManagedStackTrace>& stack_trace = {});
+
+// Low-level utility to copy a tensor handle from one device to another. If
+// successful, result TensorHandle will be populated. If the caller requests for
+// the mirror flag, EagerCopyToDevice will attempt to add a mirror to the
+// original handle and update *result to point to h. Since this is not
+// guaranteed, callers should always use the value in *result.
+Status EagerCopyToDevice(TensorHandle* h, EagerContext* ctx,
+                         EagerExecutor* executor, Device* device, bool mirror,
+                         TensorHandle** result);
+
+// Utility function that executes a fully constructed EagerOperation
+// asynchronously on the local task. This function works differently from
+// EagerExecute in several ways:
+//  - It supports local execution only.
+//  - It returns after launching the eager operation to run asynchronously.
+//    Different from EagerExecute with async context that apends the operation
+//    to the end of the eager executor schedule queue, this call bypasses the
+//    executor logic and directly launches op execution. Ops running through
+//    this call does NOT have an ordering and can be executed in parallel.
+//  - It takes a StatusCallback which will be triggered after execution with the
+//    execution status.
+//
+// Does not support custom device.
+//
+// 'retvals' must point to a pre-allocated array of TensorHandle* and
+// '*num_retvals' should be set to the size of this array. It is an error if
+// the size of 'retvals' is less than the number of outputs. This call sets
+// *num_retvals to the number of outputs.
+void EagerLocalExecuteAsync(EagerOperation* op, TensorHandle** retvals,
+                            int* num_retvals, StatusCallback done);
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_EAGER_EXECUTE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/eager/execute_node.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/eager/execute_node.h
new file mode 100644
index 0000000000000000000000000000000000000000..8fbe075c34ce1a069e5aa8cfe7680bfc4280322d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/eager/execute_node.h
@@ -0,0 +1,249 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_EAGER_EXECUTE_NODE_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_EAGER_EXECUTE_NODE_H_
+
+// clang-format off
+// Required for IS_MOBILE_PLATFORM
+#include <cstddef>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <string>
+#include <utility>
+#include "absl/container/flat_hash_map.h"
+#include "tensorflow/core/platform/errors.h"
+#include "tensorflow/core/platform/platform.h"
+// clang-format on
+
+#include "absl/container/inlined_vector.h"
+#include "absl/memory/memory.h"
+#include "absl/types/optional.h"
+#include "absl/types/span.h"
+#include "tensorflow/core/common_runtime/device.h"
+#include "tensorflow/core/common_runtime/eager/context.h"
+#include "tensorflow/core/common_runtime/eager/eager_executor.h"
+#include "tensorflow/core/common_runtime/eager/execute.h"
+#include "tensorflow/core/common_runtime/eager/kernel_and_device.h"
+#include "tensorflow/core/common_runtime/eager/tensor_handle.h"
+#include "tensorflow/core/framework/step_stats.pb.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/lib/strings/strcat.h"
+#if !defined(IS_MOBILE_PLATFORM)
+#include "tensorflow/core/distributed_runtime/eager/remote_mgr.h"
+#include "tensorflow/core/protobuf/remote_tensor_handle.pb.h"
+#endif  // IS_MOBILE_PLATFORM
+
+namespace tensorflow {
+
+class ExecuteNodeArgs : public EagerKernelArgs {
+ public:
+  explicit ExecuteNodeArgs(int count) : EagerKernelArgs(count) {}
+
+  Status Init(EagerContext* ctx,
+              const absl::InlinedVector<TensorHandle*, 4>& op_inputs,
+              const core::RefCountPtr<KernelAndDevice>& kernel);
+
+  Status GetLocalArg(const FunctionArgIndex& index, Tensor* val) const override;
+
+  bool HasRemoteOrPackedInputs() const override {
+    return has_remote_inputs_ || has_packed_inputs_;
+  };
+
+#if !defined(IS_MOBILE_PLATFORM)
+  Status GetRemoteArg(const FunctionArgIndex& index,
+                      eager::RemoteTensorHandle* val) const override {
+    return serialize_remote_handle_(index, val);
+  }
+#endif  // IS_MOBILE_PLATFORM
+
+ private:
+#if !defined(IS_MOBILE_PLATFORM)
+  // Returns whether `handle` is a remote handle or has a remote mirror on
+  // `input_device`
+  bool IsRemote(EagerContext* ctx, Device* input_device, TensorHandle* handle);
+#endif  // IS_MOBILE_PLATFORM
+
+  // Initialize a packed TensorHandle which is the `index`-th argument.
+  Status InitPackedHandle(int index, EagerContext* ctx, Device* input_device,
+                          TensorHandle* packed_handle);
+
+  bool has_remote_inputs_ = false;
+  bool has_packed_inputs_ = false;
+  // Maps from the index of a packed arg to a list of sub-args.
+  absl::flat_hash_map<int, gtl::InlinedVector<TensorValue, 4>> packed_args_;
+#if !defined(IS_MOBILE_PLATFORM)
+  std::function<Status(const FunctionArgIndex&, eager::RemoteTensorHandle*)>
+      serialize_remote_handle_;
+#endif  // IS_MOBILE_PLATFORM
+};
+
+class ExecuteNode : public EagerNode {
+ public:
+  ExecuteNode(EagerContext* ctx,
+              const absl::InlinedVector<TensorHandle*, 4>& inputs,
+              const absl::optional<EagerFunctionParams>& eager_func_params,
+              const core::RefCountPtr<KernelAndDevice>& kernel,
+              GraphCollector* graph_collector,
+              CancellationManager* cancellation_manager,
+              absl::Span<TensorHandle*> retvals,
+              std::optional<ManagedStackTrace> stack_trace)
+      : EagerNode(),
+        ctx_(ctx),
+        inputs_(inputs),
+        eager_func_params_(eager_func_params),
+        kernel_(kernel),
+        graph_collector_(graph_collector),
+        cancellation_manager_(cancellation_manager),
+        retvals_(retvals),
+        stack_trace_(stack_trace) {}
+
+  Status Run() override {
+    int i = 0;
+    for (TensorHandle* h : inputs_) {
+      if (h->RefCountIsOne()) {
+        const Device* d = ctx_->CanonicalDevice(kernel_->InputDevice(i));
+        Status s = h->Unprotect(d);
+        if (!s.ok()) {
+          VLOG(1) << "Unable to unprotect tensor: " << s;
+        }
+      }
+      ++i;
+    }
+    return EagerKernelExecute(ctx_, inputs_, eager_func_params_, kernel_,
+                              graph_collector_, cancellation_manager_, retvals_,
+                              stack_trace_);
+  }
+
+  void Abort(Status status) override {}
+
+  std::string DebugString() const override {
+    std::string out = "[ExecuteNode]";
+    strings::StrAppend(&out, " kernel: ", kernel_->name());
+    return out;
+  }
+
+ private:
+  EagerContext* ctx_;
+  const absl::InlinedVector<TensorHandle*, 4>& inputs_;
+  const absl::optional<EagerFunctionParams>& eager_func_params_;
+  const core::RefCountPtr<KernelAndDevice>& kernel_;
+  GraphCollector* graph_collector_;
+  CancellationManager* const cancellation_manager_;
+  absl::Span<TensorHandle*> retvals_;
+  std::optional<ManagedStackTrace> stack_trace_;
+};
+
+class AsyncExecuteNode : public EagerNode {
+ public:
+  AsyncExecuteNode(EagerContext* ctx,
+                   const absl::InlinedVector<TensorHandle*, 4>& inputs,
+                   const absl::optional<EagerFunctionParams>& eager_func_params,
+                   core::RefCountPtr<KernelAndDevice> kernel,
+                   GraphCollector* graph_collector,
+                   CancellationManager* cancellation_manager,
+                   absl::Span<TensorHandle*> retvals,
+                   std::optional<ManagedStackTrace> stack_trace)
+      : EagerNode(),
+        ctx_(ctx),
+        inputs_(inputs),
+        eager_func_params_(eager_func_params),
+        kernel_(std::move(kernel)),
+        graph_collector_(graph_collector),
+        cancellation_manager_(cancellation_manager),
+        stack_trace_(stack_trace) {
+    // Copy the output handles, since the container for them might get
+    // destroyed.
+    for (auto handle : retvals) {
+      handle->Ref();
+      retvals_.push_back(handle);
+    }
+
+    // This is required to ensure that the tensor handles stay alive across
+    // the execution.
+    for (auto handle : inputs_) {
+      handle->Ref();
+    }
+  }
+
+  ~AsyncExecuteNode() override {
+    for (auto handle : retvals_) {
+      handle->Unref();
+    }
+
+    for (auto handle : inputs_) {
+      handle->Unref();
+    }
+  }
+
+  Status Run() override {
+    int i = 0;
+    for (TensorHandle* h : inputs_) {
+      if (h->RefCountIsOne()) {
+        const Device* d = ctx_->CanonicalDevice(kernel_->InputDevice(i));
+        Status s = h->Unprotect(d);
+        if (!s.ok()) {
+          VLOG(1) << "Unable to unprotect tensor: " << s;
+        }
+      }
+      ++i;
+    }
+    Status status = EagerKernelExecute(
+        ctx_, inputs_, eager_func_params_, kernel_, graph_collector_,
+        cancellation_manager_, absl::MakeSpan(retvals_), stack_trace_);
+    if (!status.ok()) {
+      if (stack_trace_.has_value()) {
+        errors::SetStackTrace(
+            status, stack_trace_->ToStackFrames(
+                        {}, {}, /*reverse_traversal=*/false, /*limit=*/-1));
+      }
+      Abort(status);
+      return status;
+    }
+    // If status is ok, EagerKernelExecute would have called SetTensor on
+    // all the output handles.
+    return OkStatus();
+  }
+
+  void Abort(Status status) override {
+    int i = 0;
+    for (auto handle : retvals_) {
+      handle->Poison(status, ctx_->CanonicalDevice(kernel_->OutputDevice(i)));
+      ++i;
+    }
+  }
+
+  std::string DebugString() const override {
+    std::string out = "[AsyncExecuteNode]";
+    strings::StrAppend(&out, " kernel: ", kernel_->name());
+    return out;
+  }
+
+ private:
+  EagerContext* ctx_;
+  absl::InlinedVector<TensorHandle*, 4> inputs_;
+  const absl::optional<EagerFunctionParams> eager_func_params_;
+  core::RefCountPtr<KernelAndDevice> kernel_;
+  GraphCollector* graph_collector_;
+  CancellationManager* const cancellation_manager_;
+  std::optional<ManagedStackTrace> stack_trace_;
+  absl::InlinedVector<TensorHandle*, 2> retvals_;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_EAGER_EXECUTE_NODE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/eager/kernel_and_device.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/eager/kernel_and_device.h
new file mode 100644
index 0000000000000000000000000000000000000000..a98427a9e04d27186fda17578225032f240a888f
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/eager/kernel_and_device.h
@@ -0,0 +1,412 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_EAGER_KERNEL_AND_DEVICE_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_EAGER_KERNEL_AND_DEVICE_H_
+
+// Support for eager execution of TensorFlow kernels.
+
+#include <functional>
+#include <memory>
+#include <optional>
+#include <unordered_map>
+#include <utility>
+#include <variant>
+#include <vector>
+
+// clang-format off
+// Required for IS_MOBILE_PLATFORM
+#include "absl/memory/memory.h"
+#include "tensorflow/core/platform/platform.h"
+// clang-format on
+
+#include "absl/container/flat_hash_map.h"
+#include "absl/types/optional.h"
+#include "tensorflow/core/common_runtime/device.h"
+#include "tensorflow/core/common_runtime/process_function_library_runtime.h"
+#include "tensorflow/core/framework/cancellation.h"
+#include "tensorflow/core/framework/collective.h"
+#include "tensorflow/core/framework/node_def.pb.h"
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/lib/core/errors.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/lib/gtl/inlined_vector.h"
+#include "tensorflow/core/platform/fingerprint.h"
+#include "tensorflow/core/util/managed_stack_trace.h"
+#include "tensorflow/core/util/tensor_slice_reader_cache.h"
+#if !defined(IS_MOBILE_PLATFORM)
+#include "tensorflow/core/protobuf/remote_tensor_handle.pb.h"
+#endif  // IS_MOBILE_PLATFORM
+
+namespace tensorflow {
+
+static constexpr const char* const kOutputsOnOpDevice = "_OutputsOnOpDevice";
+
+class ProcessFunctionLibraryRuntime;
+class FunctionLibraryRuntime;
+
+const int64_t kInvalidOpId = -1;
+
+// This struc is used for:
+// 1. setting op_id and step_id, is_component_function for single-client
+// remote function scenario,
+// 2. setting step_id for multi-client parallel_device scenario.
+struct EagerFunctionParams {
+  int64_t op_id = kInvalidOpId;
+  bool is_component_function;
+  std::optional<int64_t> step_id = std::nullopt;
+};
+
+class EagerKernelArgs : public FunctionArgsInterface {
+ public:
+  EagerKernelArgs() = default;
+
+  explicit EagerKernelArgs(int count) : tensor_args_(count) {}
+
+  explicit EagerKernelArgs(gtl::InlinedVector<TensorValue, 4>&& tensor_args)
+      : tensor_args_(std::move(tensor_args)) {}
+
+  ~EagerKernelArgs() override = default;
+
+  bool HasRemoteOrPackedInputs() const override { return false; };
+  TensorValue* MutableInput(int i) { return &tensor_args_[i]; }
+
+  Status GetLocalArg(const FunctionArgIndex& index, Tensor* val) const override;
+
+  std::vector<Tensor> GetLocalTensors() const override;
+
+  const gtl::InlinedVector<TensorValue, 4>* GetTensorValues() const {
+    return &tensor_args_;
+  }
+
+ protected:
+  gtl::InlinedVector<TensorValue, 4> tensor_args_;
+};
+
+typedef std::variant<Tensor, TensorShape> EagerKernelRet;
+
+// KernelAndDevice encapsulates the logic needed to run a computation eagerly.
+// The computation can be a single instantiated kernel (implemented by
+// KernelAndDeviceOp below) or a multi-device function (implemented by
+// KernelAndDeviceFunc below).
+//
+// Also see:
+// https://www.tensorflow.org/code/tensorflow/core/common_runtime/kernel_benchmark_testlib.h
+// and
+// https://www.tensorflow.org/code/tensorflow/core/kernels/ops_testutil.h
+class KernelAndDevice : public core::RefCounted {
+ public:
+  // Populates this with a kernel appropriate for 'ndef'.
+  //
+  // The provided FunctionLibraryRuntime MUST outlive all calls to
+  // Run() on the returned KernelAndDevice.
+  virtual Status Init(bool log_device_placement, const NodeDef& ndef,
+                      GraphCollector* graph_collector) = 0;
+
+  // Non-multi-device functions are run using regular CallOp and look like
+  // primitive operations from KernelAndDevice perspective.
+  // `flr` can be nullptr if the operation is not run on any specific device
+  // (currently can happen only for multi-device functions).
+  KernelAndDevice(
+      FunctionLibraryRuntime* flr,
+      std::function<void(std::function<void()>)>* runner,
+      std::unique_ptr<CollectiveExecutor::Handle> collective_executor,
+      Device* host_cpu_device)
+      : device_(flr == nullptr ? nullptr : flr->device()),
+        host_cpu_device_(host_cpu_device),
+        flr_(flr),
+        collective_executor_(std::move(collective_executor)),
+        runner_(runner) {}
+
+  // Not thread safe.
+  ~KernelAndDevice() override = default;
+
+  virtual bool IsFunction() { return false; }
+
+  virtual bool IsCrossProcess() { return false; }
+
+  // TODO(ashankar): Handle list-valued inputs.
+  virtual Status Run(
+      ScopedStepContainer* step_container, const EagerKernelArgs& inputs,
+      std::vector<EagerKernelRet>* outputs,
+      CancellationManager* cancellation_manager,
+      const absl::optional<EagerFunctionParams>& eager_func_params,
+      const absl::optional<ManagedStackTrace>& stack_trace,
+      tsl::CoordinationServiceAgent* coordination_service_agent) = 0;
+
+  // Execute kernel asynchronously when applicable. Different from `Run` which
+  // blocks the caller thread and waits for the execution of the op/function,
+  // `RunAsync` could return before finishing the execution. The `done` callback
+  // will be triggered once the op/function execution finishes.
+  // Currently, calling RunAsync on ops might not honor the asynchronicity when
+  // it is called on an instance with only sync implementation, execute the
+  // kernel synchronously and then call the callback with the return status
+  // from sync execution.
+  virtual void RunAsync(
+      ScopedStepContainer* step_container, const EagerKernelArgs& inputs,
+      std::vector<EagerKernelRet>* outputs,
+      CancellationManager* cancellation_manager,
+      const absl::optional<EagerFunctionParams>& eager_func_params,
+      tsl::CoordinationServiceAgent* coordination_service_agent,
+      StatusCallback done) = 0;
+
+  virtual Device* InputDevice(int i) const = 0;
+  virtual Device* OutputDevice(int idx) const = 0;
+  // If idx'th output is a resource, returns the device backing the resource.
+  // Else, returns nullptr.
+  virtual Device* OutputResourceDevice(int idx) const = 0;
+
+  // Returns the kernel that will be used to run this.
+  // Returns nullptr if this will be run using function library runtime.
+  virtual const OpKernel* kernel() const = 0;
+
+  // Returns the device on which this kernel will run. In the case of
+  // multi-device functions, this is the default device that is passed to the
+  // placer but actual computation can happen on a different set of devices.
+  // Also, outputs can be produced on devices different from what this method
+  // returns.
+  Device* device() const { return device_; }
+
+  virtual const DataTypeVector& input_dtypes() const = 0;
+  virtual const DataTypeVector& output_dtypes() const = 0;
+
+  virtual int num_inputs() const = 0;
+  virtual int num_outputs() const = 0;
+  virtual const string& name() const = 0;
+
+ protected:
+  std::function<void(std::function<void()>)>* get_runner() const;
+
+  Device* const device_;               // can be null
+  Device* const host_cpu_device_;      // non-null
+  FunctionLibraryRuntime* const flr_;  // can be null
+  const std::unique_ptr<CollectiveExecutor::Handle> collective_executor_;
+
+ private:
+  std::function<void(std::function<void()>)>* const runner_;  // can be null
+};
+
+// Represents an op kernel and the device it will be run on.
+class KernelAndDeviceOp final : public KernelAndDevice {
+ public:
+  KernelAndDeviceOp(
+      tensorflow::Rendezvous* rendezvous, bool log_memory,
+      FunctionLibraryRuntime* flr,
+      std::function<void(std::function<void()>)>* runner,
+      std::unique_ptr<CollectiveExecutor::Handle> collective_executor,
+      Device* host_cpu_device)
+      : KernelAndDevice(flr, runner, std::move(collective_executor),
+                        host_cpu_device),
+        rendezvous_(rendezvous),
+        log_memory_(log_memory) {}
+
+  ~KernelAndDeviceOp() override = default;
+
+  Status Init(bool log_device_placement, const NodeDef& ndef,
+              GraphCollector* graph_collector) override;
+
+  Status Run(
+      ScopedStepContainer* step_container, const EagerKernelArgs& inputs,
+      std::vector<EagerKernelRet>* outputs,
+      CancellationManager* cancellation_manager,
+      const absl::optional<EagerFunctionParams>& eager_func_params,
+      const absl::optional<ManagedStackTrace>& stack_trace,
+      tsl::CoordinationServiceAgent* coordination_service_agent) override;
+
+  void RunAsync(ScopedStepContainer* step_container,
+                const EagerKernelArgs& inputs,
+                std::vector<EagerKernelRet>* outputs,
+                CancellationManager* cancellation_manager,
+                const absl::optional<EagerFunctionParams>& eager_func_params,
+                tsl::CoordinationServiceAgent* coordination_service_agent,
+                StatusCallback done) override {
+    // Trivial async implementation on top of the sync version
+    done(Run(step_container, inputs, outputs, cancellation_manager,
+             eager_func_params, {}, coordination_service_agent));
+  }
+
+  const OpKernel* kernel() const override { return kernel_.get(); }
+
+  Device* InputDevice(int i) const override;
+  Device* OutputDevice(int idx) const override;
+  Device* OutputResourceDevice(int idx) const override;
+
+  const DataTypeVector& input_dtypes() const override {
+    return kernel_->input_types();
+  }
+  const DataTypeVector& output_dtypes() const override {
+    return kernel_->output_types();
+  }
+  int num_inputs() const override { return kernel_->num_inputs(); }
+  int num_outputs() const override { return kernel_->num_outputs(); }
+  const string& name() const override { return kernel_->name(); }
+
+ private:
+  std::unique_ptr<OpKernel> kernel_;
+  bool is_distributed_communication_op_;
+  gtl::InlinedVector<AllocatorAttributes, 4> input_alloc_attrs_;
+  std::vector<Device*> input_devices_;
+  gtl::InlinedVector<AllocatorAttributes, 1> output_alloc_attrs_;
+  Rendezvous* const rendezvous_;
+  checkpoint::TensorSliceReaderCacheWrapper slice_reader_cache_;
+  const bool log_memory_;
+};
+
+// Represents a multi-device function. Functions can also be run using
+// various function-calling kernels including CallOp and PartitionedCallOp.
+// In such cases, KernelAndDeviceOp is used.
+class KernelAndDeviceFunc : public KernelAndDevice {
+ public:
+  // `flr` can be nullptr.
+  // `pflr` must not be nullptr.
+  // `host_cpu_device` must not be nullptr.
+  KernelAndDeviceFunc(
+      FunctionLibraryRuntime* flr, ProcessFunctionLibraryRuntime* pflr,
+      std::vector<Device*> input_devices,
+      absl::flat_hash_map<string, const std::vector<string>*> composite_devices,
+      std::unordered_map<int, DtypeAndPartialTensorShape>
+          input_resource_dtypes_and_shapes,
+      std::function<void(std::function<void()>)>* runner,
+      std::unique_ptr<CollectiveExecutor::Handle> collective_executor,
+      Device* host_cpu_device, const string& name,
+      const bool outputs_on_op_device,
+      const bool allow_small_function_optimizations,
+      const bool allow_control_flow_sync_execution,
+      const bool shape_inference_on_tfe_dialect_import,
+      const bool int_args_and_retvals_on_device,
+      std::optional<string> xla_compile_device_type,
+      const bool allow_soft_placement, Rendezvous::Factory rendezvous_factory,
+      std::function<int64_t()> get_op_id)
+      : KernelAndDevice(flr, runner, std::move(collective_executor),
+                        host_cpu_device),
+        pflr_(pflr),
+        handle_(kInvalidHandle),
+        outputs_on_op_device_(outputs_on_op_device),
+        allow_small_function_optimizations_(allow_small_function_optimizations),
+        allow_control_flow_sync_execution_(allow_control_flow_sync_execution),
+        shape_inference_on_tfe_dialect_import_(
+            shape_inference_on_tfe_dialect_import),
+        int_args_and_retvals_on_device_(int_args_and_retvals_on_device),
+        xla_compile_device_type_(xla_compile_device_type),
+        allow_soft_placement_(allow_soft_placement),
+        input_devices_(std::move(input_devices)),
+        composite_devices_(std::move(composite_devices)),
+        input_resource_dtypes_and_shapes_(
+            std::move(input_resource_dtypes_and_shapes)),
+        name_(name),
+        rendezvous_factory_(std::move(rendezvous_factory)),
+        get_op_id_(std::move(get_op_id)) {}
+
+  ~KernelAndDeviceFunc() override;
+
+  bool IsFunction() override { return true; };
+
+  bool IsCrossProcess() override { return is_cross_process_; }
+
+  Status InstantiateFunc(bool log_device_placement, const NodeDef& ndef,
+                         GraphCollector* graph_collector);
+
+  Status Init(bool log_device_placement, const NodeDef& ndef,
+              GraphCollector* graph_collector) override;
+
+  Status Run(
+      ScopedStepContainer* step_container, const EagerKernelArgs& inputs,
+      std::vector<EagerKernelRet>* outputs,
+      CancellationManager* cancellation_manager,
+      const absl::optional<EagerFunctionParams>& eager_func_params,
+      const absl::optional<ManagedStackTrace>& stack_trace,
+      tsl::CoordinationServiceAgent* coordination_service_agent) override;
+
+  void RunAsync(ScopedStepContainer* step_container,
+                const EagerKernelArgs& inputs,
+                std::vector<EagerKernelRet>* outputs,
+                CancellationManager* cancellation_manager,
+                const absl::optional<EagerFunctionParams>& eager_func_params,
+                tsl::CoordinationServiceAgent* coordination_service_agent,
+                StatusCallback done) override;
+
+  const OpKernel* kernel() const override { return nullptr; }
+
+  Device* InputDevice(int i) const override;
+  Device* OutputDevice(int idx) const override;
+  Device* OutputResourceDevice(int idx) const override;
+
+  const DataTypeVector& input_dtypes() const override { return input_dtypes_; }
+  const DataTypeVector& output_dtypes() const override {
+    return output_dtypes_;
+  }
+  int num_inputs() const override { return input_dtypes_.size(); }
+  int num_outputs() const override { return output_dtypes_.size(); }
+  const string& name() const override { return name_; };
+
+ private:
+  std::shared_ptr<FunctionLibraryRuntime::Options> PrepareForRun(
+      ScopedStepContainer* step_container, std::vector<EagerKernelRet>* outputs,
+      CancellationManager* cancellation_manager,
+      const absl::optional<EagerFunctionParams>& eager_func_params,
+      const absl::optional<ManagedStackTrace>& stack_trace,
+      tsl::CoordinationServiceAgent* coordination_service_agent,
+      tsl::core::RefCountPtr<Rendezvous>* rendezvous);
+
+  ProcessFunctionLibraryRuntime* const pflr_;  // non-null
+  FunctionLibraryRuntime::Handle handle_;
+  // Indicates whether the function needs to execute cross process.
+  bool is_cross_process_;
+
+  // If true, function outputs are explicitly assigned to the default device;
+  // if false, the output devices are inferred by pflr_.
+  bool outputs_on_op_device_;
+
+  // If True, allow optimizations which should be targeted at a limited
+  // set of small functions.  (For example, running kernels synchronously can
+  // be faster under some conditions.)
+  const bool allow_small_function_optimizations_;
+
+  // If True, allows control nodes to run on the single threaded executor.
+  const bool allow_control_flow_sync_execution_;
+
+  // TODO(b/176491312): Remove this if shape inference on import flag is
+  // removed. If True, allows mlir roundtrip to run shape inference on import.
+  const bool shape_inference_on_tfe_dialect_import_;
+
+  const bool int_args_and_retvals_on_device_;
+
+  const absl::optional<string> xla_compile_device_type_;
+
+  const bool allow_soft_placement_;
+
+  // CPU devices are null. Resource handles' devices are actual backing
+  // devices.
+  std::vector<Device*> output_devices_;
+  // CPU devices are not null. Resource handles' devices are actual backing
+  // devices.
+  std::vector<Device*> input_devices_;
+  // Maps from a CompositeDevice name to a list of physical device names.
+  absl::flat_hash_map<string, const std::vector<string>*> composite_devices_;
+  std::unordered_map<int, DtypeAndPartialTensorShape>
+      input_resource_dtypes_and_shapes_;
+
+  DataTypeVector input_dtypes_;
+  DataTypeVector output_dtypes_;
+  string name_;
+
+  Rendezvous::Factory rendezvous_factory_;
+  std::function<int64_t()> get_op_id_;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_EAGER_KERNEL_AND_DEVICE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/eager/placement_utils.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/eager/placement_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..b182cf684027a44229c48afd43ab00abea1563ac
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/eager/placement_utils.h
@@ -0,0 +1,48 @@
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_EAGER_PLACEMENT_UTILS_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_EAGER_PLACEMENT_UTILS_H_
+
+#include "tensorflow/c/eager/immediate_execution_operation.h"
+#include "tensorflow/core/common_runtime/eager/context.h"
+#include "tensorflow/core/platform/status.h"
+#include "tensorflow/core/platform/stringpiece.h"
+
+namespace tensorflow {
+namespace eager {
+
+bool IsColocationExempt(StringPiece op_name);
+
+bool IsFunction(StringPiece op_name);
+
+// TODO(b/154234908): Unify placement logic.
+
+// Pin the op to cpu if all op inputs are on the CPU, small (<64 elements) and
+// integers (int32/int64). This can be disabled by setting the environment
+// variable "TF_EAGER_ENABLE_SMALL_TENSOR_CPU_PINNING" to "0" or "false".
+Status MaybePinSmallOpsToCpu(
+    bool* result, StringPiece op_name,
+    absl::Span<ImmediateExecutionTensorHandle* const> args,
+    StringPiece cpu_device_name);
+
+// If a resource touching input is specified, all resource-touching ops run in
+// the device the resource is, regardless of anything else that has been
+// specified. This is identical to the graph mode behavior.
+Status MaybePinToResourceDevice(Device** device, const EagerOperation& op);
+}  // namespace eager
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_EAGER_PLACEMENT_UTILS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/eager/rendezvous_cache.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/eager/rendezvous_cache.h
new file mode 100644
index 0000000000000000000000000000000000000000..e79171f8e8fd9d741fa510ff8d73c65df90af5b0
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/eager/rendezvous_cache.h
@@ -0,0 +1,146 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_EAGER_RENDEZVOUS_CACHE_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_EAGER_RENDEZVOUS_CACHE_H_
+
+#include <cstddef>
+#include <cstdint>
+#include <vector>
+
+#include "absl/container/flat_hash_map.h"
+#include "tsl/platform/errors.h"
+#include "tsl/platform/mutex.h"
+#include "tsl/platform/refcount.h"
+#include "tsl/platform/thread_annotations.h"
+
+namespace tensorflow {
+
+// The class for caching Rendezvous instances per step_id.
+// If the Rendezvous object is destroyed for the step, a new one will be
+// created on demand.
+template <typename T>
+class RendezvousCache : public tsl::core::WeakRefCounted {
+ public:
+  RendezvousCache() = default;
+  ~RendezvousCache() override {
+    for (auto& p : table_) {
+      auto rendez = p.second.GetNewRef();
+      if (rendez) {
+        rendez->StartAbort(tsl::errors::Aborted("Shutdown"));
+      }
+    }
+  }
+
+  // Returns a new Reference.
+  template <typename RendezvousCreator>
+  tsl::core::RefCountPtr<T> FindOrCreate(int64_t step_id,
+                                         RendezvousCreator create_fn) {
+    tsl::mutex_lock l(table_lock_);
+    tsl::core::RefCountPtr<T> rendz = nullptr;
+    auto iter = table_.find(step_id);
+    if (iter != table_.end()) {
+      rendz = iter->second.GetNewRef();
+      VLOG(5) << "step_id:" << step_id << " "
+              << "WeakPtr returned:" << rendz.get();
+      if (!rendz) {
+        table_.erase(iter);
+      }
+    }
+    if (!rendz) {  // Deleted or not found
+      rendz = create_fn();
+      VLOG(5) << "step_id:" << step_id << " "
+              << "Rendezvous not found, inserting a new one." << rendz.get();
+      auto cleanup_fn = [weak_cache = tsl::core::WeakPtr<RendezvousCache>(this),
+                         step_id]() {
+        tsl::core::RefCountPtr<RendezvousCache> cache = weak_cache.GetNewRef();
+        if (cache != nullptr) {
+          // If the rendezvous is released, Find() will clean it up from the
+          // map.
+          cache->Find(step_id);
+        }
+      };
+      table_.insert({step_id, tsl::core::WeakPtr<T>{rendz.get(), cleanup_fn}});
+    }
+    return rendz;
+  }
+
+  // Returns a new Reference.
+  tsl::core::RefCountPtr<T> Find(int64_t step_id) {
+    tsl::mutex_lock l(table_lock_);
+    auto iter = table_.find(step_id);
+    if (iter == table_.end()) return nullptr;
+    tsl::core::RefCountPtr<T> res = iter->second.GetNewRef();
+    // Cleans the record if the rendezvous is already destroyed.
+    if (res == nullptr) {
+      table_.erase(iter);
+    }
+    return res;
+  }
+
+  // Removes a Rendezvous weak reference from table.
+  void Remove(int64_t step_id) {
+    tsl::mutex_lock l(table_lock_);
+    table_.erase(step_id);
+  }
+
+  // Removes a Rendezvous weak reference from table, and abort the rendezvous.
+  void RemoveAndAbort(int64_t step_id) {
+    tsl::core::RefCountPtr<T> rendez = nullptr;
+    {
+      tsl::mutex_lock l(table_lock_);
+      auto iter = table_.find(step_id);
+      if (iter != table_.end()) {
+        rendez = iter->second.GetNewRef();
+        table_.erase(iter);
+      }
+    }
+    if (rendez) {
+      rendez->StartAbort(tsl::errors::Aborted("Cleanup ", step_id));
+    }
+  }
+
+  void RemoveAll() {
+    tsl::mutex_lock l(table_lock_);
+    table_.clear();
+  }
+
+  // Returns a list of active step ids. This result is only informative
+  // at time of the call. The returned vector may contain step ids that have
+  // been invalidated after the call.
+  std::vector<int64_t> GetActiveStepIds() {
+    std::vector<int64_t> list;
+    tsl::mutex_lock l(table_lock_);
+    list.reserve(table_.size());
+    for (const auto& iter : table_) {
+      list.push_back(iter.first);
+    }
+    return list;
+  }
+
+  size_t Size() const {
+    tsl::mutex_lock l(table_lock_);
+    return table_.size();
+  }
+
+ private:
+  mutable tsl::mutex table_lock_;
+  absl::flat_hash_map<int64_t, tsl::core::WeakPtr<T>> table_
+      TF_GUARDED_BY(table_lock_);
+};
+
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_EAGER_RENDEZVOUS_CACHE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/eager/shape_inference.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/eager/shape_inference.h
new file mode 100644
index 0000000000000000000000000000000000000000..456bfc3fcbd2388265be3d15a13943675296c9a2
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/eager/shape_inference.h
@@ -0,0 +1,36 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_EAGER_SHAPE_INFERENCE_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_EAGER_SHAPE_INFERENCE_H_
+
+#include "tensorflow/core/common_runtime/eager/tensor_handle.h"
+#include "tensorflow/core/framework/function.h"
+#include "tensorflow/core/framework/node_def.pb.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/lib/gtl/inlined_vector.h"
+
+namespace tensorflow {
+namespace eager {
+
+Status RunShapeInference(const NodeDef& ndef,
+                         const FunctionLibraryDefinition& lib_def,
+                         const gtl::InlinedVector<TensorHandle*, 4>& inputs,
+                         const gtl::InlinedVector<TensorHandle*, 2>& retvals);
+
+}  // namespace eager
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_EAGER_SHAPE_INFERENCE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/eager/small_constants_optimizer.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/eager/small_constants_optimizer.h
new file mode 100644
index 0000000000000000000000000000000000000000..cb70fb9993f93951ae0ffd02cfe0a27acfce2717
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/eager/small_constants_optimizer.h
@@ -0,0 +1,42 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_EAGER_SMALL_CONSTANTS_OPTIMIZER_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_EAGER_SMALL_CONSTANTS_OPTIMIZER_H_
+
+#include <string>
+#include <vector>
+
+#include "absl/strings/string_view.h"
+#include "tensorflow/core/framework/function.h"
+#include "tensorflow/core/framework/function.pb.h"
+
+namespace tensorflow::small_constants_optimizer {
+
+// Checks whether small constant optimization is enabled for a tf.function.
+bool IsSmallConstantOptimizationEnabled(const FunctionDef& fdef);
+
+// Generates new FunctionDefs with the boolean input tensors folded as
+// constants into the FunctionDef.
+std::vector<FunctionDef> FoldInputTensors(
+    const FunctionDef& fdef, const FunctionLibraryDefinition& flib);
+
+// Generates the FunctionDef name for the folded function.
+std::string FoldedFunctionName(absl::string_view fname,
+                               absl::string_view input_name, bool input_value);
+
+}  // namespace tensorflow::small_constants_optimizer
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_EAGER_SMALL_CONSTANTS_OPTIMIZER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/eager/summary_optimizer.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/eager/summary_optimizer.h
new file mode 100644
index 0000000000000000000000000000000000000000..0b337e04f3773257dade9cc81166d6f29e18761f
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/eager/summary_optimizer.h
@@ -0,0 +1,51 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_EAGER_SUMMARY_OPTIMIZER_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_EAGER_SUMMARY_OPTIMIZER_H_
+
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "absl/strings/string_view.h"
+#include "tensorflow/core/framework/function.h"
+#include "tensorflow/core/framework/function.pb.h"
+
+namespace tensorflow::summary_optimizer {
+namespace internal {
+
+// Normalizes an edge's name to match the names stored in a NodeDef.
+std::string NormalizeEdgeName(absl::string_view name);
+
+}  // namespace internal
+
+// Returns the name of the input_arg and the bool value that determines whether
+// or not to disable summaries. If no such arg exists returns an empty string.
+std::pair<absl::string_view, bool> GetDisableSummariesInputArg(
+    const FunctionDef& fdef);
+
+// Generates new FunctionDef(s) with the summaries stripped out.
+// This function will traverse all the nested functions and generate a version
+// of the nested functions with summaries stripped out.
+std::vector<FunctionDef> StripSummaries(const FunctionDef& fdef,
+                                        const FunctionLibraryDefinition& flib);
+
+// Generates a new function name for the stripped function.
+std::string StrippedFunctionName(absl::string_view fname);
+
+}  // namespace tensorflow::summary_optimizer
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_EAGER_SUMMARY_OPTIMIZER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/eager/tensor_handle.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/eager/tensor_handle.h
new file mode 100644
index 0000000000000000000000000000000000000000..53c733aaa5c8f3d655a1d109232571b14d063cea
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/eager/tensor_handle.h
@@ -0,0 +1,416 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_EAGER_TENSOR_HANDLE_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_EAGER_TENSOR_HANDLE_H_
+
+#include <algorithm>
+#include <cstddef>
+#include <memory>
+#include <queue>
+#include <string>
+#include <unordered_map>
+#include <variant>
+#include <vector>
+
+// clang-format off
+// Required for IS_MOBILE_PLATFORM
+#include "tensorflow/core/framework/full_type.pb.h"
+#include "tensorflow/core/framework/shape_inference.h"
+#include "tensorflow/core/framework/tensor_shape.h"
+#include "tensorflow/core/platform/platform.h"
+// clang-format on
+
+#include "absl/types/variant.h"
+#include "tensorflow/c/eager/immediate_execution_tensor_handle.h"
+#include "tensorflow/core/common_runtime/device.h"
+#include "tensorflow/core/common_runtime/eager/eager_executor.h"
+#include "tensorflow/core/common_runtime/eager/tensor_handle_data.h"
+#include "tensorflow/core/common_runtime/function.h"
+#if !defined(IS_MOBILE_PLATFORM)
+#include "tensorflow/core/distributed_runtime/eager/remote_tensor_handle_data.h"
+#endif  // IS_MOBILE_PLATFORM
+#include "tensorflow/core/framework/tensor.h"
+
+#include "tensorflow/core/lib/core/stringpiece.h"
+
+#include "tensorflow/core/platform/mutex.h"
+#include "tensorflow/core/platform/thread_annotations.h"
+
+namespace tensorflow {
+
+class EagerContext;
+
+// Associates a Tensor and a Device, used in the eager runtime. Internal version
+// of the TFE_TensorHandle struct and the python EagerTensor class
+// (unrelated to python TensorHandle).
+class TensorHandle : public ImmediateExecutionTensorHandle {
+  // TensorHandle for dtype != DT_RESOURCE
+  TensorHandle(tensorflow::Tensor&& t, Device* d, Device* op_device,
+               Device* resource_device, EagerContext* ctx);
+  // TensorHandle for dtype == DT_RESOURCE
+  TensorHandle(tensorflow::Tensor&& t, Device* d, Device* op_device,
+               EagerContext* ctx);
+  TensorHandle(Device* d, Device* op_device, Device* resource_device,
+               tensorflow::DataType dtype, EagerContext* ctx);
+
+#if !defined(IS_MOBILE_PLATFORM)
+  TensorHandle(int64_t op_id, int32_t output_num, const string& remote_task,
+               tensorflow::DataType dtype, Device* device, EagerContext* ctx,
+               bool unknown_device);
+  TensorHandle(int64_t op_id, int32_t output_num, tensorflow::DataType dtype,
+               Device* device, bool is_ready, EagerContext* ctx);
+#endif  // IS_MOBILE_PLATFORM
+
+ public:
+  // TensorHandle with no assigned device
+  static TensorHandle* CreateLocalHandle(const tensorflow::Tensor& t);
+  static TensorHandle* CreateLocalHandle(tensorflow::Tensor&& t, Device* d,
+                                         Device* op_device, EagerContext* ctx);
+  static TensorHandle* CreateLocalHandle(tensorflow::Tensor&& t, Device* d,
+                                         Device* op_device,
+                                         Device* resource_device,
+                                         EagerContext* ctx);
+  static TensorHandle* CreateEmptyLocalHandle(Device* d, Device* op_device,
+                                              Device* resource_device,
+                                              tensorflow::DataType dtype,
+                                              EagerContext* ctx);
+
+  // Create a handle which packs the given handles of the same dtype and shape.
+  // If handles are on different devices, assign the packed handle to a
+  // CompositeDevice.
+  //
+  // The new tensor handle shares ownership of the given handle: their reference
+  // count will be increased by one after a call to `CreatePackedHandle`.
+  // TODO(b/170414377): Use `TensorHandlePtr` instead.
+  static Status CreatePackedHandle(std::vector<TensorHandle*>&& handles,
+                                   tensorflow::DataType dtype,
+                                   const tensorflow::TensorShape& shape,
+                                   const string& device_name, EagerContext* ctx,
+                                   TensorHandle** packed_handle);
+  static Status CreatePackedHandle(std::vector<TensorHandle*>&& handles,
+                                   EagerContext* ctx,
+                                   TensorHandle** packed_handle);
+
+#if !defined(IS_MOBILE_PLATFORM)
+  // An unshaped remote handle refers to a tensor on a remote worker. It's not
+  // ready until the shape is set. It controls the lifetime of the remote
+  // tensor.
+  static TensorHandle* CreateUnshapedRemoteHandle(int64_t op_id,
+                                                  int32_t output_num,
+                                                  const string& remote_task,
+                                                  tensorflow::DataType dtype,
+                                                  Device* d, EagerContext* ctx,
+                                                  bool unknown_device = false);
+  // A lazy remote handle refers to a tensor on a remote worker. The lifetime of
+  // the remote tensor is controlled by the remote worker, but not by the lazy
+  // remote handle. Lazy handles are normally created on a default function
+  // device.
+  static TensorHandle* CreateLazyRemoteHandle(int64_t op_id, int32_t output_num,
+                                              tensorflow::DataType dtype,
+                                              Device* d, bool is_ready,
+                                              EagerContext* ctx);
+#endif  // IS_MOBILE_PLATFORM
+
+  // Templated struct `AutoReleaser` in
+  // core/runtime_fallback/runtime/kernel_utils.h needs a Release() method
+  // defined.
+  void Release();
+
+  tensorflow::DataType DataType() const override;
+  Status Shape(tensorflow::PartialTensorShape* shape) const override;
+  Status NumDims(int* num_dims) const override;
+  Status NumElements(int64_t* num_elements) const override;
+  Status Dim(int dim_index, int64_t* dim) const override;
+
+  const char* DeviceName(Status* status) const override;
+  const char* BackingDeviceName(Status* status) const override;
+  const char* DeviceType(Status* status) const override;
+  int DeviceId(Status* status) const override;
+  AbstractTensorInterface* Resolve(Status* status) override;
+
+  // Subclasses may return True to instruct the string formatter
+  // to use SummarizeValue instead of the NumPy formatter.
+  bool PreferCustomSummarizer() const override {
+    return dtype == DT_VARIANT || dtype == DT_RESOURCE;
+  }
+
+  // Return the Tensor from the default device.
+  Status Tensor(const tensorflow::Tensor** t) const;
+  // Return the Tensor from the specified device which could be either the
+  // default device or a local mirror. The device pointer should be nullptr if
+  // requesting the HostCPU.
+  Status TensorFromDevice(const Device* d, const tensorflow::Tensor** t) const;
+
+  // Return the TensorValue from the specified device which could be either the
+  // default device or a local mirror. The device pointer should be nullptr if
+  // requesting the HostCPU.
+  Status TensorValue(const Device* d, tensorflow::TensorValue* t);
+
+  Device* device() const { return device_; }
+  Device* op_device() const { return op_device_; }
+  Device* resource_device() const { return resource_device_; }
+  int64_t resource_remote_device_incarnation() const {
+    return resource_remote_device_incarnation_;
+  }
+
+  // If the devices are unknown at creation time, block until the actual devices
+  // are set (data is ready).
+  Status WaitUnknownDevice() const;
+
+  Device* DeviceOrHostCPU(const EagerContext& ctx) const;
+
+  Status Shape(tensorflow::TensorShape* shape);
+
+  Status Unprotect(const Device* d);
+
+  // Checks if a mirror tensor exists for the specified device. Mirrors are only
+  // maintained for local devices, like CPUs & GPUs. Note a mirror may be empty,
+  // as it is still to be set by an async operation.
+  bool HasLocalMirror(const Device* d) const;
+  // Add an empty mirror placeholder for the specified device. The expectation
+  // is this will be populated by a call to SetTensor.
+  Status AddEmptyLocalMirror(const Device* d);
+  // Add a local mirror. This will fail if an empty local mirror was previously
+  // added. For that case, SetTensor should be used instead.
+  Status AddLocalMirror(tensorflow::Tensor&& tensor, const Device* d);
+
+#if !defined(IS_MOBILE_PLATFORM)
+  bool HasRemoteMirror(const Device* d, uint64 context_view_id) const;
+  bool HasResourceShapeMirror(const Device* d, uint64 context_view_id) const;
+
+  Status AddUnshapedRemoteMirror(const Device* d, int64_t op_id, int output_num,
+                                 const string& remote_task, EagerContext* ctx);
+  Status AddResourceShapeMirror(const Device* d, int64_t op_id, int output_num,
+                                EagerContext* ctx);
+
+  // Return the op_id and output num if the handle refers to a remote tensor.
+  // If wait_until_ready is true, block until the remote tensor is ready on the
+  // given remote worker.
+  Status RemoteAddress(const Device* d, bool wait_until_ready, int64_t* op_id,
+                       int32* output_num) const;
+
+  // Called on an async remote tensor once it's shape has been determined. This
+  // transitions the tensor handle from a non-ready to a ready state by
+  // replacing the backing data abstraction to allow for the shape to be
+  // queried.
+  // creating a TensorHandle (e.g. a remote output of a remote function).
+  // This method or Poison must be called exactly once for remote tensors that
+  // were created without a known shape.
+  Status SetRemoteShape(const TensorShape& shape, const Device* d,
+                        uint64 context_view_id);
+  // If op_device is not empty, reset the devices of a remote tensor which is
+  // created without known devices (e.g. function outputs).
+  Status SetRemoteShapeAndDevice(const TensorShape& shape, const Device* d,
+                                 uint64 context_view_id, string op_device);
+
+  // Poisons either this handle or a remote mirror with error `status`.
+  // Poisoning means that the handle will become ready and methods trying
+  // to access the remote shape will return this error `status`.
+  // Exactly one of SetRemoteShape or PoisonRemote methods must be called on a
+  // unshaped handle on a remote device.
+  void PoisonRemote(Status status, const Device* d, uint64 context_view_id);
+#endif
+
+  // Sets the `tensor` for this async non-ready handle making it ready.
+  // This method or Poison must be called exactly once for non-ready async
+  // handles to make them ready.
+  Status SetTensor(tensorflow::Tensor&& tensor, const Device* d);
+
+  // Poisons either this handle or a local mirror with error `status`.
+  // Poisoning means that the handle will become ready and methods trying
+  // to access the actual tensor or shape will return this error `status`.
+  // Exactly one of SetTensor or Poison methods must be called on a non-ready
+  // tensor for a specific device.
+  void Poison(Status status, const Device* d);
+
+  // TODO(b/154282629): Consider moving it to EagerContext.
+  // Copies to the tensor on the given device `d`, or to host iff `d` is null.
+  Status CopyToDevice(const EagerContext& ctx, tensorflow::Device* d,
+                      tensorflow::Tensor* output) const;
+
+  Status InferenceShape(shape_inference::InferenceContext* inference_context,
+                        shape_inference::ShapeHandle* shape_handle);
+  void SetInferenceShape(shape_inference::InferenceContext* inference_context,
+                         const shape_inference::ShapeHandle& shape_handle);
+  Status CopyInferenceShape(TensorHandle* other);
+
+  // dtype for the handle. It must be the same as t.dtype() once the handle is
+  // ready.
+  const tensorflow::DataType dtype;
+
+  enum HandleType { LOCAL = 0, PACKED = 1, REMOTE = 2 };
+
+  HandleType Type() const;
+  string TypeString() const;
+
+  void SetResourceHandleDtypeAndShape(
+      std::vector<DtypeAndPartialTensorShape> dtypes_and_shapes);
+
+  // If this TensorHandle is 1) a local tensor, and 2) a resource handle,
+  // return data types and shapes of the underlying resource.
+  Status GetResourceHandleDtypesAndShapes(
+      std::vector<DtypeAndPartialTensorShape>* result);
+
+  // Returns the number of packed handles. 0 if the handle type is not PACKED.
+  int NumPackedHandles() const;
+  // It's called on a packed TensorHandle. Extract a handle with the given
+  // index.
+  Status ExtractPackedHandle(int index, TensorHandle** handle) const;
+
+  // For LLVM style RTTI.
+  static bool classof(const AbstractTensorHandle* ptr) {
+    return ptr->getKind() == kEager;
+  }
+
+  tensorflow::FullTypeDef FullType() const override { return full_type_; }
+
+  void SetFullType(FullTypeDef& full_type) { full_type_ = full_type; }
+
+ private:
+  friend class PackedTensorHandleTest;
+
+  TensorHandle(std::vector<TensorHandle*>&& handles, Device* device,
+               tensorflow::DataType dtype, const tensorflow::TensorShape& shape,
+               EagerContext* ctx);
+
+  ~TensorHandle() override;
+
+  // The TensorHandleData can either represent a local or remote tensor handle.
+  // Further, it can be in a non-ready state. It would become ready with a call
+  // to either SetTensor or SetRemoteShape which replaces the underlying data
+  // with a ready version of the tensor handle data.
+  bool IsReady() const;
+  Status WaitReady(const char* caller) const;
+
+  tensorflow::Device* device_;
+
+  // Device in which the op producing this tensor was executed. Equals to
+  // device_ for constant tensors.
+  // Can be nullptr if the op producing this tensor was a function executed
+  // with function library runtime.
+  tensorflow::Device* op_device_;
+
+  // If the tensor dtype is DT_RESOURCE, resource_device_ holds the device
+  // backing the resource. Else resource_device_ is nullptr.
+  tensorflow::Device* resource_device_;
+  // Incarnation ID of the resource device if it locates on a remote device, or
+  // 0 if it locates on a local device.
+  int64_t resource_remote_device_incarnation_;
+
+  // If true, the handle refers to a remote tensor which is created without
+  // known devices. The actual devices are set by SetRemoteShape. The devices
+  // should be accessed once the handle is ready.
+  const bool unknown_device_ = false;
+
+  mutable mutex mu_;
+
+  // Map of local mirrors. This can include both ready and non-ready mirrors.
+  std::unordered_map<const tensorflow::Device*, LocalTensorHandleData>
+      local_mirrors_ TF_GUARDED_BY(mu_);
+#if !defined(IS_MOBILE_PLATFORM)
+  // TODO(yujingzhang): Remove resource_shape_mirrors_ once scalable per-replica
+  // variable is ready, since we could get the shape locally without remote copy
+  // then.
+  std::unordered_map<string, RemoteTensorHandleData> resource_shape_mirrors_
+      TF_GUARDED_BY(mu_);
+  std::unordered_map<string, RemoteTensorHandleData> remote_mirrors_
+      TF_GUARDED_BY(mu_);
+#endif
+
+  // `ctx` is only guaranteed to be set if the handle is not "ready". This is
+  // typically true when the handle was produced during async execution.
+  // `ctx` object is not owned and should outlive this handle.
+  //
+  // TODO(b/150614042): Reference count EagerContext to ensure that 'device_' of
+  // a TensorHandle does not outlive the EagerContext from which it came?
+  EagerContext* const ctx_;
+
+  // Does not need synchronization because it can be accessed only after
+  // WaitReady() has returned. At that point, is_poisoned_ is immutable.
+  Status is_poisoned_;
+
+  // If this TensorHandle 1) is a local tensor, and 2) is a resource handle or
+  // refers to a remote resource handle, we store data types and shapes for
+  // the underlying resource.
+  std::vector<DtypeAndPartialTensorShape> handle_dtypes_and_shapes_;
+
+  // A handle data which refers to multiple TensorHandles of the same dtype and
+  // shape.
+  class PackedTensorHandleData {
+   public:
+    // Initialize handle data from list of tensor handles.
+    // Ownership of the tensor handles is shared between the
+    // `PackedTensorHandleData` and the caller (the reference count for the
+    // given handles is incremented).
+    // TODO(b/170414377): Use `TensorHandlePtr` instead.
+    PackedTensorHandleData(std::vector<TensorHandle*>&& handles,
+                           const TensorShape& shape);
+
+    ~PackedTensorHandleData();
+
+    Status Shape(TensorShape* shape) const;
+    Status NumDims(int* num_dims) const;
+    Status Dim(int dim_index, int64_t* dim) const;
+    Status NumElements(int64_t* num_elements) const;
+    Status Unprotect();
+    bool IsReady() const;
+    Status WaitReady(const char* caller) const;
+    void Poison(Status status);
+    string DebugString() const;
+
+    // Number of packed handles.
+    int NumPackedHandles() const;
+    // Extract a handle on the given index.
+    Status ExtractPackedHandle(int index, TensorHandle** handle) const;
+
+   private:
+    // TODO(b/170414377): Use `TensorHandlePtr` instead.
+    const std::vector<TensorHandle*> handles_;
+    const TensorShape shape_;
+
+    mutable mutex mu_;
+    Status is_poisoned_ TF_GUARDED_BY(mu_);
+  };
+
+  // Does not need synchronization because it can be accessed only after
+  // WaitReady() has returned. At that point, data_ is immutable.
+#if !defined(IS_MOBILE_PLATFORM)
+  std::variant<LocalTensorHandleData, PackedTensorHandleData,
+               RemoteTensorHandleData>
+      data_;
+#else
+  absl::variant<LocalTensorHandleData, PackedTensorHandleData> data_;
+#endif
+
+  PartialTensorShape inference_shape_;
+
+  FullTypeDef full_type_;
+};
+
+// Returns the device backing the resource. Else, returns nullptr.
+Device* GetResourceDevice(const ResourceHandle& handle, EagerContext* ctx);
+
+class TensorHandleInterface : public ImmediateExecutionTensorHandle {
+ public:
+};
+
+template <typename T>
+inline TensorHandle* TensorHandleFromInterface(T* handle) {
+  return down_cast<TensorHandle*>(handle);
+}
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_EAGER_TENSOR_HANDLE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/eager/tensor_handle_data.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/eager/tensor_handle_data.h
new file mode 100644
index 0000000000000000000000000000000000000000..8fb2083295a17639dd1e41bc90cd3dccaccd3efa
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/eager/tensor_handle_data.h
@@ -0,0 +1,113 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_EAGER_TENSOR_HANDLE_DATA_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_EAGER_TENSOR_HANDLE_DATA_H_
+
+#include <utility>
+#include <variant>
+
+#include "absl/types/variant.h"
+#include "tensorflow/core/common_runtime/eager/context.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/lib/core/status.h"
+
+namespace tensorflow {
+
+// Local Tensor Handle: Handle to a Tensor present on the local host.
+class LocalTensorHandleData {
+ public:
+  LocalTensorHandleData() : ctrl_(absl::in_place_type<BlockingControl>) {}
+  explicit LocalTensorHandleData(tensorflow::Tensor&& t)
+      : tensor_(std::move(t)),
+        forwarding_protection_tensor_(tensor_),
+        ctrl_(absl::in_place_type<NonBlockingControl>) {}
+
+  // A local tensor handle should be able to satisfy all of these requests.
+  Status Tensor(const tensorflow::Tensor** t) const;
+  Status TensorValue(tensorflow::TensorValue* t);
+  Status Shape(TensorShape* shape) const;
+  Status NumDims(int* num_dims) const;
+  Status Dim(int dim_index, int64_t* dim) const;
+  Status NumElements(int64_t* num_elements) const;
+  Status Unprotect();
+
+  bool IsReady() const {
+    return std::visit([](auto& data) { return data.IsReady(); }, ctrl_);
+  }
+
+  Status WaitReady(const char* caller) const {
+    return std::visit([caller](auto& data) { return data.WaitReady(caller); },
+                      ctrl_);
+  }
+  void Poison(Status status) {
+    return std::visit([status](auto& data) { data.Poison(status); }, ctrl_);
+  }
+  Status IsPoisoned() const {
+    return std::visit([](auto& data) { return data.IsPoisoned(); }, ctrl_);
+  }
+
+  Status SetTensor(tensorflow::Tensor&& t);
+
+  string DebugString() const;
+
+ private:
+  tensorflow::Tensor tensor_;
+  // TensorHandle has its own reference counting which is distinct from the
+  // backing Tensor. As a result, if the Tensor reference count is 1 while
+  // executing an op, the TensorBuffer could be reused for the output. We avoid
+  // this behavior maintaining another reference count with the
+  // forwarding_protection_tensor_ Tensor. When Unprotect() is called, we
+  // release this Tensor to allow forwarding.
+  tensorflow::Tensor forwarding_protection_tensor_;
+
+  // We distinguish between ready and empty tensors with the ctrl_ variant.
+  // which contains 2 implementations of the waiting logic. The
+  // NonBlockingControl is a simple no-op class whereas the BlockingControl
+  // actually uses a mutex. By using a variant we avoid the overhead of
+  // constructing and destructing the mutex for ready local tensors.
+  class NonBlockingControl {
+   public:
+    bool IsReady() const { return true; }
+    Status WaitReady(const char* caller) const { return OkStatus(); }
+    void Poison(Status status) {}
+    Status IsPoisoned() const { return OkStatus(); }
+  };
+
+  class BlockingControl {
+   public:
+    bool IsReady() const {
+      tf_shared_lock l(mu_);
+      return is_ready_;
+    }
+    void SetReady();
+    Status WaitReady(const char* caller) const;
+    void Poison(Status status);
+    Status IsPoisoned() const {
+      tf_shared_lock l(mu_);
+      return is_poisoned_;
+    }
+
+   private:
+    mutable mutex mu_;
+    bool is_ready_ TF_GUARDED_BY(mu_);
+    Status is_poisoned_ TF_GUARDED_BY(mu_);
+  };
+
+  std::variant<NonBlockingControl, BlockingControl> ctrl_;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_EAGER_TENSOR_HANDLE_DATA_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/eval_const_tensor.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/eval_const_tensor.h
new file mode 100644
index 0000000000000000000000000000000000000000..e46c6ffc76aa51de1d72407a2f333af80bee7f3d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/eval_const_tensor.h
@@ -0,0 +1,63 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_EVAL_CONST_TENSOR_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_EVAL_CONST_TENSOR_H_
+
+#include <cstdint>
+#include <optional>
+
+#include "absl/functional/function_ref.h"
+#include "tensorflow/core/platform/statusor.h"
+
+namespace tensorflow {
+
+class GraphRunner;
+class Node;
+class OpRegistryInterface;
+class ShapeRefiner;
+class Tensor;
+
+// Configuration of the graph runner for constant folding.
+struct EvaluateConstantTensorRunner {
+  // Op registry for temporary graphs. By default, the global registry will
+  // be used.
+  const OpRegistryInterface* op_registry = nullptr;
+  // Version of the graph API to use.
+  int32_t graph_def_version = 0;
+  // Graph runner for constant folding. By default, a temporary graph runner
+  // will be created.
+  GraphRunner* graph_runner = nullptr;
+};
+
+// Attempts to evaluate an output of the given node. This will only be possible
+// if it doesn't depend on any graph inputs (this function is safe to call
+// if this isn't the case though).
+//
+// When the evaluation is successful, the function returns a tensor, otherwise
+// it returns std::nullopt.
+StatusOr<std::optional<Tensor>> EvaluateConstantTensor(
+    // The tensor to be evaluated.
+    const Node& node, int node_output,
+    // Used to fetch inference contexts for nodes in the graph.
+    const ShapeRefiner& refiner,
+    // Used to both lookup cached results and request function arguments.
+    absl::FunctionRef<std::optional<Tensor>(const Node&, int)> lookup,
+    // Configuration of the graph runner. If not set, no attempt to fold a
+    // constant subgraph will be made.
+    std::optional<EvaluateConstantTensorRunner> runner);
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_EVAL_CONST_TENSOR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/executor.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/executor.h
new file mode 100644
index 0000000000000000000000000000000000000000..607cf9b37a55a6b607a651fb2c616b4b54bcdadd
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/executor.h
@@ -0,0 +1,263 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_EXECUTOR_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_EXECUTOR_H_
+
+#include <optional>
+
+#include "absl/time/time.h"
+#include "absl/types/optional.h"
+#include "tensorflow/core/common_runtime/device.h"
+#include "tensorflow/core/common_runtime/local_executor_params.h"
+#include "tensorflow/core/framework/rendezvous.h"
+#include "tensorflow/core/framework/session_state.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/graph/graph.h"
+#include "tensorflow/core/lib/core/errors.h"
+#include "tensorflow/core/lib/core/notification.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/lib/core/threadpool_interface.h"
+#include "tensorflow/core/platform/error_logging.h"
+#include "tensorflow/core/platform/logging.h"
+#include "tensorflow/core/platform/macros.h"
+#include "tensorflow/core/util/managed_stack_trace.h"
+
+namespace tensorflow {
+
+class StepStatsCollector;
+
+// Executor runs a graph computation.
+// Example:
+//   Graph* graph = ...;
+//      ... construct graph ...
+//   Executor* executor;
+//   TF_CHECK_OK(NewSimpleExecutor(my_device, graph, &executor));
+//   Rendezvous* rendezvous = NewNaiveRendezvous();
+//   TF_CHECK_OK(rendezvous->Send("input", some_input_tensor));
+//   TF_CHECK_OK(executor->Run({ExecutorOpts, rendezvous, nullptr}));
+//   TF_CHECK_OK(rendezvous->Recv("output", &output_tensor));
+//   ... ...
+//
+// Multiple threads can call Executor::Run concurrently.
+class Executor {
+ public:
+  virtual ~Executor() {}
+
+  // RunAsync() executes the graph computation. "done" is run when the
+  // graph computation completes. If any error happens during the
+  // computation, "done" is run and the error is passed to "done".
+  //
+  // RunAsync() is given a few arguments in Args. The caller must
+  // ensure objects passed in Args (rendezvous, stats_collector, etc.)
+  // are alive at least until done is invoked. All pointers to the
+  // argument objects can be nullptr.
+  //
+  // "step_id" is a process-wide unique identifier for the step being
+  // run. Executors on different devices may receive the same step_id
+  // in the case that a step runs Ops on more than one device. The
+  // step_id is used for tracking resource usage of a given step.
+  //
+  // RunAsync() uses the given "rendezvous", if not null, as the
+  // mechanism to communicate inputs and outputs of the underlying
+  // graph computation.
+  //
+  // RunAsync() calls "stats_collector", if not null, to keep track of
+  // stats. This allows us to collect statistics and traces on demand.
+  //
+  // RunAsync() is provided a "call_frame", if the executor is used
+  // for executing a function, is used to pass arguments and return
+  // values between the caller and the callee.
+  //
+  // RunAsync() uses "cancellation_manager", if not nullptr, to
+  // register callbacks that should be called if the graph computation
+  // is canceled. Note that the callbacks merely unblock any
+  // long-running computation, and a canceled step will terminate by
+  // returning/calling the DoneCallback as usual.
+  //
+  // RunAsync() dispatches closures to "runner". Typically, "runner"
+  // is backed up by a bounded threadpool.
+  //
+  // "start_time_usecs" is a timestamp for the start of RunAsync()
+  // execution. Used for system-wide latency metrics.
+  struct Args {
+    int64_t step_id = 0;
+    // Used only by tracer/profiler, applicable only when running under
+    // FunctionRuntimeLibrary, unique per invocation.
+    std::optional<int64_t> function_trace_id;
+    RendezvousInterface* rendezvous = nullptr;
+    StepStatsCollectorInterface* stats_collector = nullptr;
+    CallFrameInterface* call_frame = nullptr;
+    CancellationManager* cancellation_manager = nullptr;
+    SessionState* session_state = nullptr;
+    // Unique session identifier. Can be empty.
+    string session_handle;
+    TensorStore* tensor_store = nullptr;
+    ScopedStepContainer* step_container = nullptr;
+    CollectiveExecutor* collective_executor = nullptr;
+    thread::ThreadPoolInterface* user_intra_op_threadpool = nullptr;
+    tsl::CoordinationServiceAgent* coordination_service_agent = nullptr;
+    int64_t start_time_usecs = 0;
+    // The deadline for the kernel to complete by. Empty if unspecified.
+    absl::optional<absl::Time> deadline;
+    absl::optional<ManagedStackTrace> stack_trace = absl::nullopt;
+
+    // If true, calls Sync() on the device.
+    bool sync_on_finish = false;
+
+    typedef std::function<void()> Closure;
+    typedef std::function<void(Closure)> Runner;
+    Runner runner = nullptr;
+
+    // If true, all kernels will be treated as "inexpensive", and hence executed
+    // on the scheduling thread.
+    bool run_all_kernels_inline = false;
+  };
+  typedef std::function<void(const Status&)> DoneCallback;
+
+  void RunAsync(const Args& args, DoneCallback done) {
+    RunAsyncInternal(args, [done = std::move(done)](const Status& s) {
+      if (!s.ok()) Log("TFExecutor", "Run", s.message()).IgnoreError();
+      done(s);
+    });
+  }
+
+  // Synchronous wrapper for RunAsync().
+  virtual Status Run(const Args& args) {
+    Status ret;
+    Notification n;
+    RunAsync(args, [&ret, &n](const Status& s) {
+      ret = s;
+      n.Notify();
+    });
+    n.WaitForNotification();
+    return ret;
+  }
+
+ private:
+  virtual void RunAsyncInternal(const Args& args, DoneCallback done) = 0;
+};
+
+// Creates an Executor that computes the given "graph".
+//
+// If successful, returns the constructed executor in "*executor". Otherwise,
+// returns an error status.
+//
+// "params" provides a set of context for the executor. We expect that
+// different context would provide different implementations.
+::tensorflow::Status NewLocalExecutor(const LocalExecutorParams& params,
+                                      const Graph& graph, Executor** executor);
+
+// A class to help run multiple executors in parallel and wait until
+// all of them are complete.
+//
+// ExecutorBarrier deletes itself after the function returned by Get()
+// is called.
+class ExecutorBarrier {
+ public:
+  typedef std::function<void(const Status&)> StatusCallback;
+
+  // Create an ExecutorBarrier for 'num' different executors.
+  //
+  // 'r' is the shared Rendezvous object that is used to communicate
+  // state.  If any of the executors experiences an error, the
+  // rendezvous object will be aborted exactly once.
+  //
+  // 'done' is called after the last executor completes, and
+  // ExecutorBarrier is deleted.
+  ExecutorBarrier(size_t num, Rendezvous* r, StatusCallback done)
+      : rendez_(r), done_cb_(done), pending_(num) {}
+
+  ~ExecutorBarrier() {}
+
+  // Returns a closure that Executors must call when they are done
+  // computing, passing the status of their execution as an argument.
+  StatusCallback Get() {
+    return std::bind(&ExecutorBarrier::WhenDone, this, std::placeholders::_1);
+  }
+
+ private:
+  Rendezvous* rendez_ = nullptr;
+  StatusCallback done_cb_ = nullptr;
+
+  mutable mutex mu_;
+  int pending_ TF_GUARDED_BY(mu_) = 0;
+  StatusGroup status_group_ TF_GUARDED_BY(mu_);
+
+  void WhenDone(const Status& s) {
+    Rendezvous* error_rendez = nullptr;
+    StatusCallback done = nullptr;
+    Status status;
+
+    {
+      mutex_lock l(mu_);
+
+      // If we are the first error encountered, trigger an abort of the
+      // Rendezvous object by this thread only.
+      if (status_group_.ok() && !s.ok()) {
+        error_rendez = rendez_;
+        error_rendez->Ref();
+      }
+
+      if (!s.ok() && !StatusGroup::IsDerived(s) &&
+          !status_group_.HasLogMessages()) {
+        status_group_.AttachLogMessages();
+      }
+
+      status_group_.Update(s);
+
+      // If this is the last call to WhenDone, call the final callback
+      // below.
+      if (--pending_ == 0) {
+        CHECK(done_cb_ != nullptr);
+        std::swap(done, done_cb_);
+        status = status_group_.as_summary_status();
+      }
+    }
+
+    if (error_rendez != nullptr) {
+      error_rendez->StartAbort(
+          errors::Aborted("Stopping remaining executors."));
+      error_rendez->Unref();
+    }
+
+    if (done != nullptr) {
+      delete this;
+      if (!status.ok()) {
+        VLOG(1) << "ExecutorBarrier finished with bad status: " << status;
+      }
+      done(status);
+    }
+  }
+
+  ExecutorBarrier(const ExecutorBarrier&) = delete;
+  void operator=(const ExecutorBarrier&) = delete;
+};
+
+// A few helpers to facilitate create/delete kernels.
+
+// Creates a kernel based on "props" on device "device". The kernel can
+// access the functions in the "flib". The caller takes ownership of
+// returned "*kernel".
+Status CreateNonCachedKernel(Device* device, FunctionLibraryRuntime* flib,
+                             const std::shared_ptr<const NodeProperties>& props,
+                             int graph_def_version, OpKernel** kernel);
+
+// Deletes "kernel" returned by CreateKernel.
+void DeleteNonCachedKernel(OpKernel* kernel);
+
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_EXECUTOR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/executor_factory.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/executor_factory.h
new file mode 100644
index 0000000000000000000000000000000000000000..bda5d3c4b82fa2d3185abd6261235d3c79d3c40d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/executor_factory.h
@@ -0,0 +1,50 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_EXECUTOR_FACTORY_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_EXECUTOR_FACTORY_H_
+
+#include <string>
+
+#include "tensorflow/core/lib/core/errors.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/lib/gtl/array_slice.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+
+class Executor;
+class Graph;
+struct LocalExecutorParams;
+
+class ExecutorFactory {
+ public:
+  virtual Status NewExecutor(const LocalExecutorParams& params,
+                             const Graph& graph,
+                             std::unique_ptr<Executor>* out_executor) = 0;
+  virtual ~ExecutorFactory() {}
+
+  static void Register(const string& executor_type, ExecutorFactory* factory);
+  static Status GetFactory(const string& executor_type,
+                           ExecutorFactory** out_factory);
+};
+
+Status NewExecutor(const string& executor_type,
+                   const LocalExecutorParams& params, const Graph& graph,
+                   std::unique_ptr<Executor>* out_executor);
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_EXECUTOR_FACTORY_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/function.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/function.h
new file mode 100644
index 0000000000000000000000000000000000000000..f86732b2dd6e3f08d5a8da302ee3c5a049af8d0b
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/function.h
@@ -0,0 +1,81 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_FUNCTION_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_FUNCTION_H_
+
+#include <functional>
+#include <memory>
+
+#include "absl/types/optional.h"
+#include "tensorflow/core/common_runtime/device.h"
+#include "tensorflow/core/common_runtime/device_mgr.h"
+#include "tensorflow/core/common_runtime/function_body.h"
+#include "tensorflow/core/common_runtime/function_def_utils.h"
+#include "tensorflow/core/common_runtime/function_utils.h"
+#include "tensorflow/core/common_runtime/graph_optimizer.h"
+#include "tensorflow/core/common_runtime/inline_function_utils.h"
+#include "tensorflow/core/common_runtime/process_function_library_runtime.h"
+#include "tensorflow/core/framework/function.h"
+#include "tensorflow/core/graph/graph.h"
+#include "tensorflow/core/protobuf/config.pb.h"
+
+namespace tensorflow {
+
+// Get default customizable kernel creator if set
+const CustomKernelCreator* GetDefaultCustomKernelCreator();
+
+// Registers a default customizable kernel creator for a function call.
+//
+// If c->CanCreateKernel returns false, we still fall back to an executor-based
+// interpreter op kernel to execute a function. Else c->CreateKernel() can be
+// used to create a kernel that will compile the function with XLA and run the
+// resulting program.
+void RegisterDefaultCustomKernelCreator(CustomKernelCreator* c);
+
+// Creates a FunctionLibraryRuntime, which instantiates functions
+// defined in "lib_def" and executes functions on the "device".
+// "device_mgr" must contain the "device".
+//
+// The returned object does not take ownerships of "device" or
+// "lib_def".  The caller must ensure "device" and "lib_def" outlives
+// the returned object.
+//
+// The "parent" is a pointer to the ProcessFunctionLibraryRuntime object that
+// typically owns the created FunctionLibraryRuntime object. The parent pointer
+// is not owned by the FunctionLibraryRuntime object.
+core::RefCountPtr<FunctionLibraryRuntime> NewFunctionLibraryRuntime(
+    const DeviceMgr* device_mgr, Env* env, const ConfigProto* config,
+    Device* device, int graph_def_version,
+    const FunctionLibraryDefinition* lib_def, thread::ThreadPool* thread_pool,
+    const OptimizerOptions& optimizer_options,
+    const SessionMetadata* session_metadata,
+    ProcessFunctionLibraryRuntime* parent);
+
+// Given a numerical function "f", returns another numerical function
+// "g", such that if "f" takes N inputs and produces M outputs, "g"
+// takes N + M inputs and produces N outputs. I.e., if
+//   (y1, y2, ..., y_M) = f(x1, x2, ..., x_N),
+// g is a function which is
+//   (dL/dx1, dL/dx2, ..., dL/dx_N) = g(x1, x2, ..., x_N,
+//                                     dL/dy1, dL/dy2, ..., dL/dy_M),
+// where L is a scalar-value function of (...x_i...).
+//
+// TODO(zhifengc): Asks math expert to say the comment again.
+std::unique_ptr<FunctionBody> SymbolicGradient(const FunctionBody& f);
+
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_FUNCTION_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/function_body.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/function_body.h
new file mode 100644
index 0000000000000000000000000000000000000000..cbd602612a2862508341eb9930370efbc578b7c5
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/function_body.h
@@ -0,0 +1,52 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_FUNCTION_BODY_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_FUNCTION_BODY_H_
+
+#include "tensorflow/core/framework/function.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/lib/gtl/inlined_vector.h"
+
+namespace tensorflow {
+
+class Graph;
+class Node;
+
+// FunctionLibraryRuntime::GetFunctionBody returns a description of an
+// instantiated function that is represented as a Graph with arg/ret
+// nodes annotated.
+struct FunctionBody {
+  FunctionDef fdef;
+  Graph* graph = nullptr;  // owned.
+  DataTypeVector arg_types;
+  DataTypeVector ret_types;
+  // arg_nodes[i] contains the i'th function input. In other words,
+  // GetNodeAttr(arg_nodes[i]->attrs(), "index") == i.
+  gtl::InlinedVector<Node*, 4> arg_nodes;
+  // ret_nodes[i] contains the i'th function output. In other words,
+  // GetNodeAttr(ret_nodes[i]->attrs(), "index") == i.
+  gtl::InlinedVector<Node*, 4> ret_nodes;
+  gtl::InlinedVector<Node*, 4> control_ret_nodes;
+
+  FunctionBody() {}
+  FunctionBody(const FunctionDef& f, DataTypeSlice arg_types,
+               DataTypeSlice ret_types, Graph* g);
+  ~FunctionBody();
+};
+
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_FUNCTION_BODY_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/function_def_utils.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/function_def_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..f269cc6a608c8253409d7fcdf0e9703714960b7b
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/function_def_utils.h
@@ -0,0 +1,49 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_FUNCTION_DEF_UTILS_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_FUNCTION_DEF_UTILS_H_
+
+#include <functional>
+#include <memory>
+
+#include "tensorflow/core/lib/core/status.h"
+
+namespace tensorflow {
+
+class AttrSlice;
+struct FunctionBody;
+class FunctionDef;
+class FunctionLibraryDefinition;
+class OpDef;
+
+// Instantiates FunctionDef into a graph. Set *fbody to point to the
+// FunctionBody that holds the instantiated FunctionDef.
+Status FunctionDefToBodyHelper(const FunctionDef& fdef, const AttrSlice& attrs,
+                               const FunctionLibraryDefinition* lib_def,
+                               std::unique_ptr<FunctionBody>* fbody);
+
+// Instantiates FunctionDef into a graph. Set *fbody to point to the
+// FunctionBody that holds the instantiated FunctionDef. Use custom function
+// signature lookup, in case instantiated function is not in the 'lib_def'.
+Status FunctionDefToBodyHelper(
+    const FunctionDef& fdef, const AttrSlice& attrs,
+    const FunctionLibraryDefinition* lib_def,
+    const std::function<Status(const string&, const OpDef**)>& get_func_sig,
+    std::unique_ptr<FunctionBody>* fbody);
+
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_FUNCTION_DEF_UTILS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/function_optimization_registry.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/function_optimization_registry.h
new file mode 100644
index 0000000000000000000000000000000000000000..29fe381fe540f397accbf6f046519b61e4da52e5
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/function_optimization_registry.h
@@ -0,0 +1,104 @@
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_FUNCTION_OPTIMIZATION_REGISTRY_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_FUNCTION_OPTIMIZATION_REGISTRY_H_
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "tensorflow/core/common_runtime/device_set.h"
+#include "tensorflow/core/framework/function.h"
+#include "tensorflow/core/graph/graph.h"
+#include "tensorflow/core/protobuf/config.pb.h"
+
+// Classes to maintain a static registry of Graph based passes to be applied to
+// a function graph.
+
+namespace tensorflow {
+
+// A pass to be registered with the FunctionOptimizationPassRegistry. This pass
+// takes in a DeviceSet (available devices for executing the Graph), ConfigProto
+// (session configuration parameters), an optional target device for XLA
+// compilation, Graph (computation),
+// FunctionLibraryDefinition (mapping between function names and function
+// definitions of the Graph), control ret/target node names (names of nodes that
+// must execute but their data outputs, if they have any, are irrelevant), and
+// whether control ret nodes (via thier name) were updated. Mutations to the
+// Graph and other associated arguments are performed inplace by the pass.
+class FunctionOptimizationPass {
+ public:
+  // Grouped Options for the optimized function.
+  struct FunctionOptions {
+    // Specifies the compilation device type(CPU, GPU, etc)
+    // that should be used for entire function.
+    std::string xla_compile_device_type = "";
+    // Whether soft placement and outside compilation
+    // are enabled for the function.
+    bool allow_soft_placement = false;
+  };
+
+  virtual ~FunctionOptimizationPass() {}
+  virtual Status Run(const std::string& function_name,
+                     const DeviceSet& device_set,
+                     const ConfigProto& config_proto,
+                     const FunctionOptions& function_options,
+                     std::unique_ptr<Graph>* graph,
+                     FunctionLibraryDefinition* flib_def,
+                     std::vector<std::string>* control_ret_node_names,
+                     bool* control_rets_updated) = 0;
+};
+
+// A global function optimization pass registry that is used to hold one
+// FunctionOptimizationPass. Passes registered to this registry will run before
+// passes registered in OptimizationPassRegistry.
+class FunctionOptimizationPassRegistry {
+ public:
+  // Initializes registry with a pass. Only one pass should be set. An assertion
+  // will be triggered if the registry already has a pass set and is being
+  // initialized with another pass.
+  void Init(std::unique_ptr<FunctionOptimizationPass> pass);
+
+  // Runs a pass if the registry contains one.
+  Status Run(const std::string& function_name, const DeviceSet& device_set,
+             const ConfigProto& config_proto,
+             const FunctionOptimizationPass::FunctionOptions& function_options,
+             std::unique_ptr<Graph>* graph, FunctionLibraryDefinition* flib_def,
+             std::vector<std::string>* control_ret_node_names,
+             bool* control_rets_updated);
+
+  // Returns the global registry of function graph passes.
+  static FunctionOptimizationPassRegistry& Global();
+
+ private:
+  std::unique_ptr<FunctionOptimizationPass> pass_;
+};
+
+namespace function_optimization_registration {
+
+class FunctionOptimizationPassRegistration {
+ public:
+  explicit FunctionOptimizationPassRegistration(
+      std::unique_ptr<FunctionOptimizationPass> pass) {
+    FunctionOptimizationPassRegistry::Global().Init(std::move(pass));
+  }
+};
+
+}  // namespace function_optimization_registration
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_FUNCTION_OPTIMIZATION_REGISTRY_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/function_utils.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/function_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..8a3de2a8402a61950fe24d0cde4e7414340e8aa4
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/function_utils.h
@@ -0,0 +1,105 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_FUNCTION_UTILS_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_FUNCTION_UTILS_H_
+
+#include <functional>
+#include <memory>
+
+#include "tensorflow/core/framework/function.h"
+#include "tensorflow/core/lib/core/status.h"
+
+namespace tensorflow {
+
+class AttrSlice;
+class Graph;
+class GraphDef;
+class NameAttrList;
+class Node;
+class NodeDef;
+class OpDef;
+
+// Debugging facility.  Returns a debug string for a graph
+// representing an instantiated function.
+string DebugString(const Graph* g);
+
+// Dump the contents of the "graph" to log files if the logging level is
+// sufficiently high.
+void DumpGraph(StringPiece label, const Graph* g);
+
+// Convert the Graph of a function to a GraphDef.
+//
+// Handles renaming of nodes to avoid duplicate names which may
+// be present after various rewriting operations.
+void ToGraphDef(const Graph* g, GraphDef* gdef, bool pretty = false);
+
+// Extracts function name and attributes from `call_def`
+// `call_def` can be a native function call (where the op type is the function
+// name) or a call through PartitionedCall/StatefulPartitionedCall.
+Status NameAndAttrsFromFunctionCall(const NodeDef& call_def,
+                                    NameAttrList* function);
+
+// A few hand-crafted optimization on the instantiated function body
+// (a Graph*).
+
+// Removes nodes that are
+//   1. not stateful; and
+//   2. not _Arg; and
+//   3. not reachable from _Retval.
+//
+// This function is triggered by function inlining, unlike 'PruneFunctionBody'
+// it doesn't preserve nodes that are reachable from control returns. Function
+// inlining is responsible for connecting control return nodes with the nodes
+// that have input control edges from the inlined function call node.
+//
+// Assuming that automatic control dependency tracking is correct, absence of
+// outgoing control edge from the function call node means that no one needs to
+// observe side-effect that might have been generated by the function (see
+// documentation in common_runtime/function.cc for details).
+//
+// Returns true iff any node is removed from "g".
+bool RemoveDeadNodes(Graph* g);
+
+// Find a pattern:
+//   src -(in)-> node -(out)-> dst, where
+// 1) node is an identity node;
+// 2) in is the only incoming data edge;
+// 3) out is the only outgoing data edge;
+//
+// Rewrites the above pattern with src->dst and relevant data
+// dependencies updated. Repeat the process until no such pattern
+// left.
+bool RemoveIdentityNodes(Graph* g);
+
+// Rewrites _ListToArray and _ArrayToList to a set of Identity nodes.
+bool RemoveListArrayConverter(Graph* g);
+
+// Extracts function name and attributes from `call_def` and invokes
+// flr->Instantiate(name, attrs, handle).
+// `call_def` can be a native function call (where the op type is the function
+// name) or a call through PartitionedCall/StatefulPartitionedCall.
+Status InstantiateFunctionCall(const NodeDef& call_def,
+                               FunctionLibraryRuntime* flr,
+                               FunctionLibraryRuntime::Handle* handle);
+
+// Returns true iff `n` represents a function call. `n` can be a native
+// function call (n.type_string() is the function name),
+// a PartitionedCall/StatefulPartitionedCall, or a SymbolicGradient (which
+// has been deprecated for a while).
+bool IsFunctionCall(const FunctionLibraryDefinition& lib_def, const Node& n);
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_FUNCTION_UTILS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/gpu/gpu_bfc_allocator.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/gpu/gpu_bfc_allocator.h
new file mode 100644
index 0000000000000000000000000000000000000000..4ecaa1210edc381bdcb8223edc0dc790963255c3
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/gpu/gpu_bfc_allocator.h
@@ -0,0 +1,63 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_GPU_GPU_BFC_ALLOCATOR_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_GPU_GPU_BFC_ALLOCATOR_H_
+
+#include <memory>
+#include <optional>
+#include <string>
+
+#include "tsl/framework/allocator.h"
+#include "tsl/framework/bfc_allocator.h"
+#include "tsl/platform/macros.h"
+
+namespace tensorflow {
+
+// A GPU memory allocator that implements a 'best-fit with coalescing'
+// algorithm.
+class GPUBFCAllocator : public tsl::BFCAllocator {
+ public:
+  // See BFCAllocator::Options.
+  struct Options {
+    // Overridden by TF_FORCE_GPU_ALLOW_GROWTH if that envvar is set.
+    bool allow_growth = false;
+
+    // If nullopt, defaults to TF_ENABLE_GPU_GARBAGE_COLLECTION, or true if that
+    // envvar is not present.
+    //
+    // Note:
+    //
+    //  - BFCAllocator defaults garbage_collection to false, not true.
+    //  - this is not the same override behavior as TF_FORCE_GPU_ALLOW_GROWTH.
+    std::optional<bool> garbage_collection;
+
+    double fragmentation_fraction = 0;
+    bool allow_retry_on_failure = true;
+  };
+
+  GPUBFCAllocator(std::unique_ptr<tsl::SubAllocator> sub_allocator,
+                  size_t total_memory, const std::string& name,
+                  const Options& opts);
+
+  ~GPUBFCAllocator() override {}
+
+  GPUBFCAllocator(const GPUBFCAllocator&) = delete;
+  void operator=(const GPUBFCAllocator&) = delete;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_GPU_GPU_BFC_ALLOCATOR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/gpu/gpu_cudamalloc_allocator.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/gpu/gpu_cudamalloc_allocator.h
new file mode 100644
index 0000000000000000000000000000000000000000..cf1360ef64f59026cc970dadc8a3e59f2c798874
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/gpu/gpu_cudamalloc_allocator.h
@@ -0,0 +1,52 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_GPU_GPU_CUDAMALLOC_ALLOCATOR_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_GPU_GPU_CUDAMALLOC_ALLOCATOR_H_
+
+#include <memory>
+#include <string>
+
+#include "xla/stream_executor/stream_executor.h"
+#include "tsl/framework/allocator.h"
+#include "tsl/framework/device_id.h"
+#include "tsl/platform/macros.h"
+
+namespace tensorflow {
+
+// An allocator which directly uses cuMemAlloc and cuMemFree to allocate and
+// free memory.
+class GPUcudaMallocAllocator : public tsl::Allocator {
+ public:
+  explicit GPUcudaMallocAllocator(tsl::PlatformDeviceId platform_device_id);
+  std::string Name() override { return "gpu_debug"; }
+  void* AllocateRaw(size_t alignment, size_t num_bytes) override;
+  void DeallocateRaw(void* ptr) override;
+  bool TracksAllocationSizes() const override;
+
+  tsl::AllocatorMemoryType GetMemoryType() const override {
+    return tsl::AllocatorMemoryType::kDevice;
+  }
+
+ private:
+  se::StreamExecutor* stream_exec_;  // Not owned.
+
+  GPUcudaMallocAllocator(const GPUcudaMallocAllocator&) = delete;
+  void operator=(const GPUcudaMallocAllocator&) = delete;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_GPU_GPU_CUDAMALLOC_ALLOCATOR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/gpu/gpu_debug_allocator.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/gpu/gpu_debug_allocator.h
new file mode 100644
index 0000000000000000000000000000000000000000..a753f0edc6cce27b2364465277bd00d60844ddb5
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/gpu/gpu_debug_allocator.h
@@ -0,0 +1,93 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_GPU_GPU_DEBUG_ALLOCATOR_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_GPU_GPU_DEBUG_ALLOCATOR_H_
+
+#include <memory>
+#include <optional>
+#include <string>
+#include <unordered_map>
+
+#include "xla/stream_executor/stream_executor.h"
+#include "tsl/framework/allocator.h"
+#include "tsl/framework/device_id.h"
+#include "tsl/platform/macros.h"
+
+namespace tensorflow {
+
+// An allocator that wraps a GPU allocator and adds debugging
+// functionality that verifies that users do not write outside their
+// allocated memory.
+class GPUDebugAllocator : public tsl::Allocator {
+ public:
+  explicit GPUDebugAllocator(tsl::Allocator* allocator,
+                             tsl::PlatformDeviceId platform_device_id);
+  ~GPUDebugAllocator() override;
+  std::string Name() override { return "gpu_debug"; }
+  void* AllocateRaw(size_t alignment, size_t num_bytes) override;
+  void DeallocateRaw(void* ptr) override;
+  bool TracksAllocationSizes() const override;
+  size_t RequestedSize(const void* ptr) const override;
+  size_t AllocatedSize(const void* ptr) const override;
+  int64_t AllocationId(const void* ptr) const override;
+  std::optional<tsl::AllocatorStats> GetStats() override;
+  bool ClearStats() override;
+
+  // For testing.
+  bool CheckHeader(void* ptr);
+  bool CheckFooter(void* ptr);
+
+ private:
+  tsl::Allocator* base_allocator_ = nullptr;  // owned
+
+  se::StreamExecutor* stream_exec_;  // Not owned.
+
+  GPUDebugAllocator(const GPUDebugAllocator&) = delete;
+  void operator=(const GPUDebugAllocator&) = delete;
+};
+
+// An allocator that wraps a GPU allocator and resets the memory on
+// allocation and free to 'NaN', helping to identify cases where the
+// user forgets to initialize the memory.
+class GPUNanResetAllocator : public tsl::Allocator {
+ public:
+  explicit GPUNanResetAllocator(tsl::Allocator* allocator,
+                                tsl::PlatformDeviceId platform_device_id);
+  ~GPUNanResetAllocator() override;
+  std::string Name() override { return "gpu_nan_reset"; }
+  void* AllocateRaw(size_t alignment, size_t num_bytes) override;
+  void DeallocateRaw(void* ptr) override;
+  size_t RequestedSize(const void* ptr) const override;
+  size_t AllocatedSize(const void* ptr) const override;
+  std::optional<tsl::AllocatorStats> GetStats() override;
+  bool ClearStats() override;
+
+  tsl::AllocatorMemoryType GetMemoryType() const override {
+    return base_allocator_->GetMemoryType();
+  }
+
+ private:
+  tsl::Allocator* base_allocator_ = nullptr;  // owned
+
+  se::StreamExecutor* stream_exec_;  // Not owned.
+
+  GPUNanResetAllocator(const GPUNanResetAllocator&) = delete;
+  void operator=(const GPUNanResetAllocator&) = delete;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_GPU_GPU_DEBUG_ALLOCATOR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/gpu/gpu_device.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/gpu/gpu_device.h
new file mode 100644
index 0000000000000000000000000000000000000000..23b55282ea5c433fe26f3862c4324280a78119ab
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/gpu/gpu_device.h
@@ -0,0 +1,464 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#if !GOOGLE_CUDA && !TENSORFLOW_USE_ROCM
+#error This file must only be included when building with Cuda or ROCm support
+#endif
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_GPU_GPU_DEVICE_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_GPU_GPU_DEVICE_H_
+
+// TODO(b/282059652): Merge google internal and open-source code path once TF
+// dependency issue is resolved.
+#if (defined(PLATFORM_GOOGLE) && defined(TF_PLATFORM_LINUX_X86_64))
+#define TF_GPU_USE_PJRT
+#endif  // PLATFORM_GOOGLE && TF_PLATFORM_LINUX_X86_64
+
+#include <functional>
+#include <memory>
+#include <optional>
+#include <set>
+#include <string>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#ifdef TF_GPU_USE_PJRT
+#include "tensorflow/compiler/jit/pjrt_device_context.h"
+#include "tensorflow/compiler/tf2xla/layout_util.h"
+#include "xla/pjrt/local_device_state.h"
+#include "xla/stream_executor/tf_allocator_adapter.h"
+#endif  // TF_GPU_USE_PJRT
+#include "tensorflow/core/common_runtime/device_factory.h"
+#include "tensorflow/core/common_runtime/gpu/gpu_event_mgr.h"
+#include "tensorflow/core/common_runtime/gpu/gpu_id_manager.h"
+#include "tensorflow/core/common_runtime/gpu_device_context.h"
+#include "tensorflow/core/common_runtime/local_device.h"
+#include "tensorflow/core/common_runtime/node_file_writer.h"
+#include "tensorflow/core/common_runtime/scoped_allocator_mgr.h"
+#include "tensorflow/core/common_runtime/shared_counter.h"
+#include "tensorflow/core/framework/allocator.h"
+#include "tensorflow/core/framework/device_base.h"
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/lib/gtl/inlined_vector.h"
+#include "tensorflow/core/platform/mutex.h"
+#include "tensorflow/core/platform/stream_executor.h"
+#include "tensorflow/core/platform/types.h"
+#include "tensorflow/core/public/session_options.h"
+#include "tsl/framework/device_id.h"
+
+namespace Eigen {
+class StreamInterface;
+}
+
+namespace tensorflow {
+class GPUKernelTracker;
+
+class ConcretePerOpGpuDevice : public PerOpGpuDevice {
+ public:
+  ConcretePerOpGpuDevice();
+
+  void Reinitialize(OpKernelContext* context, void* gpu_stream,
+                    tsl::TfDeviceId tf_device_id, Allocator* base_allocator,
+                    char* scratch);
+
+  void Reinitialize(OpKernelContext* context, void* gpu_stream,
+                    tsl::PlatformDeviceId platform_device_id,
+                    Allocator* base_allocator, char* scratch);
+
+  const Eigen::GpuDevice& device() const override;
+
+ private:
+  std::unique_ptr<::Eigen::StreamInterface> stream_device_;
+};
+
+class BaseGPUDevice : public LocalDevice {
+ public:
+  BaseGPUDevice(const SessionOptions& options, const std::string& name,
+                Bytes memory_limit, const DeviceLocality& locality,
+                tsl::TfDeviceId tf_device_id,
+                const std::string& physical_device_desc,
+                Allocator* gpu_allocator, Allocator* cpu_allocator,
+                bool sync_every_op);
+
+  ~BaseGPUDevice() override;
+
+  struct StreamGroup {
+    se::Stream* compute = nullptr;
+#if TENSORFLOW_USE_ROCM
+    se::Stream* nccl = nullptr;
+#endif
+    se::Stream* host_to_device = nullptr;
+    se::Stream* device_to_host = nullptr;
+    gtl::InlinedVector<se::Stream*, 4> device_to_device;
+    int priority = 0;
+  };
+
+  // Initialize the device and return the status of initialization.
+#ifdef TF_GPU_USE_PJRT
+  Status Init(const SessionOptions& options,
+              xla::LocalDeviceState* xla_local_device_state);
+#else
+  Status Init(const SessionOptions& options);
+#endif  // TF_GPU_USE_PJRT
+
+  void Compute(OpKernel* op_kernel, OpKernelContext* context) override;
+
+  Status Sync() override;
+
+  void ComputeAsync(AsyncOpKernel* op_kernel, OpKernelContext* context,
+                    AsyncOpKernel::DoneCallback done) override;
+
+  Status MakeTensorFromProto(const TensorProto& tensor_proto,
+                             AllocatorAttributes alloc_attrs,
+                             Tensor* tensor) override;
+
+  void CopyTensorInSameDevice(const Tensor* input_tensor, Tensor* output_tensor,
+                              const DeviceContext* device_context,
+                              StatusCallback done) override;
+
+  // The caller owns the returned device.
+  PerOpGpuDevice* MakeGpuDevice() override;
+
+  Status ReinitializeGpuDevice(OpKernelContext* context, PerOpGpuDevice* device,
+                               DeviceContext* dc,
+                               Allocator* allocator) override;
+
+  // Returns the platform GPU id of this device within the native driver system;
+  // e.g., for CUDA and ROCm this is the ordinal of the GPU within the system.
+  int gpu_id() const {
+    tsl::PlatformDeviceId platform_device_id;
+    TF_CHECK_OK(
+        GpuIdManager::TfToPlatformDeviceId(tf_device_id_, &platform_device_id));
+    return platform_device_id.value();
+  }
+
+  // The executor that provides control for the device; e.g., for CUDA this
+  // corresponds to the cuda context.
+  se::StreamExecutor* executor() const { return executor_; }
+
+  Allocator* GetScopedAllocator(AllocatorAttributes attr,
+                                int64_t step_id) override;
+
+  ScopedAllocatorMgr* GetScopedAllocatorMgr() const override {
+    return scoped_allocator_mgr_.get();
+  }
+
+  // The following two functions always return 0 unless one of the
+  // related experimental config options has been specified.
+
+  // If returned value is > 0 then GPU Memory chunks freed before this count
+  // are guaranteed not to be in use by any kernel pending on this device.
+  uint64 SafeAllocFrontier(uint64 old_value) override;
+
+  // Returns the number of kernels that have been queued for execution on
+  // the compute stream and are not yet known to have completed.
+  int PendingKernels();
+
+  int priority() const { return stream_->priority; }
+
+  // Helper method for unit tests to reset the streams. Never use in production.
+  static void TestOnlyReset();
+
+  se::Stream* compute_stream() { return stream_->compute; }
+
+  // Given the compute stream for a GPU or virtual GPU, return the TfDeviceId
+  // for the GPU or vGPU.
+  static std::optional<tsl::TfDeviceId> FindTfDeviceId(se::Stream* compute);
+
+ protected:
+  Allocator* gpu_allocator_;  // not owned
+  Allocator* cpu_allocator_;  // not owned
+
+  se::StreamExecutor* executor_;  // not owned
+  std::unique_ptr<ScopedAllocatorMgr> scoped_allocator_mgr_;
+
+ private:
+  friend class GPUDeviceTestHelper;
+  class StreamGroupFactory;
+
+  core::RefCountPtr<DeviceContext> pjrt_device_context_;
+  StreamGroup* stream_;
+  mutex scratch_init_mutex_;
+  char* scratch_ = nullptr;
+  GPUDeviceContext* device_context_;
+  DeviceBase::AcceleratorDeviceInfo* accelerator_device_info_ = nullptr;
+  mutex trace_mu_;
+  tsl::TfDeviceId tf_device_id_;
+  const bool sync_every_op_ = false;
+  EventMgr* em_ = nullptr;
+  std::unique_ptr<thread::ThreadPool> thread_pool_;
+  std::unique_ptr<GPUKernelTracker> kernel_tracker_;
+  int32 pending_cap_ = 0;
+  bool timestamped_allocator_ = false;
+  NodeFileWriter* node_file_writer_ = nullptr;  // not owned
+
+  // Initialize scratch buffers used by Eigen.
+  Status InitScratchBuffers();
+
+  void ReinitializeDevice(OpKernelContext* context, PerOpGpuDevice* device,
+                          int stream_id, Allocator* allocator);
+
+  std::string ComputeOpKernelDebugString(const OpKernel& op_kernel,
+                                         const int& stream_id);
+
+  // This method returns an initialization status, in addition to
+  // calling the "done" StatusCallback, if there is a failure to
+  // allocate memory or if the tensor "from" is not DMA-copyable.
+  // If there is no error prior to enqueueing the copy, an OK status
+  // is returned.
+  Status MaybeCopyTensorToGPU(const AllocatorAttributes& alloc_attrs,
+                              const Tensor& from, Tensor* to,
+                              StatusCallback done);
+
+  Tensor CopyGpuTensorToHostDebugOnly(const Tensor& gpu_tensor);
+  void LogInputs(OpKernel* op_kernel, OpKernelContext* context);
+  void LogOutputs(OpKernel* op_kernel, OpKernelContext* context);
+};
+
+// A per-compute-stream utility that keeps track of kernels that have been
+// queued for execution but may not yet have terminated and also the queued
+// time of the most recently terminated kernel.
+class GPUKernelTracker {
+ public:
+  // Controls the strategy for inserting tracking events after GPU kernels.
+  //   If max_interval >= 0, then insert an event after this many kernels
+  //     if an event has not been inserted for another reason.
+  //   If max_bytes > 0, then insert an event after kernels allocating this
+  //     many bytes have been queued since the last event.
+  //   If max_pending > 0, then track up to this many events at once.  If
+  //     this limit is reached the GPU::Compute() method will delay starting
+  //     additional ops until some event completes.  If 0 and one of the other
+  //     fields is non-zero, then a reasonable default will be selected.
+  struct Params {
+    int max_interval = 0;
+    int max_bytes = 0;
+    int max_pending = 0;
+    Params(int mi, int mb, int mp)
+        : max_interval(mi), max_bytes(mb), max_pending(mp) {}
+  };
+
+  // If we're going to share a SharedCounter with an allocator, it's owned
+  // by the allocator because allocators are initialized once per process.
+  // Devices are per-session.
+  explicit GPUKernelTracker(const Params& params, Env* env,
+                            se::Stream* compute_stream,
+                            SharedCounter* timing_counter, Allocator* allocator,
+                            EventMgr* event_manager)
+      : params_(params),
+        env_(env),
+        stream_(compute_stream),
+        timing_counter_(timing_counter),
+        allocator_(allocator),
+        em_(event_manager),
+        pending_kernels_(
+            params.max_pending > 0 ? std::max(8, 2 * params.max_pending) : 64) {
+    mem_since_last_ = 0;
+    if (!timing_counter_) {
+      // There's not a preexisting counter owned by GPUProcessState, i.e.
+      // pending_cap > 0 but timestamped_allocator == false.
+      owned_counter_ = std::make_unique<SharedCounter>();
+      timing_counter_ = owned_counter_.get();
+    }
+  }
+
+  // Determine whether a GPU kernel should have a recording event queued
+  // immediately afterwards.  If so, advance the counter and return the new
+  // counter value after enqueuing.
+  uint64 MaybeQueue(OpKernelContext* ctx);
+
+  // Record that a GPU kernel has just been enqueued on the compute stream.
+  // Inserts the supplied counter value in a new PendingKernel record appended
+  // to the end of the ring buffer then returns that same count.
+  // Caller is responsible for ensuring that RecordTerminate() is eventually
+  // called with the same counter value.
+  void RecordQueued(uint64 queued_count, int weight)
+      TF_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+
+  // Takes a count value returned by RecordQueued and finds the corresponding
+  // PendingKernel record in the ring buffer.  Marks the kernel as completed and
+  // advances the completion frontier accordingly.
+  void RecordTerminated(uint64 queued_count);
+
+  // Returns the largest timing count such that all kernels queued no
+  // later than that count are known to have terminated.
+  inline uint64 LastTerminatedCount(uint64 old_value) {
+    uint64 new_value = last_terminated_count_.load(std::memory_order_relaxed);
+    if (new_value == old_value) {
+      MaybeQueueProgressEvent();
+    }
+    return new_value;
+  }
+
+  // Returns the number of kernels enqueued that are not yet known to
+  // have terminated.
+  int NumPending() {
+    mutex_lock l(mu_);
+    return num_pending_;
+  }
+
+  // Yield current thread until number of pending kernels no longer
+  // exceeds the cap.
+  void PauseWhilePendingExceeds(int cap) TF_LOCKS_EXCLUDED(mu_) {
+    mutex_lock l(mu_);
+    while (num_pending_ > cap) {
+      VLOG(1) << "num_pending_=" << num_pending_ << " cap=" << cap;
+      pending_decreased_.wait(l);
+    }
+  }
+
+ private:
+  friend class GPUKernelTrackerTest;
+  Params params_;
+  Env* env_;
+  se::Stream* stream_;
+  SharedCounter* timing_counter_;
+  std::unique_ptr<SharedCounter> owned_counter_;
+  Allocator* allocator_ = nullptr;
+  EventMgr* em_ = nullptr;
+  std::atomic<uint64> last_terminated_count_ = {1};
+
+  void MaybeQueueProgressEvent();
+
+  // Records when a kernel was queued for execution.  Kernel launches are
+  // identified by a unique count value from a per-GPU device timing counter.
+  struct PendingKernel {
+    uint64 queued_count;
+    int weight;
+    bool terminated;
+    PendingKernel(const PendingKernel& pk) = default;
+    PendingKernel() : queued_count(0), weight(0), terminated(false) {}
+  };
+  mutex mu_;
+  int32 mem_since_last_ TF_GUARDED_BY(mu_);
+  int32 ops_since_last_ TF_GUARDED_BY(mu_);
+  // Ring buffer of PendingKernel records.
+  std::vector<PendingKernel> pending_kernels_ TF_GUARDED_BY(mu_);
+  // Next unused slot in pending_kernels_.
+  int first_available_ TF_GUARDED_BY(mu_) = 0;
+  // Last completed PendingKernel such that all prior PendingKernels are
+  // also completed.  With out-of-order completion there may be a mixture
+  // of completed and uncompleted entries between last_completed_ and
+  // first_available_.
+  int last_completed_ TF_GUARDED_BY(mu_) = -1;
+  // Sum of weights of the outstanding events marking tracked kernels.
+  int num_pending_ TF_GUARDED_BY(mu_) = 0;
+  condition_variable pending_decreased_ TF_GUARDED_BY(mu_);
+};
+
+class BaseGPUDeviceFactory : public DeviceFactory {
+ public:
+  Status ListPhysicalDevices(std::vector<string>* devices) override;
+  Status CreateDevices(const SessionOptions& options,
+                       const std::string& name_prefix,
+                       std::vector<std::unique_ptr<Device>>* devices) override;
+  Status GetDeviceDetails(int device_index,
+                          std::unordered_map<string, string>* details) override;
+
+  struct InterconnectMap {
+    // Name of interconnect technology, if known.
+    std::string name;
+    // If possible, strength should approximate Gb/sec bandwidth rate.
+    // Where architecture-specific subclassing is not done that won't
+    // always be possible.  The minimum expectation is that
+    // faster links should have a higher value than slower links.
+    int32 strength;
+    static const int kSameDeviceStrength;
+    static const int kStreamExecutorStrength;
+    std::set<std::pair<tsl::PlatformDeviceId, tsl::PlatformDeviceId>>
+        directed_links;
+  };
+
+ protected:
+  // Populates *maps with interconnect maps for all local direct access
+  // pathways between GPUs.
+  virtual Status GetInterconnectMaps(
+      const std::vector<tsl::PlatformDeviceId>& visible_gpu_order,
+      se::Platform* gpu_manager, std::vector<InterconnectMap>* maps);
+
+  struct TfDeviceIdHash {
+    std::size_t operator()(const tsl::TfDeviceId& id) const noexcept {
+      return std::hash<int>{}(id.value());
+    }
+  };
+  typedef std::unordered_map<tsl::TfDeviceId, DeviceLocality, TfDeviceIdHash>
+      LocalityMap;
+  // Populates *localities with the DeviceLocality descriptor for
+  // every TfDeviceId.
+  virtual Status GetDeviceLocalities(
+      int num_tf_gpus, const std::vector<InterconnectMap>& interconnects,
+      LocalityMap* localities);
+
+ private:
+  // Creates a BaseGPUDevice associated with 'tf_device_id', and adds it to the
+  // 'devices' vector. The 'gpu_allocator' is created by the caller and usually
+  // preallocates a set amount of GPU memory.
+#ifdef TF_GPU_USE_PJRT
+  Status CreateGPUDevice(const SessionOptions& options,
+                         const std::string& name_prefix,
+                         tsl::TfDeviceId tf_device_id,
+                         const DeviceLocality& dev_locality,
+                         xla::LocalDeviceState* xla_local_device_state,
+                         Allocator* gpu_allocator,
+                         std::vector<std::unique_ptr<Device>>* devices);
+#else
+  Status CreateGPUDevice(const SessionOptions& options,
+                         const std::string& name_prefix,
+                         tsl::TfDeviceId tf_device_id,
+                         const DeviceLocality& dev_locality,
+                         Allocator* gpu_allocator,
+                         std::vector<std::unique_ptr<Device>>* devices);
+#endif  // TF_GPU_USE_PJRT
+
+  virtual std::unique_ptr<BaseGPUDevice> CreateGPUDevice(
+      const SessionOptions& options, const string& name, Bytes memory_limit,
+      const DeviceLocality& dev_locality, tsl::TfDeviceId tf_device_id,
+      const string& physical_device_desc, Allocator* gpu_allocator,
+      Allocator* cpu_allocator) = 0;
+
+  Status EnablePeerAccess(
+      const std::vector<tsl::PlatformDeviceId>& visible_gpu_order);
+
+  // Returns into 'ids' the list of valid platform GPU ids, in the order that
+  // they should map to TF GPU ids "/device:GPU:0", "/device:GPU:1", etc,
+  // based upon 'visible_gpu_order' which was generated by parsing
+  // GPUOptions::visible_device_list which is a comma-separated list of CUDA or
+  // ROCm GPU ids.
+  Status GetValidDeviceIds(
+      const std::vector<tsl::PlatformDeviceId>& visible_gpu_order,
+      std::vector<tsl::PlatformDeviceId>* ids);
+
+  // Cache the valid device IDs if not already cached. Cached IDs are stored in
+  // field cached_device_ids_. Passes {0, 1, ..., num_devices-1} to
+  // GetValidDeviceIds, so this should only be used in functions where all
+  // devices should be treated as visible, like ListPhysicalDevices.
+  Status CacheDeviceIds();
+
+  // visible_gpu_initialized_[platform_device_id] is true if visible GPU
+  // platform_device_id has been initialized by the process.
+  std::unordered_map<int, bool> visible_gpu_initialized_;
+
+  // Cached device IDs, as returned by GetValidDeviceIds when every physical
+  // device is visible. Cache should not be used if some devices are not
+  // visible.
+  std::vector<tsl::PlatformDeviceId> cached_device_ids_;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_GPU_GPU_DEVICE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/gpu/gpu_event_mgr.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/gpu/gpu_event_mgr.h
new file mode 100644
index 0000000000000000000000000000000000000000..601119fb832b419edccc8255f2715c0a656db7de
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/gpu/gpu_event_mgr.h
@@ -0,0 +1,23 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+// TODO(annarev): remove this file once all includes are updated to
+// include device_event_mgr.h instead.
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_GPU_GPU_EVENT_MGR_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_GPU_GPU_EVENT_MGR_H_
+
+#include "tensorflow/core/common_runtime/device/device_event_mgr.h"
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_GPU_GPU_EVENT_MGR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/gpu/gpu_id.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/gpu/gpu_id.h
new file mode 100644
index 0000000000000000000000000000000000000000..c2849d2db8f6a46bf60cfb85d5da3a7399993a5a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/gpu/gpu_id.h
@@ -0,0 +1,22 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_GPU_GPU_ID_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_GPU_GPU_ID_H_
+
+#include "tensorflow/core/common_runtime/device/device_id.h"
+
+// TODO(sanjoy): Delete the header and forward the references.
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_GPU_GPU_ID_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/gpu/gpu_id_manager.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/gpu/gpu_id_manager.h
new file mode 100644
index 0000000000000000000000000000000000000000..b336db8451a93417528c92861a65e74304ffdda1
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/gpu/gpu_id_manager.h
@@ -0,0 +1,43 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_GPU_GPU_ID_MANAGER_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_GPU_GPU_ID_MANAGER_H_
+
+#include "tensorflow/core/lib/core/status.h"
+#include "tsl/framework/device_id.h"
+
+namespace tensorflow {
+
+// Class that maintains a map from TfDeviceId to PlatformDeviceId, and manages
+// the translation between them.
+class GpuIdManager {
+ public:
+  // Adds a mapping from tf_device_id to platform_device_id.
+  static Status InsertTfPlatformDeviceIdPair(
+      tsl::TfDeviceId tf_device_id, tsl::PlatformDeviceId platform_device_id);
+
+  // Gets the platform_device_id associated with tf_device_id. Returns OK if
+  // found.
+  static Status TfToPlatformDeviceId(tsl::TfDeviceId tf_device_id,
+                                     tsl::PlatformDeviceId* platform_device_id);
+
+  // Clears the map. Used in unit tests only.
+  static void TestOnlyReset();
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_GPU_GPU_ID_MANAGER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/gpu/gpu_managed_allocator.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/gpu/gpu_managed_allocator.h
new file mode 100644
index 0000000000000000000000000000000000000000..4bdf6cf2b6cb972bfed217e25f1362736d9ad1a4
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/gpu/gpu_managed_allocator.h
@@ -0,0 +1,38 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_GPU_GPU_MANAGED_ALLOCATOR_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_GPU_GPU_MANAGED_ALLOCATOR_H_
+
+#include <string>
+
+#include "tsl/framework/allocator.h"
+
+namespace tensorflow {
+
+// An allocator for CUDA unified memory. Memory allocated with this allocator
+// can be accessed from both host and device. CUDA transparently migrates dirty
+// pages, which can be slow. Therefore, this allocator is intended for
+// convenience in functional tests only.
+class GpuManagedAllocator : public tsl::Allocator {
+ public:
+  std::string Name() override { return "GpuManagedAllocator"; }
+  void* AllocateRaw(size_t alignment, size_t num_bytes) override;
+  void DeallocateRaw(void* ptr) override;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_GPU_GPU_MANAGED_ALLOCATOR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/gpu/gpu_process_state.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/gpu/gpu_process_state.h
new file mode 100644
index 0000000000000000000000000000000000000000..db91de11f80f85d2a3a72be17dfced6001b13e9b
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/gpu/gpu_process_state.h
@@ -0,0 +1,187 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_GPU_GPU_PROCESS_STATE_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_GPU_GPU_PROCESS_STATE_H_
+
+// TODO(b/282059652): Merge google internal and open-source code path once TF
+// dependency issue is resolved.
+#if (defined(PLATFORM_GOOGLE) && defined(TF_PLATFORM_LINUX_X86_64))
+#define TF_GPU_USE_PJRT
+#endif  // PLATFORM_GOOGLE && TF_PLATFORM_LINUX_X86_64
+
+#include <functional>
+#include <map>
+#include <memory>
+#include <unordered_map>
+#include <vector>
+
+#include "tensorflow/core/common_runtime/process_state.h"
+#include "tensorflow/core/common_runtime/shared_counter.h"
+#include "tensorflow/core/framework/allocator.h"
+#include "tensorflow/core/platform/mutex.h"
+#include "tensorflow/core/platform/thread_annotations.h"
+#include "tensorflow/core/platform/types.h"
+#include "tensorflow/core/protobuf/config.pb.h"
+#include "tsl/framework/device_id.h"
+
+namespace tensorflow {
+
+class GPUBFCAllocator;
+class PoolAllocator;
+
+// Singleton that manages per-process state when GPUs are present.
+class GPUProcessState {
+ public:
+  // If ps == nullptr, returns pointer to the single instance of this class to
+  // be used within this process.
+  //
+  // If ps != nullptrs, accepts a value to be returned by all subsequent calls.
+  // A non-null ps may ONLY be provided during program static storage
+  // initialization.  Must not be called more than once with a non-null ps.
+  //
+  // If a derived class of GPUProcessState is ever used in a process, it must
+  // always be used in place of this class.  In order to ensure that existing
+  // calls to GPUProcessState::singleton() all resolve to the derived instance
+  // instead, this function must be called once during startup, supplying the
+  // derived instance value, prior to any accessor call to this function.
+  static GPUProcessState* singleton(GPUProcessState* ps = nullptr);
+
+  // Query whether any GPU device has been created so far.
+  // Disable thread safety analysis since a race is benign here.
+  bool HasGPUDevice() const TF_NO_THREAD_SAFETY_ANALYSIS {
+    return gpu_device_enabled_;
+  }
+
+  // Set the flag to indicate a GPU device has been created.
+  // Disable thread safety analysis since a race is benign here.
+  void EnableGPUDevice() TF_NO_THREAD_SAFETY_ANALYSIS {
+    gpu_device_enabled_ = true;
+  }
+
+  // Returns the one GPU allocator used for the indexed GPU.
+  // Note that this is a system GPU index, not (necessarily) a brain
+  // device index.
+  //
+  // 'total_bytes' is the total number of bytes that should be made
+  // available to the allocator.  The first call to this function for
+  // a given tf_device_id creates the allocator, so only the total_bytes
+  // used on that first call is used.
+  //
+  // "Allocator type" describes the type of algorithm to use for the
+  // underlying allocator.  REQUIRES: Must be a valid type (see
+  // config.proto for the list of supported strings.).
+  //
+  // `options` is read on the very first call to this function in the process.
+  // After that if you pass in a set of options, they will be ignored.
+  //
+  // REQUIRES: tf_device_id must be a valid id for a BaseGPUDevice available in
+  // the current system environment.  Otherwise returns nullptr.
+  virtual Allocator* GetGPUAllocator(
+      const GPUOptions& options, tsl::TfDeviceId tf_device_id,
+      size_t total_bytes, const std::vector<tsl::TfDeviceId>& peer_gpu_ids);
+
+  Allocator* GetGPUAllocator(tsl::TfDeviceId tf_device_id) {
+    return GetGPUAllocator(/*options=*/{}, tf_device_id, /*total_bytes=*/0,
+                           /*peer_gpu_ids=*/{});
+  }
+
+  int NumGPUAllocators() {
+    mutex_lock l(mu_);
+    return gpu_allocators_.size();
+  }
+
+  // `options` is read on the very first call to this function in the process,
+  // e.g. to set the memory limit on this allocator.  After that if you pass in
+  // a different set of options, they will be ignored.
+  virtual Allocator* GetGpuHostAllocator(const GPUOptions& options,
+                                         int numa_node);
+
+  // Registers a Visitor to be invoked on new chunks of memory allocated by the
+  // SubAllocator of every GPU proximate to the specified bus.  The AllocVisitor
+  // is provided with a memory pointer, a GPU id, and the size of the area it
+  // identifies.  The pointer is not guaranteed to be valid after the call
+  // terminates.  The intention is for this interface to be used for network
+  // device memory registration.  "bus_id" is platform-specific.  On many
+  // platforms it should be 0.  On machines with multiple PCIe buses, it should
+  // be the index of one of the PCIe buses (maybe the NUMA node at which the
+  // PCIe is rooted).  If the bus_id is invalid, results are undefined.
+  virtual void AddGPUAllocVisitor(int bus_id,
+                                  const SubAllocator::Visitor& visitor);
+
+  // Registers a Visitor to be invoked on new chunks of memory allocated by
+  // the SubAllocator of the GpuHostAllocator for the given numa_node.
+  virtual void AddGpuHostAllocVisitor(int numa_node,
+                                      const SubAllocator::Visitor& visitor);
+
+  // Registers a Visitor to be invoked on each chunk handed back for freeing to
+  // the SubAllocator of the GpuHostAllocator for the given numa_node.
+  virtual void AddGpuHostFreeVisitor(int numa_node,
+                                     const SubAllocator::Visitor& visitor);
+
+  // Returns bus_id for the given GPU id.
+  virtual int BusIdForGPU(tsl::TfDeviceId tf_device_id);
+
+  SharedCounter* GPUAllocatorCounter(tsl::TfDeviceId tf_device_id);
+
+ protected:
+  // GPUProcessState is a singleton that should not normally be deleted except
+  // at process shutdown.
+  GPUProcessState();
+  virtual ~GPUProcessState() {}
+  friend class GPUDeviceTest;
+
+  // Helper method for unit tests to reset the ProcessState singleton by
+  // cleaning up everything. Never use in production.
+  virtual void TestOnlyReset();
+
+  ProcessState::MDMap* mem_desc_map() {
+    if (process_state_) return &process_state_->mem_desc_map_;
+    return nullptr;
+  }
+
+  static GPUProcessState* instance_;
+  ProcessState* process_state_;  // Not owned.
+  bool gpu_device_enabled_;
+
+  mutex mu_;
+
+  struct AllocatorParts {
+    std::unique_ptr<Allocator> allocator;
+    std::unique_ptr<SharedCounter> counter;
+    GPUBFCAllocator* bfc_allocator;
+    SubAllocator* sub_allocator;  // owned by allocator
+    std::unique_ptr<Allocator> recording_allocator;
+
+#ifdef TF_GPU_USE_PJRT
+    // Not owning GPU allocator. The allocator is owned by PJRT. If
+    // `allocator_not_owned` is set, `allocator` owned by AllocatorParts won't
+    // be set.
+    Allocator* allocator_not_owned;
+#endif  // TF_GPU_USE_PJRT
+  };
+  std::vector<AllocatorParts> gpu_allocators_ TF_GUARDED_BY(mu_);
+  std::vector<std::vector<SubAllocator::Visitor>> gpu_visitors_
+      TF_GUARDED_BY(mu_);
+
+  std::vector<AllocatorParts> gpu_host_allocators_ TF_GUARDED_BY(mu_);
+  std::vector<std::vector<SubAllocator::Visitor>> gpu_host_alloc_visitors_
+      TF_GUARDED_BY(mu_);
+  std::vector<std::vector<SubAllocator::Visitor>> gpu_host_free_visitors_
+      TF_GUARDED_BY(mu_);
+};
+
+}  // namespace tensorflow
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_GPU_GPU_PROCESS_STATE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/gpu/gpu_util.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/gpu/gpu_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..b3614e1bf189685e53bdc9e7dbc81727460d3662
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/gpu/gpu_util.h
@@ -0,0 +1,111 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_GPU_GPU_UTIL_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_GPU_GPU_UTIL_H_
+
+#include "tensorflow/core/common_runtime/device.h"
+#include "tensorflow/core/common_runtime/dma_helper.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/platform/stream_executor.h"
+
+namespace tensorflow {
+
+class RecvTensorResponse;
+class TensorProto;
+
+class GPUUtil {
+ public:
+  // "tensor" is GPU-local.  "dev" is the hosting GPU.
+  // "device_context" should be the context of the GPU "_Send" op
+  // which provides the Tensor.
+  // Sets all necessary fields of "proto" by transferring value
+  // bytes from GPU to CPU RAM. "is_dead" indicates that the
+  // tensor is dead with an uninit value.
+  static void SetProtoFromGPU(const Tensor& tensor, Device* dev,
+                              const DeviceContext* device_context,
+                              TensorProto* proto, bool is_dead,
+                              StatusCallback done);
+
+  // Copies the data in 'gpu_tensor' into 'cpu_tensor'.
+  // 'gpu_tensor''s backing memory must be on 'gpu_device' and
+  // 'cpu_tensor' must be allocated to be of the same size as
+  // 'gpu_tensor'. Synchronous: may block.
+  static void CopyGPUTensorToCPU(Device* gpu_device,
+                                 const DeviceContext* device_context,
+                                 const Tensor* gpu_tensor, Tensor* cpu_tensor,
+                                 StatusCallback done);
+
+  // Blocks until all operations queued on the stream associated with
+  // "gpu_device" at the time of the call have completed.  Returns any
+  // error pending on the stream at completion.
+  static Status Sync(Device* gpu_device);
+
+  // Blocks until all operations queued on all streams associated with the
+  // corresponding GPU device at the time of call have completed.
+  // Returns any error pending on the stream at completion.
+  static Status SyncAll(Device* gpu_device);
+
+  // For debugging purpose, given a "device" and a "tensor" allocated
+  // on the device, return a string printing each byte in the tensor
+  // (up to a limit).  "device" can be either a CPU or a GPU device.
+  static string MemoryDebugString(const Device* device, Tensor* tensor);
+
+  // Map a Tensor as a DeviceMemory object wrapping the given typed
+  // buffer.
+  //
+  // NOTE: will be removed soon, see StreamExecutorUtil::AsDeviceMemory
+  // instead.
+  template <typename T>
+  static se::DeviceMemory<T> AsDeviceMemory(const Tensor& t) {
+    T* ptr = reinterpret_cast<T*>(const_cast<void*>(DMAHelper::base(&t)));
+    return se::DeviceMemory<T>(se::DeviceMemoryBase(ptr, t.TotalBytes()));
+  }
+
+  // Computes a checksum over the contents of "tensor", which is allocated
+  // on "gpu_device".
+  static uint64 Checksum(Device* gpu_device,
+                         const DeviceContext* device_context,
+                         const Tensor& tensor);
+
+  // Computes a checksum over the contents of "tensor", which is allocated
+  // in local CPU RAM.
+  static uint64 Checksum(const Tensor& tensor);
+
+  static void CopyCPUTensorToGPU(const Tensor* cpu_tensor,
+                                 const DeviceContext* device_context,
+                                 Device* gpu_device, Tensor* gpu_tensor,
+                                 StatusCallback done, bool sync_dst_compute);
+
+  static void DeviceToDeviceCopy(
+      DeviceContext* send_dev_context, DeviceContext* recv_dev_context,
+      Device* src, Device* dst, AllocatorAttributes src_alloc_attr,
+      AllocatorAttributes dst_alloc_attr, const Tensor* input, Tensor* output,
+      int dev_to_dev_stream_index, StatusCallback done);
+
+  // Deep-copying of GPU tensor on the same device.
+  // 'src_gpu_tensor''s and 'dst_gpu_tensor''s backing memory must be on
+  // 'gpu_device' and 'dst_cpu_tensor' must be allocated to be of the same
+  // size as 'src_gpu_tensor'.
+  static void CopyGPUTensorToSameGPU(Device* gpu_device,
+                                     const DeviceContext* device_context,
+                                     const Tensor* src_gpu_tensor,
+                                     Tensor* dst_gpu_tensor,
+                                     StatusCallback done);
+};
+
+}  // namespace tensorflow
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_GPU_GPU_UTIL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/gpu/gpu_virtual_mem_allocator.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/gpu/gpu_virtual_mem_allocator.h
new file mode 100644
index 0000000000000000000000000000000000000000..abe9b4bf050d49dcf6c9be98bc932fc3b4de823e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/gpu/gpu_virtual_mem_allocator.h
@@ -0,0 +1,117 @@
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// CUDA virtual memory API is only available in CUDA versions greater than 10.2.
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_GPU_GPU_VIRTUAL_MEM_ALLOCATOR_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_GPU_GPU_VIRTUAL_MEM_ALLOCATOR_H_
+
+#include <memory>
+#include <vector>
+
+#include "xla/stream_executor/stream_executor.h"
+#include "tsl/framework/allocator.h"
+#include "tsl/framework/device_id.h"
+
+#if GOOGLE_CUDA
+#include "xla/stream_executor/gpu/gpu_driver.h"
+#include "xla/stream_executor/gpu/gpu_types.h"
+#endif
+
+#if CUDA_VERSION >= 10020
+
+namespace tensorflow {
+
+// GpuVirtualMemAllocator is a SubAllocator for use with BFCAllocator which
+// provides contiguous allocations with each call to Alloc. This is done by
+// reserving a large chunk of virtual addresses at construction and then mapping
+// physical memory pages to this virtual address range as requested.
+//
+// This class is not thread-safe.
+class GpuVirtualMemAllocator : public tsl::SubAllocator {
+ public:
+  static tsl::StatusOr<std::unique_ptr<GpuVirtualMemAllocator>> Create(
+      const std::vector<Visitor>& alloc_visitors,
+      const std::vector<Visitor>& free_visitors,
+      stream_executor::gpu::GpuContext& gpu_context,
+      tsl::PlatformDeviceId gpu_id, size_t virtual_address_space_size,
+      const std::vector<tsl::PlatformDeviceId>& peer_gpu_ids);
+  ~GpuVirtualMemAllocator() override;
+
+  // Allocates memory at least as large as requested by num_bytes. Will be
+  // aligned to the min allocation granularity (typically 2MiB).
+  // alignment is ignored by this allocator.
+  void* Alloc(size_t alignment, size_t num_bytes,
+              size_t* bytes_received) override;
+
+  // Frees should only happen at the end of the contiguous memory allocations or
+  // else we introduce pointless fragmentation...But, this is supported. If the
+  // allocation happens at the end, then the next_alloc_offset_ is moved back,
+  // otherwise a hole is created.
+  //
+  // Holes are not re-used, all allocations continue to come at the end of the
+  // next_alloc_offset_. To accommodate this, the virtual_address_space_size
+  // should be much larger than the max physical size of the allocator.
+  //
+  // In practice, since the BFC allocator coalesces adjacent AllocationRegions,
+  // this free function should never be invoked.
+  void Free(void* ptr, size_t num_bytes) override;
+
+  bool SupportsCoalescing() const override { return true; }
+
+ private:
+  GpuVirtualMemAllocator(
+      const std::vector<Visitor>& alloc_visitors,
+      const std::vector<Visitor>& free_visitors,
+      stream_executor::gpu::GpuContext& gpu_context,
+      tsl::PlatformDeviceId gpu_id,
+      std::vector<stream_executor::gpu::GpuDeviceHandle> access_device_handles,
+      stream_executor::gpu::GpuDriver::VmemSpan vmem, size_t granularity);
+
+  stream_executor::gpu::GpuContext& gpu_context_;
+  tsl::PlatformDeviceId gpu_id_;
+
+  // Peer access is configured at mmap time so the allocator must be aware of
+  // all gpus that may want to read the memory. This list also includes the
+  // above gpu_id_ to facilitate the invocation of the GpuDriver::MapMemory
+  // function.
+  const std::vector<stream_executor::gpu::GpuDeviceHandle> access_gpu_handles_;
+
+  // The virtual memory span held by this allocator.
+  stream_executor::gpu::GpuDriver::VmemSpan vmem_;
+  // The next offset from the vmem base address that will be allocated. This
+  // corresponds to the size of physically pinned memory if holes haven't been
+  // created with "free".
+  size_t next_alloc_offset_ = 0;
+
+  // Smallest allocation as determined by CUDA.
+  const size_t granularity_;
+
+  struct Mapping {
+    stream_executor::gpu::GpuDevicePtr va;
+    stream_executor::gpu::GpuDriver::GenericMemoryHandle physical;
+  };
+  // List of mappings, sorted by va.
+  std::vector<Mapping> mappings_;
+
+  GpuVirtualMemAllocator(const GpuVirtualMemAllocator&) = delete;
+  void operator=(const GpuVirtualMemAllocator&) = delete;
+};
+
+}  // namespace tensorflow
+
+#endif  // CUDA_VERSION >= 10200
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_GPU_GPU_VIRTUAL_MEM_ALLOCATOR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/gpu_device_context.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/gpu_device_context.h
new file mode 100644
index 0000000000000000000000000000000000000000..dcc3bfb4335d950d23248737a4d3f523dc093195
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/gpu_device_context.h
@@ -0,0 +1,107 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_GPU_DEVICE_CONTEXT_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_GPU_DEVICE_CONTEXT_H_
+
+#include "tensorflow/core/common_runtime/device.h"
+#include "tensorflow/core/framework/device_base.h"
+#include "tensorflow/core/lib/gtl/inlined_vector.h"
+
+namespace stream_executor {
+class Stream;
+}  // namespace stream_executor
+
+namespace tensorflow {
+
+class GPUDeviceContext : public DeviceContext {
+ public:
+  // Does not take ownership of streams.
+  GPUDeviceContext(int stream_id, se::Stream* stream,
+#if TENSORFLOW_USE_ROCM
+                   se::Stream* nccl_stream,
+#endif
+                   se::Stream* host_to_device_stream,
+                   se::Stream* device_to_host_stream,
+                   gtl::InlinedVector<se::Stream*, 4> device_to_device_stream,
+                   Allocator* host_memory_allocator)
+      : stream_id_(stream_id),
+        stream_(stream),
+#if TENSORFLOW_USE_ROCM
+        nccl_stream_(nccl_stream),
+#endif
+        host_to_device_stream_(host_to_device_stream),
+        device_to_host_stream_(device_to_host_stream),
+        device_to_device_stream_(device_to_device_stream),
+        host_memory_allocator_(host_memory_allocator) {
+  }
+
+  ~GPUDeviceContext() override {}
+
+  se::Stream* stream() const override { return stream_; }
+#if TENSORFLOW_USE_ROCM
+  se::Stream* nccl_stream() const { return nccl_stream_; }
+#endif
+  se::Stream* host_to_device_stream() const { return host_to_device_stream_; }
+  se::Stream* device_to_host_stream() const { return device_to_host_stream_; }
+  se::Stream* device_to_device_stream(int index) const {
+    return device_to_device_stream_[index % device_to_device_stream_.size()];
+  }
+  int stream_id() const { return stream_id_; }
+  Allocator* host_memory_allocator() const override {
+    return host_memory_allocator_;
+  }
+
+  void CopyCPUTensorToDevice(const Tensor* cpu_tensor, Device* device,
+                             Tensor* device_tensor, StatusCallback done,
+                             bool sync_dst_compute) const override;
+
+  void CopyDeviceTensorToCPU(const Tensor* device_tensor, StringPiece edge_name,
+                             Device* device, Tensor* cpu_tensor,
+                             StatusCallback done) override;
+
+  void CopyTensorInSameDevice(const Tensor* input_tensor, Device* device,
+                              Tensor* output_tensor,
+                              StatusCallback done) const override;
+
+  void MaintainLifetimeOnStream(const Tensor* t,
+                                se::Stream* stream) const override {}
+
+  Status ThenExecute(Device* device, se::Stream* stream,
+                     std::function<void()> func) override;
+
+ private:
+  int stream_id_;
+  // The default primary stream to use for this context.
+  // All the memory belongs to this stream.
+  se::Stream* stream_;
+#if TENSORFLOW_USE_ROCM
+  // The stream to use for nccl operations.
+  se::Stream* nccl_stream_;
+#endif
+  // The stream to use for copying data from host into GPU.
+  se::Stream* host_to_device_stream_;
+  // The stream to use for copying data from GPU to host.
+  se::Stream* device_to_host_stream_;
+  // Streams to use for copying data between GPUs.
+  gtl::InlinedVector<se::Stream*, 4> device_to_device_stream_;
+  // The allocator to use for allocating pinned host memory.
+  // Not owned.
+  Allocator* host_memory_allocator_;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_GPU_DEVICE_CONTEXT_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/gradients.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/gradients.h
new file mode 100644
index 0000000000000000000000000000000000000000..1f86af5298de3806edaa22c7ce419b80e93d14c3
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/gradients.h
@@ -0,0 +1,58 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_GRADIENTS_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_GRADIENTS_H_
+
+#include "tensorflow/core/graph/graph.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/lib/gtl/array_slice.h"
+
+namespace tensorflow {
+
+// Represents the output of 'node' at 'index'.
+struct NodeOut {
+  Node* node;
+  int index;
+
+  // Returns the string name that represents the output of this node.
+  string name() const;
+  // Returns the data type of the output of this node.
+  DataType dtype() const;
+};
+
+// NOTE: This API is a work in progress and will likely be changing frequently.
+//
+// Given initial gradient-node outputs 'y_grad_node_outputs' (which compute the
+// symbolic partial derivatives of some loss function 'L' w.r.t the node outputs
+// 'y_node_outputs'), adds gradient nodes to 'graph' that compute the symbolic
+// partial derivatives of 'L' w.r.t the node outputs 'x_node_outputs'.
+//
+// REQUIRES: Each node in 'x_node_outputs' to be unique, and so to have a single
+// output (this restriction will be removed in a subsequent change).
+
+// TODO(andydavis) Add symbolic gradient support for general graphs (the current
+// implementation only supports gradients for functions). In particular,
+// the nodes in 'x_nodes' are currently restricted to have one output.
+
+Status AddSymbolicGradients(gtl::ArraySlice<NodeOut> y_node_outputs,
+                            gtl::ArraySlice<NodeOut> x_node_outputs,
+                            gtl::ArraySlice<NodeOut> y_grad_node_outputs,
+                            std::vector<NodeOut>* x_grad_node_outputs,
+                            Graph* graph);
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_GRADIENTS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/graph_constructor.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/graph_constructor.h
new file mode 100644
index 0000000000000000000000000000000000000000..cb164732da150eae9f02f789513711e7056e3ae6
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/graph_constructor.h
@@ -0,0 +1,210 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_GRAPH_CONSTRUCTOR_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_GRAPH_CONSTRUCTOR_H_
+
+#include "tensorflow/core/framework/graph.pb.h"
+#include "tensorflow/core/graph/graph.h"
+#include "tensorflow/core/graph/tensor_id.h"
+#include "tensorflow/core/lib/core/status.h"
+
+namespace tensorflow {
+class ShapeRefiner;
+
+// Construct a Graph *g out of a GraphDef gdef. Returns non-OK on
+// error, in which case *g is left in an incomplete state.
+//
+// *g is expected to be an empty graph (with no more than a source and sink
+// nodes) when provided to ConvertGraphDefToGraph. To enhance an existing Graph,
+// see ImportGraphDef.
+struct GraphConstructorOptions {
+  GraphConstructorOptions() = default;
+
+  // If true, allows internal ops in the GraphDef.
+  bool allow_internal_ops = false;
+
+  // If true, the graph def is expected to have fully specified
+  // devices for all nodes. A node in the resulting graph "g" has the
+  // device name set accordingly.
+  //
+  // TODO(zhifengc): if possible, consider removing this option.
+  bool expect_device_spec = false;
+
+  // If true, validates that nodes being converted have all expected attrs
+  // set and no unknown attrs set by calling ValidateNodeDef().
+  // Setting validate_nodes without add_default_attributes, will fail if
+  // the GraphDef does not have all required attributes set.
+  bool validate_nodes = false;
+
+  // If true, GraphConstructor will add attributes with their default
+  // value to the Node when they are missing from the NodeDef.
+  bool add_default_attributes = true;
+};
+extern Status ConvertGraphDefToGraph(const GraphConstructorOptions& opts,
+                                     const GraphDef& gdef, Graph* g);
+extern Status ConvertGraphDefToGraph(const GraphConstructorOptions& opts,
+                                     GraphDef&& gdef, Graph* g);
+
+// Same as ConvertGraphDefToGraph, but takes just nodes.  Used by function
+// instantiation.
+// TODO(irving): This will turn into std::vector<NodeInfoPtr> soon.
+extern Status ConvertNodeDefsToGraph(
+    const GraphConstructorOptions& opts, gtl::ArraySlice<NodeDef> nodes,
+    Graph* g, const GraphDebugInfo* debug_info = nullptr);
+
+// Options for calling ImportGraphDef().
+struct ImportGraphDefOptions {
+  ImportGraphDefOptions()
+      : uniquify_names(false),
+        uniquify_prefix(false),
+        skip_mapped_nodes(false),
+        validate_shape(true),
+        propagate_device_spec(false) {}
+
+  // Name prefix to use for nodes imported from the GraphDef.  For example, if
+  // prefix="animals" and GraphDef contains a node "bunny" then the node will be
+  // named "animals/bunny" in *g. Must not be already used as a node name or
+  // prefix in the graph.
+  string prefix;
+
+  // If true, imported node names will be modified if their name already exists
+  // in the graph. If false, conflicting names will be treated as an error. Note
+  // that this option has no effect if `prefix` is specified, since `prefix`
+  // will guarantee all node names are unique.
+  bool uniquify_names;
+
+  // If true, `prefix` will be modified if it already exists as a node name or
+  // prefix in the graph. If false, a conflicting prefix will be treated as an
+  // error. This option has no effect if `prefix` isn't specified.
+  bool uniquify_prefix;
+
+  // Maps tensors in `gdef` to existing tensors in `g`. Inputs in `gdef`
+  // corresponding to `input_map` keys will be remapped to the nodes in `g`
+  // corresponding to the values.
+  //
+  // Keys should not include `prefix`, i.e., a key ID's name should be the name
+  // as it originally appears in `gdef`.
+  //
+  // If this is non-empty, ImportGraphDef must be called with the shape refiner
+  // used to create the existing nodes referenced in `input_map`.
+  // TODO(skyewm): can we remove this requirement? How do we access the original
+  // shape refiner?
+  std::map<SafeTensorId, SafeTensorId> input_map;
+
+  // If true, nodes that will have all output edges removed because of
+  // overrides in `input_map` will not be imported.
+  bool skip_mapped_nodes;
+
+  // The names of existing nodes in `g` that the imported graph should have
+  // control dependencies on.
+  //
+  // Note that to avoid creating many redundant control edges, ImportGraphDef()
+  // won't add control edges to nodes that will inherit the dependencies from
+  // other nodes in `gdef`.
+  std::vector<string> control_dependencies;
+
+  // Tensors in `gdef` that will be returned via the ImportGraphDefResults
+  // output parameter of `ImportGraphDef()`. If this list is non-empty, the
+  // caller must pass a results object to `ImportGraphDef()`. The
+  // `return_tensors` field will be populated with the imported nodes in `g`.
+  //
+  // Entries should not include `prefix`, i.e., each ID's name should be the
+  // name as it originally appears in `gdef`.
+  //
+  // If this contains a tensor that's also being remapped via `input_map`, the
+  // corresponding existing tensor in `g` will be returned.
+  std::vector<SafeTensorId> return_tensors;
+
+  // The names of nodes in `gdef` that will be returned via the
+  // ImportGraphDefResults output parameter of `ImportGraphDef()`. If this list
+  // is non-empty, the caller must pass a results object to
+  // `ImportGraphDef()`. The `return_nodes` field will be populated with the
+  // imported nodes in `g`.
+  //
+  // Entries should not include `prefix`, i.e., each node's name should be the
+  // name as it originally appears in `gdef`.
+  //
+  // Unlike `return_tensors`, `input_map` has no effect on the nodes
+  // returned. `return_nodes` must be empty if `skip_mapped_nodes` is true.
+  // TODO(skyewm): make this work with `skip_mapped_nodes` if there's a need.
+  std::vector<string> return_nodes;
+
+  // If true, checks that all colocation constraints are nodes in the GraphDef.
+  bool validate_colocation_constraints = true;
+
+  // If false skips shape validation.
+  bool validate_shape;
+
+  // TODO(ashankar): Enable handling of GraphDefs produced by newer binaries
+  // with ops that are not defined in the binary calling ImportGraphDef.
+  // Similar to the producer_op_list argument to import_graph_def in the
+  // python API.
+
+  // Try to set default execution device for this grapth.
+  string default_device;
+
+  // If true, propagates a node's assigned device. By default the runtime
+  // will recompute the assigned device every time.
+  bool propagate_device_spec;
+};
+
+// Optional results that may be returned by ImportGraphDef.
+struct ImportGraphDefResults {
+  // The requested tensors associated with
+  // ImportGraphDefOptions::return_tensors. Note that the index may be different
+  // than the requested index if the returned tensor has been remapped according
+  // to `input_map`.
+  typedef int Index;
+  std::vector<std::pair<Node*, Index>> return_tensors;
+
+  // The requested nodes associated with ImportGraphDefOptions::return_nodes.
+  std::vector<Node*> return_nodes;
+
+  // Keys in ImportGraphDefOptions::input_map that don't appear in `gdef` and
+  // weren't used as an input to any node in `gdef`. These keys are likely due
+  // to typos, and callers may wish to treat their existence as an error.
+  std::vector<SafeTensorId> missing_unused_input_map_keys;
+};
+
+// Adds the graph in GraphDef `gdef` into an existing Graph `*g`.
+//
+// On error, returns non-OK and leaves `*g` unmodified.
+//
+// `refiner` can be null. It should be non-null if the caller
+// intends to add additional nodes to the graph after the import. This
+// allows the caller to validate shapes of those nodes (since
+// ShapeRefiner::AddNode must be called in topological order).
+//
+// `results` must be non-null if `opts.return_tensors` or `opts.result_nodes` is
+// non-empty. It can also be set to fetch the unused input map keys. If it's
+// non-null, all the vector fields must be empty.
+//
+// TODO(ashankar): Push this mechanism and get rid of Session::Extend()
+// as a means of enhancing an existing Graph.
+extern Status ImportGraphDef(const ImportGraphDefOptions& opts,
+                             const GraphDef& gdef, Graph* g,
+                             ShapeRefiner* refiner,
+                             ImportGraphDefResults* results = nullptr);
+
+// Make a copy of "src" into "*dest".
+//
+// REQUIRES: "*dest" is a freshly allocated graph without any nodes or edges
+// other than the implicit Source/Sink nodes.
+extern void CopyGraph(const Graph& src, Graph* dest);
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_GRAPH_CONSTRUCTOR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/graph_def_builder_util.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/graph_def_builder_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..01f3d710460d6d1c9667ebbe67f019bb930638d5
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/graph_def_builder_util.h
@@ -0,0 +1,35 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_GRAPH_DEF_BUILDER_UTIL_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_GRAPH_DEF_BUILDER_UTIL_H_
+
+#include "tensorflow/core/graph/graph_def_builder.h"
+#include "tensorflow/core/lib/core/status.h"
+
+namespace tensorflow {
+
+class Graph;
+
+// Converts the `GraphDef` being built by `builder` to a `Graph` and
+// stores it in `*graph`.
+// TODO(josh11b): Make this faster; right now it converts
+// Graph->GraphDef->Graph.  This cleans up the graph (e.g. adds
+// edges from the source and to the sink node, resolves back edges
+// by name), and makes sure the resulting graph is valid.
+Status GraphDefBuilderToGraph(const GraphDefBuilder& builder, Graph* graph);
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_GRAPH_DEF_BUILDER_UTIL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/graph_execution_state.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/graph_execution_state.h
new file mode 100644
index 0000000000000000000000000000000000000000..87b3a12891d45a5832c8e7300961ef65aaa69e7f
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/graph_execution_state.h
@@ -0,0 +1,237 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_GRAPH_EXECUTION_STATE_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_GRAPH_EXECUTION_STATE_H_
+
+#include <functional>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "tensorflow/core/common_runtime/build_graph_options.h"
+#include "tensorflow/core/common_runtime/device.h"
+#include "tensorflow/core/common_runtime/device_set.h"
+#include "tensorflow/core/framework/function.h"
+#include "tensorflow/core/framework/graph.pb.h"
+#include "tensorflow/core/graph/costmodel.h"
+#include "tensorflow/core/graph/graph.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/platform/macros.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+struct SessionOptions;
+
+namespace subgraph {
+struct RewriteGraphMetadata;
+}
+
+struct GraphExecutionStateOptions {
+  const DeviceSet* device_set = nullptr;
+  const SessionOptions* session_options = nullptr;
+  // Unique session identifier. Can be empty.
+  string session_handle;
+  // A map from node name to device name, representing the unchangeable
+  // placement of stateful nodes.
+  std::unordered_map<string, string> stateful_placements;
+  // Whether to run Placer on the graph.
+  bool run_placer = true;
+};
+
+// A ClientGraph is simply a sub-graph of the full graph as induced by
+// BuildGraphOptions.
+struct ClientGraph {
+  explicit ClientGraph(std::unique_ptr<FunctionLibraryDefinition> flib,
+                       DataTypeVector feed_types, DataTypeVector fetch_types,
+                       int64_t collective_graph_key)
+      : flib_def(std::move(flib)),
+        graph(flib_def.get()),
+        feed_types(std::move(feed_types)),
+        fetch_types(std::move(fetch_types)),
+        collective_graph_key(collective_graph_key) {}
+  // Each client-graph gets its own function library since optimization passes
+  // post rewrite for execution might want to introduce new functions.
+  std::unique_ptr<FunctionLibraryDefinition> flib_def;
+  Graph graph;
+  DataTypeVector feed_types;
+  DataTypeVector fetch_types;
+  int64_t collective_graph_key;
+};
+
+// GraphExecutionState is responsible for generating an
+// executable ClientGraph from the original GraphDef that specifies
+// the complete graph and from BuildGraphOptions which specifies
+// input/output nodes.
+//
+// An executable Graph differs from a GraphDef by being Placed,
+// meaning that each Node is assigned to a single Device in the
+// available set.
+//
+// When GraphExecutionState is first constructed it instantiates
+// a full Graph from the provided GraphDef, and places it, using only
+// the static device assignments from the GraphDef.  Nodes without are
+// currently placed in a very naive way.  Since stateful Nodes cannot
+// be moved after initial placement, it is important that stateful
+// Nodes get sensible initial device assignments in the graph
+// definition.
+//
+// Subsequently, GraphExecutionState generates a SimpleClientGraph on
+// demand, which is a sub-graph of the latest placement of the full
+// Graph.  MasterSession uses such a ClientGraph to execute one or
+// more similar client requests.
+//
+// GraphExecutionState is thread-safe.
+
+class GraphExecutionState {
+ public:
+  virtual ~GraphExecutionState();
+
+  // Creates a new `GraphExecutionState` for the given
+  // `graph_def`, which represents the entire graph for a session.
+  static Status MakeForBaseGraph(
+      GraphDef&& graph_def, const GraphExecutionStateOptions& options,
+      std::unique_ptr<GraphExecutionState>* out_state);
+
+  // Creates a new `GraphExecutionState` and `SimpleClientGraph`
+  // for the subgraph of `original_graph_def` defined by
+  // `subgraph_options`.
+  static Status MakeForPrunedGraph(
+      const GraphExecutionState& base_execution_state,
+      const GraphExecutionStateOptions& options,
+      const BuildGraphOptions& subgraph_options,
+      std::unique_ptr<GraphExecutionState>* out_state,
+      std::unique_ptr<ClientGraph>* out_client_graph);
+
+  // Creates a new GraphExecutionState representing the
+  // concatenation of this graph, and the graph defined by
+  // "extension_def". The same name may not be used to define a node
+  // in both this graph and "extension_def".
+  //
+  // If successful, returns OK and the caller takes ownership of "*out".
+  // Otherwise returns an error and does not modify "*out".
+  //
+  // After calling `old_state->Extend()`, `old_state` may no longer be
+  // used.
+  //
+  // NOTE(mrry): This method respects the placement of stateful nodes in
+  // in *this, but currently does not transfer any other placement
+  // or cost model information to the new graph.
+  //
+  // Note that using this interface requires setting the value of
+  // config.experimental().disable_optimize_for_static_graph() in the state
+  // options to `true`, otherwise it will return an error.
+  Status Extend(const GraphDef& extension_def,
+                std::unique_ptr<GraphExecutionState>* out) const;
+
+  // Builds a ClientGraph (a sub-graph of the full graph as induced by
+  // the Node set specified in "options").  If successful, returns OK
+  // and the caller takes the ownership of "*out". Otherwise, returns
+  // an error.
+  Status BuildGraph(const BuildGraphOptions& options,
+                    std::unique_ptr<ClientGraph>* out);
+
+  // Optimize the graph with the node set specified in `options`.
+  Status OptimizeGraph(
+      const BuildGraphOptions& options, const Graph& graph,
+      const FunctionLibraryDefinition* flib_def,
+      std::unique_ptr<Graph>* optimized_graph,
+      std::unique_ptr<FunctionLibraryDefinition>* optimized_flib);
+
+  // The graph returned by BuildGraph may contain only the pruned
+  // graph, whereas some clients may want access to the full graph.
+  const Graph* full_graph() { return graph_; }
+
+  // The original graph.
+  GraphDef* original_graph_def() { return original_graph_def_.get(); }
+
+  // The original function library of this graph.
+  const FunctionLibraryDefinition& flib_def() const { return *flib_def_; }
+
+  // Returns the node with the given name, or null if it does not exist.
+  const Node* get_node_by_name(const string& name) const {
+    NodeNameToCostIdMap::const_iterator iter =
+        node_name_to_cost_id_map_.find(name);
+    if (iter != node_name_to_cost_id_map_.end()) {
+      return graph_->FindNodeId(iter->second);
+    } else {
+      return nullptr;
+    }
+  }
+
+  // Returns the map of stateful placements as a map of
+  // node name to placement string.
+  std::unordered_map<string, string> GetStatefulPlacements() const {
+    return stateful_placements_;
+  }
+
+ private:
+  GraphExecutionState(std::unique_ptr<GraphDef>&& graph_def,
+                      std::unique_ptr<FunctionLibraryDefinition>&& flib_def,
+                      const GraphExecutionStateOptions& options);
+
+  Status InitBaseGraph(std::unique_ptr<Graph>&& graph);
+
+  // Map of placed stateful nodes, i.e. nodes for which is_stateful()
+  // is true, such as "params" and "queue" nodes.  Once placed these
+  // nodes can not be moved to a different device.  Maps node names to
+  // device names.
+  std::unordered_map<string, string> stateful_placements_;  // Immutable after
+                                                            // ctor.
+  void SaveStatefulNodes(Graph* graph);
+  void RestoreStatefulNodes(Graph* graph);
+
+  // Extract the subset of the graph that needs to be run, adding feed/fetch
+  // ops as needed.
+  Status PruneGraph(const BuildGraphOptions& options, Graph* graph,
+                    subgraph::RewriteGraphMetadata* out_rewrite_metadata);
+
+  // The GraphExecutionState must store a copy of the original GraphDef if
+  // either of the following conditions holds:
+  //
+  // * `session_options_.config.graph_options().place_pruned_graph()` is true.
+  // * `session_options_.config.experimental().optimize_for_static_graph()` is
+  //   false.
+  const std::unique_ptr<GraphDef> original_graph_def_;
+
+  const DeviceSet* device_set_;            // Not owned
+  const SessionOptions* session_options_;  // Not owned
+  // Unique session identifier. Can be empty.
+  string session_handle_;
+
+  // Map from name to Node for the full graph in placed_.
+  NodeNameToCostIdMap node_name_to_cost_id_map_;
+
+  // 'flib_def_' is initialized from the initial graph def's library,
+  // and may be updated by a graph optimization pass.
+  std::unique_ptr<FunctionLibraryDefinition> flib_def_;
+
+  // `rewrite_metadata_` is only set for GraphExecutionState
+  // objects created by `MakeForPrunedGraph()`.
+  std::unique_ptr<subgraph::RewriteGraphMetadata> rewrite_metadata_;
+
+  // The dataflow graph owned by this object.
+  Graph* graph_;
+
+  // Whether to run Placer.
+  bool run_placer_;
+
+  GraphExecutionState(const GraphExecutionState&) = delete;
+  void operator=(const GraphExecutionState&) = delete;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_GRAPH_EXECUTION_STATE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/graph_optimizer.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/graph_optimizer.h
new file mode 100644
index 0000000000000000000000000000000000000000..f8322cfe7213a2cbf271e686043f17fe2805d6d1
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/graph_optimizer.h
@@ -0,0 +1,100 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_GRAPH_OPTIMIZER_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_GRAPH_OPTIMIZER_H_
+
+#include "tensorflow/core/framework/function.h"
+#include "tensorflow/core/graph/graph.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/platform/env.h"
+#include "tensorflow/core/protobuf/config.pb.h"
+
+namespace tensorflow {
+
+class GraphOptimizer {
+ public:
+  using NodePredicate = std::function<bool(const Node*)>;
+
+  struct Options {
+    // If not null it maps from nodes in graph to partially-known
+    // shapes of their outputs, and may be used, e.g., in the constant folding
+    // pass. The use of shape_map implies that the mapping from node name to the
+    // vector of partial shapes of its outputs is stable, i.e., no optimization
+    // pass may replace a node with a different node of the same name that has a
+    // different number of outputs, or outputs with different known shapes.
+    // TODO(b/65453533) introduce a unique way to name nodes in a graph.
+    std::unordered_map<string, std::vector<PartialTensorShape>>* shape_map =
+        nullptr;
+
+    // If not null then only nodes for which cse_consider_fn returns true will
+    // be considered for CSE.
+    NodePredicate cse_consider_fn = nullptr;
+
+    // If not null then only nodes for which cf_consider_fn returns true will be
+    // considered for CF.
+    NodePredicate cf_consider_fn = nullptr;
+
+    // If true, multi-device functions will be inlined if
+    // opts_.do_function_inlining() is true.
+    bool inline_multi_device_functions = false;
+
+    // If true, functions in implementation selection group will be inlined if
+    // opts_.do_function_inlining() is true.
+    bool inline_impl_selection_group_functions = false;
+
+    // If true all functions will be inlined with a single device function
+    // body placer strategy.
+    bool inline_with_single_device_body_placer = false;
+
+    // If true, the _noinline attribute on functions and callers is ignored.
+    bool ignore_noinline = false;
+  };
+
+  explicit GraphOptimizer(const OptimizerOptions& opts);
+  ~GraphOptimizer();
+
+  // Applies optimization passes specified in 'opts' to 'graph'.
+  // Maybe replace *graph with a new graph object.  'device' is device
+  // on which the 'graph' will execute. It's passed to the optimizers
+  // so that they can respect constraints if any, that should be
+  // respected.
+  void Optimize(FunctionLibraryRuntime* runtime, Env* env, const Device* device,
+                std::unique_ptr<Graph>* graph,
+                const Options& graph_optimizer_options);
+
+  const OptimizerOptions& options() { return opts_; }
+
+ private:
+  OptimizerOptions opts_;
+
+  GraphOptimizer(const GraphOptimizer&) = delete;
+  void operator=(const GraphOptimizer&) = delete;
+};
+
+// Applies graph rewrite optimization such as inlining, dead code
+// removal, etc.
+//
+// **g is a graph constructed based on the runtime library 'lib'.
+// OptimizeGraph mutates **g extensively and replaces '*g' with a
+// complete copy. Therefore, the caller should not keep any references
+// to nodes *g.
+void OptimizeGraph(FunctionLibraryRuntime* lib, std::unique_ptr<Graph>* g,
+                   const GraphOptimizer::Options& graph_optimizer_options);
+void OptimizeGraph(FunctionLibraryRuntime* lib, std::unique_ptr<Graph>* g);
+
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_GRAPH_OPTIMIZER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/graph_runner.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/graph_runner.h
new file mode 100644
index 0000000000000000000000000000000000000000..95bb95371d587301a17c5ba5272d577952add8b0
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/graph_runner.h
@@ -0,0 +1,74 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_GRAPH_RUNNER_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_GRAPH_RUNNER_H_
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "tensorflow/core/framework/function.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/lib/core/status.h"
+
+namespace tsl {
+class Env;
+}  // namespace tsl
+namespace tensorflow {
+using Env = tsl::Env;
+
+class Device;
+class Graph;
+
+// GraphRunner takes a Graph, some inputs to feed, and some outputs
+// to fetch and executes the graph required to feed and fetch the
+// inputs and outputs.
+//
+// This class is only meant for internal use where one needs to
+// partially evaluate inexpensive nodes in a graph, such as for shape
+// inference or for constant folding.  Because of its limited, simple
+// use-cases, it executes all computation on the given device (CPU by default)
+// and is not meant to be particularly lightweight, fast, or efficient.
+class GraphRunner {
+ public:
+  // REQUIRES: `env` is not nullptr.
+  GraphRunner(Env* env);
+  // REQUIRES: 'device' is not nullptr. Not owned.
+  GraphRunner(Device* device);
+  ~GraphRunner();
+
+  // Function semantics for `inputs`, `output_names` and `outputs`
+  // matches those from Session::Run().
+  //
+  // NOTE: The output tensors share lifetime with the GraphRunner, and could
+  // be destroyed once the GraphRunner is destroyed.
+  //
+  // REQUIRES: `graph`, `env`, and `outputs` are not nullptr.
+  // `function_library` may be nullptr.
+  typedef std::vector<std::pair<string, Tensor>> NamedTensorList;
+  Status Run(Graph* graph, FunctionLibraryRuntime* function_library,
+             const NamedTensorList& inputs,
+             const std::vector<string>& output_names,
+             std::vector<Tensor>* outputs);
+
+ private:
+  std::unique_ptr<Device> device_deleter_;
+  Device* const device_;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_GRAPH_RUNNER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/hierarchical_tree_broadcaster.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/hierarchical_tree_broadcaster.h
new file mode 100644
index 0000000000000000000000000000000000000000..f058a10c5a0f788ea449c065748c4707e3e8d992
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/hierarchical_tree_broadcaster.h
@@ -0,0 +1,86 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_HIERARCHICAL_TREE_BROADCASTER_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_HIERARCHICAL_TREE_BROADCASTER_H_
+
+#include <vector>
+
+#include "tensorflow/core/common_runtime/base_collective_executor.h"
+#include "tensorflow/core/framework/collective.h"
+
+namespace tensorflow {
+
+// Hierarchical tree-algorithm implementation of collective broadcast.
+class HierarchicalTreeBroadcaster : public CollectiveImplementationInterface {
+ public:
+  HierarchicalTreeBroadcaster();
+  ~HierarchicalTreeBroadcaster() override = default;
+
+  // Establishes the subdiv permutations needed for a hierarchical broadcast.
+  // If all devices are local, establishes a single subdiv comprising all
+  // devices.  If any devices are on a different task, establishes n+1 subdivs
+  // for n tasks.
+  // The first subdiv comprises one device per task which gets the tensor on
+  // each task.  Subdiv i+1 corresponds to a task-local tree-broadcast for task
+  // i.
+  Status InitializeCollectiveParams(CollectiveParams* col_params) override;
+
+  // Initializes members of CollectiveContext not yet initialized, i.e. device
+  // and device_locality.  Also saves the CollectiveContext in this object.
+  Status InitializeCollectiveContext(
+      std::shared_ptr<CollectiveContext> col_ctx) override;
+
+  // Begins async execution of the hierarchical tree broadcast.
+  // Must be called in a blockable thread.
+  // TODO(b/80529858): remove the previous warning when we have a dedicated
+  // collective threadpool.
+  void Run(StatusCallback done) override;
+
+  // Returns the rank of the device from which this device should receive
+  // its value, -1 if no value should be received.
+  static int TreeRecvFrom(const CollectiveParams& cp, int subdiv);
+
+  // Populates targets with the ranks of the devices to which this device
+  // should forward the value.
+  static void TreeSendTo(const CollectiveParams& cp, int subdiv,
+                         std::vector<int>* targets);
+
+ private:
+  // Get the task to which the device at `device_rank` belongs.
+  int GetDeviceTask(int device_rank, const std::vector<int>& dev_per_task);
+
+  // Sends `src_tensor` asynchronously from this device to device at `dst_rank`
+  // in `subdiv`.  Calls `done` upon completion.
+  void DispatchSend(int subdiv, int dst_rank, int src_rank,
+                    const Tensor* src_tensor, const StatusCallback& done);
+
+  // Receives a tensor into the memory buffer owned by `dst_tensor` at this
+  // device from device at `src_rank` in `subdiv`.  Calls `done` upon
+  // completion.
+  void DispatchRecv(int subdiv, int src_rank, int dst_rank, Tensor* dst_tensor,
+                    const StatusCallback& done);
+
+  // Executes the hierarchical broadcast defined by this op.
+  void RunTree();
+
+  std::shared_ptr<CollectiveContext> col_ctx_;
+  const CollectiveParams* col_params_;  // Not owned
+  StatusCallback done_;
+  Status status_;
+  bool is_source_;
+};
+
+}  // namespace tensorflow
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_HIERARCHICAL_TREE_BROADCASTER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/inline_function_utils.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/inline_function_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..a11f2e8b770b2a7918a1912ec35077e081bf1166
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/inline_function_utils.h
@@ -0,0 +1,240 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_INLINE_FUNCTION_UTILS_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_INLINE_FUNCTION_UTILS_H_
+
+#include <functional>
+#include <memory>
+
+#include "absl/types/optional.h"
+#include "tensorflow/core/common_runtime/device.h"
+#include "tensorflow/core/common_runtime/function_body.h"
+#include "tensorflow/core/common_runtime/lower_function_call_inline_policy.h"
+#include "tensorflow/core/framework/function.h"
+#include "tensorflow/core/graph/graph.h"
+#include "tensorflow/core/protobuf/config.pb.h"
+
+namespace tensorflow {
+
+static constexpr const char* const kNoInlineAttr = "_noinline";
+
+// Optionally override device assignment for nodes added to the graph for
+// inlined functions:
+// (1) Identity nodes added in place of function input arguments.
+// (2) Identity nodes added in place of function return values.
+// (3) Special NoOp nodes that enforce side-effects execution order.
+// (4) All nodes inside function body specified in FunctionDef.
+class InlinedFunctionBodyPlacer {
+ public:
+  virtual ~InlinedFunctionBodyPlacer() = default;
+
+  virtual absl::optional<string> InputNodeDevice(int input_index) const = 0;
+  virtual absl::optional<string> OutputNodeDevice(int output_index) const = 0;
+  // Returns true if the added input/output identity nodes should be colocated
+  // with the corresponding input/output from the function body.
+  virtual bool ColocateInputOutputIdentities() const = 0;
+  virtual absl::optional<string> ControlNodeDevice() const = 0;
+  virtual absl::optional<string> BodyNodeDevice(const NodeDef& ndef) const = 0;
+
+  // LINT.IfChange
+  // Place input nodes on the same device as the corresponding caller input
+  // node. Do not specify any placement for all other nodes.
+  static std::unique_ptr<InlinedFunctionBodyPlacer> DefaultPlacer(
+      const Graph& graph, const Node& caller);
+
+  // Place all nodes on the same device as caller node.
+  static std::unique_ptr<InlinedFunctionBodyPlacer> SingleDevicePlacer(
+      const Graph& graph, const Node& caller);
+
+  // Place input nodes on the same device as the corresponding caller input
+  // node. Do not place output node. Place control nodes on the same device as
+  // caller node. For all function body nodes set job, replica and task
+  // parts of the device assignment to match function caller node where those
+  // are unspecified.
+  static std::unique_ptr<InlinedFunctionBodyPlacer> MultiDevicePlacer(
+      const Graph& graph, const Node& caller);
+  // LINT.ThenChange(lower_function_call_inline_policy.h)
+
+  using Factory = std::function<std::unique_ptr<InlinedFunctionBodyPlacer>(
+      const Graph&, const Node&)>;
+
+  struct Config {
+    string name;
+    Factory get;
+  };
+
+  static Config Default() { return {"default", DefaultPlacer}; }
+  static Config SingleDevice() { return {"single_device", SingleDevicePlacer}; }
+  static Config MultiDevice() { return {"multi_device", MultiDevicePlacer}; }
+};
+
+struct InlineFunctionBodyOptions {
+  // All nodes that have incoming control edge *from* the function call node,
+  // will be forwarded to the "output control node". There are two options for
+  // choosing which nodes will have a control edge *to* the "output control
+  // node":
+  //   a) control returns            (`control_ret` field in FunctionDef)
+  //   b) data returns               (`ret` field in FunctionDef)
+  enum class OutputControlSource { kDataOutputs, kControlOutputs };
+
+  // Keep a node in a graph with the same name as the function call node:
+  //
+  // a) DoNotKeep: Function call node is fully inlined, and there is no node in
+  //    a graph with the same name.
+  //
+  // b) Fetchable: Add an IdentityN node to the graph in place of the inlined
+  //    function call node. It will have a control edge from inlined
+  //    'output_control_node' and data edges from function output nodes.
+  //    The IdentityN node will be placed on the same device as the caller node.
+  //
+  //    This is mostly for compatibility with Tensorflow v1 and sessions.
+  //    When we prepare a graph for execution in
+  //    GraphExecutionState::MakeForBaseGraph we don't know what nodes will be
+  //    fetched, so we can't safely remove any of them. When graph executed as a
+  //    function it has 'Retval' nodes for all fetched tensors, and we can
+  //    safely inline function calls.
+  //
+  // c) Targetable: Add a NoOp node to the graph in place of the inlined
+  //    function call node. It will have a control edge from inline
+  //    'output_control_node' and no data edges. NoOp node will be placed on the
+  //    same device as the caller node. This will keep the inlined function call
+  //    node a valid 'session.run' target, and also will keep it a valid control
+  //    output node.
+  enum class KeepCallerNode { kDoNotKeep, kFetchable, kTargetable };
+
+  // If 'true' function inlining is completely disabled. This allows to control
+  // function inlining for different types of function calls (see
+  // 'ExpandInlineFunctionsOptions' below).
+  bool disable_inlining = false;
+  // Ignore '_noinline' function attribute.
+  bool ignore_noinline = false;
+  // If 'true' function inlining will inline functions in implementation
+  // selection group. Normally those functions should not be inlined; they will
+  // be handled by Grappler.
+  bool inline_impl_selection_group_functions = false;
+  // Controls if we want to keep a node with the name as the function call node
+  // in a graph after function inlining.
+  KeepCallerNode keep_caller_node = KeepCallerNode::kDoNotKeep;
+  // For compatibility with Tensorflow v1 by default we will use data outputs.
+  // Control returns were added to Tensorflow v2 with automatic control
+  // dependencies tracking in Eager mode.
+  OutputControlSource output_control_src = OutputControlSource::kDataOutputs;
+  // Inlined function body placer decides what requested device assignments
+  // should be added to the nodes added to the graph. See documentation above
+  // for available strategies.
+  InlinedFunctionBodyPlacer::Config inlined_function_body_placer =
+      InlinedFunctionBodyPlacer::Default();
+  // If true, frame names in the function body will be
+  // made unique in the resulting graph (e.g. by prepending a unique prefix).
+  // NOTE(mrry): Only set this option to false when there is a single function
+  // call in the graph (e.g. when making a remote function call via
+  // ClusterFunctionLibraryRuntime). This option is provided because the graph
+  // partitioner generates frame names that must remain unmodified across all
+  // partitions of a multi-device function.
+  bool uniquify_frame_names = true;
+
+  // A human-readable debug string for this options.
+  string DebugString() const;
+};
+
+// Returns 'OkStatus()' iff the function '*fbody' can be inlined at 'node'
+// based on the type signature of 'node' and 'fbody':
+//
+// (1) Caller node has the same number of inputs and outputs as the function.
+// (2) Caller node inputs and outputs have the same data types as function
+//     inputs and returns.
+// (3) Validation rules defined in InlineFunctionBodyOptions.
+//
+// If function can't be safely inlined, returns error message with details why
+// inlining is not possible or safe.
+Status ValidateInlining(const Node* node, const FunctionBody* fbody,
+                        const InlineFunctionBodyOptions& options);
+
+// Given a "caller" in graph "g", which is a function call of a function
+// to "fbody". Replaces the "caller" with fbody->graph and connects
+// edges properly. "override_device" specifies whether inlining should replace
+// explicitly specified devices inside fbody with the callee's device.
+//
+// Returns 'OkStatus()' if function was successfully inlined into the graph.
+// If function inlining is not possible returns an error with a reason, and
+// leaves the graph in unmodified state.
+Status InlineFunctionBody(const FunctionLibraryDefinition& flib_def, Graph* g,
+                          Node* caller, const FunctionBody* fbody,
+                          const InlineFunctionBodyOptions& options);
+
+// There are three types of function calls that could be invoked during
+// *Tensorflow graph execution*:
+//
+// 1) Native function call (node.type_string() is the function name). These
+//    functions are always executed on a single-device, which is the device of
+//    the function call node.
+//
+// 2) Multi-device function calls (PartitionedCall or StatefulPartitionedCall
+//    ops) can execute on multiple devices and accept DT_RESOURCE inputs that
+//    belong to different devices. This type of functions was added in
+//    Tensorflow 2.0 Eager mode, and it has control outputs to represent
+//    side-effects that must always execute (see `control_ret` in FunctionDef).
+//
+// 3) SymbolicGradient has been deprecated for a while, but we still keep it and
+//    use `native` options for inlining for compatibility.
+//
+// We need to have distinct inlining rules for compatibility with Tensorflow v1.
+//
+// There are few other places in Tensorflow that could execute functions:
+//
+// 1) common_runtime/eager/kernel_and_device.{h,cc} - executes "top level"
+//    functions directly via function library runtime, without going through
+//    the graph.
+// 2) tf.data pipelines - also execute functions directly via function library
+//    runtime with custom executors.
+struct ExpandInlineFunctionsOptions {
+  ExpandInlineFunctionsOptions() : native_options(), multi_device_options() {
+    using OutputControlSrc = InlineFunctionBodyOptions::OutputControlSource;
+    multi_device_options.output_control_src = OutputControlSrc::kControlOutputs;
+  }
+
+  InlineFunctionBodyOptions native_options;
+  InlineFunctionBodyOptions multi_device_options;
+};
+
+// WARNING(ezhulenev): PLEASE DO NOT USE THIS FUNCTION. This is a temporary
+// workaround that will be enabled only during the function inlining unification
+// (b/126811947). Contact ezhulenev@ if you think you need it.
+// TODO(ezhulenev): Delete this function.
+bool ExpandInlineFunctions(FunctionLibraryRuntime* lib, Graph* graph,
+                           const ExpandInlineFunctionsOptions& options);
+
+// For each node in "graph", if "lib" indicates that the node is a
+// function call, inline the function body. Returns true if at least
+// one node is inlined.
+//
+// This routine goes through "graph" nodes once and applies the
+// inlining. The caller may decide to apply the inlining on "graph"
+// multiple times by calling ExpandInlineFunctions a few times.
+//
+// Function calls that can't be safely inlined into the graph (ValidateInlining
+// returns error), are ignored.
+//
+// TODO(ezhulenev): We do not FunctionLibraryRuntime for this. We need just the
+// FunctionLibraryDefinition and FunctionDefToBodyHelper to implement this (see
+// lower_function_call.cc).
+inline bool ExpandInlineFunctions(FunctionLibraryRuntime* lib, Graph* graph) {
+  return ExpandInlineFunctions(lib, graph, ExpandInlineFunctionsOptions());
+}
+
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_INLINE_FUNCTION_UTILS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/input_colocation_exemption_registry.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/input_colocation_exemption_registry.h
new file mode 100644
index 0000000000000000000000000000000000000000..c393fe7498b6966d6ca0ed6249ea0b43195c4ede
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/input_colocation_exemption_registry.h
@@ -0,0 +1,76 @@
+/* Copyright 2019 The TensorFlow Authors. Al Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_INPUT_COLOCATION_EXEMPTION_REGISTRY_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_INPUT_COLOCATION_EXEMPTION_REGISTRY_H_
+
+#include <string>
+
+#include "tensorflow/core/lib/gtl/flatset.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+
+// TensorFlow runtime (both eager and graph) will aim to colocate ops with
+// their resource inputs so that the ops can access the resource state. In some
+// cases, such as tf.data ops, this is not desirable as the ops themselves might
+// not have a kernel registered for the device on which the resource is placed
+// and instead use a mechanism, such as a multi-device function, to access the
+// resource state.
+//
+// This registry can be used to register and list ops that should be exempt from
+// the input colocation described above.
+//
+// Example usage:
+//   REGISTER_INPUT_COLOCATION_EXEMPTION("MapDataset");
+class InputColocationExemptionRegistry {
+ public:
+  // Returns a pointer to a global InputColocationExemptionRegistry object.
+  static InputColocationExemptionRegistry* Global();
+
+  // Returns the set of ops exempt from the input colocation constraints.
+  const gtl::FlatSet<string>& Get() { return ops_; }
+
+  // Registers an op to be excluded from the input colocation constraints.
+  void Register(const string& op);
+
+ private:
+  gtl::FlatSet<string> ops_;
+};
+
+namespace input_colocation_exemption_registration {
+
+class InputColocationExemptionRegistration {
+ public:
+  explicit InputColocationExemptionRegistration(const string& op) {
+    InputColocationExemptionRegistry::Global()->Register(op);
+  }
+};
+
+}  // namespace input_colocation_exemption_registration
+
+#define REGISTER_INPUT_COLOCATION_EXEMPTION(op) \
+  REGISTER_INPUT_COLOCATION_EXEMPTION_UNIQ_HELPER(__COUNTER__, op)
+
+#define REGISTER_INPUT_COLOCATION_EXEMPTION_UNIQ_HELPER(ctr, op) \
+  REGISTER_INPUT_COLOCATION_EXEMPTION_UNIQ(ctr, op)
+
+#define REGISTER_INPUT_COLOCATION_EXEMPTION_UNIQ(ctr, op) \
+  static input_colocation_exemption_registration::        \
+      InputColocationExemptionRegistration                \
+          input_colocation_exemption_registration_fn_##ctr(op)
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_INPUT_COLOCATION_EXEMPTION_REGISTRY_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/inspecting_placer.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/inspecting_placer.h
new file mode 100644
index 0000000000000000000000000000000000000000..b9d19a48917d94b6436b4d049b12b2e3cbc0ab6c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/inspecting_placer.h
@@ -0,0 +1,96 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_INSPECTING_PLACER_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_INSPECTING_PLACER_H_
+
+#include <vector>
+
+#include "absl/strings/str_join.h"
+#include "tensorflow/core/common_runtime/device.h"
+#include "tensorflow/core/common_runtime/placer_inspection_required_ops_utils.h"
+#include "tensorflow/core/framework/function.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/lib/core/stringpiece.h"
+#include "tensorflow/core/util/device_name_utils.h"
+#include "tensorflow/core/util/port.h"
+
+namespace tensorflow {
+
+// TODO(iga): Convert this struct into a class to ensure invariants between
+// device names, i.e.
+//  DeviceNameUtils::IsSpecification(resource_device_name,
+//                                   requested_device_name)
+// PossibleDevices does not contain assigned_device_name because we don't
+// assign devices to nested functions.
+struct PossibleDevices {
+  // The same as Member::requested_device_name_ in colocation_graph.cc.
+  DeviceNameUtils::ParsedName requested_device_name;
+
+  // The same as Member::resource_device_name_ in colocation_graph.cc.
+  DeviceNameUtils::ParsedName resource_device_name;
+
+  // A device type outside of this set will not be supported by some
+  // internal op.
+  PrioritizedDeviceTypeVector device_types;
+};
+
+// A struct for communicating constraints on devices that can
+// be chosen for inputs and outputs of an op requiring deep placer inspection.
+struct IOColocationGroups {
+  // input_groups[i] contains the group id that i'th input belongs to.
+  // List inputs are not supported.
+  std::vector<int> input_groups;
+  // output_groups[i] contains the group id that i'th output belongs to.
+  // List inputs are not supported.
+  std::vector<int> output_groups;
+  // group_devices[i] contains possible devices for group with id i.
+  std::vector<PossibleDevices> group_devices;
+
+  string DebugString() const;
+};
+
+class InspectingPlacer {
+ public:
+  // graph and device_set must not be null and must outlive this
+  // InspectingPlacer. default_device can be null. If not, must outlive this.
+  // TODO(iga): Add a "stack trace" to detect recursion and improve log
+  // messages. Currently, we will enter an infinite loop for recursive
+  // functions.
+  InspectingPlacer(const FunctionStack& stack,
+                   const FunctionLibraryDefinition* flib_def,
+                   const DeviceSet* device_set, const Device* default_device,
+                   bool allow_soft_placement, bool log_device_placement);
+
+  // `node` must be
+  // PlacerInspectionRequiredOpsChecker::IsPlacerInspectionRequired.
+  Status ComputeIOColocationGroups(const Node& node,
+                                   IOColocationGroups* groups);
+
+ private:
+  const FunctionStack stack_;
+  const FunctionLibraryDefinition& flib_def_;
+  const DeviceSet& device_set_;
+  const Device* default_device_;
+  const bool allow_soft_placement_;
+  const bool log_device_placement_;
+
+  InspectingPlacer(const InspectingPlacer&) = delete;
+  void operator=(const InspectingPlacer&) = delete;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_INSPECTING_PLACER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/int32_fulltype.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/int32_fulltype.h
new file mode 100644
index 0000000000000000000000000000000000000000..f2be1c87e3f090df40c65ec3f6e8e9e13dd6683f
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/int32_fulltype.h
@@ -0,0 +1,65 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_INT32_FULLTYPE_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_INT32_FULLTYPE_H_
+
+#include "tensorflow/core/graph/graph.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/platform/macros.h"
+
+namespace tensorflow {
+
+// An optimization (graph rewrite) pass to automatically set TFT_SHAPE_TENSOR
+// full type information annotations for all int32 tensors, creating or
+// modifying existing full type information as needed. This allows placement
+// mechanisms using full type information to always place int32 on host.
+class Int32FulltypePass {
+ public:
+  Int32FulltypePass() = default;
+  explicit Int32FulltypePass(string debug_location)
+      : debug_location_(debug_location) {}
+
+  // For each node in this graph that outputs int32 tensors, set full
+  // type information such that the int32 tensors use TFT_SHAPE_TENSOR
+  // (or TFT_TENSOR if ints_on_device is true, which is only for single
+  // device functions including the functions with just one op used for
+  // eager execution).
+  //
+  // This method is not thread-safe.
+  Status ProcessGraph(Graph* graph, bool ints_on_device);
+
+  // Update full type information for int32 tensors that are in HOST_MEMORY
+  // to use TFT_SHAPE_TENSOR. The type_id of TENSOR_T is expected to be
+  // TFT_UNSET, TFT_TENSOR or TFT_SHAPE_TENSOR on input and will be updated
+  // to TFT_SHAPE_TENSOR on output for int32 tensors if it is not
+  // TFT_SHAPE_TENSOR already. For tensors that are not int32, if the input full
+  // type information is TFT_UNSET, it will only be updated if SET_ONLY_INT32 is
+  // false. Note that TENSOR_T is not the full type information for the outputs
+  // of a node, so it does have an outer TFT_PRODUCT. NODE and OUTPUT_IDX are
+  // optional and only used in an error message to say that the tensor is output
+  // OUTPUT_IDX of node NODE.
+  Status Int32FullTypeForTensor(DataType dtype, FullTypeDef* tensor_t,
+                                bool set_only_int32, Node* node = nullptr,
+                                int output_idx = 0);
+
+ private:
+  // Location of where annotations were added for debug messages.
+  string debug_location_;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_INT32_FULLTYPE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/isolate_placer_inspection_required_ops_pass.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/isolate_placer_inspection_required_ops_pass.h
new file mode 100644
index 0000000000000000000000000000000000000000..3d86c4538f0d171bb51d4e093b96e635c7f286a1
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/isolate_placer_inspection_required_ops_pass.h
@@ -0,0 +1,63 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_ISOLATE_PLACER_INSPECTION_REQUIRED_OPS_PASS_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_ISOLATE_PLACER_INSPECTION_REQUIRED_OPS_PASS_H_
+
+#include "tensorflow/core/common_runtime/optimization_registry.h"
+
+namespace tensorflow {
+// Adds Identities for each input/output of function-calling ops.
+//
+// For example, the following graph calling a function on inputs `a` and `b`
+// and producing output `y` will be rewritted to include identities on all
+// edges:
+//
+//      a             b
+//      |             |
+//      v             v
+//    f (PartitionedCallOp)
+//         |
+//         v
+//         y
+//
+// is transformed to
+//
+//      a             b
+//      |             |
+//  a_f (Identity)   a_f (Identity)
+//      |             |
+//      v             v
+//    f (PartitionedCallOp)
+//         |
+//      f_y (Identity)
+//         |
+//         v
+//         y
+//
+// This pass is currently needed to simplify correctly placing the nodes
+// producing inputs for as well as consuming output from function-calling ops.
+//
+// This pass should also help to implement replacing PartitionedCallOp with
+// component function calls (to avoid copying input/output tensors), if we get
+// to it.
+class IsolatePlacerInspectionRequiredOpsPass : public GraphOptimizationPass {
+ public:
+  Status Run(const GraphOptimizationPassOptions& options) override;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_ISOLATE_PLACER_INSPECTION_REQUIRED_OPS_PASS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/local_device.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/local_device.h
new file mode 100644
index 0000000000000000000000000000000000000000..595d3b88e8f09241381dff01ed3b77373df85691
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/local_device.h
@@ -0,0 +1,58 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_LOCAL_DEVICE_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_LOCAL_DEVICE_H_
+
+#include "tensorflow/core/common_runtime/device.h"
+#include "tensorflow/core/framework/device_attributes.pb.h"
+#include "tensorflow/core/platform/macros.h"
+
+namespace tensorflow {
+
+namespace test {
+class Benchmark;
+}
+struct SessionOptions;
+
+// This class is shared by ThreadPoolDevice and GPUDevice and
+// initializes a shared Eigen compute device used by both.  This
+// should eventually be removed once we refactor ThreadPoolDevice and
+// GPUDevice into more 'process-wide' abstractions.
+class LocalDevice : public Device {
+ public:
+  LocalDevice(const SessionOptions& options,
+              const DeviceAttributes& attributes);
+  ~LocalDevice() override;
+
+ private:
+  static bool use_global_threadpool_;
+
+  static void set_use_global_threadpool(bool use_global_threadpool) {
+    use_global_threadpool_ = use_global_threadpool;
+  }
+
+  struct EigenThreadPoolInfo;
+  std::unique_ptr<EigenThreadPoolInfo> owned_tp_info_;
+
+  friend class test::Benchmark;
+
+  LocalDevice(const LocalDevice&) = delete;
+  void operator=(const LocalDevice&) = delete;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_LOCAL_DEVICE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/local_executor_params.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/local_executor_params.h
new file mode 100644
index 0000000000000000000000000000000000000000..6c201d79dafa8ea658641f4aed30275ac51b1011
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/local_executor_params.h
@@ -0,0 +1,57 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_LOCAL_EXECUTOR_PARAMS_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_LOCAL_EXECUTOR_PARAMS_H_
+
+#include <functional>
+#include <memory>
+
+#include "tensorflow/core/lib/core/status.h"
+
+namespace tensorflow {
+class Device;
+class StepStatsCollector;
+class SessionMetadata;
+class FunctionLibraryRuntime;
+class NodeProperties;
+class OpKernel;
+
+// LocalExecutorParams provides arguments that will be shared by all invocations
+// of an executor. We expect that different contexts would provide different
+// implementations (e.g. local versus distributed).
+struct LocalExecutorParams {
+  Device* device;
+
+  const SessionMetadata* session_metadata = nullptr;
+
+  // The library runtime support.
+  FunctionLibraryRuntime* function_library = nullptr;
+
+  // create_kernel returns an instance of op kernel based on NodeDef.
+  // delete_kernel is called for every kernel used by the executor
+  // when the executor is deleted.
+  std::function<Status(const std::shared_ptr<const NodeProperties>&,
+                       OpKernel**)>
+      create_kernel;
+  std::function<void(OpKernel*)> delete_kernel;
+
+  // Whether control flow nodes are allowed to be executed synchronously.
+  bool allow_control_flow_sync_execution = false;
+};
+
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_LOCAL_EXECUTOR_PARAMS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/local_session_selection.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/local_session_selection.h
new file mode 100644
index 0000000000000000000000000000000000000000..9e21c8d7ff65b81e2ed3c471e7b4046d61f515be
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/local_session_selection.h
@@ -0,0 +1,33 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_LOCAL_SESSION_SELECTION_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_LOCAL_SESSION_SELECTION_H_
+
+namespace tensorflow {
+
+// The TF Session implementations that can be used to run local sessions, i.e.
+// when session_target in SessionOptions is empty.
+enum class LocalSessionImpl {
+  kDirectSession,
+  kTfrtSession,
+};
+
+void SetDefaultLocalSessionImpl(LocalSessionImpl impl);
+LocalSessionImpl GetDefaultLocalSessionImpl();
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_LOCAL_SESSION_SELECTION_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/lower_case_op.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/lower_case_op.h
new file mode 100644
index 0000000000000000000000000000000000000000..110ac20a929d89af6cd63616bd42a76965e96f72
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/lower_case_op.h
@@ -0,0 +1,31 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_LOWER_CASE_OP_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_LOWER_CASE_OP_H_
+
+#include "tensorflow/core/lib/core/status.h"
+
+namespace tensorflow {
+
+class Graph;
+class Node;
+
+// Replaces Case node `n` with a lowered form that uses _SwitchN/Merge nodes.
+Status RewriteCaseNode(Node* n, Graph* g, bool keep_node_fetchable);
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_LOWER_CASE_OP_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/lower_function_call_inline_policy.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/lower_function_call_inline_policy.h
new file mode 100644
index 0000000000000000000000000000000000000000..6dc48f8e3732068b38ac69aa961a1488bcad71fb
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/lower_function_call_inline_policy.h
@@ -0,0 +1,60 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_LOWER_FUNCTION_CALL_INLINE_POLICY_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_LOWER_FUNCTION_CALL_INLINE_POLICY_H_
+
+#include "tensorflow/core/graph/graph.h"
+
+namespace tensorflow {
+
+// LINT.IfChange
+enum class FunctionCallInlinePolicy {
+  // Place input nodes on the same device as the corresponding caller input
+  // node. Do not specify any placement for all other nodes.
+  kDefaultPlacer,
+
+  // Place all nodes on the same device as caller node.
+  kSingleDevicePlacer,
+
+  // Place input nodes on the same device as the corresponding caller input
+  // node. Do not place output node. Place control nodes on the same device as
+  // caller node. For all function body nodes overrides job, replica and task
+  // parts of the device assignment to match function caller node.
+  kMultiDevicePlacer
+};
+// LINT.ThenChange(inline_function_utils.h,\
+//   ../../compiler/mlir/tensorflow/ir/tf_ops.cc)
+
+struct LowerFunctionalOpsConstants {
+  static constexpr const char* const kLowerUsingSwitchMergeAttr =
+      "_lower_using_switch_merge";
+  static constexpr const char* const kLowerAsMultiDeviceFunctionAttr =
+      "_lower_as_multi_device_function";
+};
+
+// Inliner policy used in common runtime's lower function call op.
+
+// Returns the function call inline policy to use for a given call.
+FunctionCallInlinePolicy GetFunctionCallInlinePolicy(const Node* n);
+
+// Overload of GetFunctionCallInlinePolicy that doesn't require an op but only
+// the features required.
+FunctionCallInlinePolicy GetFunctionCallInlinePolicy(
+    bool is_partioned_call, bool has_lower_as_multi_device_function_attr);
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_LOWER_FUNCTION_CALL_INLINE_POLICY_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/lower_function_call_op.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/lower_function_call_op.h
new file mode 100644
index 0000000000000000000000000000000000000000..84f6f68dd71b65da6606f922181feafc82b399e1
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/lower_function_call_op.h
@@ -0,0 +1,37 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_LOWER_FUNCTION_CALL_OP_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_LOWER_FUNCTION_CALL_OP_H_
+
+#include "tensorflow/core/lib/core/status.h"
+
+namespace tensorflow {
+
+class FunctionLibraryDefinition;
+class Graph;
+class Node;
+
+// Replaces function call node `n` with its function body. Uses
+// InlineFunctionBody from `common_runtime/function.{h,cc}`. If function
+// inlining is not possible or safe (see ValidateInlining), leaves the graph in
+// unmodified state and returns OkStatus();
+Status RewriteFunctionCallNode(Node* n, Graph* g,
+                               const FunctionLibraryDefinition& flib_def,
+                               bool keep_caller_fetchable);
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_LOWER_FUNCTION_CALL_OP_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/lower_functional_ops.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/lower_functional_ops.h
new file mode 100644
index 0000000000000000000000000000000000000000..c372dfbad40ed6c0491966e548cd051fcae29f20
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/lower_functional_ops.h
@@ -0,0 +1,47 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_LOWER_FUNCTIONAL_OPS_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_LOWER_FUNCTIONAL_OPS_H_
+
+#include "absl/types/optional.h"
+#include "tensorflow/core/common_runtime/inline_function_utils.h"
+#include "tensorflow/core/common_runtime/optimization_registry.h"
+#include "tensorflow/core/lib/core/status.h"
+
+namespace tensorflow {
+
+// Rewrite functional ops into low level primitives:
+// - If/While ops lowered into low level control flow primitives: Switch, Merge,
+//   Enter, Exit, NextIteration
+// - Function calls inlined into the main graph
+//
+// IMPORTANT: Although SymbolicGradient is a function call, we currently do not
+// lower it, because it has been deprecated for a while.
+class LowerFunctionalOpsPass : public GraphOptimizationPass {
+ public:
+  LowerFunctionalOpsPass() = default;
+
+  Status Run(const GraphOptimizationPassOptions& options) override;
+
+  static constexpr const char* const kLowerUsingSwitchMergeAttr =
+      LowerFunctionalOpsConstants::kLowerUsingSwitchMergeAttr;
+  static constexpr const char* const kLowerAsMultiDeviceFunctionAttr =
+      LowerFunctionalOpsConstants::kLowerAsMultiDeviceFunctionAttr;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_LOWER_FUNCTIONAL_OPS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/lower_if_op.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/lower_if_op.h
new file mode 100644
index 0000000000000000000000000000000000000000..55b7b91b56f460ca8b7503434860ab0e5322146e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/lower_if_op.h
@@ -0,0 +1,31 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_LOWER_IF_OP_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_LOWER_IF_OP_H_
+
+#include "tensorflow/core/lib/core/status.h"
+
+namespace tensorflow {
+
+class Graph;
+class Node;
+
+// Replaces If node `n` with its lowered form that uses Switch and Merge nodes.
+Status RewriteIfNode(Node* n, Graph* g, bool keep_node_fetchable);
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_LOWER_IF_OP_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/lower_while_op.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/lower_while_op.h
new file mode 100644
index 0000000000000000000000000000000000000000..479cdc23a1d84559ef1b2d2d3cc0276067bca056
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/lower_while_op.h
@@ -0,0 +1,35 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_LOWER_WHILE_OP_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_LOWER_WHILE_OP_H_
+
+#include "tensorflow/core/lib/core/status.h"
+
+namespace tensorflow {
+
+class Graph;
+class Node;
+class FunctionLibraryDefinition;
+
+// Replaces While node `n` with its lowered form that uses Enter, Exit, Switch,
+// Merge, NextIteration and LoopCond nodes.
+Status RewriteWhileNode(Node* n, Graph* g,
+                        const FunctionLibraryDefinition* flib_def,
+                        bool keep_node_fetchable);
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_LOWER_WHILE_OP_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/memory_types.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/memory_types.h
new file mode 100644
index 0000000000000000000000000000000000000000..f854acfdc55d66c1ffa93acc0954edae393b2359
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/memory_types.h
@@ -0,0 +1,48 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_MEMORY_TYPES_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_MEMORY_TYPES_H_
+
+#include "tensorflow/core/framework/memory_types.h"
+#include "tensorflow/core/graph/graph.h"
+#include "tensorflow/core/lib/core/status.h"
+
+namespace tensorflow {
+
+// Returns an error iff *g running on a single device of 'device_type'
+// has memory type mismatch for any edge's source and destination.
+Status ValidateMemoryTypes(const DeviceType& device_type, const Graph* g);
+
+// Updates '*g' so that every edge's source and destination has
+// compatible memory types by inserting proper HostSend/Recv and
+// Send/HostRecv nodes.  'device_type' specifies the type of device on
+// which '*g' is going to run on and that device has the name
+// 'device_name'.
+//
+// Returns OK if '*g' is updated properly (ValidateMemoryTypes(g) must
+// be OK). Otherwise, returns an error and '*g' may be in an
+// invalidate state and the caller should discard it.
+Status EnsureMemoryTypes(const DeviceType& device_type,
+                         const string& device_name, Graph* g);
+
+// Get the memory type for 'index'th output of node 'n' in graph 'g', when
+// running on 'device_type'.
+Status MemoryTypeForOutput(const DeviceType& device_type, const Graph* g,
+                           const Node* n, int index, MemoryType* memory_type);
+
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_MEMORY_TYPES_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/mkl_cpu_allocator.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/mkl_cpu_allocator.h
new file mode 100644
index 0000000000000000000000000000000000000000..54d60fdc93ad66f5e2e8c1abb0b5279a8a14bf76
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/mkl_cpu_allocator.h
@@ -0,0 +1,331 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// A simple CPU allocator that intercepts malloc/free calls from MKL library
+// and redirects them to Tensorflow allocator
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_MKL_CPU_ALLOCATOR_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_MKL_CPU_ALLOCATOR_H_
+
+#ifdef INTEL_MKL
+
+#include <cstdlib>
+
+#include "tensorflow/core/common_runtime/bfc_allocator.h"
+#include "tensorflow/core/common_runtime/pool_allocator.h"
+#include "tensorflow/core/lib/strings/numbers.h"
+#include "tensorflow/core/lib/strings/str_util.h"
+#include "tensorflow/core/platform/mem.h"
+#include "tensorflow/core/platform/numa.h"
+#include "tensorflow/core/util/env_var.h"
+#include "tensorflow/core/util/onednn_env_vars.h"
+#ifdef _WIN32
+typedef unsigned int uint;
+#endif
+
+namespace tensorflow {
+
+static bool mkl_small_allocator_collect_stats = false;
+
+class MklSubAllocator : public BasicCPUAllocator {
+ public:
+  MklSubAllocator() : BasicCPUAllocator(port::kNUMANoAffinity, {}, {}) {}
+  ~MklSubAllocator() override {}
+};
+
+// CPU allocator that handles small-size allocations by calling
+// suballocator directly. Mostly, it is just a wrapper around a suballocator
+// (that calls malloc and free directly) with support for bookkeeping.
+class MklSmallSizeAllocator : public Allocator {
+ public:
+  MklSmallSizeAllocator(SubAllocator* sub_allocator, size_t total_memory,
+                        const string& name)
+      : sub_allocator_(sub_allocator), name_(name) {
+    stats_.bytes_limit = total_memory;
+  }
+  ~MklSmallSizeAllocator() override {}
+
+  MklSmallSizeAllocator(const MklSmallSizeAllocator&) = delete;
+  void operator=(const MklSmallSizeAllocator&) = delete;
+
+  inline string Name() override { return name_; }
+
+  void* AllocateRaw(size_t alignment, size_t num_bytes) override {
+    void* ptr = port::AlignedMalloc(num_bytes, alignment);
+    if (mkl_small_allocator_collect_stats) IncrementStats(num_bytes);
+    return ptr;
+  }
+
+  void DeallocateRaw(void* ptr) override {
+    if (ptr == nullptr) {
+      LOG(ERROR) << "tried to deallocate nullptr";
+      return;
+    }
+
+    if (mkl_small_allocator_collect_stats) {
+      const size_t alloc_size = port::MallocExtension_GetAllocatedSize(ptr);
+      DecrementStats(alloc_size);
+    }
+    port::AlignedFree(ptr);
+  }
+
+  absl::optional<AllocatorStats> GetStats() override {
+    mutex_lock l(mutex_);
+    return stats_;
+  }
+
+  bool ClearStats() override {
+    mutex_lock l(mutex_);
+    stats_.num_allocs = 0;
+    stats_.peak_bytes_in_use = 0;
+    stats_.largest_alloc_size = 0;
+    stats_.bytes_in_use = 0;
+    stats_.bytes_limit = 0;
+    return true;
+  }
+
+ private:
+  // Increment statistics for the allocator handling small allocations.
+  inline void IncrementStats(size_t alloc_size) TF_LOCKS_EXCLUDED(mutex_) {
+    mutex_lock l(mutex_);
+    ++stats_.num_allocs;
+    stats_.bytes_in_use += alloc_size;
+    stats_.peak_bytes_in_use =
+        std::max(stats_.peak_bytes_in_use, stats_.bytes_in_use);
+    stats_.largest_alloc_size =
+        std::max(alloc_size, static_cast<size_t>(stats_.largest_alloc_size));
+  }
+
+  // Decrement statistics for the allocator handling small allocations.
+  inline void DecrementStats(size_t dealloc_size) TF_LOCKS_EXCLUDED(mutex_) {
+    mutex_lock l(mutex_);
+    stats_.bytes_in_use -= dealloc_size;
+  }
+
+  SubAllocator* sub_allocator_;  // Not owned by this class.
+
+  // Mutex for protecting updates to map of allocations.
+  mutable mutex mutex_;
+
+  // Allocator name
+  string name_;
+
+  // Allocator stats for small allocs
+  AllocatorStats stats_ TF_GUARDED_BY(mutex_);
+};
+
+/// CPU allocator for MKL that wraps BFC allocator and intercepts
+/// and redirects memory allocation calls from MKL.
+class MklCPUAllocator : public Allocator {
+ public:
+  // Constructor and other standard functions
+
+  /// Environment variable that user can set to upper bound on memory allocation
+  static constexpr const char* kMaxLimitStr = "TF_MKL_ALLOC_MAX_BYTES";
+
+  /// Default upper limit on allocator size - 64GB
+  static constexpr size_t kDefaultMaxLimit = 64LL << 30;
+
+  MklCPUAllocator() { TF_CHECK_OK(Initialize()); }
+
+  ~MklCPUAllocator() override {
+    delete small_size_allocator_;
+    delete large_size_allocator_;
+  }
+
+  Status Initialize() {
+    VLOG(2) << "MklCPUAllocator: In MklCPUAllocator";
+
+    // Set upper bound on memory allocation to physical RAM available on the
+    // CPU unless explicitly specified by user
+    uint64 max_mem_bytes = kDefaultMaxLimit;
+#if defined(_SC_PHYS_PAGES) && defined(_SC_PAGESIZE)
+    max_mem_bytes =
+        (uint64)sysconf(_SC_PHYS_PAGES) * (uint64)sysconf(_SC_PAGESIZE);
+#endif
+    char* user_mem_bytes = getenv(kMaxLimitStr);
+
+    if (user_mem_bytes != NULL) {
+      uint64 user_val = 0;
+      if (!strings::safe_strtou64(user_mem_bytes, &user_val)) {
+        return errors::InvalidArgument("Invalid memory limit (", user_mem_bytes,
+                                       ") specified for MKL allocator through ",
+                                       kMaxLimitStr);
+      }
+#if defined(_SC_PHYS_PAGES) && defined(_SC_PAGESIZE)
+      if (user_val > max_mem_bytes) {
+        LOG(WARNING) << "The user specified a memory limit " << kMaxLimitStr
+                     << "=" << user_val
+                     << " greater than available physical memory: "
+                     << max_mem_bytes
+                     << ". This could significantly reduce performance!";
+      }
+#endif
+      max_mem_bytes = user_val;
+    }
+
+    VLOG(1) << "MklCPUAllocator: Setting max_mem_bytes: " << max_mem_bytes;
+
+    sub_allocator_ = new MklSubAllocator();
+
+    // SubAllocator is owned by BFCAllocator, so we do not need to deallocate
+    // it in MklSmallSizeAllocator.
+    small_size_allocator_ =
+        new MklSmallSizeAllocator(sub_allocator_, max_mem_bytes, kName);
+
+    BFCAllocator::Options large_allocator_opts;
+    large_allocator_opts.allow_growth = kAllowGrowth;
+    large_size_allocator_ =
+        new BFCAllocator(absl::WrapUnique(sub_allocator_), max_mem_bytes, kName,
+                         large_allocator_opts);
+    return OkStatus();
+  }
+
+  inline string Name() override { return kName; }
+  inline bool IsSmallSizeAllocation(const void* ptr) const
+      TF_LOCKS_EXCLUDED(mutex_) {
+    mutex_lock l(mutex_);
+    return large_allocations_map_.find(ptr) == large_allocations_map_.end();
+  }
+  // AddLargeAllocMap and RemoveLargeAllocMap are always called with a lock held
+  inline void AddLargeAllocMap(void* ptr, size_t num_bytes)
+      TF_EXCLUSIVE_LOCKS_REQUIRED(mutex_) {
+    if (ptr != nullptr) {
+      std::pair<void*, size_t> map_val(ptr, num_bytes);
+      large_allocations_map_.insert(map_val);
+    }
+  }
+  inline void RemoveLargeAllocMap(void* ptr)
+      TF_EXCLUSIVE_LOCKS_REQUIRED(mutex_) {
+    auto map_iter = large_allocations_map_.find(ptr);
+    if (map_iter != large_allocations_map_.end()) {
+      large_allocations_map_.erase(map_iter);
+    } else {
+      LOG(ERROR) << "tried to deallocate invalid pointer";
+    }
+    return;
+  }
+
+  inline void* AllocateRaw(size_t alignment, size_t num_bytes) override {
+    // If the allocation size is less than threshold, call small allocator,
+    // otherwise call large-size allocator (BFC). We found that BFC allocator
+    // does not deliver good performance for small allocations when
+    // inter_op_parallelism_threads is high.
+    if (UseSystemAlloc() || num_bytes < kSmallAllocationsThreshold) {
+      return small_size_allocator_->AllocateRaw(alignment, num_bytes);
+    } else {
+      mutex_lock l(mutex_);
+      void* ptr = large_size_allocator_->AllocateRaw(alignment, num_bytes);
+      AddLargeAllocMap(ptr, num_bytes);
+      return ptr;
+    }
+  }
+  inline void DeallocateRaw(void* ptr) override {
+    // Check if ptr is for "small" allocation. If it is, then call Free
+    // directly. Otherwise, call BFC to handle free.
+    if (UseSystemAlloc() || IsSmallSizeAllocation(ptr)) {
+      small_size_allocator_->DeallocateRaw(ptr);
+    } else {
+      mutex_lock l(mutex_);
+      RemoveLargeAllocMap(ptr);
+      large_size_allocator_->DeallocateRaw(ptr);
+    }
+  }
+  absl::optional<AllocatorStats> GetStats() override {
+    auto s_stats = small_size_allocator_->GetStats();
+    auto l_stats = large_size_allocator_->GetStats();
+
+    // Combine statistics from small-size and large-size allocator.
+    mutex_lock l(mutex_);
+    stats_.num_allocs = l_stats->num_allocs + s_stats->num_allocs;
+    stats_.bytes_in_use = l_stats->bytes_in_use + s_stats->bytes_in_use;
+    stats_.peak_bytes_in_use =
+        l_stats->peak_bytes_in_use + s_stats->peak_bytes_in_use;
+
+    // Since small-size allocations go to MklSmallSizeAllocator,
+    // max_alloc_size from large_size_allocator would be the maximum
+    // size allocated by MklCPUAllocator.
+    stats_.largest_alloc_size = l_stats->largest_alloc_size;
+    stats_.bytes_limit = std::max(s_stats->bytes_limit, l_stats->bytes_limit);
+    return stats_;
+  }
+
+  bool ClearStats() override {
+    bool stats_cleared = small_size_allocator_->ClearStats();
+    stats_cleared &= large_size_allocator_->ClearStats();
+    return stats_cleared;
+  }
+
+ private:
+  // Hooks provided by this allocator for memory allocation routines from MKL
+  static inline void* MallocHook(size_t size) {
+    VLOG(3) << "MklCPUAllocator: In MallocHook";
+    return cpu_allocator()->AllocateRaw(kAlignment, size);
+  }
+
+  static inline void FreeHook(void* ptr) {
+    VLOG(3) << "MklCPUAllocator: In FreeHook";
+    cpu_allocator()->DeallocateRaw(ptr);
+  }
+
+  static inline void* CallocHook(size_t num, size_t size) {
+    Status s = Status(absl::StatusCode::kUnimplemented,
+                      "Unimplemented case for hooking MKL function.");
+    TF_CHECK_OK(s);  // way to assert with an error message
+    return nullptr;  // return a value and make static code analyzers happy
+  }
+
+  static inline void* ReallocHook(void* ptr, size_t size) {
+    Status s = Status(absl::StatusCode::kUnimplemented,
+                      "Unimplemented case for hooking MKL function.");
+    TF_CHECK_OK(s);  // way to assert with an error message
+    return nullptr;  // return a value and make static code analyzers happy
+  }
+
+  // Do we allow growth in BFC Allocator
+  static const bool kAllowGrowth = true;
+
+  // Name
+  static constexpr const char* kName = "mklcpu";
+
+  // The alignment that we need for the allocations
+  static constexpr const size_t kAlignment = 64;
+
+  Allocator* large_size_allocator_;              // owned by this class
+  MklSmallSizeAllocator* small_size_allocator_;  // owned by this class.
+
+  SubAllocator* sub_allocator_;  // not owned by this class
+  mutable mutex mutex_;
+  AllocatorStats stats_ TF_GUARDED_BY(mutex_);
+
+  // Hash map to keep track of "BFC" allocations
+  // We do not use BFC allocator for small allocations.
+  std::unordered_map<const void*, size_t> large_allocations_map_
+      TF_GUARDED_BY(mutex_);
+
+  // Size in bytes that defines the upper-bound for "small" allocations.
+  // Any allocation below this threshold is "small" allocation.
+  static constexpr const size_t kSmallAllocationsThreshold = 262144;
+
+  // Prevent copying and assignment
+  MklCPUAllocator(const MklCPUAllocator&) = delete;
+  void operator=(const MklCPUAllocator&) = delete;
+};
+
+}  // namespace tensorflow
+
+#endif  // INTEL_MKL
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_MKL_CPU_ALLOCATOR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/mkl_layout_pass.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/mkl_layout_pass.h
new file mode 100644
index 0000000000000000000000000000000000000000..6b5c586ceabb3ed01c188deba266cdb22f6f98be
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/mkl_layout_pass.h
@@ -0,0 +1,36 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// A graph pass that rewrites graph for propagating MKL layout as a tensor
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_MKL_LAYOUT_PASS_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_MKL_LAYOUT_PASS_H_
+
+#ifdef INTEL_MKL
+
+#include <sys/types.h>
+#include <memory>
+#include "tensorflow/core/graph/graph.h"
+
+namespace tensorflow {
+// Interface to invoke the pass for unit test
+//
+// Returns true if and only if 'g' is mutated.
+extern bool RunMklLayoutRewritePass(std::unique_ptr<Graph>* g);
+}  // namespace tensorflow
+
+#endif
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_MKL_LAYOUT_PASS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/next_pluggable_device/c/plugin_c_api.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/next_pluggable_device/c/plugin_c_api.h
new file mode 100644
index 0000000000000000000000000000000000000000..e44e5f3ff26aaeecae68970ea2d4410809f99081
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/next_pluggable_device/c/plugin_c_api.h
@@ -0,0 +1,176 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_NEXT_PLUGGABLE_DEVICE_C_PLUGIN_C_API_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_NEXT_PLUGGABLE_DEVICE_C_PLUGIN_C_API_H_
+
+#include <cstddef>
+
+#include "tensorflow/c/c_api.h"
+#include "tensorflow/c/c_api_macros.h"
+#include "tensorflow/c/tf_status.h"
+#include "tensorflow/c/tf_tensor.h"
+#include "xla/c/c_api_decl.h"
+#include "xla/pjrt/c/pjrt_c_api.h"
+#include "xla/stream_executor/tpu/c_api_decl.h"
+
+#define TFNPD_MAJOR 0
+#define TFNPD_MINOR 0
+#define TFNPD_PATCH 1
+
+// Experimental C API for TensorFlow Next Pluggable device (TFNPD).
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// ----------------------------  Event  ----------------------------------------
+typedef struct TFNPD_DeviceEvent TFNPD_DeviceEvent;
+
+typedef TFNPD_DeviceEvent* TFNPD_NewDeviceEvent();
+
+typedef void TFNPD_DeviceEventAwait(TFNPD_DeviceEvent* event,
+                                    TF_Status* status);
+
+typedef bool TFNPD_DeviceEventIsReady(TFNPD_DeviceEvent* event);
+
+// Invokes the callback after event becomes ready.
+typedef void TFNPD_DeviceEventAndThen(TFNPD_DeviceEvent* event,
+                                      void (*callback)(void*),
+                                      void* callback_arg);
+
+typedef void TFNPD_DeviceEventDelete(TFNPD_DeviceEvent* event);
+
+// --------------------------  Allocator  --------------------------------------
+typedef struct TFNPD_DeviceAllocator TFNPD_DeviceAllocator;
+
+typedef TFNPD_DeviceAllocator* TFNPD_DeviceAllocatorCreate(int device_ordinal);
+
+typedef void* TFNPD_DeviceAllocateRaw(TFNPD_DeviceAllocator* allocator,
+                                      size_t alignment, size_t num_bytes);
+
+typedef void TFNPD_DeviceDeallocateRaw(TFNPD_DeviceAllocator* allocator,
+                                       void* ptr);
+
+typedef TF_StringView TFNPD_DeviceAllocatorName(
+    TFNPD_DeviceAllocator* allocator);
+
+typedef bool TFNPD_DeviceAllocatorAllocatesOpaqueHandle(
+    TFNPD_DeviceAllocator* allocator);
+
+typedef void TFNPD_DeviceAllocatorDelete(TFNPD_DeviceAllocator* allocator);
+
+// ------------------------  Tensor Transfers  ---------------------------------
+typedef struct TFNPD_DeviceContext TFNPD_DeviceContext;
+
+// TODO(chuanhao): use an option struct to create context. Plugin can define the
+// option so that we support more features in the DeviceContext, e.g.
+// shape_determination_fns.
+typedef TFNPD_DeviceContext* TFNPD_DeviceContextCreate(int device_ordinal);
+
+typedef TFNPD_DeviceEvent* TFNPD_DeviceTensorToHostTensor(
+    TFNPD_DeviceContext* device_context, const TF_Tensor* device_tensor,
+    TF_Tensor* cpu_tensor, TF_Status* status);
+
+typedef TFNPD_DeviceEvent* TFNPD_HostTensorToDeviceTensor(
+    TFNPD_DeviceContext* device_context, const TF_Tensor* cpu_tensor,
+    TF_Tensor* device_tensor, TF_Status* status);
+
+typedef TFNPD_DeviceEvent* TFNPD_SameDeviceTensorCopy(
+    TFNPD_DeviceContext* context);
+
+typedef PJRT_Buffer* TFNPD_SameDevicePjRtBufferCopy(PJRT_Buffer* src_buffer,
+                                                    PJRT_Client* c_client,
+                                                    TF_Status* status);
+
+typedef void TFNPD_DeviceContextDelete(TFNPD_DeviceContext* context);
+
+// ------------------------------  TF2XLA  -------------------------------------
+// TODO(b/254484247): either separate XLA_Shape to its own file, or use PJRT
+// solution when it is ready.
+typedef void TFNPD_XlaShapeToDeviceShapeRepresentation(
+    XLA_Shape* serialized_xla_shape, int data_type, bool use_fast_memory,
+    XLA_LayoutPreference layout_preference, XLA_Shape* serialized_device_shape,
+    TF_Status* tf_status);
+
+// -----------------------  Plugin System related  -----------------------------
+typedef int32_t TFNPD_GetDeviceCount(TF_Status* status);
+
+// Initialize any per-device states or resources that are internal to plugin.
+typedef void TFNPD_InitPluginInternalDeviceStates(TF_Status* status);
+
+// --------------------------- C API access ------------------------------------
+#define TFNPD_API_STRUCT_FN(fn_type) fn_type* fn_type
+
+typedef struct {
+  size_t struct_size;
+  void* priv;
+
+  TFNPD_API_STRUCT_FN(TFNPD_NewDeviceEvent);
+  TFNPD_API_STRUCT_FN(TFNPD_DeviceEventAwait);
+  TFNPD_API_STRUCT_FN(TFNPD_DeviceEventIsReady);
+  TFNPD_API_STRUCT_FN(TFNPD_DeviceEventAndThen);
+  TFNPD_API_STRUCT_FN(TFNPD_DeviceEventDelete);
+
+  TFNPD_API_STRUCT_FN(TFNPD_DeviceAllocatorCreate);
+  TFNPD_API_STRUCT_FN(TFNPD_DeviceAllocateRaw);
+  TFNPD_API_STRUCT_FN(TFNPD_DeviceDeallocateRaw);
+  TFNPD_API_STRUCT_FN(TFNPD_DeviceAllocatorName);
+  TFNPD_API_STRUCT_FN(TFNPD_DeviceAllocatorAllocatesOpaqueHandle);
+  TFNPD_API_STRUCT_FN(TFNPD_DeviceAllocatorDelete);
+
+  TFNPD_API_STRUCT_FN(TFNPD_DeviceContextCreate);
+  TFNPD_API_STRUCT_FN(TFNPD_DeviceContextDelete);
+
+  // TODO(chuanhao): Deprecate the tensor transfer C APIs when PJRT API
+  // development is ready since we plan to adopt PJRT as Device API.
+  TFNPD_API_STRUCT_FN(TFNPD_DeviceTensorToHostTensor);
+  TFNPD_API_STRUCT_FN(TFNPD_HostTensorToDeviceTensor);
+  TFNPD_API_STRUCT_FN(TFNPD_SameDeviceTensorCopy);
+  TFNPD_API_STRUCT_FN(TFNPD_SameDevicePjRtBufferCopy);
+
+  TFNPD_API_STRUCT_FN(TFNPD_XlaShapeToDeviceShapeRepresentation);
+
+  TFNPD_API_STRUCT_FN(TFNPD_GetDeviceCount);
+  TFNPD_API_STRUCT_FN(TFNPD_InitPluginInternalDeviceStates);
+} TFNPD_Api;
+
+const size_t TFNPD_Api_STRUCT_SIZE =
+    TF_OFFSET_OF_END(TFNPD_Api, TFNPD_InitPluginInternalDeviceStates);
+
+#undef TFNPD_API_STRUCT_FN
+
+typedef struct TFNPD_PluginParams {
+  size_t struct_size;
+  void* ext;  // reserved for future use
+
+  const char* device_type;              // output, set by plugin
+  const char* compilation_device_name;  // output, set by plugin
+  int32_t priority;                     // output, set by plugin
+  // Certain devices may set this one to false to avoid using device copy logic
+  // implemented for legacy PluggableDevice.
+  bool is_pluggable_device;         // output, set by plugin
+  bool use_pjrt_on_demand_compile;  // output, set by plugin
+} TFNPD_PluginParams;
+const size_t TFNPD_PLUGIN_PARAMS_STRUCT_SIZE =
+    TF_OFFSET_OF_END(TFNPD_PluginParams, is_pluggable_device);
+const TFNPD_Api* TFNPD_InitPlugin(TFNPD_PluginParams* params,
+                                  TF_Status* tf_status);
+
+#if defined(__cplusplus)
+}  // extern "C"
+#endif  // defined(__cplusplus)
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_NEXT_PLUGGABLE_DEVICE_C_PLUGIN_C_API_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/next_pluggable_device/next_pluggable_device_api.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/next_pluggable_device/next_pluggable_device_api.h
new file mode 100644
index 0000000000000000000000000000000000000000..8576b75e4212898890a9178a3c6e514525464157
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/next_pluggable_device/next_pluggable_device_api.h
@@ -0,0 +1,36 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_NEXT_PLUGGABLE_DEVICE_NEXT_PLUGGABLE_DEVICE_API_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_NEXT_PLUGGABLE_DEVICE_NEXT_PLUGGABLE_DEVICE_API_H_
+
+#include <string>
+
+#include "tensorflow/core/common_runtime/next_pluggable_device/c/plugin_c_api.h"
+#include "tsl/platform/statusor.h"
+
+namespace tensorflow {
+
+// Global TFNPD_Api* singleton.
+const TFNPD_Api* TfnpdApi();
+void SetTfnpdApi(const TFNPD_Api* api);
+
+typedef const TFNPD_Api* (*TFNPDInitPluginFn)(TFNPD_PluginParams*, TF_Status*);
+tsl::StatusOr<TFNPD_PluginParams> InitNextPluggableDevicePlugin(
+    TFNPDInitPluginFn init_fn);
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_NEXT_PLUGGABLE_DEVICE_NEXT_PLUGGABLE_DEVICE_API_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/next_pluggable_device/next_pluggable_device_factory.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/next_pluggable_device/next_pluggable_device_factory.h
new file mode 100644
index 0000000000000000000000000000000000000000..6d9d4d4d1ab16a0d52b433bab8dff9658c091138
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/next_pluggable_device/next_pluggable_device_factory.h
@@ -0,0 +1,56 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_NEXT_PLUGGABLE_DEVICE_NEXT_PLUGGABLE_DEVICE_FACTORY_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_NEXT_PLUGGABLE_DEVICE_NEXT_PLUGGABLE_DEVICE_FACTORY_H_
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "tensorflow/core/common_runtime/next_pluggable_device/c/plugin_c_api.h"
+#include "tensorflow/core/common_runtime/next_pluggable_device/next_pluggable_device_api.h"
+#include "tensorflow/core/framework/device_factory.h"
+
+namespace tensorflow {
+
+class NextPluggableDeviceFactory : public DeviceFactory {
+ public:
+  explicit NextPluggableDeviceFactory(
+      const std::string& device_type,
+      const std::string& compilation_device_name)
+      : api_(TfnpdApi()),
+        device_type_(device_type),
+        compilation_device_name_(compilation_device_name) {}
+
+  Status ListPhysicalDevices(std::vector<string>* devices) override;
+
+  Status CreateDevices(const SessionOptions& session_options,
+                       const std::string& name_prefix,
+                       std::vector<std::unique_ptr<Device>>* devices) override;
+
+  const std::string& compilation_device_name() const {
+    return compilation_device_name_;
+  }
+
+ private:
+  const TFNPD_Api* api_;
+  const std::string device_type_;
+  const std::string compilation_device_name_;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_NEXT_PLUGGABLE_DEVICE_NEXT_PLUGGABLE_DEVICE_FACTORY_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/node_file_writer.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/node_file_writer.h
new file mode 100644
index 0000000000000000000000000000000000000000..f0e0ae830c6e4846e65de2abc7c8f7ad35a3036e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/node_file_writer.h
@@ -0,0 +1,71 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_NODE_FILE_WRITER_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_NODE_FILE_WRITER_H_
+
+#include <string>
+#include <unordered_map>
+
+#include "absl/container/flat_hash_set.h"
+#include "tensorflow/core/framework/node_def.pb.h"
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/platform/env.h"
+#include "tensorflow/core/platform/mutex.h"
+#include "tensorflow/core/util/env_var.h"
+
+namespace tensorflow {
+
+// Writes out the NodeDef and the input shapes/dtypes for an executed node to a
+// file. This allows the set of executed nodes for a model or test to be
+// examined and processed. Currently this is used by an internal tool which
+// checks that ops executed by tests are deterministic.
+class NodeFileWriter {
+ public:
+  // Creates or reuses a NodeFileWriter if environmental variable
+  // TF_NODE_FILE_WRITER_DIRECTORY is set, which specifies the directory where
+  // the node file will be created in. Otherwise, returns nullptr. When called
+  // with the same device_name, the same NodeFileWriter will be returned.
+  static StatusOr<NodeFileWriter*> GetNodeFileWriterIfEnabled(
+      const std::string& device_name, Env* env);
+
+  // Records the execution of a node, if eligible, by writing the node to the
+  // file. Only writes the node if the exact node with the given input
+  // shapes/dtypes hasn't already been written. Should be called once every time
+  // a node is run.
+  Status RecordNodeExecution(OpKernel* op_kernel, OpKernelContext* context);
+
+  const std::string& filename() { return filename_; }
+
+ private:
+  explicit NodeFileWriter(std::string filename)
+      : filename_{std::move(filename)} {}
+
+  Status Init(Env* env) {
+    return env->NewWritableFile(filename_, &node_def_file_);
+  }
+
+  // Writes the NodeDef to a file, if it hasn't already been written yet.
+  Status MaybeWriteNodeDefToFile(const NodeDef& def);
+
+  const std::string filename_;
+  mutex mu_;
+  // Hashes of the NodeDefs already written to the file
+  absl::flat_hash_set<uint64> written_hashes_ TF_GUARDED_BY(mu_);
+
+  std::unique_ptr<WritableFile> node_def_file_ TF_PT_GUARDED_BY(mu_);
+};
+
+}  // namespace tensorflow
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_NODE_FILE_WRITER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/optimization_registry.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/optimization_registry.h
new file mode 100644
index 0000000000000000000000000000000000000000..290887711f0b5a15439397f8828284b77698670a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/optimization_registry.h
@@ -0,0 +1,188 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// Classes to maintain a static registry of whole-graph optimization
+// passes to be applied by the Session when it initializes a graph.
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_OPTIMIZATION_REGISTRY_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_OPTIMIZATION_REGISTRY_H_
+
+#include <functional>
+#include <map>
+#include <vector>
+
+#include "tensorflow/core/common_runtime/composite_device.h"
+#include "tensorflow/core/common_runtime/device_set.h"
+#include "tensorflow/core/framework/function.h"
+#include "tensorflow/core/graph/costmodel.h"
+#include "tensorflow/core/graph/graph.h"
+
+namespace tensorflow {
+struct SessionOptions;
+
+// All the parameters used by an optimization pass are packaged in
+// this struct. They should be enough for the optimization pass to use
+// as a key into a state dictionary if it wants to keep state across
+// calls.
+struct GraphOptimizationPassOptions {
+  // Filled in by DirectSession for PRE_PLACEMENT optimizations. Can be empty.
+  string session_handle;
+  const SessionOptions* session_options = nullptr;
+  const CostModel* cost_model = nullptr;
+
+  FunctionLibraryDefinition* flib_def = nullptr;  // Not owned.
+  // The DeviceSet contains all the devices known to the system and is
+  // filled in for optimizations run by the session master, i.e.,
+  // PRE_PLACEMENT, POST_PLACEMENT, and POST_REWRITE_FOR_EXEC. It is
+  // nullptr for POST_PARTITIONING optimizations which are run at the
+  // workers.
+  const DeviceSet* device_set = nullptr;  // Not owned.
+
+  // Maps from a CompositeDevice name to a list of underlying physical
+  // devices.
+  const std::vector<CompositeDevice*>* composite_devices =
+      nullptr;  // Not owned.
+
+  // The graph to optimize, for optimization passes that run before
+  // partitioning. Null for post-partitioning passes.
+  // An optimization pass may replace *graph with a new graph object.
+  std::unique_ptr<Graph>* graph = nullptr;
+
+  // Graphs for each partition, if running post-partitioning. Optimization
+  // passes may alter the graphs, but must not add or remove partitions.
+  // Null for pre-partitioning passes.
+  std::unordered_map<string, std::unique_ptr<Graph>>* partition_graphs =
+      nullptr;
+
+  // Indicator of whether or not the graph was derived from a function.
+  bool is_function_graph = false;
+  // Set when is_function_graph is true. The default device where the function
+  // runs. If nullptr, it runs on the local host.
+  const Device* default_function_device = nullptr;
+  // Set when is_function_graph is true. The function where the graph was
+  // derived. `graph` doesn't contain all the information in the function_def,
+  // e.g. function attributes.
+  const FunctionDef* function_def = nullptr;
+
+  // TODO(b/176491312): Remove this if shape inference on import flag is
+  // removed. If True, allows mlir roundtrip to run shape inference on import.
+  bool shape_inference_on_tfe_dialect_import = true;
+
+  // A unique filename prefix (using hostname, process ID, thread ID and
+  // timestamp) for graph dumps.
+  string debug_filename_prefix;
+};
+
+// Optimization passes are implemented by inheriting from
+// GraphOptimizationPass.
+class GraphOptimizationPass {
+ public:
+  virtual ~GraphOptimizationPass() {}
+  virtual Status Run(const GraphOptimizationPassOptions& options) = 0;
+  void set_name(const string& name) { name_ = name; }
+  string name() const { return name_; }
+
+ private:
+  // The name of the optimization pass, which is the same as the inherited
+  // class name.
+  string name_;
+};
+
+// The key is a 'phase' number. Phases are executed in increasing
+// order. Within each phase the order of passes is undefined.
+typedef std::map<int, std::vector<std::unique_ptr<GraphOptimizationPass>>>
+    GraphOptimizationPasses;
+
+// A global OptimizationPassRegistry is used to hold all passes.
+class OptimizationPassRegistry {
+ public:
+  // Groups of passes are run at different points in initialization.
+  enum Grouping {
+    PRE_PLACEMENT,          // after cost model assignment, before placement.
+    POST_PLACEMENT,         // after placement.
+    POST_REWRITE_FOR_EXEC,  // after re-write using feed/fetch endpoints.
+    POST_PARTITIONING,      // after partitioning
+  };
+
+  // Add an optimization pass to the registry.
+  void Register(Grouping grouping, int phase,
+                std::unique_ptr<GraphOptimizationPass> pass);
+
+  const std::map<Grouping, GraphOptimizationPasses>& groups() {
+    return groups_;
+  }
+
+  // Run all passes in grouping, ordered by phase, with the same
+  // options.
+  Status RunGrouping(Grouping grouping,
+                     const GraphOptimizationPassOptions& options);
+
+  // Returns the global registry of optimization passes.
+  static OptimizationPassRegistry* Global();
+
+  // Prints registered optimization passes for debugging.
+  void LogGrouping(Grouping grouping, int vlog_level);
+  void LogAllGroupings(int vlog_level);
+
+ private:
+  std::map<Grouping, GraphOptimizationPasses> groups_;
+
+  const char* GetGroupingName(Grouping grouping) const {
+    switch (grouping) {
+      case PRE_PLACEMENT:
+        return "pre_placement";
+      case POST_PLACEMENT:
+        return "post_placement";
+      case POST_REWRITE_FOR_EXEC:
+        return "post_rewrite_for_exec";
+      case POST_PARTITIONING:
+        return "post_partitioning";
+    }
+    return "unknown";
+  }
+};
+
+namespace optimization_registration {
+
+class OptimizationPassRegistration {
+ public:
+  OptimizationPassRegistration(OptimizationPassRegistry::Grouping grouping,
+                               int phase,
+                               std::unique_ptr<GraphOptimizationPass> pass,
+                               string optimization_pass_name) {
+    pass->set_name(optimization_pass_name);
+    OptimizationPassRegistry::Global()->Register(grouping, phase,
+                                                 std::move(pass));
+  }
+};
+
+}  // namespace optimization_registration
+
+#define REGISTER_OPTIMIZATION(grouping, phase, optimization) \
+  REGISTER_OPTIMIZATION_UNIQ_HELPER(__COUNTER__, grouping, phase, optimization)
+
+#define REGISTER_OPTIMIZATION_UNIQ_HELPER(ctr, grouping, phase, optimization) \
+  REGISTER_OPTIMIZATION_UNIQ(ctr, grouping, phase, optimization)
+
+#define REGISTER_OPTIMIZATION_UNIQ(ctr, grouping, phase, optimization)         \
+  static ::tensorflow::optimization_registration::OptimizationPassRegistration \
+      register_optimization_##ctr(                                             \
+          grouping, phase,                                                     \
+          ::std::unique_ptr<::tensorflow::GraphOptimizationPass>(              \
+              new optimization()),                                             \
+          #optimization)
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_OPTIMIZATION_REGISTRY_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/optimized_function_graph_info.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/optimized_function_graph_info.h
new file mode 100644
index 0000000000000000000000000000000000000000..2b92e145b6b63787e1abc1eee84b3e8e8e57c573
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/optimized_function_graph_info.h
@@ -0,0 +1,89 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_OPTIMIZED_FUNCTION_GRAPH_INFO_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_OPTIMIZED_FUNCTION_GRAPH_INFO_H_
+
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <utility>
+
+#include "tensorflow/core/framework/function.h"
+#include "tensorflow/core/framework/optimized_function_graph.pb.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/graph/graph.h"
+#include "tensorflow/core/platform/statusor.h"
+
+namespace tensorflow {
+
+// Function graph related information after optimizations. This struct can be
+// converted to and from
+// third_party/tensorflow/core/framework/optimized_function_graph.proto.
+struct OptimizedFunctionGraphInfo {
+  // Function name.
+  string name;
+  // Optimized function graph.
+  std::unique_ptr<Graph> function_graph;
+  // Optimized function library.
+  FunctionLibraryDefinition lib_def;
+  // Map from original node names to control return names.
+  std::unordered_map<string, string> node_name_to_control_ret;
+  // Return node types of the function.
+  DataTypeVector ret_types;
+  // Number of return nodes.
+  size_t num_return_nodes;
+  // Time (in microseconds) spent on running the graph optimization passes for
+  // this function.
+  uint64_t optimization_duration_usecs;
+  // Indicates the source environment where the optimization is created.
+  OptimizedFunctionGraph::OptimizationSource optimization_source;
+
+  ~OptimizedFunctionGraphInfo() = default;
+  OptimizedFunctionGraphInfo() : lib_def(OpRegistry::Global()) {}
+  OptimizedFunctionGraphInfo(
+      const std::string& name, std::unique_ptr<Graph>&& graph,
+      FunctionLibraryDefinition&& lib_def,
+      const std::unordered_map<string, string>& node_name_to_control_ret,
+      const DataTypeVector& ret_types, size_t num_return_nodes,
+      uint64_t optimization_duration_usecs,
+      OptimizedFunctionGraph::OptimizationSource optimization_source)
+      : name(name),
+        function_graph(std::move(graph)),
+        lib_def(std::move(lib_def)),
+        node_name_to_control_ret(node_name_to_control_ret),
+        ret_types(ret_types),
+        num_return_nodes(num_return_nodes),
+        optimization_duration_usecs(optimization_duration_usecs),
+        optimization_source(optimization_source) {}
+
+  OptimizedFunctionGraphInfo(OptimizedFunctionGraphInfo& info) = delete;
+  OptimizedFunctionGraphInfo& operator=(OptimizedFunctionGraphInfo& info) =
+      delete;
+  OptimizedFunctionGraphInfo(OptimizedFunctionGraphInfo&& info) = default;
+  OptimizedFunctionGraphInfo& operator=(OptimizedFunctionGraphInfo&& info) =
+      default;
+
+  // Converts from the struct to OptimizedFunctionGraph proto.
+  static OptimizedFunctionGraph ToProto(const OptimizedFunctionGraphInfo& info);
+
+  // Converts from the proto to struct OptimizedFunctionGraphInfo. Returns error
+  // if the conversion fails.
+  static StatusOr<OptimizedFunctionGraphInfo> FromProto(
+      const OptimizedFunctionGraph& proto);
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_OPTIMIZED_FUNCTION_GRAPH_INFO_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/partitioning_utils.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/partitioning_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..f62633996ecf995bb5e09553e0cc13ff802e7c82
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/partitioning_utils.h
@@ -0,0 +1,108 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_PARTITIONING_UTILS_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_PARTITIONING_UTILS_H_
+
+#include <unordered_map>
+#include <vector>
+
+#include "tensorflow/core/common_runtime/device_set.h"
+#include "tensorflow/core/framework/function.h"
+#include "tensorflow/core/lib/core/status.h"
+
+namespace tensorflow {
+
+// Given a `device_set` and a `graph`, partitions the `graph` into
+// `subgraphs`. `subgraphs` maps device names to the graph assigned to that
+// device. `graph` must have been placed (e.g. by running Placer),
+// i.e. all nodes must have an assigned_device set.
+// `graph` is non-const because the underlying Partition() function transforms
+// the graph to correctly partition distributed control flow.
+// `get_tensor_name_attr` computes the "tensor_name" attr value of Send/Recv ops
+// inserted during partitioning. Use the default one if not set. It needs to be
+// thread safe if it's shared in multple threads.
+Status PartitionFunctionGraph(
+    const DeviceSet& device_set, std::unique_ptr<Graph> graph,
+    std::unordered_map<string, std::unique_ptr<Graph>>* subgraphs,
+    std::function<string(const Edge*)> get_tensor_name_attr = nullptr);
+
+// Inserts send/recv ops to `graph` if nodes are assigned to multiple devices.
+// Returns the new graph with the added nodes. Moreover, the dependency between
+// a send/recv pair is made explicit by adding a control dependency between
+// them.
+// Note that, the returned graph is intended to be used by TF MLIR importer.
+// The dependencies between send/recv pairs ensure the importer will generate TF
+// MLIR ops in a valid order.
+StatusOr<std::unique_ptr<Graph>> InsertTransferOps(
+    const DeviceSet& device_set, std::unique_ptr<Graph> graph);
+
+// This function performs bookkeeping to track which `Arg` and `Retval` nodes
+// were placed on a particular device / graph.
+//
+// More specifically, this function
+//
+//  (1) rewrites the indices of the `Arg` and `Retval` nodes in `graph` to be
+//      consecutive.
+//
+//      These indices might not be consecutive after grappler's pruning
+//      optimization (e.g. removing redundant Args), or graph partitioning. In
+//      the latter case, the nodes in `graph` are placed on `device_type`, and
+//      each such graph partition gets a subset of the arguments and return
+//      values. The `index` attributes of these _Arg and _Retval nodes reflect
+//      the indices of these parameters in the original function. To convert
+//      `subgraph` to a function, we need to replace there original indices with
+//      0, 1, 2, ... .
+//
+//      The argument and return value order in `graph` is determined by the
+//      argument and return value order in the original function. This stability
+//      is important because it enables us to treat a single-partition function
+//      as having the same signature as the subgraph.
+//
+//  (2) records the subsets of `Arg` and `Retval` nodes assigned to the
+//      device in `*_indices`, and
+//  (3) records which `Arg` and `Retval` nodes live in host memory in
+//      `*_alloc_attrs`. If these vectors are NULL, do nothing here. If
+//      `ints_on_device` is false, int32 `Arg` and `Retval` nodes are placed on
+//      host else not. This is needed because in certain special cases e.g.
+//      when graph is placed on TPU/XLA device or when the `Retval` is an output
+//      of an iterator, int32 tensors live on device.
+Status UpdateArgAndRetvalMetadata(
+    Graph* graph, std::vector<FunctionArgIndex>* arg_indices,
+    std::vector<int>* ret_indices,
+    std::vector<AllocatorAttributes>* arg_alloc_attrs,
+    std::vector<AllocatorAttributes>* ret_alloc_attrs, bool ints_on_device);
+
+// Utility for generating function names not present in `flib_def`, using
+// given `name` as the base for the name.
+class FunctionNameGenerator {
+ public:
+  // `flib_def` must outlive this.
+  FunctionNameGenerator(const FunctionLibraryDefinition* flib_def,
+                        const string& name)
+      : flib_def_(flib_def), name_(name), counter_(0) {}
+
+  // Returns a function name not present in `flib_def` using `name` as
+  // the base and appending a numeric suffix.
+  string GetName();
+
+ private:
+  const FunctionLibraryDefinition* flib_def_;
+  const string name_;
+  uint32 counter_;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_PARTITIONING_UTILS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/permuter.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/permuter.h
new file mode 100644
index 0000000000000000000000000000000000000000..654ab0b27291d82b21d3ed812fe60b877e80d5f8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/permuter.h
@@ -0,0 +1,82 @@
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_PERMUTER_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_PERMUTER_H_
+
+#include <deque>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "tensorflow/core/common_runtime/base_collective_executor.h"
+#include "tensorflow/core/framework/collective.h"
+
+namespace tensorflow {
+class Device;
+
+// Implementation of collective permute.
+//
+// Permute takes
+// - a list of devices participating in the collective
+// - a permutation as a list of integers.
+// - a tensor
+//
+// The list of devices replaces the need for group_key and group_size. The
+// number of inputs only scales with the number of devices within one group.
+//
+// The integers in the permutation are based on indices of the list of devices.
+// E.g. devices = {"GPU:0", "GPU:1"} and permutation = {1,0} means
+// - devices[0] sends to devices[permutation[0]] and
+// - devices[1] sends to devices[permutation[1]].
+//
+// Each device sends exactly one tensor and receives exactly one tensor.
+class Permuter : public CollectiveImplementationInterface {
+ public:
+  Permuter();
+  ~Permuter() override = default;
+
+  void Run(StatusCallback done) override;
+
+  Status InitializeCollectiveParams(CollectiveParams* col_params) override {
+    return OkStatus();
+  }
+
+  // Initializes members of CollectiveContext not yet initialized, i.e. device
+  // and device_locality.  Also saves the CollectiveContext in this object.
+  Status InitializeCollectiveContext(
+      std::shared_ptr<CollectiveContext> col_ctx) override;
+
+ private:
+  std::shared_ptr<CollectiveContext> col_ctx_;
+  const CollectiveParams* col_params_;  // Not owned
+  StatusCallback done_;
+  mutex mu_;
+  Status status_ TF_GUARDED_BY(mu_);
+  int counter_ TF_GUARDED_BY(mu_);
+
+  void DispatchSend(int src_rank, int target_rank, const Tensor* tensor,
+                    const StatusCallback& done);
+
+  void DispatchRecv(int src_rank, int target_rank, Tensor* tensor,
+                    const StatusCallback& done);
+
+  // Atomically increments counter_ by one for sending, one for receiving.
+  // Invokes done when counter_ reaches 2.
+  // The purpose of checking counter_ is to ensure that done_ is called once.
+  StatusCallback CheckCounterAndCallDone();
+};
+
+}  // namespace tensorflow
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_PERMUTER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/placer.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/placer.h
new file mode 100644
index 0000000000000000000000000000000000000000..53d9ec9d170f9ed22d5ae16c23a4972be86e130c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/placer.h
@@ -0,0 +1,112 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_PLACER_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_PLACER_H_
+
+#include <string>
+
+#include "tensorflow/core/common_runtime/device_set.h"
+#include "tensorflow/core/common_runtime/optimization_registry.h"
+#include "tensorflow/core/framework/function.h"
+#include "tensorflow/core/graph/graph.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/platform/macros.h"
+#include "tensorflow/core/platform/types.h"
+#include "tensorflow/core/public/session_options.h"
+
+namespace tensorflow {
+
+// A placement algorithm that assigns the nodes of the given Graph to
+// devices the given DeviceSet, respecting the following constraints:
+//
+// 1. Existing device assignments remain unchanged.
+// 2. Requested (partial or complete) device specifications given by device name
+//    for each node are granted.
+// 3. Nodes connected by edges of a reference type are colocated on
+//    the same device.
+// 4. Given nodes "A" and "B", if node "B" has a colocation group
+//    "@loc:A", nodes "A" and "B" will be colocated on the same device.
+//
+// The implementation builds a constraint graph with the same set of
+// nodes, and edges that represent colocation constraints between
+// nodes.  Each connected component in the resulting constraint graph
+// is then assigned to a set of valid devices.
+//
+// Run() will finally assign the device to each node given the list of
+// possible devices.
+//
+// TODO(mrry): "Soft" constraints, such as "place node 'x' as close as
+// possible to node 'y' while respecting the other constraints"?
+// TODO(mrry): Create a common interface for this and the other
+// placement algorithms so that they may be injected into the graph
+// builder.
+class Placer {
+ public:
+  // Creates an instance of the Placer algorithm for the given
+  // Graph "graph" (nodes in which may or may not be assigned) on the
+  // given DeviceSet "devices".
+  // "function_name" should be set to the name of the function whose body is
+  // represented by "graph". If "graph" is not representing a function body,
+  // "function_name" should be empty.
+  //
+  // If non-null, default_local_device is used where possible as a placement for
+  // nodes which do not have a device specified, ahead of other devices which
+  // would otherwise be higher priority. default_local_device should be on the
+  // local host so that its FLR is directly accessible by the current process.
+  //
+  // The "graph", "devices", and "default_local_device" pointer arguments are
+  // borrowed by this Placer, and must outlive it.
+  Placer(Graph* graph, const string& function_name,
+         const FunctionLibraryDefinition* flib_def, const DeviceSet* devices,
+         const Device* default_local_device, bool allow_soft_placement,
+         bool log_device_placement);
+  Placer(Graph* graph, const string& function_name,
+         const FunctionLibraryDefinition* flib_def, const DeviceSet* devices);
+  Placer(Graph* graph, const string& function_name,
+         const FunctionLibraryDefinition* flib_def, const DeviceSet* devices,
+         const Device* default_local_device);
+
+  ~Placer();
+
+  // Assigns each node in this Placer's graph to a device in its
+  // set of devices.
+  //
+  // This method is not thread-safe.
+  // Run() may be invoked at most once.
+  Status Run();
+  Status Run(const GraphOptimizationPassOptions& options);
+
+ private:
+  // Returns true if the device type of 'candidate_device_name' is
+  // found in 'devices'.
+  bool CanAssignToDevice(const string& candidate_device_name,
+                         const std::vector<Device*>& devices) const;
+
+  Graph* const graph_;  // Not owned.
+  const string function_name_;
+  const FunctionLibraryDefinition* const flib_def_;  // Not owned.
+  const DeviceSet* const devices_;                   // Not owned.
+  const Device* default_local_device_;               // Not owned.
+  const bool allow_soft_placement_;
+  const bool log_device_placement_;
+
+  Placer(const Placer&) = delete;
+  void operator=(const Placer&) = delete;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_PLACER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/placer_inspection_required_ops_utils.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/placer_inspection_required_ops_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..f882d02b9160e15e344d312d3c0e012383009964
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/placer_inspection_required_ops_utils.h
@@ -0,0 +1,156 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_PLACER_INSPECTION_REQUIRED_OPS_UTILS_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_PLACER_INSPECTION_REQUIRED_OPS_UTILS_H_
+
+// Operations calling functions are becoming ubiquitous in TF 2.0.
+// Examples include PartitionedCallOp, functional If/While, and Dataset ops.
+// Such operations might require deep inspection - looking at the body of the
+// called function - to place them and surrounding ops correctly.
+
+// This file contains some utilities for placer to correctly place such ops
+// including:
+// - PlacerInspectionRequiredOpChecker: A simple class with a single
+// IsPlacerInspectionRequired method.
+// - IsolatePlacerInspectionRequiredOps: This function adds Identity ops for
+// each input/output of ops requiring placer inspection. It greatly simplifies
+// the implementation of placing such ops.
+
+#include <vector>
+
+#include "absl/types/optional.h"
+#include "tensorflow/core/framework/function.h"
+#include "tensorflow/core/graph/graph.h"
+#include "tensorflow/core/lib/core/status.h"
+
+namespace tensorflow {
+
+// PlacerInspectionRequiredOpChecker allows one to check if Placer needs to
+// look deeply into the op to place ops consuming the outputs correctly.
+//
+// It is a class instead of a standalone method because checking whether
+// a function returns a resource takes non-trivial time and we cache the
+// results.
+class PlacerInspectionRequiredOpChecker {
+ public:
+  // Constructs a PlacerInspectionRequiredOpChecker for nodes of `graph`.
+  // The functions referenced by nodes in `graph` will be looked up in
+  // `flib_def`
+  PlacerInspectionRequiredOpChecker(const Graph* graph,
+                                    const FunctionLibraryDefinition* flib_def);
+
+  // If `node` is considered a deep op, sets `*is_deep` to true and returns
+  // OkStatus(). If an error occurs, returns that error, and the value of
+  // `*is_deep` is undefined.
+  // Currently, an op is considered deep, if it is a calling a function
+  // returning a resource. This definition is driven by Placer's need to
+  // look inside the op.
+  // REQUIRES: `node` is part of `graph` passed into constructor.
+  Status IsPlacerInspectionRequired(const Node& node, bool* is_deep);
+
+ private:
+  const Graph& graph_;
+  const FunctionLibraryDefinition& flib_def_;
+  // Indexed by the node id.
+  // If cache_[node_id] is empty, the deepness of the node with id `node_id` has
+  // not been computed yet. Else, it contains the value already computed.
+  std::vector<absl::optional<bool>> cache_;
+};
+
+// Extracts `fdef` and `func` from `flib_def` for the function identified
+// in "f" attribute of `node`.
+Status GetFunctionDefAndAttrs(const FunctionLibraryDefinition& flib_def,
+                              const Node& node, const FunctionDef** fdef,
+                              NameAttrList* func);
+
+// The "call" stack of functions.
+// Useful for better error messages as well as for detecting recursion.
+// Stores references to graph nodes. These references must outlive this.
+class FunctionStack {
+ public:
+  explicit FunctionStack(const string& function_name);
+
+  // `node_in_current_function` must outlive this.
+  FunctionStack Push(const Node* node_in_current_function,
+                     const string& new_current_function) const;
+
+  // Returns true iff this stack already includes `function_name`.
+  bool HasFunction(const string& function_name) const;
+
+  const string& current_function_name() const { return current_function_name_; }
+
+  // Format's this suitable for error interpolation that retrieves
+  // Python files and line numbers.
+  string FormatForError() const;
+
+ private:
+  struct Frame {
+    Frame(const string& function, const Node* node)
+        : function_name(function), node(node) {}
+
+    string function_name;
+    const Node* node;
+  };
+
+  // The function at the top of the stack. In other words, the function
+  // that is currently being inspected for placement.
+  string current_function_name_;
+
+  // The stack of frames that got the placement to the current_function_name_.
+  // frames_[0].function_name is the top function that Placer was constructed
+  // with. frames_[0].function_name can be empty if placer was constructed with
+  // a nameless graph, not a function.  frames_[0].node_name is a name of a node
+  // in frames_[0].function_name that required deep inspection (e.g. a
+  // PartitionedCallOp). The function that this node invoked is
+  // frames_[1].function_name, if frames_.size() > 1.  Else, the function that
+  // this node invoked is current_function_name_.
+  std::vector<Frame> frames_;
+};
+
+// Adds Identities for each input and output of function-calling ops in `graph`
+//
+// For example, the following graph calling a function on inputs `a` and `b`
+// and producing output `y` will be rewritten to include identities on all
+// edges:
+//
+//      a             b
+//      |             |
+//      v             v
+//    f (PartitionedCallOp)
+//         |
+//         v
+//         y
+//
+// is transformed to
+//
+//      a             b
+//      |             |
+//  a_f (Identity)   b_f (Identity)
+//      |             |
+//      v             v
+//    f (PartitionedCallOp)
+//         |
+//      f_y (Identity)
+//         |
+//         v
+//         y
+//
+Status IsolatePlacerInspectionRequiredOps(
+    const FunctionLibraryDefinition& flib_def, Graph* graph);
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_PLACER_INSPECTION_REQUIRED_OPS_UTILS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/pluggable_device/pluggable_device.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/pluggable_device/pluggable_device.h
new file mode 100644
index 0000000000000000000000000000000000000000..74ad5893921ecc844f009f71449117bb18dc0829
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/pluggable_device/pluggable_device.h
@@ -0,0 +1,117 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_PLUGGABLE_DEVICE_PLUGGABLE_DEVICE_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_PLUGGABLE_DEVICE_PLUGGABLE_DEVICE_H_
+
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include "tensorflow/core/common_runtime/device/device_event_mgr.h"
+#include "tensorflow/core/common_runtime/device/device_id.h"
+#include "tensorflow/core/common_runtime/device/device_id_manager.h"
+#include "tensorflow/core/common_runtime/local_device.h"
+#include "tensorflow/core/common_runtime/pluggable_device/pluggable_device_context.h"
+#include "tensorflow/core/common_runtime/shared_counter.h"
+#include "tensorflow/core/framework/allocator.h"
+#include "tensorflow/core/framework/device_base.h"
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/lib/gtl/inlined_vector.h"
+#include "tensorflow/core/platform/mutex.h"
+#include "tensorflow/core/platform/stream_executor.h"
+#include "tensorflow/core/platform/types.h"
+#include "tensorflow/core/public/session_options.h"
+
+namespace tensorflow {
+
+class PluggableDevice : public LocalDevice {
+ public:
+  PluggableDevice(const SessionOptions& options, const std::string& name,
+                  const string& device_type, const string& platform_name,
+                  Bytes memory_limit, const DeviceLocality& locality,
+                  TfDeviceId tf_device_id,
+                  const std::string& physical_device_desc,
+                  Allocator* device_allocator, Allocator* cpu_allocator,
+                  bool sync_every_op);
+
+  ~PluggableDevice() override;
+
+  // Initialize the device and return the status of initialization.
+  Status Init(const SessionOptions& options);
+
+  void ComputeAsync(AsyncOpKernel* op_kernel, OpKernelContext* context,
+                    AsyncOpKernel::DoneCallback done) override;
+
+  void Compute(OpKernel* op_kernel, OpKernelContext* context) override;
+
+  Status Sync() override;
+
+  Allocator* GetAllocator(AllocatorAttributes attr) override;
+
+  Status MakeTensorFromProto(const TensorProto& tensor_proto,
+                             AllocatorAttributes alloc_attrs,
+                             Tensor* tensor) override;
+
+  void CopyTensorInSameDevice(const Tensor* input_tensor, Tensor* output_tensor,
+                              const DeviceContext* device_context,
+                              StatusCallback done) override;
+
+  // The executor that provides control for the pluggable device;
+  se::StreamExecutor* executor() const { return executor_; }
+
+ private:
+  Allocator* device_allocator_;
+  Allocator* cpu_allocator_;
+
+  se::StreamExecutor* executor_ = nullptr;
+  struct StreamGroup {
+    se::Stream* compute = nullptr;
+    se::Stream* host_to_device = nullptr;
+    se::Stream* device_to_host = nullptr;
+    gtl::InlinedVector<se::Stream*, 4> device_to_device;
+  };
+
+  class StreamGroupFactory;
+
+  StreamGroup* stream_;
+  PluggableDeviceContext* device_context_;
+  // TODO(penpornk): Investigate renaming `GpuDeviceInfo` to `DeviceInfo`.
+  DeviceBase::AcceleratorDeviceInfo* pluggable_device_info_ = nullptr;
+  TfDeviceId tf_device_id_;
+  const string platform_name_;
+  const bool sync_every_op_ = false;
+  EventMgr* em_ = nullptr;
+  std::unique_ptr<thread::ThreadPool> thread_pool_;
+  bool force_gpu_compatible_ = false;
+  std::string ComputeOpKernelDebugString(const OpKernel& op_kernel,
+                                         int stream_id);
+
+  // This method returns an initialization status, in addition to
+  // calling the "done" StatusCallback, if there is a failure to
+  // allocate memory or if the tensor "from" is not DMA-copyable.
+  // If there is no error prior to enqueueing the copy, an OK status
+  // is returned.
+  Status MaybeCopyTensorToPluggableDevice(
+      const AllocatorAttributes& alloc_attrs, const Tensor& from, Tensor* to,
+      StatusCallback done);
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_PLUGGABLE_DEVICE_PLUGGABLE_DEVICE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/pluggable_device/pluggable_device_bfc_allocator.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/pluggable_device/pluggable_device_bfc_allocator.h
new file mode 100644
index 0000000000000000000000000000000000000000..b668bf0f2fd749d3dd16a83e7e75d55da21ddbf2
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/pluggable_device/pluggable_device_bfc_allocator.h
@@ -0,0 +1,56 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_PLUGGABLE_DEVICE_PLUGGABLE_DEVICE_BFC_ALLOCATOR_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_PLUGGABLE_DEVICE_PLUGGABLE_DEVICE_BFC_ALLOCATOR_H_
+
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include "tensorflow/core/common_runtime/bfc_allocator.h"
+#include "tensorflow/core/common_runtime/device/device_mem_allocator.h"
+#include "tensorflow/core/platform/thread_annotations.h"
+#include "tensorflow/core/platform/types.h"
+#include "tensorflow/core/protobuf/config.pb.h"
+
+namespace tensorflow {
+
+// A PluggableDevice memory allocator that implements a 'best-fit with
+// coalescing' algorithm
+class PluggableDeviceBFCAllocator : public BFCAllocator {
+ public:
+  PluggableDeviceBFCAllocator(DeviceMemAllocator* sub_allocator,
+                              size_t total_memory, const string& name,
+                              bool force_memory_growth_requested);
+  PluggableDeviceBFCAllocator(DeviceMemAllocator* sub_allocator,
+                              size_t total_memory,
+                              const GPUOptions& gpu_options, const string& name,
+                              bool force_memory_growth_requested);
+  ~PluggableDeviceBFCAllocator() override = default;
+
+  PluggableDeviceBFCAllocator(const PluggableDeviceBFCAllocator&) = delete;
+  void operator=(const PluggableDeviceBFCAllocator&) = delete;
+
+ private:
+  static bool GetAllowGrowthValue(const GPUOptions& gpu_options,
+                                  bool force_memory_growth_requested);
+  static bool GetGarbageCollectionValue();
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_PLUGGABLE_DEVICE_PLUGGABLE_DEVICE_BFC_ALLOCATOR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/pluggable_device/pluggable_device_context.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/pluggable_device/pluggable_device_context.h
new file mode 100644
index 0000000000000000000000000000000000000000..5798be1c13bc747e0439353c1bd1bb4fb6951761
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/pluggable_device/pluggable_device_context.h
@@ -0,0 +1,89 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_PLUGGABLE_DEVICE_PLUGGABLE_DEVICE_CONTEXT_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_PLUGGABLE_DEVICE_PLUGGABLE_DEVICE_CONTEXT_H_
+
+#include <functional>
+
+#include "tensorflow/core/common_runtime/device.h"
+#include "tensorflow/core/framework/device_base.h"
+#include "tensorflow/core/lib/gtl/inlined_vector.h"
+
+namespace stream_executor {
+class Stream;
+}  // namespace stream_executor
+
+namespace tensorflow {
+
+class PluggableDeviceContext : public DeviceContext {
+ public:
+  // Does not take ownership of streams.
+  PluggableDeviceContext(
+      int stream_id, se::Stream* stream, se::Stream* host_to_device_stream,
+      se::Stream* device_to_host_stream,
+      gtl::InlinedVector<se::Stream*, 4> device_to_device_stream)
+      : stream_id_(stream_id),
+        stream_(stream),
+        host_to_device_stream_(host_to_device_stream),
+        device_to_host_stream_(device_to_host_stream),
+        device_to_device_stream_(device_to_device_stream) {}
+
+  ~PluggableDeviceContext() override = default;
+
+  se::Stream* stream() const override { return stream_; }
+  se::Stream* host_to_device_stream() const { return host_to_device_stream_; }
+  se::Stream* device_to_host_stream() const { return device_to_host_stream_; }
+  se::Stream* device_to_device_stream(int index) const {
+    return device_to_device_stream_[index % device_to_device_stream_.size()];
+  }
+  int stream_id() const { return stream_id_; }
+
+  void CopyCPUTensorToDevice(const Tensor* cpu_tensor, Device* device,
+                             Tensor* device_tensor, StatusCallback done,
+                             bool sync_dst_compute) const override;
+
+  void CopyDeviceTensorToCPU(const Tensor* device_tensor,
+                             StringPiece tensor_name, Device* device,
+                             Tensor* cpu_tensor, StatusCallback done) override;
+
+  void CopyTensorInSameDevice(const Tensor* input_tensor, Device* device,
+                              Tensor* output_tensor,
+                              StatusCallback done) const override;
+
+  void MaintainLifetimeOnStream(const Tensor* t,
+                                se::Stream* stream) const override {}
+
+  Status ThenExecute(Device* device, se::Stream* stream,
+                     std::function<void()> func) override;
+
+  bool IsPluggableDevice() override;
+
+ private:
+  int stream_id_;
+  // The default primary stream to use for this context.
+  // All the memory belongs to this stream.
+  se::Stream* stream_;
+  // The stream to use for copying data from host into PluggableDevice.
+  se::Stream* host_to_device_stream_;
+  // The stream to use for copying data from PluggableDevice to host.
+  se::Stream* device_to_host_stream_;
+  // Streams to use for copying data between PluggableDevices.
+  gtl::InlinedVector<se::Stream*, 4> device_to_device_stream_;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_PLUGGABLE_DEVICE_PLUGGABLE_DEVICE_CONTEXT_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/pluggable_device/pluggable_device_factory.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/pluggable_device/pluggable_device_factory.h
new file mode 100644
index 0000000000000000000000000000000000000000..c423dd2a1fc13a5b58a5b1e76be0eb83d93b2e38
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/pluggable_device/pluggable_device_factory.h
@@ -0,0 +1,61 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_PLUGGABLE_DEVICE_PLUGGABLE_DEVICE_FACTORY_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_PLUGGABLE_DEVICE_PLUGGABLE_DEVICE_FACTORY_H_
+
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include "tensorflow/core/common_runtime/device/device_id.h"
+#include "tensorflow/core/common_runtime/device_factory.h"
+#include "tensorflow/core/framework/device_attributes.pb.h"
+#include "tensorflow/core/public/session_options.h"
+
+namespace tensorflow {
+class PluggableDeviceFactory : public DeviceFactory {
+ public:
+  PluggableDeviceFactory(const string& device_type,
+                         const string& platform_name);
+  Status ListPhysicalDevices(std::vector<string>* devices) override;
+  Status CreateDevices(const SessionOptions& options,
+                       const std::string& name_prefix,
+                       std::vector<std::unique_ptr<Device>>* devices) override;
+  Status GetDeviceDetails(int device_index,
+                          std::unordered_map<string, string>* details) override;
+
+ private:
+  // Populates *device_localities with the DeviceLocality descriptor for
+  // every TfDeviceId.
+  Status GetDeviceLocalities(int num_tf_devices,
+                             std::vector<DeviceLocality>* device_localities);
+  // Create a PluggableDevice associated with 'tf_device_id', allocates
+  // (strictly) 'memory_limit' bytes of PluggableDevice memory to it, and adds
+  // it to the 'devices' vector.
+  Status CreatePluggableDevice(const SessionOptions& options,
+                               const std::string& name_prefix,
+                               TfDeviceId tf_device_id, int64_t memory_limit,
+                               const DeviceLocality& dev_locality,
+                               std::vector<std::unique_ptr<Device>>* devices);
+
+  const string device_type_;
+  const string platform_name_;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_PLUGGABLE_DEVICE_PLUGGABLE_DEVICE_FACTORY_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/pluggable_device/pluggable_device_init.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/pluggable_device/pluggable_device_init.h
new file mode 100644
index 0000000000000000000000000000000000000000..6362de9856ae38b6d511cc43e4dc8d959e4c286a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/pluggable_device/pluggable_device_init.h
@@ -0,0 +1,43 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_PLUGGABLE_DEVICE_PLUGGABLE_DEVICE_INIT_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_PLUGGABLE_DEVICE_PLUGGABLE_DEVICE_INIT_H_
+
+#include <string>
+
+#include "tensorflow/core/lib/core/status.h"
+
+namespace stream_executor {
+class Platform;
+}  // namespace stream_executor
+
+namespace tensorflow {
+
+// Initializes the PluggableDevice platform and returns OK if the
+// PluggableDevice platform could be initialized.
+Status ValidatePluggableDeviceMachineManager(const string& platform_name);
+
+// Returns the PluggableDevice machine manager singleton, creating it and
+// initializing the PluggableDevices on the machine if needed the first time it
+// is called.  Must only be called when there is a valid PluggableDevice
+// environment in the process (e.g., ValidatePluggableDeviceMachineManager()
+// returns OK).
+stream_executor::Platform* PluggableDeviceMachineManager(
+    const string& platform_name);
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_PLUGGABLE_DEVICE_PLUGGABLE_DEVICE_INIT_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/pluggable_device/pluggable_device_process_state.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/pluggable_device/pluggable_device_process_state.h
new file mode 100644
index 0000000000000000000000000000000000000000..b968c15fa84d61cf11f37bed813de564fa6fa297
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/pluggable_device/pluggable_device_process_state.h
@@ -0,0 +1,127 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_PLUGGABLE_DEVICE_PLUGGABLE_DEVICE_PROCESS_STATE_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_PLUGGABLE_DEVICE_PLUGGABLE_DEVICE_PROCESS_STATE_H_
+
+#include <functional>
+#include <map>
+#include <memory>
+#include <unordered_map>
+#include <vector>
+
+#include "tensorflow/core/common_runtime/device/device_id.h"
+#include "tensorflow/core/common_runtime/process_state.h"
+#include "tensorflow/core/common_runtime/shared_counter.h"
+#include "tensorflow/core/framework/allocator.h"
+#include "tensorflow/core/platform/mutex.h"
+#include "tensorflow/core/platform/thread_annotations.h"
+#include "tensorflow/core/platform/types.h"
+#include "tensorflow/core/protobuf/config.pb.h"
+
+namespace tensorflow {
+
+class PluggableDeviceBFCAllocator;
+class PluggableDeviceSimpleAllocator;
+class PoolAllocator;
+
+// Singleton that manages per-process state when PluggableDevices are present.
+class PluggableDeviceProcessState {
+ public:
+  // Singleton that manages each platform's per-process state. e.g. allocation
+  // of shared resource.
+  static PluggableDeviceProcessState* singleton(const string& device_type,
+                                                const string& platform_name);
+
+  // Query whether any PluggableDevice has been created so far.
+  // Disable thread safety analysis since a race is benign here.
+  bool HasPluggableDevice() const TF_NO_THREAD_SAFETY_ANALYSIS {
+    return pluggable_device_enabled_;
+  }
+
+  // Set the flag to indicate a PluggableDevice has been created.
+  // Disable thread safety analysis since a race is benign here.
+  void EnablePluggableDevice() TF_NO_THREAD_SAFETY_ANALYSIS {
+    pluggable_device_enabled_ = true;
+  }
+
+  // Returns the one PluggableDevice allocator used for the indexed
+  // PluggableDevice. Note that this is a system PluggableDevice index.
+  //
+  // 'total_bytes' is the total number of bytes that should be made
+  // available to the allocator.  The first call to this function for
+  // a given tf_device_id creates the allocator, so only the
+  // total_bytes used on that first call is used.
+  //
+  // 'allocator_type' describes the type of algorithm to use for the
+  // underlying allocator.  REQUIRES: Must be a valid type (see
+  // config.proto for the list of supported strings.).
+  //
+  // REQUIRES: tf_device_id must be a valid id for a PluggableDevice
+  // available in the current system environment. Otherwise returns nullptr.
+  virtual Allocator* GetPluggableDeviceAllocator(const GPUOptions& options,
+                                                 TfDeviceId tf_device_id,
+                                                 size_t total_bytes);
+
+  int NumPluggableDeviceAllocators() {
+    mutex_lock l(mu_);
+    return pluggable_device_allocators_.size();
+  }
+
+  virtual Allocator* GetPluggableDeviceHostAllocator(int numa_node);
+
+  // Returns bus_id for the given PluggableDevice id.
+  virtual int BusIdForPluggableDevice(TfDeviceId tf_device_id);
+
+ protected:
+  // PluggableDeviceProcessState is a singleton that should not normally be
+  // deleted except at process shutdown.
+  PluggableDeviceProcessState(const string& device_type,
+                              const string& platform_name);
+  virtual ~PluggableDeviceProcessState() = default;
+
+  ProcessState::MDMap* mem_desc_map() {
+    if (process_state_) return &process_state_->mem_desc_map_;
+    return nullptr;
+  }
+
+  static PluggableDeviceProcessState* instance_;
+  ProcessState* process_state_;  // Not owned.
+  bool pluggable_device_enabled_;
+  const string device_type_;
+  const string platform_name_;
+  mutex mu_;
+
+  struct AllocatorParts {
+    std::unique_ptr<Allocator> allocator;
+    Allocator* device_allocator;
+    SubAllocator* sub_allocator;  // owned by allocator
+  };
+
+  std::vector<AllocatorParts> pluggable_device_allocators_ TF_GUARDED_BY(mu_);
+  std::vector<std::vector<SubAllocator::Visitor>> pluggable_device_visitors_
+      TF_GUARDED_BY(mu_);
+
+  std::vector<AllocatorParts> pluggable_device_host_allocators_
+      TF_GUARDED_BY(mu_);
+  std::vector<std::vector<SubAllocator::Visitor>>
+      pluggable_device_host_alloc_visitors_ TF_GUARDED_BY(mu_);
+  std::vector<std::vector<SubAllocator::Visitor>>
+      pluggable_device_host_free_visitors_ TF_GUARDED_BY(mu_);
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_PLUGGABLE_DEVICE_PLUGGABLE_DEVICE_PROCESS_STATE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/pluggable_device/pluggable_device_simple_allocator.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/pluggable_device/pluggable_device_simple_allocator.h
new file mode 100644
index 0000000000000000000000000000000000000000..3a46f76680944949fac292c1cdb07caa6ee624b5
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/pluggable_device/pluggable_device_simple_allocator.h
@@ -0,0 +1,56 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_PLUGGABLE_DEVICE_PLUGGABLE_DEVICE_SIMPLE_ALLOCATOR_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_PLUGGABLE_DEVICE_PLUGGABLE_DEVICE_SIMPLE_ALLOCATOR_H_
+
+#include <memory>
+#include <optional>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include "tensorflow/core/common_runtime/device/device_mem_allocator.h"
+#include "tensorflow/core/platform/thread_annotations.h"
+#include "tensorflow/core/platform/types.h"
+#include "tensorflow/core/protobuf/config.pb.h"
+
+namespace tensorflow {
+
+class PluggableDeviceSimpleAllocator : public Allocator {
+ public:
+  explicit PluggableDeviceSimpleAllocator(DeviceMemAllocator* sub_allocator);
+  ~PluggableDeviceSimpleAllocator() override = default;
+
+  void* AllocateRaw(size_t alignment, size_t num_bytes) override;
+  void DeallocateRaw(void* ptr) override;
+
+  bool TracksAllocationSizes() const override { return false; }
+  string Name() override { return "Simple allocator"; }
+  std::optional<AllocatorStats> GetStats() override;
+
+  AllocatorMemoryType GetMemoryType() const override {
+    return sub_allocator_->GetMemoryType();
+  }
+
+ private:
+  PluggableDeviceSimpleAllocator(const PluggableDeviceSimpleAllocator&) =
+      delete;
+  void operator=(const PluggableDeviceSimpleAllocator&) = delete;
+  std::unique_ptr<SubAllocator> sub_allocator_;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_PLUGGABLE_DEVICE_PLUGGABLE_DEVICE_SIMPLE_ALLOCATOR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/pluggable_device/pluggable_device_util.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/pluggable_device/pluggable_device_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..8cff5449c853f5bdd38e7c5e4bb7ef928b70792d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/pluggable_device/pluggable_device_util.h
@@ -0,0 +1,72 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_PLUGGABLE_DEVICE_PLUGGABLE_DEVICE_UTIL_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_PLUGGABLE_DEVICE_PLUGGABLE_DEVICE_UTIL_H_
+
+#include "tensorflow/core/common_runtime/device.h"
+#include "tensorflow/core/common_runtime/dma_helper.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/platform/stream_executor.h"
+
+namespace tensorflow {
+
+class RecvTensorResponse;
+class TensorProto;
+
+class PluggableDeviceUtil {
+ public:
+  // Copies the data in 'device_tensor' into 'cpu_tensor'.
+  // 'device_tensor''s backing memory must be on 'device' and
+  // 'cpu_tensor' must be allocated to be of the same size as
+  // 'device_tensor'. Synchronous: may block.
+  static void CopyPluggableDeviceTensorToCPU(
+      Device* device, const DeviceContext* device_context,
+      const Tensor* device_tensor, Tensor* cpu_tensor, StatusCallback done);
+  // Blocks until all operations queued on the stream associated with
+  // 'device' at the time of the call have completed. Returns any
+  // error pending on the stream at completion.
+  static Status Sync(Device* device);
+
+  // Blocks until all operations queued on all streams associated with the
+  // corresponding 'device' at the time of call have completed.
+  // Returns any error pending on the stream at completion.
+  static Status SyncAll(Device* device);
+
+  static void CopyCPUTensorToPluggableDevice(
+      const Tensor* cpu_tensor, const DeviceContext* device_context,
+      Device* device, Tensor* device_tensor, StatusCallback done,
+      bool sync_dst_compute);
+
+  static void DeviceToDeviceCopy(
+      DeviceContext* send_dev_context, DeviceContext* recv_dev_context,
+      Device* src, Device* dst, AllocatorAttributes src_alloc_attr,
+      AllocatorAttributes dst_alloc_attr, const Tensor* input, Tensor* output,
+      int dev_to_dev_stream_index, StatusCallback done);
+
+  // Deep-copying of PluggableDevice tensor on the same device.
+  // 'src_device_tensor''s and 'dst_device_tensor''s backing memory must be on
+  // 'device' and 'dst_cpu_tensor' must be allocated to be of the same
+  // size as 'src_device_tensor'.
+  static void CopyPluggableDeviceTensorToSameDevice(
+      Device* device, const DeviceContext* device_context,
+      const Tensor* src_device_tensor, Tensor* dst_device_tensor,
+      StatusCallback done);
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_PLUGGABLE_DEVICE_PLUGGABLE_DEVICE_UTIL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/pool_allocator.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/pool_allocator.h
new file mode 100644
index 0000000000000000000000000000000000000000..6ce3b7886cfa6b8fae7370802e50c05c78ae549c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/pool_allocator.h
@@ -0,0 +1,181 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_POOL_ALLOCATOR_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_POOL_ALLOCATOR_H_
+
+// Simple LRU pool allocators for various flavors of CPU RAM.
+
+#include <atomic>
+#include <map>
+#include <memory>
+#include <vector>
+
+#include "tensorflow/core/framework/allocator.h"
+#include "tensorflow/core/lib/core/bits.h"
+#include "tensorflow/core/platform/logging.h"
+#include "tensorflow/core/platform/macros.h"
+#include "tensorflow/core/platform/mutex.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+
+// Interface of an object that rounds up integers.
+class RoundUpInterface {
+ public:
+  virtual ~RoundUpInterface() {}
+  virtual size_t RoundUp(size_t num_bytes) = 0;
+};
+
+// Size-limited pool of memory buffers obtained from a SubAllocator
+// instance.  Pool eviction policy is LRU.
+class PoolAllocator : public Allocator {
+ public:
+  // "pool_size_limit" is the maximum number of returned, re-usable
+  // memory buffers to keep in the pool.  If pool_size_limit == 0, the
+  // pool is effectively a thin wrapper around the allocator.
+  // If "auto_resize" is true, then the pool_size_limit will gradually
+  // be raised so that deallocations happen very rarely, if at all.
+  // Transitory start-up objects may deallocate, but the long-term
+  // working-set should not. Auto-resizing can raise pool_size_limit
+  // but will never lower it.
+  // "allocator" is the object that performs the underlying memory
+  // malloc/free operations.  This object takes ownership of allocator.
+  PoolAllocator(size_t pool_size_limit, bool auto_resize,
+                SubAllocator* allocator, RoundUpInterface* size_rounder,
+                string name);
+  ~PoolAllocator() override;
+
+  string Name() override { return name_; }
+
+  void* AllocateRaw(size_t alignment, size_t num_bytes) override;
+
+  void DeallocateRaw(void* ptr) override;
+
+  // Allocate an unused memory region of size "num_bytes".  Fetch from
+  // the pool if available, otherwise call allocator_.
+  void* Get(size_t num_bytes);
+
+  // Return a no-longer needed memory region to the pool.  It is an error
+  // to deference "ptr" after this call.  If the pool is full, the least
+  // recently used region will be deallocated.
+  void Put(void* ptr, size_t num_bytes);
+
+  // Reset the pool to empty.
+  void Clear();
+
+  // The following accessors permit monitoring the effectiveness of
+  // the pool at avoiding repeated malloc/frees on the underlying
+  // allocator.  Read locks are not taken on the theory that value
+  // consistency with other threads is not important.
+
+  // Number of Get() requests satisfied from pool.
+  int64_t get_from_pool_count() const TF_NO_THREAD_SAFETY_ANALYSIS {
+    return get_from_pool_count_;
+  }
+  // Number of Put() requests.
+  int64_t put_count() const TF_NO_THREAD_SAFETY_ANALYSIS { return put_count_; }
+  // Number of Get() requests requiring a fresh allocation.
+  int64_t allocated_count() const TF_NO_THREAD_SAFETY_ANALYSIS {
+    return allocated_count_;
+  }
+  // Number of pool evictions.
+  int64_t evicted_count() const TF_NO_THREAD_SAFETY_ANALYSIS {
+    return evicted_count_;
+  }
+  // Current size limit.
+  size_t size_limit() const TF_NO_THREAD_SAFETY_ANALYSIS {
+    return pool_size_limit_;
+  }
+
+  AllocatorMemoryType GetMemoryType() const override {
+    return allocator_->GetMemoryType();
+  }
+
+ private:
+  struct PtrRecord {
+    void* ptr;
+    size_t num_bytes;
+    PtrRecord* prev;
+    PtrRecord* next;
+  };
+
+  // Remove "pr" from the double-linked LRU list.
+  void RemoveFromList(PtrRecord* pr) TF_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
+
+  // Add "pr" to the head of the double-linked LRU list.
+  void AddToList(PtrRecord* pr) TF_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
+
+  // Delete the least recently used record.
+  void EvictOne() TF_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
+
+  const string name_;
+  const bool has_size_limit_;
+  const bool auto_resize_;
+  size_t pool_size_limit_;
+  std::unique_ptr<SubAllocator> allocator_;
+  std::unique_ptr<RoundUpInterface> size_rounder_;
+  mutex mutex_;
+  std::multimap<const size_t, PtrRecord*> pool_ TF_GUARDED_BY(mutex_);
+  PtrRecord* lru_head_ TF_GUARDED_BY(mutex_) = nullptr;
+  PtrRecord* lru_tail_ TF_GUARDED_BY(mutex_) = nullptr;
+  int64_t get_from_pool_count_ TF_GUARDED_BY(mutex_) = 0;
+  int64_t put_count_ TF_GUARDED_BY(mutex_) = 0;
+  int64_t allocated_count_ TF_GUARDED_BY(mutex_) = 0;
+  int64_t evicted_count_ TF_GUARDED_BY(mutex_) = 0;
+};
+
+// Do-nothing rounder. Passes through sizes unchanged.
+class NoopRounder : public RoundUpInterface {
+ public:
+  size_t RoundUp(size_t num_bytes) override { return num_bytes; }
+};
+
+// Power of 2 rounder: rounds up to nearest power of 2 size.
+class Pow2Rounder : public RoundUpInterface {
+ public:
+  size_t RoundUp(size_t num_bytes) override {
+    return 1uLL << Log2Ceiling64(num_bytes);
+  }
+};
+
+class BasicCPUAllocator : public SubAllocator {
+ public:
+  BasicCPUAllocator(int numa_node, const std::vector<Visitor>& alloc_visitors,
+                    const std::vector<Visitor>& free_visitors)
+      : SubAllocator(alloc_visitors, free_visitors), numa_node_(numa_node) {}
+
+  ~BasicCPUAllocator() override {}
+
+  void* Alloc(size_t alignment, size_t num_bytes,
+              size_t* bytes_received) override;
+
+  void Free(void* ptr, size_t num_bytes) override;
+
+  bool SupportsCoalescing() const override { return false; }
+
+  AllocatorMemoryType GetMemoryType() const override {
+    return AllocatorMemoryType::kHostPageable;
+  }
+
+ private:
+  int numa_node_;
+
+  BasicCPUAllocator(const BasicCPUAllocator&) = delete;
+  void operator=(const BasicCPUAllocator&) = delete;
+};
+
+}  // namespace tensorflow
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_POOL_ALLOCATOR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/process_function_library_runtime.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/process_function_library_runtime.h
new file mode 100644
index 0000000000000000000000000000000000000000..8721fb448ed2eba7d5a1f42aee7912fef175b4db
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/process_function_library_runtime.h
@@ -0,0 +1,554 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_PROCESS_FUNCTION_LIBRARY_RUNTIME_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_PROCESS_FUNCTION_LIBRARY_RUNTIME_H_
+
+#include <functional>
+#include <optional>
+#include <string>
+#include <unordered_map>
+
+#include "absl/types/variant.h"
+#include "tensorflow/core/common_runtime/composite_device.h"
+#include "tensorflow/core/common_runtime/device_mgr.h"
+#include "tensorflow/core/common_runtime/device_set.h"
+#include "tensorflow/core/common_runtime/optimized_function_graph_info.h"
+#include "tensorflow/core/common_runtime/stats_publisher_interface.h"
+#include "tensorflow/core/framework/function.h"
+#include "tensorflow/core/framework/graph.pb.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/platform/platform.h"
+#include "tensorflow/core/protobuf/config.pb.h"
+#include "tsl/platform/notification.h"
+#include "tsl/platform/thread_annotations.h"
+
+#if !defined(IS_MOBILE_PLATFORM)
+#include "tensorflow/core/protobuf/remote_tensor_handle.pb.h"
+#endif  // !IS_MOBILE_PLATFORM
+
+namespace tensorflow {
+
+class FunctionArgsInterface {
+ public:
+  virtual ~FunctionArgsInterface() {}
+
+  virtual bool HasRemoteOrPackedInputs() const = 0;
+
+  virtual Status GetLocalArg(const FunctionArgIndex& index,
+                             Tensor* val) const = 0;
+
+  virtual std::vector<Tensor> GetLocalTensors() const = 0;
+
+#if !defined(IS_MOBILE_PLATFORM)
+  virtual Status GetRemoteArg(const FunctionArgIndex& index,
+                              eager::RemoteTensorHandle* val) const {
+    return errors::Unimplemented(
+        "Serializing a remote argument is not implemented.");
+  }
+#endif  // IS_MOBILE_PLATFORM
+};
+
+// A class that stores all the FunctionLibraryRuntime objects, one per device.
+class ProcessFunctionLibraryRuntime {
+ public:
+  // Creates FunctionLibraryRuntime objects for each device in the provided
+  // DeviceMgr. Caller needs to make sure that device_mgr, lib_def and parent
+  // (if provided) outlive this object.
+  ProcessFunctionLibraryRuntime(
+      const DeviceMgr* device_mgr, Env* env, const ConfigProto* config,
+      int graph_def_version, const FunctionLibraryDefinition* lib_def,
+      const OptimizerOptions& optimizer_options,
+      thread::ThreadPool* thread_pool = nullptr,
+      DistributedFunctionLibraryRuntime* parent = nullptr,
+      const SessionMetadata* session_metadata = nullptr,
+      Rendezvous::Factory rendezvous_factory = Rendezvous::Factory(),
+      StatsPublisherFactory stats_publisher_factory = CreateNoOpStatsPublisher);
+
+  ~ProcessFunctionLibraryRuntime() {
+    // Deleting the FunctionLibraryRuntime map will delete the function handles
+    // registered in it, which may call ReleaseHandle in this class again to
+    // release their sub-function. These circular calls may cause segfault
+    // since the flr_map_ may have already been deleted. Explicitly releasing
+    // flr_map_ here and checking flr_map_ in ReleaseHandle to avoid this.
+    flr_map_.reset();
+    // Graph and stats publishers might have pending work in async threads that
+    // requires access to PFLR instance. Wait for completion before destructing.
+    for (const auto& n : stats_publisher_completed_) {
+      n->WaitForNotification();
+    }
+  }
+
+  // Sends `tensors_to_send` from `source_device` to `target_device` using
+  // `rendezvous`. `key_prefix` is used as a prefix for the keys sent to the
+  // Rendezvous. `device_context` should be the DeviceContext of the device
+  // doing the sending. `alloc_attrs` should either be empty or be the size of
+  // `tensors_to_send` and indicates how the input tensors are allocated. Method
+  // takes references on each of the `tensors_to_send`. Method doesn't block.
+  static Status SendTensors(const string& source_device,
+                            const string& target_device,
+                            const string& key_prefix, int64_t src_incarnation,
+                            gtl::ArraySlice<Tensor> tensors_to_send,
+                            DeviceContext* device_context,
+                            const std::vector<AllocatorAttributes>& alloc_attrs,
+                            RendezvousInterface* rendezvous);
+
+  // Receives `received_tensors` from `target_device` (originally sent from
+  // `source_device`) using `rendezvous`. Uses `key_prefix` to construct the
+  // keys to be retrieved. `device_context` should be for the device receiving
+  // the tensors. `alloc_attrs` indicates how to allocate the received
+  // tensors and should either be empty or `num_tensors` in size. Method doesn't
+  // block and calls `done` when `num_tensors` are fetched.
+  static void ReceiveTensorsAsync(
+      const string& source_device, const string& target_device,
+      const string& key_prefix, int64_t src_incarnation, int64_t num_tensors,
+      DeviceContext* device_context,
+      const std::vector<AllocatorAttributes>& alloc_attrs,
+      RendezvousInterface* rendezvous, std::vector<Tensor>* received_tensors,
+      StatusCallback done);
+
+  static const char kDefaultFLRDevice[];
+  // Returns the FunctionLibraryRuntime for the corresponding device_name.
+  FunctionLibraryRuntime* GetFLR(const string& device_name) const;
+
+  // Returns the return types for the function identified by handle `h`.
+  Status GetRetTypes(FunctionLibraryRuntime::Handle h,
+                     DataTypeVector* ret_types);
+
+  // Returns the device incarnation for the given device_name.
+  Status GetDeviceIncarnation(const string& device_name,
+                              int64_t* incarnation) const;
+
+  // For a given canonicalized key signature of the function instantiated
+  // on device `device_name` and a `local_handle`, creates a handle and returns
+  // that value. Uses core/common_runtime/framework/function.h::Canonicalize
+  // to canonicalize the function signature.
+  FunctionLibraryRuntime::Handle AddHandle(
+      const string& function_key, const string& device_name,
+      FunctionLibraryRuntime::LocalHandle local_handle);
+
+  // Returns a handle if found for the given key, else returns kInvalidHandle.
+  FunctionLibraryRuntime::Handle GetHandle(const string& function_key) const;
+
+  // For the given handle instantiated on device `device_name` returns the local
+  // index of instantiation of that function. If the function was not
+  // instantiated on `device_name` or the function is multi-device,
+  // returns kInvalidLocalHandle.
+  //
+  // If `include_multi_device` is true and `handle` is a multi-device function
+  // with a single component that is placed on `device_name`, then this method
+  // will return the local handle for that component.
+  FunctionLibraryRuntime::LocalHandle GetHandleOnDevice(
+      const string& device_name, FunctionLibraryRuntime::Handle handle,
+      bool include_multi_device = false) const;
+
+  // Fills `output_devices` with the devices on which the results will
+  // be produced. If some output is produced on CPU, the corresponding Device*
+  // is set to nullptr. If some output is DT_RESOURCE, the corresponding Device*
+  // is set to the device backing the resource.
+  // REQUIRES: `handle` identifies a multi-device function.
+  Status GetOutputDevices(FunctionLibraryRuntime::Handle handle,
+                          std::vector<Device*>* output_devices) const;
+
+  // Instantiates the function. See framework/function.h for more details.
+  // Allows for function_name to be instantiated on different devices
+  // as specified in attrs.
+  Status Instantiate(const string& function_name, AttrSlice attrs,
+                     const FunctionLibraryRuntime::InstantiateOptions& options,
+                     FunctionLibraryRuntime::Handle* handle);
+
+  // Returns whether the function represented by the given handle needs to
+  // execute cross process.
+  Status IsCrossProcess(FunctionLibraryRuntime::Handle handle,
+                        bool* is_cross_process) const;
+
+  // Delegates to the local FLR that owns state corresponding to `handle` and
+  // tells it to release it. If the `handle` isn't needed at all, the local FLR
+  // might call RemoveHandle on this to get rid of the state owned by the Proc
+  // FLR.
+  // For multi-device functions, calls ReleaseHandle on local FLRs for each
+  // component function that is part of this multi-device function.
+  // Each local FLR might call RemoveHandle on this.
+  Status ReleaseHandle(FunctionLibraryRuntime::Handle handle);
+
+  // Runs the function with given `handle`. Function could have been
+  // instantiated on any device. More details in framework/function.h
+  void Run(const FunctionLibraryRuntime::Options& opts,
+           FunctionLibraryRuntime::Handle handle, gtl::ArraySlice<Tensor> args,
+           std::vector<Tensor>* rets,
+           FunctionLibraryRuntime::DoneCallback done) const;
+  void Run(const FunctionLibraryRuntime::Options& opts,
+           FunctionLibraryRuntime::Handle handle, CallFrameInterface* frame,
+           FunctionLibraryRuntime::DoneCallback done) const;
+
+  void Run(const FunctionLibraryRuntime::Options& opts,
+           FunctionLibraryRuntime::Handle handle,
+           const FunctionArgsInterface& args, std::vector<FunctionRet>* rets,
+           FunctionLibraryRuntime::DoneCallback done) const;
+
+  Status RunSync(const FunctionLibraryRuntime::Options& opts,
+                 FunctionLibraryRuntime::Handle handle,
+                 gtl::ArraySlice<Tensor> args, std::vector<Tensor>* rets) const;
+  Status RunSync(const FunctionLibraryRuntime::Options& opts,
+                 FunctionLibraryRuntime::Handle handle,
+                 CallFrameInterface* frame) const;
+
+  const DeviceMgr* device_mgr() { return device_mgr_; }
+
+  const std::shared_ptr<DeviceSet> device_set() const {
+    tf_shared_lock l(mu_);
+    return device_set_;
+  }
+
+  // Initialize the set of local and remote devices and corresponding flr for op
+  // device selection.
+  void InitializeDeviceAndFlr();
+
+  const ConfigProto* config() const { return config_ ? &(*config_) : nullptr; }
+
+  const FunctionLibraryDefinition* GetFunctionLibraryDefinition() const {
+    return lib_def_;
+  }
+
+  // Add a CompositeDevice to `device_set_`
+  void AddCompositeDevice(CompositeDevice* d) TF_LOCKS_EXCLUDED(mu_) {
+    mutex_lock l(mu_);
+    device_set_->AddDevice(d);
+    composite_devices_.push_back(d);
+  }
+
+ protected:
+  friend class FunctionLibraryRuntimeImpl;
+
+  struct InternalArgs {
+    std::vector<FunctionArg> args;
+#if !defined(IS_MOBILE_PLATFORM)
+    // Holds the RemoteTensorHandles referred by args.
+    std::vector<std::unique_ptr<eager::RemoteTensorHandle>> remote_args;
+#endif  // IS_MOBILE_PLATFORM
+  };
+
+  // Structure detailing the asynchronous assumptions of a component function,
+  // such as whether it can support synchronous execution and any information
+  // needed to execute in proper order to resolve inter-subgraph dependencies.
+  class AsyncAttributes {
+   public:
+    enum Summary { kSafeForSync = 0, kSendOnly, kRecvOnly, kAsyncRequired };
+
+    AsyncAttributes()
+        : allow_control_flow_sync_execution_(false), summary_(kSafeForSync) {}
+    explicit AsyncAttributes(const Graph* graph,
+                             bool allow_control_flow_sync_execution)
+        : allow_control_flow_sync_execution_(allow_control_flow_sync_execution),
+          summary_(Summarize(graph)) {}
+    Summary summary() const { return summary_; }
+    bool allow_control_flow_sync_execution() const {
+      return allow_control_flow_sync_execution_;
+    }
+
+   private:
+    // This data member should be initialized before the summary_.
+    bool allow_control_flow_sync_execution_;
+    Summary summary_;
+    Summary Summarize(const Graph* graph);
+  };
+
+  // Structure to keep track of how a component function (a single-device
+  // piece of a multi-device function) fits into the multi-device function.
+  struct ComponentFunctionData {
+    // The handle for the instantiated component function.
+    FunctionLibraryRuntime::Handle handle;
+    // arg_indices.size() is the number of arguments to the component function.
+    // The i-th argument of the component function comes from the
+    // `arg_indices[i]`-th argument of the multi-device function.
+    std::vector<FunctionArgIndex> arg_indices;
+    // ret_indices.size() is the number of return values of the component
+    // function.  The i-th return value of the component function goes to the
+    // `ret_indices[i]`-th return value of the multi-device function.
+    std::vector<int> ret_indices;
+    // arg_alloc_attrs[i] are the allocator attributes of the i-th argument to
+    // the component function.
+    std::vector<AllocatorAttributes> arg_alloc_attrs;
+    // ret_alloc_attrs[i] are the allocator attributes of the i-th return value
+    // of the component function.
+    std::vector<AllocatorAttributes> ret_alloc_attrs;
+
+    AsyncAttributes async_attributes;
+  };
+
+  // Data structure holding information for a single instantiated multi-device
+  // function.
+  // The fields are filled in during instantiation. Once the object is
+  // added to mdevice_data_, all fields are constant.
+  struct MultiDeviceFunctionData {
+    MultiDeviceFunctionData(const string& function_name,
+                            const string& function_key, int num_outputs,
+                            FunctionLibraryDefinition&& lib_def,
+                            DataTypeVector ret_types)
+        : function_name_(function_name),
+          function_key_(function_key),
+          instantiation_counter_(1),
+          lib_def_(std::move(lib_def)),
+          num_outputs_(num_outputs),
+          ret_types_(std::move(ret_types)),
+          is_cross_process_(false),
+          has_remote_outputs(false) {}
+
+    const string function_name_;
+    const string function_key_;
+    uint64 instantiation_counter_;
+    // A library that contains definitions of component functions and their
+    // transitive dependencies.
+    FunctionLibraryDefinition lib_def_;
+    // Stored here to resize the output tensor vector when function is run.
+    const int num_outputs_;
+    DataTypeVector ret_types_;
+
+    // Indicates whether this function needs to execute cross process.
+    bool is_cross_process_;
+    // Indicates whether this function has remote outputs.
+    bool has_remote_outputs;
+
+    //  Indicates if running this function synchronously is both allowed + safe.
+    bool enable_sync_execution;
+
+    // Maps the device name to the information about the component function
+    // be run on this device.
+    std::unordered_map<string, ComponentFunctionData> glue_;
+  };
+
+  struct CleanUpItem {
+    string device;
+    uint64 step_id;
+    FunctionLibraryRuntime::Handle local_handle;
+  };
+
+  // If `handle` represents a multi-device function, returns the multi-device
+  // data associated with `handle`. Else, nullptr.
+  MultiDeviceFunctionData* IsMultiDevice(
+      FunctionLibraryRuntime::Handle handle) const;
+
+  DistributedFunctionLibraryRuntime* const parent_;
+
+ private:
+  FunctionLibraryRuntime::Handle AddHandleLocked(
+      const string& function_key, const string& device_name,
+      FunctionLibraryRuntime::LocalHandle local_handle)
+      TF_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+
+  // For a given device_name, returns a DeviceContext for copying
+  // tensors to/from the device.
+  Status GetDeviceContext(const string& device_name,
+                          DeviceContext** device_context) const;
+
+  // Looks up the information for the given `handle` and returns the name
+  // of the device where the function is registered.
+  string GetDeviceName(FunctionLibraryRuntime::Handle handle) const;
+
+  // Removes handle from the state owned by this object.
+  Status RemoveHandle(FunctionLibraryRuntime::Handle handle);
+
+  // Clones ProcessFunctionLibraryRuntime and FunctionLibraryDefinition
+  // (transferring ownership of both to the caller). Note that the
+  // ProcessFunctionLibraryRuntime borrows a pointer to the
+  // FunctionLibraryDefinition and so the FunctionLibraryDefinition should
+  // outlive the ProcessFunctionLibraryRuntime.
+  //
+  // The `skip_flib_def` argument controls whether the method should clone the
+  // FunctionLibraryDefinition (default behavior) or return an empty function
+  // library. The latter is used by tf.data, which manages
+  // FunctionLibraryDefinitions for its functions independently (and passes
+  // these into the FunctionLibraryRuntime through an overlay), to avoid linear
+  // runtime w.r.t. to number of functions in the current function library.
+  Status Clone(Env* env, int graph_def_version,
+               const OptimizerOptions& optimizer_options,
+               std::unique_ptr<FunctionLibraryDefinition>* out_lib_def,
+               std::unique_ptr<ProcessFunctionLibraryRuntime>* out_pflr,
+               bool skip_flib_def = false) const;
+
+  Status ReleaseMultiDeviceHandle(FunctionLibraryRuntime::Handle handle);
+
+  Status InstantiateMultiDevice(
+      const string& function_name, AttrSlice attrs,
+      const FunctionLibraryRuntime::InstantiateOptions& options,
+      FunctionLibraryRuntime::Handle* handle);
+
+  void InstantiateRemote(
+      const string& function_name, AttrSlice attrs,
+      const FunctionLibraryRuntime::InstantiateOptions& options,
+      FunctionLibraryRuntime::Handle* handle,
+      FunctionLibraryRuntime::DoneCallback done);
+
+  FunctionLibraryRuntime::Handle AddMultiDeviceHandle(
+      const std::unique_ptr<MultiDeviceFunctionData> data,
+      const string& function_key);
+
+  bool HasMultiDeviceHandle(FunctionLibraryRuntime::Handle handle) const;
+
+  void RunInternal(const FunctionLibraryRuntime::Options& opts,
+                   FunctionLibraryRuntime::Handle handle,
+                   gtl::ArraySlice<FunctionArg> args,
+                   std::vector<FunctionRet>* rets,
+                   std::vector<std::unique_ptr<CleanUpItem>>* cleanup_items,
+                   FunctionLibraryRuntime::DoneCallback done) const;
+
+  Status CreateRendezvous(
+      FunctionLibraryRuntime::Options& opts,
+      tsl::core::RefCountPtr<Rendezvous>* created_rendezvous) const;
+
+  FunctionLibraryRuntime::DoneCallback ApplyCleanUpToDoneCallback(
+      std::vector<std::unique_ptr<CleanUpItem>>* items,
+      FunctionLibraryRuntime::DoneCallback done,
+      const FunctionLibraryRuntime::Options& opts,
+      tsl::core::RefCountPtr<Rendezvous> rendezvous) const;
+
+  void CleanUp(std::vector<std::unique_ptr<CleanUpItem>>* items,
+               FunctionLibraryRuntime::DoneCallback done) const;
+
+  static Status GetComponentArgs(gtl::ArraySlice<Tensor> args,
+                                 const ComponentFunctionData& comp_data,
+                                 InternalArgs* comp_args);
+
+#if !defined(IS_MOBILE_PLATFORM)
+  static Status GetComponentArgs(const FunctionArgsInterface& args,
+                                 const ComponentFunctionData& comp_data,
+                                 InternalArgs* comp_args);
+#endif  // IS_MOBILE_PLATFORM
+
+  std::vector<string> GetOrderedSubgraphs(
+      const MultiDeviceFunctionData* data) const;
+
+  Status PrepareRunMultiDevice(const FunctionLibraryRuntime::Options& opts,
+                               FunctionLibraryRuntime::Handle handle,
+                               const MultiDeviceFunctionData** data) const;
+
+  Status RunMultiDeviceSync(
+      const FunctionLibraryRuntime::Options& opts,
+      FunctionLibraryRuntime::Handle handle, std::vector<FunctionRet>* rets,
+      std::function<Status(const ComponentFunctionData& comp_data,
+                           InternalArgs* args)>
+          get_component_args) const;
+
+  void RunMultiDeviceAsync(
+      const FunctionLibraryRuntime::Options& opts,
+      FunctionLibraryRuntime::Handle handle, std::vector<FunctionRet>* rets,
+      std::vector<std::unique_ptr<CleanUpItem>>* cleanup_items,
+      FunctionLibraryRuntime::DoneCallback done,
+      std::function<Status(const ComponentFunctionData& comp_data,
+                           InternalArgs* args)>
+          get_component_args) const;
+
+  void PublishSubgraphs(
+      const std::string& function_name,
+      std::unique_ptr<std::unordered_map<string, std::unique_ptr<Graph>>>
+          subgraphs);
+
+  // Data structure holding information for a single instantiated remote
+  // (to be executed on `target_device`) function.
+  class FunctionData {
+   public:
+    FunctionData(const string& target_device,
+                 FunctionLibraryRuntime::LocalHandle local_handle,
+                 const string& function_key)
+        : target_device_(target_device),
+          local_handle_(local_handle),
+          function_key_(function_key) {}
+
+    const string& target_device() { return target_device_; }
+    const string& function_key() { return function_key_; }
+
+    FunctionLibraryRuntime::LocalHandle local_handle() {
+      mutex_lock l(mu_);
+      return local_handle_;
+    }
+
+    // Initializes the FunctionData object by potentially making an Initialize
+    // call to the DistributedFunctionLibraryRuntime.
+    void DistributedInit(
+        DistributedFunctionLibraryRuntime* parent, const string& function_name,
+        const FunctionLibraryDefinition& lib_def, AttrSlice attrs,
+        const FunctionLibraryRuntime::InstantiateOptions& options,
+        FunctionLibraryRuntime::DoneCallback done);
+
+    bool is_cross_process() {
+      mutex_lock l(mu_);
+      return is_cross_process_;
+    }
+
+   private:
+    mutex mu_;
+
+    const string target_device_;
+    FunctionLibraryRuntime::LocalHandle local_handle_ TF_GUARDED_BY(mu_);
+    const string function_key_;
+    bool is_cross_process_ TF_GUARDED_BY(mu_) = false;
+    bool init_started_ TF_GUARDED_BY(mu_) = false;
+    Status init_result_ TF_GUARDED_BY(mu_);
+    Notification init_done_;
+  };
+
+  mutable mutex mu_;
+
+  Env* const env_;
+  const std::optional<const ConfigProto> config_;
+  const DeviceMgr* const device_mgr_;
+  const FunctionLibraryDefinition* lib_def_;
+  thread::ThreadPool* default_thread_pool_;
+
+  // Cluster update can reinitialize the device_set_ due to remote device
+  // changes. At the same time, InstantiateMultiDevice can use the cached
+  // devices to instantiate multi-worker functions. Function instantiation would
+  // fail if it spans the changed remote devices.
+  std::shared_ptr<DeviceSet> device_set_ TF_GUARDED_BY(mu_);
+
+  // Composite devices owned by a EagerContext.
+  std::vector<CompositeDevice*> composite_devices_ TF_GUARDED_BY(mu_);
+
+  // Holds all the function instantiations. Maps function_keys to handles.
+  std::unordered_map<string, FunctionLibraryRuntime::Handle> table_
+      TF_GUARDED_BY(mu_);
+
+  // Function data for instantiated remote functions.
+  std::unordered_map<FunctionLibraryRuntime::Handle,
+                     std::unique_ptr<FunctionData>>
+      function_data_ TF_GUARDED_BY(mu_);
+
+  // Function data for instantiated multi-device functions.
+  std::unordered_map<FunctionLibraryRuntime::Handle,
+                     std::unique_ptr<MultiDeviceFunctionData>>
+      mdevice_data_ TF_GUARDED_BY(mu_);
+
+  std::unique_ptr<
+      std::unordered_map<Device*, core::RefCountPtr<FunctionLibraryRuntime>>>
+      flr_map_;
+  int next_handle_ TF_GUARDED_BY(mu_);
+  const SessionMetadata* const session_metadata_;
+  const Rendezvous::Factory rendezvous_factory_;
+
+  const OptimizerOptions optimizer_options_;
+  const int graph_def_version_;
+
+  StatsPublisherFactory stats_publisher_factory_;
+  // Holds all stats publishers, one for publishing subgraphs of each
+  // instantiated function.
+  std::vector<std::unique_ptr<StatsPublisherInterface>> stats_publishers_
+      TF_GUARDED_BY(mu_);
+  std::vector<std::unique_ptr<tsl::Notification>> stats_publisher_completed_
+      TF_GUARDED_BY(mu_);
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_PROCESS_FUNCTION_LIBRARY_RUNTIME_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/process_state.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/process_state.h
new file mode 100644
index 0000000000000000000000000000000000000000..dd667cc236a8e9b0e82a0c435b2027de352606df
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/process_state.h
@@ -0,0 +1,161 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_PROCESS_STATE_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_PROCESS_STATE_H_
+
+#include <functional>
+#include <map>
+#include <unordered_map>
+#include <vector>
+
+#include "tensorflow/core/framework/allocator.h"
+#include "tensorflow/core/framework/allocator_registry.h"
+#include "tensorflow/core/platform/mutex.h"
+#include "tensorflow/core/platform/thread_annotations.h"
+#include "tensorflow/core/platform/types.h"
+#include "tensorflow/core/protobuf/config.pb.h"
+
+namespace tensorflow {
+
+class PoolAllocator;
+
+// Singleton that manages per-process state, e.g. allocation of
+// shared resources.
+class ProcessState : public ProcessStateInterface {
+ public:
+  static ProcessState* singleton();
+
+  // Descriptor for memory allocation attributes, used by optional
+  // runtime correctness analysis logic.
+  struct MemDesc {
+    enum MemLoc { CPU, GPU };
+    MemLoc loc;
+    int dev_index;
+    bool gpu_registered;
+    bool nic_registered;
+    MemDesc()
+        : loc(CPU),
+          dev_index(0),
+          gpu_registered(false),
+          nic_registered(false) {}
+    string DebugString();
+  };
+
+  // If NUMA Allocators are desired, call this before calling any
+  // Allocator accessor.
+  void EnableNUMA() { numa_enabled_ = true; }
+
+  // Returns what we know about the memory at ptr.
+  // If we know nothing, it's called CPU 0 with no other attributes.
+  MemDesc PtrType(const void* ptr);
+
+  // Returns the one CPUAllocator used for the given numa_node.
+  // Treats numa_node == kNUMANoAffinity as numa_node == 0.
+  Allocator* GetCPUAllocator(int numa_node) override;
+
+  // Registers alloc visitor for the CPU allocator(s).
+  // REQUIRES: must be called before GetCPUAllocator.
+  void AddCPUAllocVisitor(SubAllocator::Visitor v);
+
+  // Registers free visitor for the CPU allocator(s).
+  // REQUIRES: must be called before GetCPUAllocator.
+  void AddCPUFreeVisitor(SubAllocator::Visitor v);
+
+  typedef std::unordered_map<const void*, MemDesc> MDMap;
+
+ protected:
+  ProcessState();
+  virtual ~ProcessState() {}
+  friend class GPUProcessState;
+  friend class PluggableDeviceProcessState;
+
+  // If these flags need to be runtime configurable consider adding
+  // them to ConfigProto.
+  static constexpr bool FLAGS_brain_mem_reg_gpu_dma = true;
+  static constexpr bool FLAGS_brain_gpu_record_mem_types = false;
+
+  // Helper method for unit tests to reset the ProcessState singleton by
+  // cleaning up everything. Never use in production.
+  void TestOnlyReset();
+
+  static ProcessState* instance_;
+  bool numa_enabled_;
+
+  mutex mu_;
+
+  // Indexed by numa_node.  If we want numa-specific allocators AND a
+  // non-specific allocator, maybe should index by numa_node+1.
+  std::vector<Allocator*> cpu_allocators_ TF_GUARDED_BY(mu_);
+  std::vector<SubAllocator::Visitor> cpu_alloc_visitors_ TF_GUARDED_BY(mu_);
+  std::vector<SubAllocator::Visitor> cpu_free_visitors_ TF_GUARDED_BY(mu_);
+
+  // A cache of cpu allocators indexed by a numa node. Used as a fast path to
+  // get CPU allocator by numa node id without locking the mutex. We can't use
+  // `cpu_allocators_` storage in the lock-free path because concurrent
+  // operation can deallocate the vector storage.
+  std::atomic<int> cpu_allocators_cached_;
+  std::array<Allocator*, 8> cpu_allocators_cache_;
+
+  // Optional RecordingAllocators that wrap the corresponding
+  // Allocators for runtime attribute use analysis.
+  MDMap mem_desc_map_;
+  std::vector<Allocator*> cpu_al_ TF_GUARDED_BY(mu_);
+};
+
+namespace internal {
+class RecordingAllocator : public Allocator {
+ public:
+  RecordingAllocator(ProcessState::MDMap* mm, Allocator* a,
+                     ProcessState::MemDesc md, mutex* mu)
+      : mm_(mm), a_(a), md_(md), mu_(mu) {}
+
+  string Name() override { return a_->Name(); }
+  void* AllocateRaw(size_t alignment, size_t num_bytes) override {
+    void* p = a_->AllocateRaw(alignment, num_bytes);
+    mutex_lock l(*mu_);
+    (*mm_)[p] = md_;
+    return p;
+  }
+  void DeallocateRaw(void* p) override {
+    mutex_lock l(*mu_);
+    auto iter = mm_->find(p);
+    mm_->erase(iter);
+    a_->DeallocateRaw(p);
+  }
+  bool TracksAllocationSizes() const override {
+    return a_->TracksAllocationSizes();
+  }
+  size_t RequestedSize(const void* p) const override {
+    return a_->RequestedSize(p);
+  }
+  size_t AllocatedSize(const void* p) const override {
+    return a_->AllocatedSize(p);
+  }
+  absl::optional<AllocatorStats> GetStats() override { return a_->GetStats(); }
+  bool ClearStats() override { return a_->ClearStats(); }
+
+  AllocatorMemoryType GetMemoryType() const override {
+    return a_->GetMemoryType();
+  }
+
+  ProcessState::MDMap* mm_;  // not owned
+  Allocator* a_;             // not owned
+  ProcessState::MemDesc md_;
+  mutex* mu_;
+};
+}  // namespace internal
+}  // namespace tensorflow
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_PROCESS_STATE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/process_util.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/process_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..cc2bc4390793c0658f372c60bc66b523437261fd
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/process_util.h
@@ -0,0 +1,64 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_PROCESS_UTIL_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_PROCESS_UTIL_H_
+
+#include <functional>
+
+#include "absl/functional/any_invocable.h"
+#include "tensorflow/core/lib/core/threadpool.h"
+#include "tensorflow/core/public/session_options.h"
+
+// TODO(vrv, mrry): Remove this library: its interface circumvents the
+// callers' Env and calls Env::Default() directly.
+
+namespace tensorflow {
+
+// Returns a process-wide ThreadPool for scheduling compute operations
+// using 'options'.  Caller does not take ownership over threadpool.
+thread::ThreadPool* ComputePool(const SessionOptions& options);
+
+// Returns the TF_NUM_INTEROP_THREADS environment value, or 0 if not specified.
+int32 NumInterOpThreadsFromEnvironment();
+
+// Returns the TF_NUM_INTRAOP_THREADS environment value, or 0 if not specified.
+int32 NumIntraOpThreadsFromEnvironment();
+
+// Returns the number of inter op threads specified in `options` or a default.
+// If no value or a negative value is specified in the provided options, then
+// the function returns the value defined in the TF_NUM_INTEROP_THREADS
+// environment variable. If neither a value is specified in the options or in
+// the environment, this function will return a reasonable default value based
+// on the number of schedulable CPUs, and any MKL and OpenMP configurations.
+int32 NumInterOpThreadsFromSessionOptions(const SessionOptions& options);
+
+// Creates a thread pool with number of inter op threads.
+// The number is set if `num_threads` > 0, otherwise it will be configured by
+// SessionOptions.
+thread::ThreadPool* NewThreadPoolFromSessionOptions(
+    const SessionOptions& options, int32_t num_threads = 0);
+
+// Schedule "closure" in the default thread queue.
+void SchedClosure(absl::AnyInvocable<void()> closure);
+
+// Schedule "closure" after the given number of microseconds in the
+// fixed-size ThreadPool used for non-blocking compute tasks.
+void SchedNonBlockingClosureAfter(int64_t micros,
+                                  absl::AnyInvocable<void()> closure);
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_PROCESS_UTIL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/profile_handler.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/profile_handler.h
new file mode 100644
index 0000000000000000000000000000000000000000..391dc8c19878b7fddf22f1c0950460005033c129
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/profile_handler.h
@@ -0,0 +1,67 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_PROFILE_HANDLER_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_PROFILE_HANDLER_H_
+
+#include "tensorflow/core/framework/step_stats.pb.h"
+#include "tensorflow/core/graph/types.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/lib/core/stringpiece.h"
+
+namespace tensorflow {
+
+// A profile handler collects event stats from a running step.
+class ProfileHandler {
+ public:
+  ProfileHandler() {}
+  virtual ~ProfileHandler() {}
+
+  // Records that a single Op was executed in the current step.
+  //
+  // Implementations of this method must be thread-safe.
+  //
+  // Args:
+  // - device: Device on which the Op was executed.
+  // - stats: Statistics of node execution timing.
+  // - is_copy: True if the op was a copy, send or recv.
+  // - label: Extra content for timeline click text.
+  // - op_type: String name of the Op.
+  // - details: Main content for timeline click text.
+  virtual void RecordOneOp(const string& device, const NodeExecStats& stats,
+                           bool is_copy, StringPiece label, StringPiece op_type,
+                           StringPiece details) = 0;
+
+  // Records that the current step finished.
+  //
+  // Implementations of this method need not be thread-safe.
+  //
+  // Args:
+  // - start_time: The time at which the step started.
+  // - finish_time: The time at which the step finished.
+  // - cleanup_time: The time at which cleanup for the step finished.
+  // - total_runops: The number of ops that ran during this step.
+  // - final_status: The status that this step finished with.
+  virtual void StepDone(Microseconds start_time, Microseconds finish_time,
+                        Microseconds cleanup_time, int total_runops,
+                        Status final_status) = 0;
+
+  // Returns true if the caller should collect rpc activity.
+  virtual bool should_collect_rpcs() = 0;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_PROFILE_HANDLER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/quantize_training.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/quantize_training.h
new file mode 100644
index 0000000000000000000000000000000000000000..4013caef4126385b50c1663f297aead4f1eb6555
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/quantize_training.h
@@ -0,0 +1,57 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_QUANTIZE_TRAINING_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_QUANTIZE_TRAINING_H_
+
+#include "tensorflow/core/graph/graph.h"
+
+namespace tensorflow {
+// Rewrites graph for quantized training.
+// Rewrites the forward pass to include the precision loss with quantization so
+// the model can learn to deal with such loss and achieve better accuracy when
+// it is quantized later for inference.
+// Note that the num_bits should be in [1, 63] and 'g' must be not null.
+// quant_op_type specifies which quantization op should be used.
+// Current ops supported:
+// - QuantizeAndDequantizeV2.
+// - FakeQuantWithMinMaxVars.
+//
+// On success, returns OK.
+//
+// On failure, returns the error status. Possible errors include:
+//    - num_bits out of range.
+//    - g is null.
+//    - More than 1 unknown ops encountered.
+Status DoQuantizeTraining(int32_t num_bits, const string& quant_op_type,
+                          Graph* g);
+
+// Converts the input serialized GraphDef and returns a rewritten serialized
+// GraphDef for quantized training.
+Status DoQuantizeTrainingOnSerializedGraphDef(const string& input_graph,
+                                              int32_t num_bits,
+                                              const string& quant_op_type,
+                                              string* result_graph);
+
+// Converts the input GraphDef and returns a rewritten GraphDef for quantized
+// training.
+Status DoQuantizeTrainingOnGraphDef(const GraphDef& input_graphdef,
+                                    int32_t num_bits,
+                                    const string& quant_op_type,
+                                    GraphDef* result_graphdef);
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_QUANTIZE_TRAINING_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/renamed_device.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/renamed_device.h
new file mode 100644
index 0000000000000000000000000000000000000000..d67bdf228108f45d6c3aecff646cce86367ead19
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/renamed_device.h
@@ -0,0 +1,173 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_RENAMED_DEVICE_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_RENAMED_DEVICE_H_
+
+#include "tensorflow/core/common_runtime/device.h"
+#include "tensorflow/core/lib/core/threadpool_interface.h"
+#include "tensorflow/core/util/device_name_utils.h"
+
+namespace tensorflow {
+
+// Wraps a device with a new name, delegating work to the wrapped device.
+//
+// This class is used to wrap local devices when using clusterspec propagation
+// where the name of a particular device may change in the context of a given
+// session.
+class RenamedDevice : public Device {
+ public:
+  static std::unique_ptr<Device> NewRenamedDevice(
+      const string& new_base, Device* underlying, bool owns_underlying,
+      bool isolate_session_state,
+      thread::ThreadPoolInterface* underlying_threadpool = nullptr);
+
+  ~RenamedDevice() override;
+
+  const DeviceBase* UnderlyingDevice() const override {
+    return underlying_device_->UnderlyingDevice();
+  }
+  DeviceBase* UnderlyingDevice() override {
+    return underlying_device_->UnderlyingDevice();
+  }
+
+  const CpuWorkerThreads* tensorflow_cpu_worker_threads() const override {
+    if (underlying_threadpool_) {
+      return Device::tensorflow_cpu_worker_threads();
+    }
+    return underlying_device_->tensorflow_cpu_worker_threads();
+  }
+
+  const DeviceBase::AcceleratorDeviceInfo* tensorflow_accelerator_device_info()
+      const override {
+    return underlying_device_->tensorflow_accelerator_device_info();
+  }
+
+  Allocator* GetAllocator(AllocatorAttributes attr) override {
+    return underlying_device_->GetAllocator(attr);
+  }
+
+  Allocator* GetScopedAllocator(AllocatorAttributes attr,
+                                int64_t step_id) override {
+    return underlying_device_->GetScopedAllocator(attr, step_id);
+  }
+
+  ScopedAllocatorMgr* GetScopedAllocatorMgr() const override {
+    return underlying_device_->GetScopedAllocatorMgr();
+  }
+
+  const Eigen::ThreadPoolDevice* eigen_cpu_device() override {
+    // Use the underlying threadpool only if the underlying device supports
+    // eigen_cpu_device.
+    if (underlying_threadpool_ && underlying_device_->has_eigen_cpu_device()) {
+      return Device::eigen_cpu_device();
+    }
+    return underlying_device_->eigen_cpu_device();
+  }
+
+  thread::ThreadPool* tensorflow_device_thread_pool() override {
+    // Use the underlying threadpool instead of tensorflow_device_thread_pool
+    // of the underlying device only if tensorflow_device_thread_pool is defined
+    // for the underlying device.
+    if (underlying_threadpool_ &&
+        underlying_device_->tensorflow_device_thread_pool() != nullptr) {
+      return Device::tensorflow_device_thread_pool();
+    }
+    return underlying_device_->tensorflow_device_thread_pool();
+  }
+
+  bool has_eigen_cpu_device() const override {
+    return underlying_device_->has_eigen_cpu_device();
+  }
+
+
+  PerOpGpuDevice* MakeGpuDevice() override {
+    return underlying_device_->MakeGpuDevice();
+  }
+
+  Status ReinitializeGpuDevice(OpKernelContext* context, PerOpGpuDevice* device,
+                               DeviceContext* dc,
+                               Allocator* allocator) override {
+    return underlying_device_->ReinitializeGpuDevice(context, device, dc,
+                                                     allocator);
+  }
+
+  Status MakeTensorFromProto(const TensorProto& tensor_proto,
+                             const AllocatorAttributes alloc_attrs,
+                             Tensor* tensor) override {
+    return underlying_device_->MakeTensorFromProto(tensor_proto, alloc_attrs,
+                                                   tensor);
+  }
+
+  void CopyTensorInSameDevice(const Tensor* input_tensor, Tensor* output_tensor,
+                              const DeviceContext* device_context,
+                              StatusCallback done) override {
+    underlying_device_->CopyTensorInSameDevice(input_tensor, output_tensor,
+                                               device_context, std::move(done));
+  }
+
+  // Below are virtual methods defined on Device
+
+  void Compute(OpKernel* op_kernel, OpKernelContext* context) override {
+    underlying_device_->Compute(op_kernel, context);
+  }
+
+  void ComputeAsync(AsyncOpKernel* op_kernel, OpKernelContext* context,
+                    AsyncOpKernel::DoneCallback done) override {
+    underlying_device_->ComputeAsync(op_kernel, context, std::move(done));
+  }
+
+  Status Sync() override { return underlying_device_->Sync(); }
+
+  Status MaybeRewriteGraph(std::unique_ptr<Graph>* graph) override {
+    return underlying_device_->MaybeRewriteGraph(graph);
+  }
+
+  Status TryGetDeviceContext(DeviceContext** out_context) override {
+    return underlying_device_->TryGetDeviceContext(out_context);
+  }
+
+  // Returns the resource manager associated w/ this device.
+  ResourceMgr* resource_manager() override {
+    if (isolate_session_state_) {
+      return Device::resource_manager();
+    } else {
+      return underlying_device_->resource_manager();
+    }
+  }
+
+  bool IsLocal() const override { return underlying_device_->IsLocal(); }
+
+  bool IsRemoteCallAllowed() const override {
+    return underlying_device_->IsRemoteCallAllowed();
+  }
+
+ private:
+  RenamedDevice(Device* underlying, const DeviceAttributes& attributes,
+                bool owns_underlying, bool isolate_session_state,
+                thread::ThreadPoolInterface* underlying_threadpool);
+  Device* const underlying_device_;
+  const bool owns_underlying_device_;
+  const bool isolate_session_state_;
+
+  std::unique_ptr<thread::ThreadPool> underlying_threadpool_;
+  // eigen_worker_threads_ is stored here so that we can pass the pointer
+  // of eigen_worker_threads_.workers to the parent class.
+  DeviceBase::CpuWorkerThreads eigen_worker_threads_;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_RENAMED_DEVICE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/rendezvous_mgr.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/rendezvous_mgr.h
new file mode 100644
index 0000000000000000000000000000000000000000..a6e70fcab911010a872ffa775c82af2d2d22c1f8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/rendezvous_mgr.h
@@ -0,0 +1,106 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_RENDEZVOUS_MGR_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_RENDEZVOUS_MGR_H_
+
+#include <string>
+#include <unordered_map>
+
+#include "tensorflow/core/common_runtime/device_mgr.h"
+#include "tensorflow/core/framework/local_rendezvous.h"
+#include "tensorflow/core/framework/rendezvous.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/platform/macros.h"
+#include "tensorflow/core/platform/mutex.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+
+// The IntraProcessRendezvous classes are implementations of a Rendezvous that
+// expects all producers and consumers to be devices immediately accessible
+// within the process. That is, it will never be necessary to perform an RPC to
+// communicate with either.
+//
+// Buffering of Tensor values is delegated to a `LocalRendezvous`. An
+// IntraProcessRendezvous. just adds functionality to coordinate multiple
+// process-local devices.
+
+// Reference-counted implementation that may be shared between multiple threads.
+class RefCountedIntraProcessRendezvous : public Rendezvous {
+ public:
+  explicit RefCountedIntraProcessRendezvous(const DeviceMgr* device_mgr);
+
+  // Implementation of RendezvousInterface methods.
+  // NOTE: The methods may clear the Item list and destroy 'this' if there are
+  // no other references to the RefCountedIntraProcessRendezvous object.
+  // If the caller intend to keep a longer life time then it shall keep its own
+  // reference to the RefCountedIntraProcessRendezvous.
+  Status Send(const ParsedKey& key, const Rendezvous::Args& args,
+              const Tensor& val, const bool is_dead) override;
+  void RecvAsync(const ParsedKey& key, const Rendezvous::Args& args,
+                 DoneCallback done) override;
+  void StartAbort(const Status& status) override;
+
+  // Returns the member LocalRendezvous' status.
+  Status GetLocalRendezvousStatus();
+
+  inline void UpdateDeviceManager(DeviceMgr* device_mgr) {
+    device_mgr_ = device_mgr;
+  }
+
+ private:
+  const DeviceMgr* device_mgr_;  // Not owned.
+  LocalRendezvous local_;
+
+  ~RefCountedIntraProcessRendezvous() override;
+
+  RefCountedIntraProcessRendezvous(const RefCountedIntraProcessRendezvous&) =
+      delete;
+  void operator=(const RefCountedIntraProcessRendezvous&) = delete;
+};
+
+// RefCountedIntraProcessRendezvous is aliased to IntraProcessRendezvous for
+// backwards compatibility with existing users.
+using IntraProcessRendezvous = RefCountedIntraProcessRendezvous;
+
+// Non-reference-counted implementation that may be stack-allocated for
+// performance.
+//
+// Prefer to use PrivateIntraProcessRendezvous in new code.
+class PrivateIntraProcessRendezvous : public RendezvousInterface {
+ public:
+  explicit PrivateIntraProcessRendezvous(const DeviceMgr* device_mgr);
+  ~PrivateIntraProcessRendezvous() override;
+
+  // Implementation of RendezvousInterface methods.
+  Status Send(const ParsedKey& key, const Rendezvous::Args& args,
+              const Tensor& val, const bool is_dead) override;
+  void RecvAsync(const ParsedKey& key, const Rendezvous::Args& args,
+                 DoneCallback done) override;
+  void StartAbort(const Status& status) override;
+
+ private:
+  const DeviceMgr* device_mgr_;
+  LocalRendezvous local_;
+
+  PrivateIntraProcessRendezvous(const PrivateIntraProcessRendezvous&) = delete;
+  void operator=(const PrivateIntraProcessRendezvous&) = delete;
+};
+
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_RENDEZVOUS_MGR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/rendezvous_util.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/rendezvous_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..fe95dc0ef57c85972949c85fd2072e0f72d9ee6f
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/rendezvous_util.h
@@ -0,0 +1,54 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_RENDEZVOUS_UTIL_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_RENDEZVOUS_UTIL_H_
+
+#include <map>
+
+#include "tensorflow/core/framework/rendezvous.h"
+#include "tensorflow/core/lib/core/status.h"
+
+namespace tensorflow {
+
+typedef std::map<string, Tensor> NamedTensors;
+typedef std::function<void(const Status&)> StatusCallback;
+
+// Uses `rendezvous` to send tensors in `tensors_to_send`. `device_context`
+// should be the DeviceContext associated with the source of the tensors.
+// `alloc_attrs` contains information about how the `tensors_to_send` are
+// allocated. `alloc_attrs` should either be {} or should match the length of
+// `keys`.
+Status SendTensorsToRendezvous(
+    RendezvousInterface* rendezvous, DeviceContext* device_context,
+    const std::vector<AllocatorAttributes>& alloc_attrs,
+    const std::vector<string>& keys, gtl::ArraySlice<Tensor> tensors_to_send);
+
+// Uses `rendezvous` to obtain tensors. `device_context` should be the
+// DeviceContext associated with the receiving device. `alloc_attrs` contains
+// information as how to store the received tensors. Should be {} or match the
+// length of `keys`.
+void RecvOutputsFromRendezvousAsync(
+    RendezvousInterface* rendezvous, DeviceContext* device_context,
+    const std::vector<AllocatorAttributes>& alloc_attrs,
+    const std::vector<string>& keys, std::vector<Tensor>* received_tensors,
+    StatusCallback done);
+
+Status RecvOutputsFromRendezvous(RendezvousInterface* rendezvous,
+                                 NamedTensors* out,
+                                 const Rendezvous::Args& args);
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_RENDEZVOUS_UTIL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/replicate_constants_pass.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/replicate_constants_pass.h
new file mode 100644
index 0000000000000000000000000000000000000000..b7b2f0fe98c0d205c0c8bbf90cb652bdf0c40fa0
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/replicate_constants_pass.h
@@ -0,0 +1,50 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_REPLICATE_CONSTANTS_PASS_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_REPLICATE_CONSTANTS_PASS_H_
+
+#include "tensorflow/core/common_runtime/optimization_registry.h"
+
+// Small constants are replicated to the hosts of their successors. This pass
+// only applies when there are multiple successors.
+//
+// For example, the graph:
+//   C -> {Op0, Op1, Op2, Op3}
+//   C's assigned_device is /job:tpu_host_worker/replica:0/task:0/device:CPU:0
+//   Op0's assigned_device is /job:tpu_host_worker/replica:0/task:0/device:TPU:0
+//   Op1's assigned_device is /job:tpu_host_worker/replica:0/task:0/device:TPU:1
+//   Op2's assigned_device is /job:tpu_host_worker/replica:0/task:1/device:TPU:0
+//   Op3's assigned_device is /job:tpu_host_worker/replica:0/task:1/device:TPU:1
+// is rewritten to:
+//   C0 -> {Op0, Op1}
+//   C1 -> {Op2, Op3}
+//   C0's assigned_device is /job:tpu_host_worker/replica:0/task:0/device:CPU:0
+//   C1's assigned_device is /job:tpu_host_worker/replica:0/task:1/device:CPU:0
+//   Op0's assigned_device is /job:tpu_host_worker/replica:0/task:0/device:TPU:0
+//   Op1's assigned_device is /job:tpu_host_worker/replica:0/task:0/device:TPU:1
+//   Op2's assigned_device is /job:tpu_host_worker/replica:0/task:1/device:TPU:0
+//   Op3's assigned_device is /job:tpu_host_worker/replica:0/task:1/device:TPU:1
+
+namespace tensorflow {
+
+class ReplicateConstantsPass : public GraphOptimizationPass {
+ public:
+  Status Run(const GraphOptimizationPassOptions& options) override;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_REPLICATE_CONSTANTS_PASS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/replicate_per_replica_nodes.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/replicate_per_replica_nodes.h
new file mode 100644
index 0000000000000000000000000000000000000000..fd696db4905e9af6bdc682cf5b77ab25bf0792c1
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/replicate_per_replica_nodes.h
@@ -0,0 +1,44 @@
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_REPLICATE_PER_REPLICA_NODES_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_REPLICATE_PER_REPLICA_NODES_H_
+
+#include "absl/container/flat_hash_map.h"
+#include "tensorflow/core/graph/graph.h"
+#include "tensorflow/core/lib/core/status.h"
+
+namespace tensorflow {
+
+// `composite_device` maps from a virtual device to a set of devices.
+// In a function graph, for each node assigned to a composite device
+// (representing N devices), replace it with N replicated nodes (one per
+// device).
+// REQUIREMENTS:
+// 1) Each node has been assigned to a device (including composite device).
+// 2) Each cluster of nodes assigned to a composite device should include at
+// least one "_Arg" node.
+// composite device.
+// 3) Clusters assigned to different composite devices should have no data
+// dependency.
+// TODO(b/145922293): Register it as a POST_REWRITE_FOR_EXEC pass.
+Status ReplicatePerReplicaNodesInFunctionGraph(
+    const absl::flat_hash_map<string, const std::vector<string>*>&
+        composite_devices,
+    Graph* graph);
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_REPLICATE_PER_REPLICA_NODES_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/request_cost.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/request_cost.h
new file mode 100644
index 0000000000000000000000000000000000000000..c67827014663eb3a66376cfa21efe22515b49bb4
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/request_cost.h
@@ -0,0 +1,78 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_REQUEST_COST_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_REQUEST_COST_H_
+
+#include <cstdint>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "absl/base/thread_annotations.h"
+#include "absl/container/flat_hash_map.h"
+#include "absl/strings/string_view.h"
+#include "absl/synchronization/mutex.h"
+#include "absl/time/time.h"
+
+namespace tensorflow {
+
+// RequestCost collects the costs and metrics for processing an rpc request.
+class RequestCost {
+ public:
+  // Records costs. The inputs should be pairs of cost type and cost.
+  // It's thread-safe, and can be called from different threads.
+  void RecordCost(
+      const std::vector<std::pair<absl::string_view, absl::Duration>>& costs);
+
+  // Gets all types of costs for processing an rpc request.
+  // It's thread-safe. It's expected to be called at the end of processing an
+  // rpc request, when all the costs have been collected.
+  absl::flat_hash_map<std::string, absl::Duration> GetCosts() const;
+
+  // Metrics of each batch that processes this rpc request.
+  struct BatchMetrics {
+    // Size of the batch.
+    int64_t processed_size = 0;
+    // In this batch, input size from this rpc request.
+    int64_t input_size = 0;
+    // In this batch, the padding amount.
+    int64_t padding_size = 0;
+  };
+
+  // Records the metrics of a batch.
+  // It's thread-safe, and can be called from different threads. It may be
+  // called multiple times if a request is processed by more than one batches.
+  void RecordBatchMetrics(const BatchMetrics& batch_metrics);
+
+  // Get metrics of all the batches that process this rpc request.
+  // It's thread-safe. It's expected to be called at the end of processing an
+  // rpc request, when all batch processing has completed.
+  std::vector<BatchMetrics> GetBatchMetrics() const;
+
+ private:
+  mutable absl::Mutex mutex_;
+
+  // Query costs. Map from cost type to cost.
+  absl::flat_hash_map<std::string, absl::Duration> cost_map_
+      ABSL_GUARDED_BY(mutex_);
+
+  // Metrics of batches that process this rpc request.
+  std::vector<BatchMetrics> batch_metrics_ ABSL_GUARDED_BY(mutex_);
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_REQUEST_COST_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/request_cost_accessor.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/request_cost_accessor.h
new file mode 100644
index 0000000000000000000000000000000000000000..ba64da4b296a7b94fd6239da6ed435baf3a49734
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/request_cost_accessor.h
@@ -0,0 +1,37 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_REQUEST_COST_ACCESSOR_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_REQUEST_COST_ACCESSOR_H_
+
+#include <string>
+
+#include "absl/container/flat_hash_map.h"
+#include "absl/time/time.h"
+#include "tensorflow/core/common_runtime/request_cost.h"
+
+namespace tensorflow {
+
+// An interface for accessing the RequestCost associated with the current rpc
+// request.
+class RequestCostAccessor {
+ public:
+  virtual ~RequestCostAccessor() {}
+  virtual RequestCost* GetRequestCost() const = 0;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_REQUEST_COST_ACCESSOR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/request_cost_accessor_registry.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/request_cost_accessor_registry.h
new file mode 100644
index 0000000000000000000000000000000000000000..6e91678f8ae136a309ad88a41cfa79ea09eda32e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/request_cost_accessor_registry.h
@@ -0,0 +1,71 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_REQUEST_COST_ACCESSOR_REGISTRY_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_REQUEST_COST_ACCESSOR_REGISTRY_H_
+
+#include <functional>
+#include <memory>
+#include <string>
+
+#include "absl/memory/memory.h"
+#include "absl/strings/string_view.h"
+#include "tensorflow/core/common_runtime/request_cost_accessor.h"
+
+namespace tensorflow {
+
+// TODO(b/185852990): Create a template Registry that allows registering
+// different types (e.g  RequestCostAccessor, CostMeasurement).
+//
+// RequestCostAccessorRegistry allows to
+// - register a RequestCostAccessor type to the global map
+// - create an instance of registered RequestCostAccessor.
+class RequestCostAccessorRegistry {
+ public:
+  // Creates an instance of registered RequestCostAccessor by name. If the named
+  // RequestCostAccessor is not registered yet, returns nullptr.
+  static std::unique_ptr<RequestCostAccessor> CreateByNameOrNull(
+      absl::string_view name);
+
+  using Creator = std::function<std::unique_ptr<RequestCostAccessor>()>;
+
+  // Registers a RequestCostAccessor type to the global map. Registering
+  // different types of RequestCostAccessor with the same name is prohibited.
+  static void RegisterRequestCostAccessor(absl::string_view name,
+                                          Creator creator);
+};
+
+// Registers a RequestCostAccessor type to the global map. Registering different
+// types of RequestCostAccessor with the same name is prohibited.
+class RequestCostAccessorRegistrar {
+ public:
+  explicit RequestCostAccessorRegistrar(
+      absl::string_view name, RequestCostAccessorRegistry::Creator creator) {
+    RequestCostAccessorRegistry::RegisterRequestCostAccessor(
+        name, std::move(creator));
+  }
+};
+
+#define REGISTER_REQUEST_COST_ACCESSOR(name, MyRequestCostAccessorClass) \
+  namespace {                                                            \
+  static ::tensorflow::RequestCostAccessorRegistrar                      \
+      MyRequestCostAccessorClass##_registrar((name), [] {                \
+        return std::make_unique<MyRequestCostAccessorClass>();          \
+      });                                                                \
+  }  // namespace
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_REQUEST_COST_ACCESSOR_REGISTRY_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/ring_alg.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/ring_alg.h
new file mode 100644
index 0000000000000000000000000000000000000000..a5d5f2931d81f3ac1377d096a8d4eeeceef782f8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/ring_alg.h
@@ -0,0 +1,120 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_RING_ALG_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_RING_ALG_H_
+
+#include <deque>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "tensorflow/core/common_runtime/base_collective_executor.h"
+#include "tensorflow/core/framework/collective.h"
+
+namespace tensorflow {
+class Device;
+
+// Basic ring-algorithm implementation to be further specialized
+// for specific collective functions.
+class RingAlg : public CollectiveImplementationInterface {
+ public:
+  explicit RingAlg(CollectiveType type, const string& name);
+  ~RingAlg() override {}
+
+  // Establishes the requested number of subdivision permutations based on the
+  // ring order implicit in the device order.
+  Status InitializeCollectiveParams(CollectiveParams* col_params) override;
+
+  // Initializes members of CollectiveContext not yet initialized, i.e. device
+  // and device_locality.  Also saves the CollectiveContext in this object.
+  Status InitializeCollectiveContext(
+      std::shared_ptr<CollectiveContext> col_ctx) override;
+
+ protected:
+  // Called when a bad status is received that implies we should terminate
+  // execution and return a bad status.
+  void StartAbort(const Status& s);
+  void Finish(bool ok);
+
+  // Current status of a RingField
+  enum RingFieldAction {
+    RF_INIT = 0,    // Just initialized for a pass
+    RF_RECV,        // Recv pending
+    RF_REDUCE,      // Reduce pending
+    RF_FINALIZE,    // FinalOp pending
+    RF_SEND_READY,  // Ready to send
+    RF_SEND,        // Send pending
+    RF_DONE,        // No more work
+  };
+
+  // Tracks progress of actions on a single subfield of the entire tensor.
+  struct RingField {
+    int16 chunk_idx;     // major division index
+    int16 subdiv_idx;    // minor division index
+    int16 sc_idx;        // subchunk index
+    int16 rank;          // rank within subdiv permutation
+    int16 recv_dev_idx;  // dev from which value should be recv'd
+    RingFieldAction action;
+    bool second_pass;
+    bool recv_is_remote = false;
+    bool send_is_remote = false;
+    bool do_send = false;   // is the value sent in this pass?
+    bool do_recv = false;   // is the value recv'd in this pass?
+    bool is_final = false;  // is the last field in the pass for this rank
+    Tensor chunk;           // alias to field values
+    Tensor tmp_chunk;
+    Status status;
+    string DebugString() const;
+  };
+  virtual void InitRingField(RingField* rf, int chunk_idx, int subdiv_idx,
+                             int field_idx);
+  void AdvanceToSecondPass(RingField* rf);
+  void DispatchSend(RingField* rf, const StatusCallback& done);
+  void DispatchRecv(RingField* rf, const StatusCallback& done);
+
+  // For constructing log messages for debugging.
+  string FieldState();
+  string TensorDebugString(const Tensor& tensor);
+
+  // Producer/Consumer Queue of RingField structs.
+  class PCQueue {
+   public:
+    void Enqueue(RingField* rf);
+    RingField* Dequeue();
+
+   private:
+    mutex pcq_mu_;
+    condition_variable cv_;
+    int waiter_count_ TF_GUARDED_BY(pcq_mu_) = 0;
+    std::deque<RingField*> deque_ TF_GUARDED_BY(pcq_mu_);
+  };
+
+  const CollectiveType type_;
+  const string name_;
+  std::shared_ptr<CollectiveContext> col_ctx_;
+  const CollectiveParams* col_params_;  // Not owned
+  StatusCallback done_;
+  int group_size_;
+  int num_subdivs_;
+  Tensor group_size_tensor_;
+  Notification group_size_tensor_ready_;
+  std::unique_ptr<CollectiveAdapter> ca_;
+  mutex status_mu_;
+  Status status_ TF_GUARDED_BY(status_mu_);
+  std::vector<RingField> rfv_;
+};
+
+}  // namespace tensorflow
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_RING_ALG_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/ring_gatherer.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/ring_gatherer.h
new file mode 100644
index 0000000000000000000000000000000000000000..ee9634834d2b6c9d986cfb1841ae03c51e22564b
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/ring_gatherer.h
@@ -0,0 +1,51 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_RING_GATHERER_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_RING_GATHERER_H_
+
+#include <deque>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "tensorflow/core/common_runtime/base_collective_executor.h"
+#include "tensorflow/core/common_runtime/ring_alg.h"
+#include "tensorflow/core/framework/collective.h"
+
+namespace tensorflow {
+class Device;
+
+// Ring-algorithm implementation of collective all-gather.
+class RingGatherer : public RingAlg {
+ public:
+  RingGatherer() : RingAlg(GATHER_COLLECTIVE, "Gather") {}
+  ~RingGatherer() override {}
+
+  Status InitializeCollectiveParams(CollectiveParams* col_params) override;
+
+  // Begins async execution of the ring gather algorithm.
+  // Must be called in a blockable thread.
+  // TODO(b/80529858): remove the previous warning when we have a dedicated
+  // collective threadpool.
+  void Run(StatusCallback done) override;
+
+ private:
+  bool RunAsyncParts();
+
+  friend class RingGathererTest;
+};
+
+}  // namespace tensorflow
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_RING_GATHERER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/ring_reducer.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/ring_reducer.h
new file mode 100644
index 0000000000000000000000000000000000000000..e7b869398bf7faaa6d418fe158ccef3c5218556e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/ring_reducer.h
@@ -0,0 +1,60 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_RING_REDUCER_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_RING_REDUCER_H_
+
+#include <deque>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "tensorflow/core/common_runtime/base_collective_executor.h"
+#include "tensorflow/core/common_runtime/ring_alg.h"
+#include "tensorflow/core/framework/collective.h"
+
+namespace tensorflow {
+class Device;
+
+// Ring-algorithm implementation of collective all-reduce.
+class RingReducer : public RingAlg {
+ public:
+  RingReducer() : RingAlg(REDUCTION_COLLECTIVE, "Reduce") {}
+  ~RingReducer() override;
+
+  // Begins async execution of the ring reduce algorithm.
+  // Must be called in a blockable thread.
+  // TODO(b/80529858): remove the previous warning when we have a dedicated
+  // collective threadpool.
+  void Run(StatusCallback done) override;
+
+  Status InitializeCollectiveParams(CollectiveParams* col_params) override;
+
+ protected:
+  void InitRingField(RingField* rf, int chunk_idx, int subdiv_idx,
+                     int field_idx) override;
+
+ private:
+  void ContinueAfterInputCopy();
+  bool RunAsyncParts();
+
+  Tensor group_size_tensor_;
+  Notification group_size_tensor_ready_;
+
+  friend class RingReducerTest;
+  friend class RingReducerInitParamsTest;
+};
+
+}  // namespace tensorflow
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_RING_REDUCER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/scoped_allocator.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/scoped_allocator.h
new file mode 100644
index 0000000000000000000000000000000000000000..15e581024c9cd85c806ae5570fb82e0cfded11e1
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/scoped_allocator.h
@@ -0,0 +1,127 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_SCOPED_ALLOCATOR_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_SCOPED_ALLOCATOR_H_
+
+#include "tensorflow/core/framework/allocator.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/lib/core/refcount.h"
+#include "tensorflow/core/platform/mutex.h"
+
+namespace tensorflow {
+class ScopedAllocatorContainer;
+class ScopedAllocatorInstance;
+
+// Manages a single backing tensor and a collection of aliases.
+class ScopedAllocator {
+ public:
+  static constexpr int32_t kInvalidId = 0;
+  static constexpr size_t kMaxAlignment = 64;
+
+  // A subrange of the TensorBuffer associated with this object that
+  // will be the backing memory for one aliased tensor.
+  struct Field {
+    int32 scope_id;
+    size_t offset;
+    size_t bytes_requested;
+    size_t bytes_allocated;
+  };
+  // Field index that refers to backing tensor, not any aliased field.
+  static constexpr int32_t kBackingIndex = -1;
+
+  // backing_tensor is expected to be newly allocated by a ScopedAllocatorOp
+  // instance.  It must be large enough to back all of the specified
+  // (offset, byte) ranges of the fields.
+  ScopedAllocator(const Tensor& backing_tensor, int32_t scope_id,
+                  const std::string& name, const gtl::ArraySlice<Field> fields,
+                  int32_t expected_call_count,
+                  ScopedAllocatorContainer* container);
+
+  // Automatically deletes when last use expires, or when
+  // ScopedAllocatorContainer decides to delete.
+  ~ScopedAllocator() TF_LOCKS_EXCLUDED(mu_);
+
+  // For debugging: returns true iff p is a pointer that could have
+  // been returned by AllocateRaw.
+  bool VerifyPointer(const void* p);
+  bool VerifyTensor(const Tensor* t);
+
+  const Tensor& tensor() const { return backing_tensor_; }
+
+  const std::string& name() const { return name_; }
+
+ private:
+  friend class ScopedAllocatorInstance;
+  // Only ScopedAllocatorInstances can call AllocateRaw and DeallocateRaw on a
+  // ScopedAllocator
+  void* AllocateRaw(int32_t field_index, size_t num_bytes)
+      TF_LOCKS_EXCLUDED(mu_);
+  void DeallocateRaw(void* p) TF_LOCKS_EXCLUDED(mu_);
+  Tensor backing_tensor_;
+  TensorBuffer* tbuf_;
+  int32 id_;
+  std::string name_;
+  ScopedAllocatorContainer* container_;
+  std::vector<Field> fields_;
+  mutex mu_;
+  int32 expected_call_count_ TF_GUARDED_BY(mu_);
+  int32 live_alloc_count_ TF_GUARDED_BY(mu_);
+};
+
+// An Allocator that will return a pointer into the backing buffer of
+// a previously allocated tensor, allowing creation of an alias
+// tensor.  There is a one-to-one mapping between the fields of a
+// ScopedAllocator and ScopedAllocatorInstances.  There is also a one-to-one
+// mapping between scope_ids and ScopedAllocatorInstances.  It should be
+// discarded immediately after a single use.
+class ScopedAllocatorInstance : public Allocator {
+ public:
+  explicit ScopedAllocatorInstance(ScopedAllocator* sa, int32_t field_index);
+
+ private:
+  ~ScopedAllocatorInstance() override {
+    VLOG(1) << "~ScopedAllocatorInstance " << this;
+  }
+
+ public:
+  // When a ScopedAllocatorContainer "Drops" a scope_id, it calls DropFromTable
+  // on the underlying ScopedAllocatorInstance.  If this instance has already
+  // deallocated the tensor slice, we can safely delete this.
+  void DropFromTable() TF_LOCKS_EXCLUDED(mu_);
+  void* AllocateRaw(size_t alignment, size_t num_bytes)
+      TF_LOCKS_EXCLUDED(mu_) override;
+  void* AllocateRaw(size_t alignment, size_t num_bytes,
+                    const AllocationAttributes& allocator_attr) override {
+    return AllocateRaw(alignment, num_bytes);
+  }
+  void DeallocateRaw(void* p) TF_LOCKS_EXCLUDED(mu_) override;
+  bool TracksAllocationSizes() const override { return false; }
+  size_t RequestedSize(const void* ptr) const override { return 0; }
+  size_t AllocatedSize(const void* ptr) const override { return 0; }
+  int64_t AllocationId(const void* ptr) const override { return 0; }
+  size_t AllocatedSizeSlow(const void* ptr) const override { return 0; }
+  std::string Name() override;
+
+ private:
+  mutex mu_;
+  ScopedAllocator* scoped_allocator_;
+  int32 field_index_;
+  bool allocated_ TF_GUARDED_BY(mu_);
+  bool deallocated_ TF_GUARDED_BY(mu_);
+  bool in_table_ TF_GUARDED_BY(mu_);
+};
+
+}  // namespace tensorflow
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_SCOPED_ALLOCATOR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/scoped_allocator_mgr.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/scoped_allocator_mgr.h
new file mode 100644
index 0000000000000000000000000000000000000000..b8e5dcb15649fc77a94e43e1122557b9ff71d433
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/scoped_allocator_mgr.h
@@ -0,0 +1,111 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_SCOPED_ALLOCATOR_MGR_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_SCOPED_ALLOCATOR_MGR_H_
+
+#include <string>
+#include <unordered_map>
+
+#include "tensorflow/core/common_runtime/scoped_allocator.h"
+#include "tensorflow/core/lib/core/refcount.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/platform/mutex.h"
+
+namespace tensorflow {
+class ScopedAllocatorMgr;
+
+// At most one of these exists per <device, step_id> pair.
+// A Ref is held by every ScopedAllocator and also by the ScopedAllocatorMgr.
+class ScopedAllocatorContainer : public core::RefCounted {
+ public:
+  // Establishes a reachable ScopedAllocator.
+  Status AddScopedAllocator(
+      const Tensor& backing_tensor, int32_t scope_id,
+      const std::string& scope_name,
+      const gtl::ArraySlice<ScopedAllocator::Field>& fields,
+      int32_t expected_call_count);
+
+  ScopedAllocatorInstance* GetInstance(int32_t scope_id);
+  ScopedAllocator* GetAllocator(int32_t scope_id);
+
+  // Retire the scope_id.
+  void Drop(int32_t scope_id, ScopedAllocator* sa);
+
+ protected:
+  friend class ScopedAllocatorMgr;
+  ScopedAllocatorContainer(const ScopedAllocatorMgr* mgr, int64_t step_id)
+      : mgr_(mgr), step_id_(step_id) {}
+  ~ScopedAllocatorContainer();
+
+ private:
+  const ScopedAllocatorMgr* mgr_;
+  int64_t step_id_;
+  mutex mu_;
+  struct SAField {
+    int32 field_index;
+    union {
+      ScopedAllocator* scoped_allocator;
+      ScopedAllocatorInstance* instance;
+    };
+    SAField(int32_t fi, ScopedAllocatorInstance* sai)
+        : field_index(fi), instance(sai) {}
+    SAField(int32_t fi, ScopedAllocator* sa)
+        : field_index(fi), scoped_allocator(sa) {}
+    SAField()
+        : field_index(ScopedAllocator::kBackingIndex),
+          scoped_allocator(nullptr) {}
+  };
+  std::unordered_map<int32, SAField> allocators_ TF_GUARDED_BY(mu_);
+};
+
+// At most one of these exists per device.
+class ScopedAllocatorMgr {
+ public:
+  explicit ScopedAllocatorMgr(const std::string& device_name)
+      : device_name_(device_name) {}
+  ~ScopedAllocatorMgr();
+
+  ScopedAllocatorContainer* GetContainer(int64_t step_id);
+
+  // Establishes a reachable ScopedAllocator.
+  Status AddScopedAllocator(
+      const Tensor& backing_tensor, int64_t step_id, int32_t scope_id,
+      const std::string& scope_name,
+      const gtl::ArraySlice<ScopedAllocator::Field>& fields,
+      int32_t expected_call_count);
+
+  void Cleanup(int64_t step_id);
+
+  // Populate the bytes and offset members of Field.  Instance allocaters get
+  // consecutive scope_id values following that of the base ScopedAllocator.
+  // Returns the total number of bytes required to be allocated in the
+  // backing tensor, for convenience.  (The same value can be obtained
+  // by summing offset and bytes in the last field.)
+  static size_t PopulateFields(int32_t scope_id,
+                               const gtl::ArraySlice<TensorShape>& shapes,
+                               const DataType dtype,
+                               std::vector<ScopedAllocator::Field>* fields);
+
+  const std::string& device_name() const { return device_name_; }
+
+ private:
+  std::string device_name_;
+  mutex mu_;
+  std::unordered_map<int64_t, ScopedAllocatorContainer*> per_step_map_
+      TF_GUARDED_BY(mu_);
+};
+
+}  // namespace tensorflow
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_SCOPED_ALLOCATOR_MGR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/session_factory.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/session_factory.h
new file mode 100644
index 0000000000000000000000000000000000000000..8976abd1a818d94892689dbf78b580ea1e6536ef
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/session_factory.h
@@ -0,0 +1,76 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_SESSION_FACTORY_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_SESSION_FACTORY_H_
+
+#include <string>
+
+#include "tensorflow/core/lib/core/errors.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/lib/gtl/array_slice.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+
+class Session;
+struct SessionOptions;
+
+class SessionFactory {
+ public:
+  // Creates a new session and stores it in *out_session, or fails with an error
+  // status if the Session could not be created. Caller takes ownership of
+  // *out_session if this returns OkStatus().
+  virtual Status NewSession(const SessionOptions& options,
+                            Session** out_session) = 0;
+
+  virtual bool AcceptsOptions(const SessionOptions& options) = 0;
+
+  // Abort and close all existing sessions, disconnecting their resources from
+  // future sessions.
+  //
+  // Reset() allows misbehaving or slow sessions to be aborted and closed, and
+  // causes their resources eventually to be released.  Reset() does not wait
+  // for the computations in old sessions to cease; it merely starts the
+  // process of tearing them down.  However, if a new session is started after
+  // a Reset(), the new session is isolated from changes that old sessions
+  // (started prior to the Reset()) may continue to make to resources, provided
+  // all those resources are in containers listed in "containers".
+  //
+  // Old sessions may continue to have side-effects on resources not in
+  // containers listed in "containers", and thus may affect future
+  // sessions' results in ways that are hard to predict.  Thus, if well-defined
+  // behavior is desired, is it recommended that all containers be listed in
+  // "containers".
+  //
+  // If the "containers" vector is empty, the default container is assumed.
+  // If the "containers" vector is non-empty, the default container should be
+  // listed explicitly.
+  //
+  // Sessions that support resource containers should override this function.
+  virtual Status Reset(const SessionOptions& options,
+                       const std::vector<string>& containers) {
+    return errors::Unimplemented("Reset()");
+  }
+
+  virtual ~SessionFactory() {}
+  static void Register(const string& runtime_type, SessionFactory* factory);
+  static Status GetFactory(const SessionOptions& options,
+                           SessionFactory** out_factory);
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_SESSION_FACTORY_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/shape_refiner.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/shape_refiner.h
new file mode 100644
index 0000000000000000000000000000000000000000..29ade55ea9b417d0f3c793bff539bf52445382af
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/shape_refiner.h
@@ -0,0 +1,336 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_SHAPE_REFINER_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_SHAPE_REFINER_H_
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "absl/container/flat_hash_map.h"
+#include "tensorflow/core/common_runtime/graph_runner.h"
+#include "tensorflow/core/framework/function.pb.h"
+#include "tensorflow/core/framework/shape_inference.h"
+#include "tensorflow/core/graph/graph.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/platform/macros.h"
+
+namespace tensorflow {
+namespace grappler {
+class GraphProperties;
+}
+
+// This class stores extra inference information in addition to
+// InferenceContext, such as node input and output types.
+class ExtendedInferenceContext {
+ public:
+  ExtendedInferenceContext(
+      std::unique_ptr<shape_inference::InferenceContext> ic, const Node* node)
+      : inference_context_(std::move(ic)), op_(node->name()) {
+    input_types_.reserve(node->num_inputs());
+    for (int i = 0; i < node->num_inputs(); i++) {
+      input_types_.push_back(node->input_type(i));
+    }
+    output_types_.reserve(node->num_outputs());
+    for (int i = 0; i < node->num_outputs(); i++) {
+      output_types_.push_back(node->output_type(i));
+    }
+  }
+
+  DataType input_type(int64_t idx) const { return input_types_[idx]; }
+  DataType output_type(int64_t idx) const { return output_types_[idx]; }
+
+  shape_inference::InferenceContext* get_context() {
+    return inference_context_.get();
+  }
+
+  std::string op() const { return op_; }
+
+ private:
+  std::unique_ptr<shape_inference::InferenceContext> inference_context_;
+  std::string op_;
+  std::vector<DataType> input_types_;
+  std::vector<DataType> output_types_;
+
+  ExtendedInferenceContext(const ExtendedInferenceContext&) = delete;
+  void operator=(const ExtendedInferenceContext&) = delete;
+};
+
+// ShapeRefiner performs shape inference for TensorFlow Graphs.  It is
+// responsible for instantiating InferenceContext objects for each
+// Node in the Graph, and providing/storing the 'input_tensor' Tensors
+// used by Shape Inference functions, when available at graph
+// construction time.
+class ShapeRefiner {
+ public:
+  ShapeRefiner(int graph_def_version, const OpRegistryInterface* ops);
+
+  // Same as ShapeRefiner(versions.producer(), ops)
+  ShapeRefiner(const VersionDef& versions, const OpRegistryInterface* ops);
+
+  ~ShapeRefiner();
+
+  // Performs validation of 'node' and runs 'node's shape function,
+  // storing its shape outputs.
+  //
+  // All inputs of 'node' must be added to ShapeRefiner prior to
+  // adding 'node'.
+  //
+  // Returns an error if:
+  //  - the shape function for 'node' was not registered.
+  //  - 'node' was added before its inputs.
+  //  - The shape inference function returns an error.
+  Status AddNode(const Node* node);
+
+  // Sets 'node's 'output_port' output to have shape 'shape'.
+  //
+  // Returns an error if 'node' was not previously added to this
+  // object, if 'output_port' is invalid, or if 'shape' is
+  // not compatible with the existing shape of the output.
+  Status SetShape(const Node* node, int output_port,
+                  shape_inference::ShapeHandle shape);
+
+  // Update the input shapes of node in case the shapes of the fan-ins of 'node'
+  // have themselves been modified (For example, in case of incremental shape
+  // refinement). If 'relax' is true, a new shape with the broadest set of
+  // information will be set as the new input (see InferenceContext::RelaxInput
+  // for full details and examples). Sets refined to true if any shapes have
+  // changed (in their string representations). Note that shapes may have been
+  // updated to newer versions (but with identical string representations) even
+  // if <*refined> is set to false.
+  Status UpdateNode(const Node* node, bool relax, bool* refined);
+
+  // Returns the InferenceContext for 'node', if present.
+  shape_inference::InferenceContext* GetContext(const Node* node) const {
+    auto it = node_to_context_.find(node);
+    if (it == node_to_context_.end()) {
+      return nullptr;
+    }
+    return it->second->get_context();
+  }
+
+  // Returns the ExtendedInferenceContext for 'node', if present.
+  ExtendedInferenceContext* GetExtendedContext(const Node* node) const {
+    auto it = node_to_context_.find(node);
+    if (it == node_to_context_.end()) {
+      return nullptr;
+    }
+    return it->second.get();
+  }
+
+  // Getters and setters for graph_def_version_.
+  int32 graph_def_version() const { return graph_def_version_; }
+  void set_graph_def_version(int32_t version) { graph_def_version_ = version; }
+
+  void set_require_shape_inference_fns(bool require_shape_inference_fns) {
+    require_shape_inference_fns_ = require_shape_inference_fns;
+  }
+  void set_disable_constant_propagation(bool disable) {
+    disable_constant_propagation_ = disable;
+  }
+
+  // Set function library to enable function shape inference.
+  // Without function library, function inference always yields unknown shapes.
+  // With this enabled, shape inference can take more time since it descends
+  // into all function calls. It doesn't do inference once for each function
+  // definition, but once for each function call.
+  // The function library must outlive the shape refiner.
+  void set_function_library_for_shape_inference(
+      const tensorflow::FunctionLibraryDefinition* lib) {
+    function_library_ = lib;
+  }
+
+  bool function_shape_inference_supported() const {
+    return function_library_ != nullptr;
+  }
+
+ private:
+  friend class ShapeRefinerTest;
+  friend class ::tensorflow::grappler::GraphProperties;
+
+  // Returns true if the ranks and all dimensions of <s0> and <s1> are either
+  // equal in value or both unknown.
+  static bool SameDefinedShape(shape_inference::InferenceContext* c,
+                               shape_inference::ShapeHandle s0,
+                               shape_inference::ShapeHandle s1);
+
+  // Returns true if the shapes and types stored in <*existing> are identical in
+  // value to the shapes and types in <*updated>.
+  static bool IsUpdatedShapesOrTypes(
+      shape_inference::InferenceContext* c,
+      const std::vector<shape_inference::ShapeAndType>& existing,
+      const std::vector<shape_inference::ShapeAndType>& updated);
+
+  // Performs shape inference for the given function_def within the
+  // given outer_context. Internally it instantiates the function as a graph
+  // and runs shape inference recursively on it with the input shapes provided
+  // by the outer_context.
+  //
+  // Returns an error if:
+  // - number of inputs/outputs on outer_context doesn't match the function_def
+  //
+  // On success:
+  // - outer_context will contain output shapes inferred from input shapes
+  Status InferShapesForFunction(
+      const FunctionDef* function_def, AttrSlice attributes,
+      shape_inference::InferenceContext* outer_context);
+
+  // Performs shape inference for a node inside a function.
+  //
+  // 'outer_context' is the 'InferenceContext' for the function's call op.
+  Status InferShapesForFunctionSubNode(
+      const Node* node, shape_inference::InferenceContext* outer_context);
+
+  // Performs validation of 'node' and runs 'node's shape function,
+  // storing its shape outputs.
+  //
+  // All inputs of 'node' must be added to ShapeRefiner prior to
+  // adding 'node'.
+  //
+  // Optionally, if 'node' is in a nested function, the 'InferenceContext' for
+  // the call op of the function can be passed as 'outer_context' (pass nullptr
+  // otherwise). This gets used to perform constant propagation across Arg nodes
+  // by requesting the constant of value of the incoming tensor from the
+  // 'outer_context'.
+  //
+  // Returns an error if:
+  //  - the shape function for 'node' was not registered.
+  //  - 'node' was added before its inputs.
+  //  - The shape inference function returns an error.
+  Status AddNodeInternal(const Node* node,
+                         shape_inference::InferenceContext* outer_context);
+
+  // Attempts to evaluate the 'dst_idx'-th input to 'node'. If the input edge
+  // value can be evaluated, 'evaluated' is set to true and the value returned
+  // in 'result'. Otherwise 'evaluated' is set to false.
+  //
+  // Optionally, if 'node' is in a nested function, the 'InferenceContext' for
+  // the call op of the function can be passed as 'outer_context' (pass nullptr
+  // otherwise). This gets used to perform constant propagation across Arg nodes
+  // by requesting the constant of value of the incoming tensor from the
+  // 'outer_context'.
+  Status EvaluateConstantTensorForEdge(
+      const Node* node, int dst_idx, bool* evaluated, Tensor* result,
+      shape_inference::InferenceContext* outer_context);
+
+  // Wrapper around EvaluateConstantTensorForEdge for scalar int32/int64 input
+  // tensors. The caller is responsible for checking that the specified edge is
+  // scalar and int32 or int64.
+  //
+  // Optionally, if 'node' is in a nested function, the 'InferenceContext' for
+  // the call op of the function can be passed as 'outer_context' (pass nullptr
+  // otherwise). This gets used to perform constant propagation across Arg nodes
+  // by requesting the constant of value of the incoming tensor from the
+  // 'outer_context'.
+  Status EvaluateConstantIntScalarEdge(
+      const Node* node, int dst_idx, bool* evaluated, int64_t* result,
+      shape_inference::InferenceContext* outer_context);
+
+  // This function tries to materialize as much information about the 'node''s
+  // dst_idx input as a statically computable shape, and the result may be
+  // partially known, depending on what is statically inferable.
+  //
+  // This is called when node.input[dst_idx] is a tensor that is used to define
+  // the shape of some other tensor (e.g., the second argument to Reshape is a
+  // <shape> tensor, where each element of the shape tensor is a dimension of
+  // the target tensor).  It returns in <result> a shape for that input.
+  //
+  // Unlike simply resolving node.input[dst_idx] to a constant and then
+  // converting that to a shape, this function can return a partial shape. This
+  // is useful for cases where the shape tensor is only partially defined, such
+  // as with calls for: reshape(x, shape(y)) where shape(y) is partially
+  // defined.
+  //
+  // The implementation has op implementations for ops commonly called on shape
+  // tensors, and the implementations are specialized to shape tensors (namely,
+  // the output is a vector).
+  //
+  // <target_context> is used when creating new DimensionHandle and ShapeHandle
+  // objects.
+  //
+  // Optionally, if 'node' is in a nested function, the 'InferenceContext' for
+  // the call op of the function can be passed as 'outer_context' (pass nullptr
+  // otherwise). This gets used to perform constant propagation across Arg nodes
+  // by requesting the constant of value of the incoming tensor from the
+  // 'outer_context'.
+  Status ConstantPartialShape(shape_inference::InferenceContext* target_context,
+                              const Node* node, int dst_idx,
+                              shape_inference::ShapeHandle* result,
+                              shape_inference::InferenceContext* outer_context);
+
+  // Implementation of ConstantPartialShape for StridedSlice nodes.
+  //
+  // Optionally, if 'node' is in a nested function, the 'InferenceContext' for
+  // the call op of the function can be passed as 'outer_context' (pass nullptr
+  // otherwise). This gets used to perform constant propagation across Arg nodes
+  // by requesting the constant of value of the incoming tensor from the
+  // 'outer_context'.
+  Status PartialStridedSliceShape(
+      Node* slice_node, shape_inference::InferenceContext* ctx,
+      shape_inference::ShapeHandle* result,
+      shape_inference::InferenceContext* outer_context);
+
+  // Runs the shape function registered for the node's op type.
+  //
+  // Optionally, if 'node' is in a nested function, the 'InferenceContext' for
+  // the call op of the function can be passed as 'outer_context' (pass nullptr
+  // otherwise). This gets used to perform constant propagation across Arg nodes
+  // by requesting the constant of value of the incoming tensor from the
+  // 'outer_context'.
+  Status RunShapeFn(const Node* node, const OpRegistrationData* op_reg_data,
+                    ExtendedInferenceContext* ec,
+                    shape_inference::InferenceContext* outer_context = nullptr);
+
+  int32 graph_def_version_;
+  const OpRegistryInterface* const ops_registry_;
+
+  // The lifetime of the tensors are bound to the runner, so it should be the
+  // deleted after the tensors.
+  GraphRunner graph_runner_;
+
+  // Stores a map from a node to its ExtendedInferenceContext.
+  absl::flat_hash_map<const Node*, std::unique_ptr<ExtendedInferenceContext>,
+                      hash<const Node*>>
+      node_to_context_;
+
+  // Holds a cache from tensor id (node id:node output) to the tensor that
+  // is evaluable as a constant expression. This reduces repeated execution
+  // of the entire constant subgraph as a graph is being built up. This could
+  // be changed to some kind of size-based LRU cache to avoid consuming too much
+  // memory, if that eventually becomes a concern.
+  //
+  // Only tensors less than 1KiB are currently stored in the cache.
+  static constexpr int64_t kMaxTensorSize = 1024;
+  absl::flat_hash_map<std::pair<int, int>, Tensor> const_tensor_map_;
+
+  bool require_shape_inference_fns_ = true;
+  bool disable_constant_propagation_ = false;
+
+  // Function library is optional, but has to be set to enable function
+  // shape inference.
+  const tensorflow::FunctionLibraryDefinition* function_library_ = nullptr;
+
+  // Cache the graph corresponding to each function definition for which shapes
+  // are refined.
+  absl::flat_hash_map<std::string, std::unique_ptr<const Graph>> functions_;
+
+  ShapeRefiner(const ShapeRefiner&) = delete;
+  void operator=(const ShapeRefiner&) = delete;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_SHAPE_REFINER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/shared_counter.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/shared_counter.h
new file mode 100644
index 0000000000000000000000000000000000000000..7931dba4661cb96ae6895083cdf7c2ffc9203041
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/shared_counter.h
@@ -0,0 +1,26 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_SHARED_COUNTER_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_SHARED_COUNTER_H_
+
+#include <atomic>
+
+#include "tensorflow/core/platform/types.h"
+#include "tsl/framework/shared_counter.h"
+
+namespace tensorflow {
+using tsl::SharedCounter;  // NOLINT
+}  // namespace tensorflow
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_SHARED_COUNTER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/single_threaded_cpu_device.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/single_threaded_cpu_device.h
new file mode 100644
index 0000000000000000000000000000000000000000..3498e4aa6ea2e684c21003de634414c9339aac06
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/single_threaded_cpu_device.h
@@ -0,0 +1,36 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_SINGLE_THREADED_CPU_DEVICE_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_SINGLE_THREADED_CPU_DEVICE_H_
+
+namespace tsl {
+class Env;
+}  // namespace tsl
+namespace tensorflow {
+using Env = tsl::Env;
+
+class Device;
+
+// Returns a simple single-threaded CPU device. This can be used to run
+// inexpensive computations. In particular, using this avoids initializing the
+// global thread pools in LocalDevice.
+//
+// The returned pointer is owned by the caller.
+Device* NewSingleThreadedCpuDevice(Env* env);
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_SINGLE_THREADED_CPU_DEVICE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/stats_publisher_interface.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/stats_publisher_interface.h
new file mode 100644
index 0000000000000000000000000000000000000000..6f771068101ec7d3a971dca4822a240e46939148
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/stats_publisher_interface.h
@@ -0,0 +1,82 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_STATS_PUBLISHER_INTERFACE_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_STATS_PUBLISHER_INTERFACE_H_
+
+#include <functional>
+#include <memory>
+#include <string>
+
+#include "tensorflow/core/common_runtime/build_graph_options.h"
+#include "tensorflow/core/common_runtime/profile_handler.h"
+#include "tensorflow/core/platform/macros.h"
+#include "tensorflow/core/protobuf/config.pb.h"
+#include "tensorflow/core/public/session_options.h"
+
+namespace tensorflow {
+
+class StatsPublisherInterface;
+
+typedef std::function<std::unique_ptr<StatsPublisherInterface>(
+    const std::string&, const BuildGraphOptions&, const SessionOptions&)>
+    StatsPublisherFactory;
+
+// StatsPublisherInterface describes objects that publish information exported
+// by Sessions.
+// NOTE: This interface is experimental and subject to change.
+// Implementations must be thread-safe.
+class StatsPublisherInterface {
+ public:
+  // PublishStatsProto publishes step_stats.
+  // When PublishStatsProto is called multiple times, only the step_stats
+  // corresponding to the latest call will be published.
+  virtual void PublishStatsProto(const StepStats& step_stats) = 0;
+
+  // PublishGraphProto publishes the graph_defs corresponding to each partition
+  // in the session.
+  // When PublishGraphProto is called multiple times, only the graph_defs
+  // corresponding to the latest call will be published.
+  virtual void PublishGraphProto(
+      const std::vector<const GraphDef*>& graph_defs) = 0;
+  virtual void PublishGraphProto(std::vector<GraphDef> graph_defs) = 0;
+
+  // Returns a profile handler for the given step based on the execution_count
+  // and RunOptions.
+  //
+  // This method may return a null pointer, if no handler was created.
+  virtual std::unique_ptr<ProfileHandler> GetProfileHandler(
+      uint64 step, int64_t execution_count, const RunOptions& ropts) = 0;
+
+  virtual ~StatsPublisherInterface() {}
+
+  static void RegisterStatsPublisher(StatsPublisherFactory factory_fn);
+
+  static StatsPublisherFactory GetStatsPublisherFactory();
+
+ private:
+  static StatsPublisherFactory** GetStatsPublisherFactoryPtr() {
+    static StatsPublisherFactory* stats_publisher_factory = nullptr;
+    return &stats_publisher_factory;
+  }
+};
+
+std::unique_ptr<StatsPublisherInterface> CreateNoOpStatsPublisher(
+    const string& session, const BuildGraphOptions& bopts,
+    const SessionOptions& sopts);
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_STATS_PUBLISHER_INTERFACE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/step_stats_collector.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/step_stats_collector.h
new file mode 100644
index 0000000000000000000000000000000000000000..df1e579f6d89327dc259962d1c8c47c78d06671d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/step_stats_collector.h
@@ -0,0 +1,208 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_STEP_STATS_COLLECTOR_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_STEP_STATS_COLLECTOR_H_
+
+#include <memory>
+#include <unordered_map>
+#include <vector>
+
+#include "tensorflow/core/framework/allocator.h"
+#include "tensorflow/core/framework/step_stats.pb.h"
+#include "tensorflow/core/framework/tracking_allocator.h"
+#include "tensorflow/core/lib/gtl/inlined_vector.h"
+#include "tensorflow/core/platform/env.h"
+#include "tensorflow/core/platform/mutex.h"
+#include "tensorflow/core/platform/thread_annotations.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+
+class AllocatorMemoryUsed;
+class CostModelManager;
+class Graph;
+class NodeDef;
+class NodeExecStats;
+class OpKernelContext;
+class StepStats;
+class StepStatsCollector;
+class Tensor;
+
+// Statistics collection interface for individual node execution.
+//
+// See `NodeExecStatsWrapper` for a concrete implementation of this interface
+// that interfaces with the `Session` layer.
+class NodeExecStatsInterface {
+ public:
+  virtual ~NodeExecStatsInterface() {}
+
+  // Called when the statistics collection for the node has finished. Once this
+  // method is called, the caller should not make assumptions about the validity
+  // of this object.
+  virtual void Done(const string& device) = 0;
+
+  // Called immediately after this node starts being processed by the executor.
+  virtual void RecordExecutorStarted() = 0;
+
+  // Called immediately before this node's `Compute()` or `ComputeAsync()`
+  // method is called.
+  virtual void RecordComputeStarted() = 0;
+
+  // Called immediately after this node's `Compute()` method returned (or, for
+  // asynchronous operations, the callback passed to its `ComputeAsync()` method
+  // was called).
+  virtual void RecordComputeEnded() = 0;
+
+  // Called immediately after this executor finishes processing this node.
+  virtual void RecordExecutorEnded() = 0;
+
+  // Returns `true` if this object should track memory allocations.
+  virtual bool TrackAllocations() const = 0;
+
+  // Records information about the memory allocated during the execution of this
+  // node.
+  //
+  // Takes ownership of any `TrackingAllocator` objects stored in `ctx`.
+  virtual void SetMemory(OpKernelContext* ctx) = 0;
+
+  // Records information about the tensor produced by this node at the given
+  // output slot.
+  virtual void SetOutput(int slot, const Tensor* tensor) = 0;
+
+  // Records the absolute time in nanoseconds at which this node became
+  // runnable (i.e. was scheduled for execution).
+  virtual void SetScheduled(int64_t nanos) = 0;
+};
+
+// Wraps NodeExecStats and adds allocation to it.
+class NodeExecStatsWrapper : public NodeExecStatsInterface {
+ public:
+  // Does not take ownership of `node` or `step_stats_collector`.
+  NodeExecStatsWrapper(const NodeDef* node,
+                       StepStatsCollector* step_stats_collector);
+
+  // Takes ownership of 'stats' but not `node` or `step_stats_collector`.
+  NodeExecStatsWrapper(std::unique_ptr<NodeExecStats> stats,
+                       const NodeDef* node,
+                       StepStatsCollector* step_stats_collector);
+
+  // Destructor calls Finalize() to release the TrackingAllocators.
+  ~NodeExecStatsWrapper() override { Finalize(); }
+
+  void Done(const string& device) override;
+  void RecordExecutorStarted() override;
+  void RecordComputeStarted() override;
+  void RecordComputeEnded() override;
+  void RecordExecutorEnded() override;
+  bool TrackAllocations() const override { return true; }
+  void SetMemory(OpKernelContext* ctx) override;
+  void SetOutput(int slot, const Tensor* tensor) override;
+  void SetScheduled(int64_t nanos) override;
+
+ private:
+  friend class StepStatsCollector;
+
+  NodeExecStats* stats() { return stats_.get(); }
+
+  // Populates stats_ and releases TrackingAllocator.
+  void Finalize();
+
+  // Does not take ownership of the `allocator`.
+  // Takes ownership of `tracking_allocator`.
+  void AddAllocation(Allocator* allocator,
+                     TrackingAllocator* tracking_allocator);
+
+  gtl::InlinedVector<std::pair<AllocatorMemoryUsed*, TrackingAllocator*>, 2>
+      allocations_;
+  std::unique_ptr<NodeExecStats> stats_;
+  const NodeDef* const node_;                       // Not owned.
+  StepStatsCollector* const step_stats_collector_;  // Not owned.
+};
+
+// Statistics collection interface for step execution.
+//
+// See `StepStatsCollector` for a concrete implementation of this interface
+// that interfaces with the `Session` layer.
+class StepStatsCollectorInterface {
+ public:
+  virtual ~StepStatsCollectorInterface() {}
+
+  // Creates an instance of `NodeExecStatsInterface` that should be used for
+  // collecting statistics about individual node execution.
+  virtual NodeExecStatsInterface* CreateNodeExecStats(const NodeDef* node) = 0;
+
+  // Generates a string reporting the currently used memory based
+  // on ResourceExhausted OOM `err` message.
+  // `err` message needs to contain device name and allocator name, e.g.:
+  // "ResourceExhaustedError: OOM when allocating tensor ...
+  // on /job:localhost/replica:0/task:0/device:GPU:0 by allocator GPU_0_bfc"
+  virtual string ReportAllocsOnResourceExhausted(absl::string_view err) = 0;
+};
+
+// StepStatsCollector manages the collection of a StepStats object.
+// The StepStats object holds multiple DeviceStats.
+// Each DeviceStats object holds multiple NodeExecStats.
+class StepStatsCollector : public StepStatsCollectorInterface {
+ public:
+  // Does not take ownership of `step_stats`.
+  explicit StepStatsCollector(StepStats* step_stats);
+
+  // BuildCostModel builds or updates a CostModel managed by cost_model_manager,
+  // using the currently collected DeviceStats associated with the devices in
+  // device_map.
+  void BuildCostModel(
+      CostModelManager* cost_model_manager,
+      const std::unordered_map<string, const Graph*>& device_map);
+
+  // Saves node statistics to the DeviceStats object associated with device.
+  // Should be called before Finalize.
+  void Save(const string& device, NodeExecStats* node_stats_pb);
+  void Save(const string& device, NodeExecStatsWrapper* node_stats);
+
+  // Saves thread name.
+  void SaveThreadName(const string& device, const uint32 thread_id,
+                      const string& thread_name);
+
+  NodeExecStatsInterface* CreateNodeExecStats(const NodeDef* node) override;
+  string ReportAllocsOnResourceExhausted(absl::string_view err) override;
+
+  // The following 2 Finalize methods populate the StepStats passed
+  // from the constructor. Calling it more than once won't have any effect.
+  // User shouldn't call Save() methods after Finalize.
+  void Finalize();
+  // swaps the content of StepStats* from constructor with 'ss'.
+  void FinalizeAndSwap(StepStats* step_stats);
+
+ private:
+  // TODO(suharshs): Make this configurable if its not possible to find a value
+  // that works for all cases.
+  static constexpr uint64 kMaxCollectedNodes = 1 << 20;
+
+  typedef std::vector<std::unique_ptr<NodeExecStatsWrapper>> NodeStatsVector;
+  typedef std::unordered_map<uint32, string> ThreadNamesMap;
+
+  void FinalizeInternal() TF_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+
+  mutex mu_;
+  bool finalized_ TF_GUARDED_BY(mu_);
+  std::unordered_map<string, NodeStatsVector> dev_stats_ TF_GUARDED_BY(mu_);
+  std::unordered_map<string, ThreadNamesMap> thread_names_ TF_GUARDED_BY(mu_);
+  StepStats* step_stats_ TF_GUARDED_BY(mu_);
+  uint64 collected_nodes_ TF_GUARDED_BY(mu_) = 0;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_STEP_STATS_COLLECTOR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/threadpool_device.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/threadpool_device.h
new file mode 100644
index 0000000000000000000000000000000000000000..5ca3deb7247602bfdecc83ac77f23cd4f5f98b8b
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/common_runtime/threadpool_device.h
@@ -0,0 +1,63 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_COMMON_RUNTIME_THREADPOOL_DEVICE_H_
+#define TENSORFLOW_CORE_COMMON_RUNTIME_THREADPOOL_DEVICE_H_
+
+#include "tensorflow/core/common_runtime/device_factory.h"
+#include "tensorflow/core/common_runtime/local_device.h"
+#include "tensorflow/core/common_runtime/node_file_writer.h"
+
+namespace tensorflow {
+
+// CPU device implementation.
+class ThreadPoolDevice : public LocalDevice {
+ public:
+  ThreadPoolDevice(const SessionOptions& options, const string& name,
+                   Bytes memory_limit, const DeviceLocality& locality,
+                   Allocator* allocator);
+  ~ThreadPoolDevice() override;
+
+  Allocator* GetAllocator(AllocatorAttributes attr) override;
+  Allocator* GetScopedAllocator(AllocatorAttributes attr,
+                                int64_t step_id) override;
+  ScopedAllocatorMgr* GetScopedAllocatorMgr() const override {
+    return scoped_allocator_mgr_.get();
+  }
+  Status MakeTensorFromProto(const TensorProto& tensor_proto,
+                             const AllocatorAttributes alloc_attrs,
+                             Tensor* tensor) override;
+  void CopyTensorInSameDevice(const Tensor* input_tensor, Tensor* output_tensor,
+                              const DeviceContext* device_context,
+                              StatusCallback done) override;
+
+  Status Sync() override { return OkStatus(); }
+
+  void Compute(OpKernel* op_kernel, OpKernelContext* context) override;
+  void ComputeAsync(AsyncOpKernel* op_kernel, OpKernelContext* context,
+                    AsyncOpKernel::DoneCallback done) override;
+
+ private:
+  void LogInputs(OpKernel* op_kernel, OpKernelContext* context);
+  void LogOutputs(OpKernel* op_kernel, OpKernelContext* context);
+
+  Allocator* allocator_;  // Not owned
+  std::unique_ptr<ScopedAllocatorMgr> scoped_allocator_mgr_;
+  NodeFileWriter* node_file_writer_ = nullptr;  // not owned
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_COMMON_RUNTIME_THREADPOOL_DEVICE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/config/flag_defs.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/config/flag_defs.h
new file mode 100644
index 0000000000000000000000000000000000000000..14ae3cbf24e7328ec1f03385207b37690f69b77d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/config/flag_defs.h
@@ -0,0 +1,64 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_CONFIG_FLAG_DEFS_H_
+#define TENSORFLOW_CORE_CONFIG_FLAG_DEFS_H_
+
+#include "tensorflow/core/config/flags.h"
+
+namespace tensorflow {
+namespace flags {
+
+class Flags {
+ public:
+  // Test only flags. See flags_test.cc for example usage.
+  TF_DECLARE_FLAG(test_only_experiment_1, true, "Test only experiment 1.");
+  TF_DECLARE_FLAG(test_only_experiment_2, false, "Test only experiment 2.");
+
+  // Declare flags below here.
+  // LINT.IfChange
+  TF_DECLARE_FLAG(enable_nested_function_shape_inference, false,
+                  "Allow ops such as tf.cond to invoke the ShapeRefiner on "
+                  "their nested functions.");
+  TF_DECLARE_FLAG(enable_quantized_dtypes_training, false,
+                  "Set quantized dtypes, like tf.qint8, to be trainable.");
+  TF_DECLARE_FLAG(graph_building_optimization, false,
+                  "Optimize graph building for faster tf.function tracing.");
+  TF_DECLARE_FLAG(
+      op_building_optimization, true,
+      "Optimize tf.Operation building for faster tf.function tracing.");
+  TF_DECLARE_FLAG(saved_model_fingerprinting, true,
+                  "Add fingerprint to SavedModels.");
+  TF_DECLARE_FLAG(
+      tf_shape_default_int64, false,
+      "The default output of tf.shape (i.e. when out_type is not specified) is "
+      "int64 when this flag is true and int32 otherwise. Setting this to true "
+      "is an unsupported, experimental setting that causes known breakages.");
+  TF_DECLARE_FLAG(more_stack_traces, false,
+                  "Enable experimental code that preserves and propagates "
+                  "graph node stack traces in C++.");
+  TF_DECLARE_FLAG(replicate_small_constants, true,
+                  "Enable a graph optimization pass that replicate each small "
+                  "constant to its successors' devices. This can decrease "
+                  "message passing.");
+  // LINT.ThenChange(//tensorflow/core/config/flags_api_wrapper.cc)
+};
+
+Flags& Global();
+
+}  // namespace flags
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_CONFIG_FLAG_DEFS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/config/flags.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/config/flags.h
new file mode 100644
index 0000000000000000000000000000000000000000..3a01e65f12b294953684d756d097008cb61ca354
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/config/flags.h
@@ -0,0 +1,47 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_CONFIG_FLAGS_H_
+#define TENSORFLOW_CORE_CONFIG_FLAGS_H_
+
+#include "tensorflow/core/platform/stringpiece.h"
+
+namespace tensorflow {
+namespace config {
+
+// Container class for a single feature flag.
+// Note: this class is not thread safe.
+class Flag {
+ public:
+  explicit Flag(StringPiece flag_name, bool default_value);
+  bool value() { return value_; }
+  void reset(bool value) { value_ = value; }
+
+ private:
+  bool value_;
+};
+
+// Macro to declare new flags. Declare all flags in core/config/flag_defs.h
+// These flags can be overridden by setting the associated environment variable
+// TF_FLAG_* flag to true or false. E.g. setting TF_FLAG_MY_FLAG=false will
+// override the default value for a flag named `my_flag` to false.
+#define TF_DECLARE_FLAG(flag_name, default_value, doc) \
+  ::tensorflow::config::Flag flag_name =               \
+      ::tensorflow::config::Flag("TF_FLAG_" #flag_name, default_value);
+
+}  // namespace config
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_CONFIG_FLAGS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/data/captured_function.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/data/captured_function.h
new file mode 100644
index 0000000000000000000000000000000000000000..c3d489dd8552639986acc4eec638057096e12c6c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/data/captured_function.h
@@ -0,0 +1,322 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_DATA_CAPTURED_FUNCTION_H_
+#define TENSORFLOW_CORE_DATA_CAPTURED_FUNCTION_H_
+
+#include <functional>
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include "tensorflow/core/framework/cancellation.h"
+#include "tensorflow/core/framework/dataset.h"
+#include "tensorflow/core/framework/function.h"
+#include "tensorflow/core/framework/model.h"
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/lib/gtl/array_slice.h"
+#include "tensorflow/core/lib/random/random.h"
+#include "tensorflow/core/platform/macros.h"
+
+namespace tensorflow {
+
+class Device;
+class OpKernelContext;
+class ResourceMgr;
+
+namespace data {
+
+class CapturedFunction;
+class InstantiatedCapturedFunction;
+
+// Creates an iterator for a dataset which is created by applying the given
+// function to the given input element.
+Status MakeIteratorFromInputElement(
+    IteratorContext* ctx, const IteratorBase* parent,
+    const std::vector<Tensor>& input_element, int64_t thread_index,
+    const InstantiatedCapturedFunction& inst_captured_func, StringPiece prefix,
+    std::unique_ptr<IteratorBase>* out_iterator);
+
+// Creates an iterator for a dataset which is created by applying the given
+// function to the given input element. Pass non-null `node` to record
+// processing time for modeling Iterator's GetNext() resource usage.
+Status MakeIteratorFromInputElement(
+    IteratorContext* ctx, const IteratorBase* parent,
+    const std::vector<Tensor>& input_element, int64_t thread_index,
+    const InstantiatedCapturedFunction& inst_captured_func, StringPiece prefix,
+    std::unique_ptr<IteratorBase>* out_iterator,
+    const std::shared_ptr<model::Node>& node);
+
+struct ShortCircuitInfo {
+  std::vector<int> indices;
+  std::vector<bool> can_move;
+};
+
+// Metadata shared across all captures of the same function.
+class FunctionMetadata {
+ public:
+  struct Params {
+    bool use_inter_op_parallelism = true;
+    bool use_default_device = true;
+  };
+
+  // Creates a new instance of the `FunctionMetadata` class, fetching function
+  // from a context argument.
+  static Status Create(tensorflow::OpKernelConstruction* ctx,
+                       const string& func_name, Params params,
+                       std::shared_ptr<FunctionMetadata>* out_metadata);
+
+  // Creates a new instance of the `FunctionMetadata` class, using the provided
+  // function.
+  static Status Create(tensorflow::OpKernelConstruction* ctx,
+                       NameAttrList&& func, Params params,
+                       std::shared_ptr<FunctionMetadata>* out_metadata);
+
+  // Returns the named list of function arguments.
+  const NameAttrList& func() const { return func_; }
+
+  // Returns a borrowed pointer to the function library that contains the
+  // transitive closure of definitions used by the function.
+  const FunctionLibraryDefinition* lib_def() const { return lib_def_.get(); }
+
+  // Returns short-circuit information.
+  const ShortCircuitInfo& short_circuit_info() const {
+    return short_circuit_info_;
+  }
+
+  // Indicates whether a default device should be used for executing function
+  // ops.
+  bool use_default_device() const { return use_default_device_; }
+
+  // Indicates whether to use inter-op parallelism for execution of the
+  // function.
+  bool use_inter_op_parallelism() const { return use_inter_op_parallelism_; }
+
+  // Indicates whether the function should a multi-device function backend.
+  bool use_multi_device_function() const { return use_multi_device_function_; }
+
+ private:
+  FunctionMetadata(NameAttrList&& func, Params params)
+      : func_(std::move(func)),
+        use_default_device_(params.use_default_device),
+        use_inter_op_parallelism_(params.use_inter_op_parallelism) {}
+
+  NameAttrList func_;
+  std::unique_ptr<FunctionLibraryDefinition> lib_def_ = nullptr;
+  ShortCircuitInfo short_circuit_info_;
+  bool use_default_device_ = true;
+  bool use_inter_op_parallelism_ = true;
+  bool use_multi_device_function_ = true;
+};
+
+// Constructs and stores the parameters for the CapturedFunction Instantiate
+// function.
+struct InstantiateCapturedFunctionParams {
+  explicit InstantiateCapturedFunctionParams(IteratorContext* ctx) {
+    flr = ctx->flr();
+    function_handle_cache = ctx->function_handle_cache();
+    runner = ctx->runner();
+  }
+
+  explicit InstantiateCapturedFunctionParams(OpKernelContext* ctx) {
+    flr = ctx->function_library();
+    function_handle_cache = nullptr;
+    runner = ctx->runner();
+  }
+
+  FunctionLibraryRuntime* flr;
+  FunctionHandleCache* function_handle_cache;
+  std::function<void(std::function<void()>)>* runner;
+};
+
+// A `CapturedFunction` encapsulates a TensorFlow function, plus any "captured"
+// arguments that it closed over in the user program.
+class CapturedFunction {
+ public:
+  // Creates a new instance using a list of named attributes, fetching captured
+  // inputs from a context argument.
+  static Status Create(OpKernelContext* ctx,
+                       std::shared_ptr<const FunctionMetadata> metadata,
+                       const string& argument_name,
+                       std::unique_ptr<CapturedFunction>* out_function);
+
+  // Creates a new instance using a list of named attributes, using provided
+  // captured inputs.
+  static Status Create(OpKernelContext* ctx,
+                       std::shared_ptr<const FunctionMetadata> metadata,
+                       std::vector<Tensor>&& captured_inputs,
+                       std::unique_ptr<CapturedFunction>* out_function);
+
+  // Adds the definition of this captured function into the given graph,
+  // returning its captured inputs and types through the respective output
+  // arguments.
+  Status AddToGraph(SerializationContext* ctx,
+                    DatasetBase::DatasetGraphDefBuilder* b,
+                    std::vector<Node*>* other_arguments,
+                    DataTypeVector* other_arguments_types) const;
+
+  // Instantiates this function for use in the given context, providing an
+  // InstantiatedCapturedFunction that can be used to execute functions.
+  Status Instantiate(IteratorContext* ctx,
+                     std::unique_ptr<InstantiatedCapturedFunction>*
+                         instantiated_captured_function);
+
+  Status Instantiate(InstantiateCapturedFunctionParams params,
+                     std::unique_ptr<InstantiatedCapturedFunction>*
+                         instantiated_captured_function);
+
+  // Determines whether the captured function is stateful.
+  Status CheckExternalState() const;
+
+  // Returns the additional captured inputs that will be passed to the function.
+  const std::vector<Tensor>& captured_inputs() const {
+    return captured_inputs_;
+  }
+
+  // Returns the named list of function arguments.
+  const NameAttrList& func() const { return metadata_->func(); }
+
+  // Returns the transitive set of function definition required to instantiate
+  // this function.
+  const FunctionLibraryDefinition* lib_def() const {
+    return metadata_->lib_def();
+  }
+
+  // If every function output corresponds to one of its inputs, the method
+  // returns the mapping from output indices to input indices. Otherwise, it
+  // returns an empty list.
+  const ShortCircuitInfo& short_circuit_info() const {
+    return metadata_->short_circuit_info();
+  }
+
+  // Indicates whether the function should use inter op parallelism.
+  bool use_inter_op_parallelism() const {
+    return metadata_->use_inter_op_parallelism();
+  }
+
+ private:
+  CapturedFunction(std::shared_ptr<const FunctionMetadata> metadata,
+                   std::vector<Tensor> captured_inputs);
+
+  Status IsMultiDevice(FunctionLibraryRuntime* flr,
+                       bool* is_multi_device) const;
+
+  const std::shared_ptr<const FunctionMetadata> metadata_;
+  const std::vector<Tensor> captured_inputs_;
+
+  CapturedFunction(const CapturedFunction&) = delete;
+  void operator=(const CapturedFunction&) = delete;
+};
+
+// `InstantiatedCapturedFunction` encapsulates all the runtime support needed
+// to execute a tensorflow function.
+//
+// While `CapturedFunction` encapsulates constant attributes of the function,
+// such as its name and captured arguments, `InstantiatedCapturedFunction`
+// encapsulates runtime aspects, such as `FunctionLibraryRuntime` and function
+// handle.
+//
+// The `Iterator` related classes use `InstantiatedCapturedFunction` to execute
+// functions outside of the normal `OpKernel::Compute()` context.
+class InstantiatedCapturedFunction {
+ public:
+  // Runs the instantiated captured function. This method takes ownership of
+  // the tensors in `args`, in order to be able to deallocate them as early as
+  // possible. Use `RunWithBorrowedArgs()` if the caller needs to retain
+  // ownership of the `args`.
+  Status Run(IteratorContext* ctx, std::vector<Tensor>&& args,
+             std::vector<Tensor>* rets) const;
+
+  // Runs the instantiated captured function. This method takes ownership of
+  // the tensors in `args`, in order to be able to deallocate them as early as
+  // possible. Use `RunWithBorrowedArgs()` if the caller needs to retain
+  // ownership of the `args`. Pass non-null `node` to record processing time
+  // for modeling Iterator's GetNext() resource usage. When non-null node is
+  // provided, the pre-requisite is that the calling thread has previously
+  // called `DatasetBaseIterator::RecordStart().
+  Status Run(IteratorContext* ctx, std::vector<Tensor>&& args,
+             std::vector<Tensor>* rets,
+             const std::shared_ptr<model::Node>& node) const;
+
+  // Synchronously runs the captured function on the given `args`, and stores
+  // the results in `*rets`. Prefer to use `Run()` or `RunAsync()` when
+  // possible.
+  Status RunWithBorrowedArgs(IteratorContext* ctx,
+                             const std::vector<Tensor>& args,
+                             std::vector<Tensor>* rets) const;
+
+  // Synchronously runs the captured function on the given `args`, and stores
+  // the results in `*rets`. Prefer to use `Run()` or `RunAsync()` when
+  // possible. Pass non-null `node` to record processing time for modeling
+  // Iterator's GetNext() resource usage. When non-null node is provided, the
+  // pre-requisite is that the calling thread has previously called
+  // `DatasetBaseIterator::RecordStart().
+  Status RunWithBorrowedArgs(IteratorContext* ctx,
+                             const std::vector<Tensor>& args,
+                             std::vector<Tensor>* rets,
+                             const std::shared_ptr<model::Node>& node) const;
+
+  // Synchronously runs the captured function on the given `args`, and stores
+  // the results in `*rets`. Prefer to use `Run()` or `RunAsync()` when
+  // possible. This can be useful for calling a captured function in cases where
+  // an `IteratorContext*` is not available (such as a destructor).
+  //
+  // TODO(b/144278100): Avoid running functions without IteratorContext.
+  Status RunInstantiated(const std::vector<Tensor>& args,
+                         std::vector<Tensor>* rets);
+
+  // Asynchronously runs the captured function on the given `args`, stores the
+  // results in `*rets`, and calls the given `done` callback when the function
+  // returns. This method takes ownership of the tensors in `args`, in order to
+  // be able to deallocate them as early as possible. Pass non-null `node` to
+  // record processing time for modeling Iterator's GetNext() resource usage.
+  // When non-null node is provided, the pre-requisite is that the calling
+  // thread has previously called `DatasetBaseIterator::RecordStart().
+  void RunAsync(IteratorContext* ctx, std::vector<Tensor>&& args,
+                std::vector<Tensor>* rets,
+                FunctionLibraryRuntime::DoneCallback done,
+                const std::shared_ptr<model::Node>& node) const;
+
+ private:
+  friend class CapturedFunction;
+
+  InstantiatedCapturedFunction(
+      FunctionLibraryRuntime* lib, FunctionLibraryRuntime::Handle f_handle,
+      DataTypeVector ret_types,
+      std::function<void(std::function<void()>)> runner,
+      CapturedFunction* captured_func, bool is_multi_device);
+
+  // Determines whether a rendezvous object should be created when running the
+  // instantiated function.
+  bool ShouldCreateRendezvous() const;
+
+  FunctionLibraryRuntime* const lib_;  // Not owned.
+  const FunctionLibraryRuntime::Handle f_handle_;
+  const DataTypeVector ret_types_;
+  // Note: We capture the runner at function instantiation time to be able to
+  // run the function without `IteratorContext` via `RunInstantiated`.
+  std::function<void(std::function<void()>)> captured_runner_;
+  CapturedFunction* const captured_func_;  // Not owned.
+  const bool is_multi_device_;
+
+  InstantiatedCapturedFunction(const InstantiatedCapturedFunction&) = delete;
+  void operator=(const InstantiatedCapturedFunction&) = delete;
+};
+
+}  // namespace data
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DATA_CAPTURED_FUNCTION_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/data/compression_utils.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/data/compression_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..0d309fc5c05d0a49455b5d973797cd3f861d7c2d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/data/compression_utils.h
@@ -0,0 +1,43 @@
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_DATA_COMPRESSION_UTILS_H_
+#define TENSORFLOW_CORE_DATA_COMPRESSION_UTILS_H_
+
+#include <vector>
+
+#include "tensorflow/core/framework/dataset.pb.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/platform/status.h"
+
+namespace tensorflow {
+namespace data {
+
+// Compresses the components of `element` into the `CompressedElement` proto.
+//
+// In addition to writing the actual compressed bytes, `Compress` fills
+// out the per-component metadata for the `CompressedElement`.
+//
+// Returns an error if the uncompressed size of the element exceeds 4GB.
+Status CompressElement(const std::vector<Tensor>& element,
+                       CompressedElement* out);
+
+// Uncompresses a `CompressedElement` into a vector of tensor components.
+Status UncompressElement(const CompressedElement& compressed,
+                         std::vector<Tensor>* out);
+
+}  // namespace data
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DATA_COMPRESSION_UTILS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/data/dataset_utils.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/data/dataset_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..b975fc0aad567ee037401f2ec060dc365b80c56d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/data/dataset_utils.h
@@ -0,0 +1,441 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_DATA_DATASET_UTILS_H_
+#define TENSORFLOW_CORE_DATA_DATASET_UTILS_H_
+
+#include <atomic>
+#include <functional>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "absl/container/flat_hash_set.h"
+#include "tensorflow/core/common_runtime/function.h"
+#include "tensorflow/core/framework/dataset.h"
+#include "tensorflow/core/framework/function.h"
+#include "tensorflow/core/framework/resource_handle.h"
+#include "tensorflow/core/framework/resource_mgr.h"
+#include "tensorflow/core/framework/tensor.h"
+
+namespace tensorflow {
+namespace data {
+
+// Constant used for indicating that the argument of tf.data.Dataset.shard
+// should be supplied by the auto-sharding rewrite.
+constexpr int kShardHint = -1;
+
+// The initial parallelism value before Autotune has a chance to optimize.
+constexpr int kAutotuneDefaultParallelism = 16;
+
+// Creates a resource handle with a unique name for the given resource where
+// the resource is managed by the Resource Manager.
+template <typename T>
+Status CreateWeakHandle(OpKernelContext* ctx, T* resource,
+                        const string& container_name, ResourceHandle* handle) {
+  static std::atomic<int64_t> resource_id_counter(0);
+  string unique_name =
+      strings::StrCat(container_name, resource_id_counter.fetch_add(1));
+  ResourceMgr* mgr = ctx->resource_manager();
+  TF_RETURN_IF_ERROR(mgr->Create<T>(container_name, unique_name, resource));
+
+  *handle = MakeResourceHandle(container_name, unique_name, *ctx->device(),
+                               TypeIndex::Make<T>());
+  return OkStatus();
+}
+
+// Creates a ref-counting resource handle for the given resource, where the
+// resource is owned by the handle.
+template <typename T>
+Status CreateHandle(OpKernelContext* ctx, T* resource, ResourceHandle* handle) {
+  ResourceMgr* mgr = ctx->resource_manager();
+  *handle =
+      ResourceHandle::MakeRefCountingHandle(resource, ctx->device()->name());
+  TF_RETURN_IF_ERROR(
+      mgr->CreateUnowned<T>(handle->container(), handle->name(), resource));
+  return OkStatus();
+}
+
+// TODO(b/198162355): Merge this class with ResourceOpKernel.
+template <typename T>
+class AnonymousResourceOp : public OpKernel {
+ public:
+  // Creates an AnonymousResourceOp.
+  // ref_counting: Determines if the Op returns a ref-counting ResourceHandle.
+  // ResourceHandle. See go/tf-resource-handle-ref-count.
+  // return_deleter: Determines if the Op outputs a deleter tensor in addition
+  // to the resource handle tensor.
+  // If the resource handle is ref-counting, a no-op deleter is returned.
+  explicit AnonymousResourceOp(OpKernelConstruction* context, bool ref_counting,
+                               bool return_deleter)
+      : OpKernel(context),
+        ref_counting_(ref_counting),
+        return_deleter_(return_deleter) {}
+
+  void Compute(OpKernelContext* ctx) override {
+    FunctionLibraryRuntime* lib;
+    std::unique_ptr<FunctionLibraryDefinition> flib_def(nullptr);
+    std::unique_ptr<ProcessFunctionLibraryRuntime> pflr(nullptr);
+    OP_REQUIRES_OK(
+        ctx, ctx->function_library()->Clone(&flib_def, &pflr, &lib, true));
+    T* resource;
+    OP_REQUIRES_OK(ctx, CreateResource(ctx, std::move(flib_def),
+                                       std::move(pflr), lib, &resource));
+
+    ResourceHandle handle;
+    if (ref_counting_) {
+      OP_REQUIRES_OK(ctx, CreateHandle(ctx, resource, &handle));
+    } else {
+      OP_REQUIRES_OK(ctx, CreateWeakHandle(ctx, resource, name(), &handle));
+    }
+    Tensor* handle_t;
+    OP_REQUIRES_OK(ctx, ctx->allocate_output(0, TensorShape({}), &handle_t));
+    handle_t->scalar<ResourceHandle>()() = handle;
+
+    if (return_deleter_) {
+      Tensor* deleter_t;
+      AllocatorAttributes attr;
+      attr.set_on_host(true);
+      OP_REQUIRES_OK(
+          ctx, ctx->allocate_output(1, TensorShape({}), &deleter_t, attr));
+      // TODO(feyu): Consider returning an OptionalVariant.
+      if (!ref_counting_) {
+        // A deleter output that deletes the resource when destroyed.
+        deleter_t->scalar<Variant>()() =
+            ResourceDeleter(handle, ctx->resource_manager());
+      }
+    }
+  }
+
+ protected:
+  virtual string name() = 0;
+
+  virtual Status CreateResource(
+      OpKernelContext* ctx, std::unique_ptr<FunctionLibraryDefinition> flib_def,
+      std::unique_ptr<ProcessFunctionLibraryRuntime> pflr,
+      FunctionLibraryRuntime* lib, T** resource) = 0;
+
+ private:
+  const bool ref_counting_;
+  const bool return_deleter_;
+};
+
+// Returns OkStatus() if `expected` and `received` types match,
+// errors::InvalidArgument otherwise.
+Status VerifyTypesMatch(const DataTypeVector& expected,
+                        const DataTypeVector& received);
+
+Status VerifyTypesMatch(const DataTypeVector& expected,
+                        const std::vector<Tensor>& received);
+
+// Returns OkStatus() if `expected` and `received` shapes are compatible,
+// errors::InvalidArgument otherwise.
+Status VerifyShapesCompatible(const std::vector<PartialTensorShape>& expected,
+                              const std::vector<PartialTensorShape>& received);
+
+Status VerifyShapesCompatible(const std::vector<PartialTensorShape>& expected,
+                              const std::vector<Tensor>& received);
+
+// Dataset op level determinism policy.
+class DeterminismPolicy {
+ public:
+  enum class Type : int {
+    // The op must produce elements deterministically.
+    kDeterministic,
+    // The op may relax determinism to improve performance.
+    kNondeterministic,
+    // The determinism policy is not specified at the op level. In this case we
+    // use the experimental_deterministic dataset option to determine the
+    // determinism policy.
+    kDefault,
+  };
+  static constexpr const char* const kDeterministic = "true";
+  static constexpr const char* const kNondeterministic = "false";
+  static constexpr const char* const kDefault = "default";
+
+  DeterminismPolicy() : determinism_(Type::kDefault) {}
+  explicit DeterminismPolicy(Type determinism) : determinism_(determinism) {}
+  // Creates a DeterminismPolicy with Type kDeterministic or
+  // kNondeterministic, depending on the values of `is_deterministic`.
+  explicit DeterminismPolicy(bool is_deterministic);
+
+  static Status FromString(const std::string& s, DeterminismPolicy* out);
+
+  // Returns the string representing the determinism policy. This will be one of
+  // the string constants defined above.
+  std::string String() const;
+
+  /// Convenience methods for checking the DeterminismPolicy::Type.
+  bool IsDeterministic() const { return determinism_ == Type::kDeterministic; }
+  bool IsNondeterministic() const {
+    return determinism_ == Type::kNondeterministic;
+  }
+  bool IsDefault() const { return determinism_ == Type::kDefault; }
+
+ private:
+  Type determinism_;
+};
+
+// Resolves non-deterministic seeds if necessary, returning either the original
+// seeds or the resolved seeds.
+//
+// By TensorFlow convention, if both seeds are 0, they should be replaced with
+// non-deterministically chosen seeds.
+std::pair<int64_t, int64_t> MaybeOverrideSeeds(
+    std::pair<int64_t, int64_t> seeds);
+
+// Adds the functions in `to_add` to `base`. If a function with a matching
+// signature already exists in `base`, replaces it with the function from
+// `to_add`.
+Status AddToFunctionLibrary(FunctionLibraryDefinition* base,
+                            const FunctionLibraryDefinition& to_add);
+Status AddToFunctionLibrary(FunctionLibraryDefinition* base,
+                            const FunctionDefLibrary& to_add);
+
+// Determines whether the given function is stateful.
+Status IsFunctionStateful(const FunctionLibraryDefinition& library,
+                          const FunctionDef& function_def);
+
+// Determines whether the given node is stateful.
+Status IsNodeStateful(const FunctionLibraryDefinition& library,
+                      const NodeDef& node);
+
+// Creates a runner that runs functions with limited parallelism.
+std::function<void(std::function<void()>)> RunnerWithMaxParallelism(
+    std::function<void(std::function<void()>)> runner, int max_parallelism);
+
+// Op for creating a typed dummy resource.
+//
+// This op is used to provide a resource "placeholder" for ops such as
+// `CacheDatasetV2` or `ShuffleDatasetV2` that expects a resource input.
+// Originally, the lifetime of the resources passed into these ops was managed
+// externally. After the implementation changed to manage the lifetime of the
+// resources (including creation) by the ops themselves, the resource input is
+// only needed to pass a resource handle through graph rewrites. When they are
+// invoked from user code, the implementation passes in a dummy resource.
+template <typename ResourceType>
+class DummyResourceOp : public OpKernel {
+ public:
+  explicit DummyResourceOp(OpKernelConstruction* ctx) : OpKernel(ctx) {}
+
+  void Compute(OpKernelContext* ctx) override {
+    Tensor* tensor;
+    OP_REQUIRES_OK(ctx, ctx->allocate_output(0, TensorShape({}), &tensor));
+    tensor->scalar<ResourceHandle>()() = MakeResourceHandle<ResourceType>(
+        ctx, /*container=*/"", /*name=*/"dummy_resource");
+  }
+};
+
+// Given an op prefix and an op to match, returns whether the op to match
+// is a match for any version of the op prefix. For example,
+// MatchesAnyVersion("BatchDataset", "BatchDataset") == true
+// MatchesAnyVersion("BatchDataset", "BatchDatasetV2") == true
+// MatchesAnyVersion("BatchDataset", "BatchDatasetV3") == true
+// MatchesAnyVersion("PaddedBatchDataset", "BatchDataset") == false
+bool MatchesAnyVersion(StringPiece op_prefix, StringPiece op_to_match);
+
+// Returns the index-th slice of a given tensor. If the index-th slice of
+// the tensor is not aligned, returns a deep copy of the tensor.
+Tensor MaybeCopySubSlice(const Tensor& tensor, int64 index);
+
+// Removes device placements from the ops of all functions in `library`.
+void StripDevicePlacement(FunctionDefLibrary* library);
+
+// Copies partial of the batch output.
+Status CopyPartialBatch(int64_t num_elements, const Tensor& value,
+                        Tensor* output);
+
+// Reads a batch when restoring the iterator.
+Status ReadBatch(IteratorContext* ctx, IteratorStateReader* reader,
+                 int64_t batch_size, const string& iterator_prefix,
+                 const string& batch_prefix, std::vector<Tensor>* batch);
+
+// Writes a batch when saving the iterator.
+Status WriteBatch(int64_t batch_size, int64_t num_elements,
+                  const string& iterator_prefix, const string& batch_prefix,
+                  IteratorStateWriter* writer, std::vector<Tensor>* batch);
+
+// Reads a status when restoring the iterator.
+Status ReadStatus(const string& iterator_prefix, const string& prefix,
+                  IteratorStateReader* reader, Status* status);
+
+// Writes a status when saving the iterator.
+Status WriteStatus(const string& iterator_prefix, const string& prefix,
+                   const Status& status, IteratorStateWriter* writer);
+
+// Processes a batch to output. In the case a partial batch is encountered, copy
+// only partial of the batch.
+Status ProcessBatch(int64_t batch_size, int64_t num_elements,
+                    bool drop_remainder, const Status& status,
+                    IteratorContext* ctx, std::vector<Tensor>* output,
+                    bool* end_of_sequence, std::vector<Tensor>* batch);
+
+// Constructs and stores the parameters for the CopyBatch function.
+struct CopyBatchParams {
+  Allocator* allocator;
+  std::function<void(std::function<void()>)>* runner;
+  int64 runner_threadpool_size;
+
+  explicit CopyBatchParams(IteratorContext* ctx) {
+    allocator = ctx->allocator({});
+    runner = ctx->runner();
+    runner_threadpool_size = ctx->runner_threadpool_size();
+  }
+
+  explicit CopyBatchParams(OpKernelContext* ctx) {
+    allocator = ctx->get_allocator({});
+    runner = ctx->runner();
+    runner_threadpool_size = GetRunnerThreadpoolSizeFromOpKernelContext(ctx);
+  }
+};
+
+// Copies the input elements to a batch.
+//
+// The `batch_elements` argument contains the individual elements to copy into a
+// batch. The `parallel_copy` argument indicates whether to parallelize the
+// copy. The `allocation_callback` argument can be used to pass a callback to
+// invoke upon successful allocation of the memory for the batch. The
+// `out_tensors` argument will be used to store the resulting batch (one for
+// each component of the input).
+Status CopyBatch(CopyBatchParams params,
+                 const std::vector<std::vector<Tensor>>& batch_elements,
+                 bool parallel_copy,
+                 std::function<Status()> allocation_callback,
+                 std::vector<Tensor>* out_tensors);
+
+// Computes the set of experiments to apply based on the job name, task id,
+// rollout percentage of registered experiments, and the
+// TF_DATA_EXPERIMENT_OPT_IN and TF_DATA_EXPERIMENT_OPT_OUT environment
+// variables.
+absl::flat_hash_set<string> GetExperiments();
+absl::flat_hash_set<string> GetExperiments(
+    const std::string& job_name, int64_t task_id,
+    std::function<uint64_t(const string&)> hash_func);
+
+// Logs and records the experiments that will be applied.
+void LogAndRecordExperiments(const absl::flat_hash_set<string>& experiments);
+
+// Computes the set of enabled, disabled, and default optimizations based on the
+// given options. An optimization must be a graph optimizer name that has been
+// registered with Grappler.
+void GetOptimizations(const Options& options,
+                      absl::flat_hash_set<tstring>* optimizations_enabled,
+                      absl::flat_hash_set<tstring>* optimizations_disabled,
+                      absl::flat_hash_set<tstring>* optimizations_default);
+
+// Creates graph rewrite configs based on the given options. The configs will
+// only be used if their corresponding optimizers registered with Grappler are
+// enabled.
+// A config is a string with the following format:
+//   <optimizer name>:<attribute name>:<attribute value>
+absl::flat_hash_set<tstring> CreateGraphRewriteConfigs(const Options& options);
+
+// Determines whether max intra-op parallelism should be configured.
+bool ShouldConfigureMaxIntraOpParallelism(const Options& options);
+
+// Determines whether private threadpool should be used.
+bool ShouldUsePrivateThreadPool(const Options& options);
+
+// Determines whether autotuning should be used.
+bool ShouldUseAutotuning(const Options& options);
+
+// Determines whether optimizations should be applied.
+bool ShouldApplyOptimizations(
+    const Options& options,
+    const absl::flat_hash_set<tstring>& optimizations_enabled,
+    const absl::flat_hash_set<tstring>& optimizations_default);
+
+// Returns the default CPU budget.
+inline int GetCpuBudget() {
+  static bool in_experiment = GetExperiments().contains("tune_cpu_budget");
+  return (in_experiment ? 1.2 : 1.0) * port::NumSchedulableCPUs();
+}
+
+// Returns the initial value for parallelism parameter before the first Autotune
+// optimization.
+int64 GetAutotuneDefaultParallelism(IteratorContext* ctx);
+
+// Creates an iterator context appropriate for a nested dataset's iterator. A
+// nested dataset is a dataset created within another dataset, e.g. by the
+// function passed to `interleave` or `flat_map`.
+IteratorContext MakeNestedIteratorContext(IteratorContext* ctx);
+
+// A `DatasetExperimentRegistry::JobSelector` that randomly selects
+// `rollout_pct` percent of all jobs. `name_hash` is a hash of the experiment
+// and job names.
+template <int64_t rollout_pct>
+bool RandomJobSamplePercentage(uint64_t name_hash) {
+  return name_hash % 100 < rollout_pct;
+}
+
+// A `DatasetExperimentRegistry::TaskSelector` that selects all tasks.
+bool AllTasks(int64_t unused_task_id, bool unused_evens);
+
+// A `DatasetExperimentRegistry::TaskSelector` that selects the tasks for half
+// of all hosts. Typically, one or two consecutive tasks run on a single host.
+// If `evens` is `true`, selects tasks 0,1,4,5,8,9,..., otherwise selects tasks
+// 2,3,6,7,10,11,...
+bool IndependentHostTasks(int64_t task_id, bool evens);
+
+// Registry of tf.data experiments.
+class DatasetExperimentRegistry {
+ public:
+  using JobSelector = std::function<bool(uint64_t name_hash)>;
+  using TaskSelector = std::function<bool(int64_t task_id, bool evens)>;
+
+  struct ExperimentSelector {
+    JobSelector job_selector;
+    TaskSelector task_selector;
+  };
+
+  // Registers the experiment.
+  static void Register(const string& experiment, JobSelector job_selector,
+                       TaskSelector task_selector);
+
+  // Returns all registered experiments.
+  static absl::flat_hash_map<string, ExperimentSelector> Experiments();
+};
+
+// Helper class to register a dataset experiment.
+class DatasetExperimentRegistrar {
+ public:
+  explicit DatasetExperimentRegistrar(
+      const string& experiment,
+      DatasetExperimentRegistry::JobSelector job_selector,
+      DatasetExperimentRegistry::TaskSelector task_selector) {
+    DatasetExperimentRegistry::Register(experiment, job_selector,
+                                        task_selector);
+  }
+};
+
+// Macro that can be used to register a dataset experiment.
+#define REGISTER_DATASET_EXPERIMENT(experiment, job_selector, task_selector)  \
+  REGISTER_DATASET_OP_NAME_UNIQ_HELPER(__COUNTER__, experiment, job_selector, \
+                                       task_selector)
+
+#define REGISTER_DATASET_OP_NAME_UNIQ_HELPER(ctr, experiment, job_selector, \
+                                             task_selector)                 \
+  REGISTER_DATASET_OP_NAME_UNIQ(ctr, experiment, job_selector, task_selector)
+
+#define REGISTER_DATASET_OP_NAME_UNIQ(ctr, experiment, job_selector, \
+                                      task_selector)                 \
+  static ::tensorflow::data::DatasetExperimentRegistrar              \
+      registrar__body__##ctr##__object(experiment, job_selector,     \
+                                       task_selector)
+
+}  // namespace data
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DATA_DATASET_UTILS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/data/finalization_utils.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/data/finalization_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..c0ed2afb1b053e79d5a3796536a0ea33c9029d22
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/data/finalization_utils.h
@@ -0,0 +1,35 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DATA_FINALIZATION_UTILS_H_
+#define TENSORFLOW_CORE_DATA_FINALIZATION_UTILS_H_
+
+#include <functional>
+
+#include "tensorflow/core/framework/dataset.h"
+#include "tensorflow/core/framework/op_kernel.h"
+
+namespace tensorflow {
+namespace data {
+
+// Returns the finalized version of the dataset. The returned DatasetBase is
+// unowned and lives for as long as this dataset.
+StatusOr<DatasetBase*> GetFinalizedDataset(OpKernelContext* ctx,
+                                           const DatasetBase* dataset);
+
+}  // namespace data
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DATA_FINALIZATION_UTILS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/data/hash_utils.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/data/hash_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..401f047e47003f7715fd7d92afeedf91113362c3
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/data/hash_utils.h
@@ -0,0 +1,62 @@
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_DATA_HASH_UTILS_H_
+#define TENSORFLOW_CORE_DATA_HASH_UTILS_H_
+
+#include "tensorflow/core/common_runtime/function.h"
+#include "tensorflow/core/framework/dataset.h"
+#include "tensorflow/core/framework/function.h"
+#include "tensorflow/core/framework/resource_mgr.h"
+#include "tensorflow/core/framework/tensor.h"
+
+namespace tensorflow {
+namespace data {
+
+// Returns a stable hash of the subgraph rooted at the given node.
+//
+// NOTE: There is currently no guarantee that the hash of a subgraph will stay
+// the same between TensorFlow builds.
+Status HashNode(const GraphDef& graph, const NodeDef& node, uint64* hash);
+Status HashNode(const GraphDef& graph, const NodeDef& node,
+                const FunctionLibraryDefinition& flib_def, uint64* hash);
+
+// Returns a stable hash of the given tensor.
+//
+// NOTE: There is currently no guarantee that the hash of a subgraph will stay
+// the same between TensorFlow builds.
+Status HashTensor(const Tensor& tensor, uint64* hash);
+
+// Returns a stable hash of the given graph.
+//
+// NOTE: There is currently no guarantee that the hash of a subgraph will stay
+// the same between TensorFlow builds.
+Status HashGraph(const GraphDef& graph, uint64* hash);
+
+// Determines whether the given graphs are equal, following the same logic used
+// for HashGraph. Returns OK if the graphs can be determined to be equal,
+// otherwise returns an error message explaining why the graphs couldn't be
+// determined to be equal.
+Status CheckGraphsEqual(const GraphDef& a, const GraphDef& b);
+
+// Determines whether the subgraphs rooted at the given nodes are equal
+// following the same logic used for HashGraph. Returns OK if the graphs can be
+// determined to be equal, otherwise returns an error message explaining why the
+// graphs couldn't be determined to be equal.
+Status CheckSubgraphsEqual(const GraphDef& a, const NodeDef* node_a,
+                           const GraphDef& b, const NodeDef* node_b);
+}  // namespace data
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DATA_HASH_UTILS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/data/metric_utils.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/data/metric_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..7d67cb92115fdec730b1a0fef8f1948dfbc1d69f
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/data/metric_utils.h
@@ -0,0 +1,87 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_DATA_METRIC_UTILS_H_
+#define TENSORFLOW_CORE_DATA_METRIC_UTILS_H_
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+#include "absl/time/time.h"
+#include "tensorflow/core/data/tfdataz_metrics.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/platform/env.h"
+#include "tensorflow/core/platform/mutex.h"
+#include "tensorflow/core/platform/thread_annotations.h"
+
+namespace tensorflow {
+namespace data {
+
+// Exports the metrics for `GetNext` calls by tf.data iterators. When the user
+// calls `RecordStart` and `RecordStop`, it will export a latency sample. It
+// also exports throughput, tf.data iterator life time, etc. This class is
+// thread-safe. Example usage:
+//
+//   ```
+//   IteratorMetricsCollector metrics_collector(DEVICE_CPU, env);
+//   absl::Time start_time = metrics_collector.RecordStart();
+//   auto status = iterator_->GetNext(IteratorContext(std::move(params)),
+//                                    out_tensors, end_of_sequence);
+//   metrics_collector.RecordStop(start_time, *out_tensors);
+//   ```
+class IteratorMetricsCollector {
+ public:
+  // Constructs a `IteratorMetricsCollector`. `device_type` is one of the
+  // devices defined in `types.h` (DEVICE_CPU, DEVICE_GPU, DEVICE_TPU, etc).
+  // We only collect metrics for CPU devices. This is a heuristic to avoid
+  // collecting metrics for device-side iterators created by the multi-device
+  // iterator mechanism.
+  IteratorMetricsCollector(const std::string& device_type, const Env& env);
+
+  // Starts the timer for the next `GetNext` call. Returns the start time.
+  absl::Time RecordStart();
+
+  // Records metrics for the most recent `GetNext` call, including the latency,
+  // bytes fetched, iterator life time, etc. `start_time` is the start time
+  // returned by `RecordStart`. `output` is the output of the `GetNext` call.
+  void RecordStop(absl::Time start_time, const std::vector<Tensor>& output);
+
+ private:
+  // We only collect metrics for CPU devices.
+  bool ShouldCollectMetrics() const;
+
+  // One of the devices defined in `types.h`
+  // (DEVICE_CPU, DEVICE_GPU, DEVICE_TPU, etc).
+  const std::string device_type_;
+  const Env& env_;
+
+  mutex mu_;
+
+  // Records the number of currently active `GetNext` calls.
+  uint64_t num_active_calls_ TF_GUARDED_BY(mu_) = 0;
+
+  // Records the start time (in microseconds) of the first `RecordStart()` call
+  // that followed the last period of inactivity.
+  uint64_t first_start_time_us_ TF_GUARDED_BY(mu_) = 0;
+
+  // Records the end time (in microseconds) of the most recent `RecordStop()`
+  // call.
+  uint64_t end_time_us_ TF_GUARDED_BY(mu_) = 0;
+};
+
+}  // namespace data
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DATA_METRIC_UTILS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/data/name_utils.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/data/name_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..72e870a1caccfe11024ad0efda8225639bcdc2e9
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/data/name_utils.h
@@ -0,0 +1,109 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_DATA_NAME_UTILS_H_
+#define TENSORFLOW_CORE_DATA_NAME_UTILS_H_
+
+#include <vector>
+
+#include "tensorflow/core/lib/strings/strcat.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+namespace data {
+namespace name_utils {
+
+extern const char kDelimiter[];
+extern const char kDefaultDatasetDebugStringPrefix[];
+
+struct OpNameParams {
+  int op_version = 1;
+};
+
+struct DatasetDebugStringParams {
+  template <typename... T>
+  void set_args(T... input_args) {
+    args = {static_cast<const strings::AlphaNum&>(input_args).data()...};
+  }
+
+  int op_version = 1;
+  string dataset_prefix = "";
+  std::vector<string> args;
+};
+
+struct IteratorPrefixParams {
+  int op_version = 1;
+  string dataset_prefix = "";
+};
+
+// Merge the given args in the format of "(arg1, arg2, ..., argn)".
+//
+// e.g. ArgsToString({"1", "2", "3"}) -> "(1, 2, 3)"; ArgsToString({}) -> "".
+string ArgsToString(const std::vector<string>& args);
+
+// Returns the dataset op name.
+//
+// e.g. OpName("Map") -> "MapDataset".
+string OpName(const string& dataset_type);
+
+// Returns the dataset op names.
+//
+// e.g. OpName(ConcatenateDatasetOp::kDatasetType, OpNameParams())
+// -> "ConcatenateDataset"
+//
+// OpNameParams params;
+// params.op_version = 2;
+// OpName(ParallelInterleaveDatasetOp::kDatasetType, params)
+// -> "ParallelInterleaveDatasetV2"
+string OpName(const string& dataset_type, const OpNameParams& params);
+
+// Returns a human-readable debug string for this dataset in the format of
+// "FooDatasetOp(arg1, arg2, ...)::Dataset".
+//
+// e.g. DatasetDebugString("Map") -> "MapDatasetOp::Dataset";
+string DatasetDebugString(const string& dataset_type);
+
+// Returns a human-readable debug string for this dataset in the format of
+// "FooDatasetOp(arg1, arg2, ...)::Dataset".
+//
+// e.g.
+//  DatasetDebugStringParams range_params;
+//  range_params.set_args(0, 10, 3);
+//  DatasetDebugString(RangeDatasetOp::kDatasetType, range_params)
+//  -> "RangeDatasetOp(0, 10, 3)::Dataset");
+string DatasetDebugString(const string& dataset_type,
+                          const DatasetDebugStringParams& params);
+
+// Returns a string that identifies the sequence of iterators leading up to
+// the iterator of this dataset.
+//
+// e.g. IteratorPrefix("Map", "Iterator::Range") -> "Iterator::Range::Map".
+string IteratorPrefix(const string& dataset_type, const string& prefix);
+
+// Returns a string that identifies the sequence of iterators leading up to
+// the iterator of this dataset.
+//
+// e.g.
+// IteratorPrefixParams params;
+// params.op_version = 2;
+// IteratorPrefix(BatchDatasetOp::KDatasetType, "Iterator::Range", params) ->
+// "Iterator::Range::BatchV2".
+string IteratorPrefix(const string& dataset_type, const string& prefix,
+                      const IteratorPrefixParams& params);
+
+}  // namespace name_utils
+}  // namespace data
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DATA_NAME_UTILS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/data/rewrite_utils.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/data/rewrite_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..23ea965d67e1057b8c49173c40369b4862ee2749
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/data/rewrite_utils.h
@@ -0,0 +1,88 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_DATA_REWRITE_UTILS_H_
+#define TENSORFLOW_CORE_DATA_REWRITE_UTILS_H_
+
+#include "tensorflow/core/platform/platform.h"
+
+// On mobile we do not provide this functionality because not all of its
+// dependencies are available there.
+#if !defined(IS_MOBILE_PLATFORM)
+
+#include <functional>
+#include <memory>
+#include <string>
+
+#include "absl/container/flat_hash_set.h"
+#include "tensorflow/core/framework/dataset.h"
+#include "tensorflow/core/framework/function.h"
+#include "tensorflow/core/framework/graph.pb.h"
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/grappler/grappler_item.h"
+#include "tensorflow/core/platform/status.h"
+#include "tensorflow/core/platform/statusor.h"
+#include "tensorflow/core/platform/tstring.h"
+#include "tensorflow/core/platform/types.h"
+#include "tensorflow/core/protobuf/rewriter_config.pb.h"
+
+namespace tensorflow {
+namespace data {
+
+RewriterConfig CreateRewriterConfig(
+    const absl::flat_hash_set<tstring>& optimizations,
+    const absl::flat_hash_set<tstring>& optimizations_configs);
+
+// Rewrites the input dataset using the given config. The rewritten_input
+// stored in the core::RefCountPtr<DatasetBase>* output parameter is owned.
+Status RewriteDataset(OpKernelContext* ctx, const DatasetBase* input,
+                      std::function<RewriterConfig(void)> config_factory,
+                      bool record_fingerprint,
+                      core::RefCountPtr<DatasetBase>* rewritten_input);
+
+// Creates a grappler item for `graph_def`, which is required for graph
+// optimization.
+// `dataset_node` is the name of the node corresponding to the dataset.
+// If `add_fake_sinks` is true, it adds fake sink node to graph and functions to
+// allow rewriting the actual sink nodes.
+// TODO(b/118820916): When MetaOptimizer adds provisions for function retvals to
+// be optimizable, we will no longer need to add fake nodes.
+std::unique_ptr<tensorflow::grappler::GrapplerItem> GetGrapplerItem(
+    GraphDef* graph_def, std::string* dataset_node, bool add_fake_sinks);
+
+// Returns the name of the node corresponding to the dataset. It is indicated by
+// the symbolic `_Retval` node.
+StatusOr<std::string> GetDatasetNode(const GraphDef& graph_def);
+
+// Like `GetDatasetNode` above, but returns the entire node object.
+StatusOr<NodeDef> GetDatasetNodeDef(const GraphDef& graph_def);
+
+// Determines which optimizations should be applied.
+//
+// The result will contain any optimizations that are explicitly enabled, any
+// default optimization that are not explicitly disabled, and any experiment
+// that corresponds to an optimization as long as the optimization is not
+// explicitly disabled.
+absl::flat_hash_set<tstring> SelectOptimizations(
+    const absl::flat_hash_set<string>& experiments,
+    const absl::flat_hash_set<tstring>& optimizations_enabled,
+    const absl::flat_hash_set<tstring>& optimizations_disabled,
+    const absl::flat_hash_set<tstring>& optimizations_default);
+
+}  // namespace data
+}  // namespace tensorflow
+#endif  // !IS_MOBILE_PLATFORM
+
+#endif  // TENSORFLOW_CORE_DATA_REWRITE_UTILS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/data/root_dataset.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/data/root_dataset.h
new file mode 100644
index 0000000000000000000000000000000000000000..3d73f6e8cbdfac9e2b84a64959400657fc66a494
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/data/root_dataset.h
@@ -0,0 +1,99 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_DATA_ROOT_DATASET_H_
+#define TENSORFLOW_CORE_DATA_ROOT_DATASET_H_
+
+#include <cstdint>
+#include <functional>
+#include <memory>
+#include <vector>
+
+#include "tensorflow/core/framework/dataset.h"
+#include "tensorflow/core/framework/model.pb.h"
+#include "tensorflow/core/platform/refcount.h"
+
+namespace tensorflow {
+namespace data {
+
+// Dataset transformation responsible for internal tf.data logic such as
+// autotuning, applying threading configuration.
+class RootDataset : public DatasetBase {
+ public:
+  struct Params {
+    bool autotune = true;
+    model::AutotuneAlgorithm autotune_algorithm;
+    std::function<int64_t()> autotune_cpu_budget_func;
+    std::function<int64_t()> autotune_free_memory_func;
+    int64_t autotune_ram_budget_from_options;
+    int64_t max_intra_op_parallelism = 1;
+    int64_t private_threadpool_size = 0;
+
+    int64_t ComputeInitialAutotuneRamBudget() const {
+      if (autotune_ram_budget_from_options > 0) {
+        return autotune_ram_budget_from_options;
+      } else {
+        return autotune_free_memory_func();
+      }
+    }
+  };
+
+  static Status FromOptions(const DatasetBase* input, DatasetBase** output);
+  static Status FromOptions(core::RefCountPtr<DatasetBase> input,
+                            DatasetBase** output);
+
+  ~RootDataset() override;
+
+  const DataTypeVector& output_dtypes() const override;
+  const std::vector<PartialTensorShape>& output_shapes() const override;
+
+  int64_t CardinalityInternal(CardinalityOptions options) const override;
+  Status Get(OpKernelContext* ctx, int64 index,
+             std::vector<Tensor>* out_tensors) const override;
+  Status CheckExternalState() const override;
+  string DebugString() const override;
+  Status InputDatasets(std::vector<const DatasetBase*>* inputs) const override;
+  std::unique_ptr<IteratorBase> MakeIteratorInternal(
+      const string& prefix) const override;
+
+ protected:
+  Status AsGraphDefInternal(SerializationContext* ctx,
+                            DatasetGraphDefBuilder* b,
+                            Node** output) const override;
+
+ private:
+  class Iterator;
+
+  RootDataset(const DatasetBase* input, const Params& params);
+
+  RootDataset(core::RefCountPtr<DatasetBase> input, const Params& params);
+
+  const DatasetBase* input_;
+  core::RefCountPtr<DatasetBase> owned_input_;
+  const Params params_;
+  TraceMeMetadata traceme_metadata_;
+};
+
+// Finalizes the `input` dataset, which is expected to be called before the
+// dataset is about to be iterated. This can for instance apply static graph
+// optimizations or inject internal tf.data transformations responsible for
+// autotuning or threading configuration. The caller must ensure that the
+// input dataset to be finalized outlives the output.
+Status FinalizeDataset(OpKernelContext* ctx, const DatasetBase* input,
+                       DatasetBase** output);
+
+}  // namespace data
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DATA_ROOT_DATASET_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/data/serialization_utils.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/data/serialization_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..d5e83c32eb488f245292be11b28a36f340df2384
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/data/serialization_utils.h
@@ -0,0 +1,220 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DATA_SERIALIZATION_UTILS_H_
+#define TENSORFLOW_CORE_DATA_SERIALIZATION_UTILS_H_
+
+#include <cstdint>
+#include <map>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "absl/container/flat_hash_map.h"
+#include "tensorflow/core/framework/dataset.h"
+#include "tensorflow/core/framework/dataset.pb.h"
+#include "tensorflow/core/framework/variant_tensor_data.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tsl/platform/statusor.h"
+
+namespace tensorflow {
+namespace data {
+
+// Reads dataset elements from the checkpoint reader using the given key prefix.
+Status ReadElementsFromCheckpoint(IteratorContext* ctx,
+                                  IteratorStateReader* reader,
+                                  StringPiece key_prefix,
+                                  std::vector<std::vector<Tensor>>* elements);
+
+// Writes dataset elements to the checkpoint writer using the given key prefix.
+// The elements can be read back by passing the same key prefix to
+// ReadElementsFromCheckpoint. Only one list of elements can be written under
+// the same key_prefix.
+Status WriteElementsToCheckpoint(
+    IteratorStateWriter* writer, StringPiece key_prefix,
+    const std::vector<std::vector<Tensor>>& elements);
+
+// Helper class for reading data from a vector of VariantTensorData objects.
+class VariantTensorDataReader : public IteratorStateReader {
+ public:
+  explicit VariantTensorDataReader(
+      const std::vector<const VariantTensorData*>& data);
+
+  bool Contains(StringPiece key) const override;
+  bool Contains(StringPiece name, StringPiece key) const override;
+
+  Status ReadScalar(StringPiece key, int64_t* val) const override;
+  Status ReadScalar(StringPiece name, StringPiece key,
+                    int64_t* val) const override;
+  Status ReadScalar(StringPiece key, tstring* val) const override;
+  Status ReadScalar(StringPiece name, StringPiece key,
+                    tstring* val) const override;
+  Status ReadTensor(StringPiece key, Tensor* val) const override;
+  Status ReadTensor(FunctionLibraryRuntime* flr, StringPiece key,
+                    Tensor* val) const override;
+  Status ReadTensor(StringPiece name, StringPiece key,
+                    Tensor* val) const override;
+  Status ReadTensor(FunctionLibraryRuntime* flr, StringPiece name,
+                    StringPiece key, Tensor* val) const override;
+
+ private:
+  template <typename T>
+  Status ReadScalarInternal(StringPiece name, StringPiece key, T* val) const;
+  Status ReadTensorInternal(FunctionLibraryRuntime* flr, StringPiece name,
+                            StringPiece key, Tensor* val) const;
+  Status ReadDatasetInternal(FunctionLibraryRuntime* flr, StringPiece name,
+                             StringPiece key, Tensor* val) const;
+  // Produces all key/value pairs stored in this reader. Useful for debugging.
+  std::map<string, Tensor> ReadAllTensors();
+
+  // For access to ReadAllTensors()
+  friend tsl::StatusOr<absl::flat_hash_map<std::string, int64_t>>
+  CheckpointStats(const std::string& checkpoint_bytes);
+
+  std::map<string, std::map<string, size_t>> map_;
+  std::map<string, const VariantTensorData*> data_;  // Not owned.
+};
+
+// Helper class used to build a list of VariantTensorData objects, one for each
+// iterator which is determined from the key supplied from the Write* calls.
+// Sample usage:
+// VariantTensorDataWriter writer;
+// writer.WriteScalar(full_name("buffer_size"), buffer_.size());
+// writer.WriteScalar(full_name("num_threads"), threadpool_.size());
+// ....
+// std::vector<std::unique_ptr<VariantTensorData>> variants;
+// writer.ReleaseData(&variants);
+// Now the VariantTensorData objects can be used to serialize.
+class VariantTensorDataWriter : public IteratorStateWriter {
+ public:
+  Status WriteScalar(StringPiece key, int64_t val) override;
+  Status WriteScalar(StringPiece name, StringPiece key, int64_t val) override;
+
+  Status WriteScalar(StringPiece key, const tstring& val) override;
+  Status WriteScalar(StringPiece name, StringPiece key,
+                     const tstring& val) override;
+
+  Status WriteTensor(StringPiece key, const Tensor& val) override;
+  Status WriteTensor(StringPiece name, StringPiece key,
+                     const Tensor& val) override;
+
+  // Releases the built VariantTensorData's to `variants`. Clears out all
+  // class state.
+  void ReleaseData(std::vector<std::unique_ptr<VariantTensorData>>* variants);
+
+  // Obtains a read-only version of the VariantTensorData's built.
+  void GetData(std::vector<const VariantTensorData*>* variants);
+
+ private:
+  void MaybeFlush();
+  void Reset();
+
+  template <typename T>
+  Status WriteScalarInternal(StringPiece name, StringPiece key, const T& val);
+  Status WriteTensorInternal(StringPiece name, StringPiece key,
+                             const Tensor& val);
+  Status WriteDatasetInternal(StringPiece name, StringPiece key,
+                              const DatasetBase* dataset);
+
+  bool is_flushed_ = false;
+  std::map<string, std::unique_ptr<VariantTensorData>> data_;
+  std::map<string, std::vector<string>> keys_;
+};
+
+// Wrapper for encoding/decoding the iterator state stored in a Variant tensor.
+// The `GetData()` method returns an VariantTensorData object which contains all
+// the state needed to restore a single iterator.
+//
+// Usage example:
+//
+// Encoding:
+//
+//   Tensor t(DT_VARIANT, TensorShape({}));
+//   t->scalar<Variant>()() = IteratorStateVariant();
+//
+// Encode() sets the type_name of the VariantTensorData object to
+// IteratorStateVariant::TypeName().
+//
+// Decoding:
+//
+//   Variant v = <VariantTensorDataProto object>;
+//   DecodeUnaryVariant(&v);
+//   IteratorStateVariant* wrapper = v.get<IteratorStateVariant>();
+//   IteratorStateReader reader({wrapper->GetData()});
+//   iterator_resource->Restore(ctx, &reader);
+//
+// The type_name of the VariantTensorData object to be decoded must match
+// IteratorStateVariant::TypeName().
+class IteratorStateVariant {
+ public:
+  IteratorStateVariant() = default;
+  IteratorStateVariant(const IteratorStateVariant& other);
+  IteratorStateVariant& operator=(IteratorStateVariant&& other) = default;
+  IteratorStateVariant& operator=(const IteratorStateVariant& other) = delete;
+
+  static std::string TypeName();
+
+  // Initializes `this` from a VariantTensorData object.
+  Status InitializeFromVariantData(std::unique_ptr<VariantTensorData> data);
+
+  // Returns a borrowed pointer to the underlying VariantTensorData.
+  const VariantTensorData* GetData() const { return data_.get(); }
+
+  // Encodes this `IteratorStateVariant` into `*data`. Data will be compressed
+  // and stored as a scalar `CompressedElement` tensor, or left uncompressed if
+  // compression fails.
+  void Encode(VariantTensorData* data) const;
+
+  // Decodes from `data`. If `data` contains a single scalar `CompressedElement`
+  // tensor, it is assumed to be compressed by `Encode`, and will be
+  // uncompressed as part of `Decode`.
+  bool Decode(VariantTensorData data);
+
+  std::string DebugString() const;
+
+ private:
+  // Returns the compressed element in `data`. If `data` does not contain a
+  // compressed element, returns nullptr.
+  static const CompressedElement* GetCompressedElement(
+      const VariantTensorData& data);
+
+  std::unique_ptr<VariantTensorData> data_;
+};
+
+// Returns a GraphDef representation of the given dataset.
+Status AsGraphDef(const DatasetBase* dataset,
+                  SerializationContext&& serialization_ctx,
+                  GraphDef* graph_def);
+
+// Returns a GraphDef representation of the given dataset suitable for
+// optimization rewrites. It sets serialization parameters to export a minimum
+// graph with additional information for optimization (i.e. ignoring external
+// state, not serializing data tensors, not failing if there are datasets which
+// do not have AsGraphDef implemented). Sets the `dataset_node` parameter to the
+// dataset's node name in the resulting GraphDef.
+Status AsGraphDefForRewrite(OpKernelContext* ctx, const DatasetBase* input,
+                            std::vector<std::pair<string, Tensor>>* input_list,
+                            GraphDef* result, string* dataset_node);
+
+// Analyzes the bytes of a tf.data iterator checkpoint to identify all of the
+// keys in the checkpoint along with their sizes in bytes.
+tsl::StatusOr<absl::flat_hash_map<std::string, int64_t>> CheckpointStats(
+    const std::string& checkpoint_bytes);
+
+}  // namespace data
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_SERIALIZATION_UTILS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/data/snapshot_utils.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/data/snapshot_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..4e8c3a79b85eb2cfe80992add67be06051269786
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/data/snapshot_utils.h
@@ -0,0 +1,448 @@
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DATA_SNAPSHOT_UTILS_H_
+#define TENSORFLOW_CORE_DATA_SNAPSHOT_UTILS_H_
+
+#include <cstdint>
+#include <deque>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "tensorflow/core/framework/dataset.h"
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/lib/io/compression.h"
+#include "tensorflow/core/lib/io/inputstream_interface.h"
+#include "tensorflow/core/lib/io/record_reader.h"
+#include "tensorflow/core/lib/io/record_writer.h"
+#include "tensorflow/core/platform/env.h"
+#include "tensorflow/core/platform/file_system.h"
+#include "tensorflow/core/platform/path.h"
+#include "tensorflow/core/platform/status.h"
+#include "tensorflow/core/protobuf/snapshot.pb.h"
+
+namespace tensorflow {
+
+class GraphDef;
+
+namespace data {
+
+namespace experimental {
+
+class SnapshotMetadataRecord;
+class SnapshotTensorMetadata;
+
+}  // namespace experimental
+
+namespace snapshot_util {
+
+constexpr char kMetadataFilename[] = "snapshot.metadata";
+
+constexpr char kModeAuto[] = "auto";
+constexpr char kModeWrite[] = "write";
+constexpr char kModeRead[] = "read";
+constexpr char kModePassthrough[] = "passthrough";
+constexpr char kShardDirectorySuffix[] = ".shard";
+
+enum Mode { READER = 0, WRITER = 1, PASSTHROUGH = 2 };
+
+// Returns the name of the "hash" directory for the given base path and hash ID.
+std::string HashDirectory(const std::string& path, uint64 hash);
+
+// Returns the name of the "run" directory for the given base path and run ID.
+std::string RunDirectory(const std::string& hash_directory, uint64 run_id);
+std::string RunDirectory(const std::string& hash_directory,
+                         const std::string& run_id);
+
+// Returns the name of the "shard" directory for the given base path and shard
+// ID.
+std::string ShardDirectory(const std::string& run_directory, int64_t shard_id);
+
+// Returns the checkpoint file name for the given directory and checkpoint ID.
+std::string GetCheckpointFileName(const std::string& shard_directory,
+                                  uint64 checkpoint_id);
+
+// This is a interface class that exposes snapshot writing functionality.
+class Writer {
+ public:
+  // Creates a new writer object.
+  static Status Create(Env* env, const std::string& filename,
+                       const std::string& compression_type, int version,
+                       const DataTypeVector& dtypes,
+                       std::unique_ptr<Writer>* out_writer);
+
+  // Writes a vector of tensors to the snapshot writer file.
+  virtual Status WriteTensors(const std::vector<Tensor>& tensors) = 0;
+
+  // Flushes any in-memory buffers to disk.
+  virtual Status Sync() = 0;
+
+  // Closes and finalizes the snapshot file. All calls to any other method will
+  // be invalid after this call.
+  virtual Status Close() = 0;
+
+  virtual ~Writer() = default;
+
+ protected:
+  virtual Status Initialize(tensorflow::Env* env) = 0;
+};
+
+// Writes snapshots with the standard TFRecord file format.
+class TFRecordWriter : public Writer {
+ public:
+  TFRecordWriter(const std::string& filename,
+                 const std::string& compression_type);
+
+  Status Initialize(tensorflow::Env* env) override;
+
+  Status WriteTensors(const std::vector<Tensor>& tensors) override;
+
+  Status Sync() override;
+
+  Status Close() override;
+
+  ~TFRecordWriter() override;
+
+ private:
+  const std::string filename_;
+  const std::string compression_type_;
+
+  std::unique_ptr<WritableFile> dest_;
+  std::unique_ptr<io::RecordWriter> record_writer_;
+};
+
+// Writes snapshot with a custom (legacy) file format.
+class CustomWriter : public Writer {
+ public:
+  static constexpr const size_t kHeaderSize = sizeof(uint64);
+
+  static constexpr const char* const kClassName = "SnapshotWriter";
+  static constexpr const char* const kWriteStringPiece = "WriteStringPiece";
+  static constexpr const char* const kWriteCord = "WriteCord";
+  static constexpr const char* const kSeparator = "::";
+
+  CustomWriter(const std::string& filename, const std::string& compression_type,
+               const DataTypeVector& dtypes);
+
+  Status WriteTensors(const std::vector<Tensor>& tensors) override;
+
+  Status Sync() override;
+
+  Status Close() override;
+
+  ~CustomWriter() override;
+
+ protected:
+  Status Initialize(tensorflow::Env* env) override;
+
+ private:
+  Status WriteRecord(const StringPiece& data);
+
+#if defined(TF_CORD_SUPPORT)
+  Status WriteRecord(const absl::Cord& data);
+#endif  // TF_CORD_SUPPORT
+
+  std::unique_ptr<WritableFile> dest_;
+  const std::string filename_;
+  const std::string compression_type_;
+  const DataTypeVector dtypes_;
+  // We hold zlib_dest_ because we may create a ZlibOutputBuffer and put that
+  // in dest_ if we want compression. ZlibOutputBuffer doesn't own the original
+  // dest_ and so we need somewhere to store the original one.
+  std::unique_ptr<WritableFile> zlib_underlying_dest_;
+  std::vector<bool> simple_tensor_mask_;  // true for simple, false for complex.
+  int num_simple_ = 0;
+  int num_complex_ = 0;
+};
+
+// Interface class for reading snapshot files previous written with Writer.
+class Reader {
+ public:
+  // Op kernel that creates an instance of `Reader::Dataset` needed to support
+  // serialization and deserialization of `Reader::Dataset`.
+  class DatasetOp : public DatasetOpKernel {
+   public:
+    explicit DatasetOp(OpKernelConstruction* ctx);
+
+   protected:
+    void MakeDataset(OpKernelContext* ctx, DatasetBase** output) override;
+
+   private:
+    DataTypeVector output_types_;
+    std::vector<PartialTensorShape> output_shapes_;
+    std::string compression_;
+    int64_t version_;
+  };
+
+  // Op kernel that creates an instance of `Reader::NestedDataset` needed to
+  // support serialization and deserialization of `Reader::NestedDataset`.
+  class NestedDatasetOp : public DatasetOpKernel {
+   public:
+    explicit NestedDatasetOp(OpKernelConstruction* ctx);
+
+   protected:
+    void MakeDataset(OpKernelContext* ctx, DatasetBase** output) override;
+
+   private:
+    DataTypeVector output_types_;
+    std::vector<PartialTensorShape> output_shapes_;
+  };
+
+  // Creates a new Reader object that reads data from `filename`. Note that
+  // the `version`, `compression_type`, and `dtypes` arguments passed into
+  // `Writer` and `Reader` must be the same for the reading to succeed.
+  static Status Create(Env* env, const std::string& filename,
+                       const string& compression_type, int version,
+                       const DataTypeVector& dtypes,
+                       std::unique_ptr<Reader>* out_reader);
+
+  // Returns a nested dataset for a set of given snapshot file names.
+  //
+  // This function takes a vector of snapshot files, and returns a nested
+  // dataset. Each element within the nested dataset is itself a dataset, and
+  // contains all the elements written out to each individual snapshot file.
+  static Status MakeNestedDataset(Env* env,
+                                  const std::vector<std::string>& shard_dirs,
+                                  const string& compression_type, int version,
+                                  const DataTypeVector& dtypes,
+                                  const std::vector<PartialTensorShape>& shapes,
+                                  int64_t start_index, DatasetBase** output);
+
+  // Returns a nested dataset for the given datasets.
+  static void MakeNestedDataset(const std::vector<DatasetBase*>& datasets,
+                                DatasetBase** output);
+
+  // Reads a vector of Tensors from the snapshot file.
+  virtual Status ReadTensors(std::vector<Tensor>* read_tensors) = 0;
+
+  // Skips `num_records`. Equivalent to calling `ReadTensors` `num_records`
+  // times then discarding the results.
+  virtual Status SkipRecords(int64_t num_records);
+
+  virtual ~Reader() = default;
+
+ protected:
+  virtual Status Initialize(Env* env) = 0;
+
+  class Dataset;
+  class NestedDataset;
+};
+
+class TFRecordReaderImpl {
+ public:
+  // Constructs a `TFRecordReaderImpl`.
+  // `filename` is the file to read from.
+  // `compression_type` is the compression method, as defined in
+  // tensorflow/tsl/lib/io/compression.h.
+  // `output_buffer_size` specifies the buffer size required by Snappy/Zlib
+  // compression algorithms. Ignored if compression is not enabled.
+  TFRecordReaderImpl(const std::string& filename, const string& compression,
+                     std::optional<int64_t> output_buffer_size = std::nullopt);
+
+  // Initializes the reader. Callers must initialize the reader before calling
+  // `GetNext` or `GetTensors`.
+  Status Initialize(Env* env);
+
+  // Reads the next Tensor in the input file.
+  StatusOr<Tensor> GetNext();
+
+  // Reads all Tensors in the input file.
+  StatusOr<std::vector<Tensor>> GetTensors();
+
+ private:
+  // Parses `record` into a Tensor.
+  StatusOr<Tensor> Parse(const tstring& record);
+
+  std::string filename_;
+  std::unique_ptr<RandomAccessFile> file_;
+  std::unique_ptr<io::RecordReader> record_reader_;
+  uint64_t offset_;
+
+  const string compression_;
+  const std::optional<int64_t> output_buffer_size_;
+};
+
+// Reads snapshots previously written with `TFRecordWriter`.
+class TFRecordReader : public Reader {
+ public:
+  TFRecordReader(const std::string& filename, const string& compression,
+                 const DataTypeVector& dtypes,
+                 std::optional<int64_t> output_buffer_size = std::nullopt)
+      : reader_impl_(filename, compression, output_buffer_size),
+        dtypes_(dtypes) {}
+
+  // Initializes the reader. Callers must initialize the reader before calling
+  // `ReadTensors`.
+  Status Initialize(Env* env) override { return reader_impl_.Initialize(env); }
+
+  // Reads Tensors into `read_tensors`. Returns OK on success, OutOfRange for
+  // end of file, or an error status if there is an error.
+  Status ReadTensors(std::vector<Tensor>* read_tensors) override;
+
+ private:
+  TFRecordReaderImpl reader_impl_;
+  const DataTypeVector dtypes_;
+};
+
+// Reads snapshots previously written with `CustomWriter`.
+class CustomReader : public Reader {
+ public:
+  // The reader input buffer size is deliberately large because the input reader
+  // will throw an error if the compressed block length cannot fit in the input
+  // buffer.
+  static constexpr const int64_t kSnappyReaderInputBufferSizeBytes =
+      1 << 30;  // 1 GiB
+  // TODO(b/148804377): Set this in a smarter fashion.
+  static constexpr const int64_t kSnappyReaderOutputBufferSizeBytes =
+      32 << 20;  // 32 MiB
+  static constexpr const size_t kHeaderSize = sizeof(uint64);
+
+  static constexpr const char* const kClassName = "SnapshotReader";
+  static constexpr const char* const kReadString = "ReadString";
+  static constexpr const char* const kReadCord = "ReadCord";
+  static constexpr const char* const kSeparator = "::";
+
+  CustomReader(const std::string& filename, const string& compression_type,
+               int version, const DataTypeVector& dtypes);
+
+  Status ReadTensors(std::vector<Tensor>* read_tensors) override;
+
+  ~CustomReader() override = default;
+
+ protected:
+  Status Initialize(Env* env) override;
+
+ private:
+  Status ReadTensorsV0(std::vector<Tensor>* read_tensors);
+
+  Status SnappyUncompress(
+      const experimental::SnapshotTensorMetadata* metadata,
+      std::vector<Tensor>* simple_tensors,
+      std::vector<std::pair<std::unique_ptr<char[]>, size_t>>*
+          tensor_proto_strs);
+
+  Status ReadRecord(tstring* record);
+
+#if defined(TF_CORD_SUPPORT)
+  Status ReadRecord(absl::Cord* record);
+#endif
+
+  std::string filename_;
+  std::unique_ptr<RandomAccessFile> file_;
+  std::unique_ptr<io::InputStreamInterface> input_stream_;
+  const string compression_type_;
+  const int version_;
+  const DataTypeVector dtypes_;
+  int num_simple_ = 0;
+  int num_complex_ = 0;
+  std::vector<bool> simple_tensor_mask_;  // true for simple, false for complex.
+};
+
+// Writes snapshot metadata to the given directory.
+Status WriteMetadataFile(Env* env, const string& dir,
+                         const experimental::SnapshotMetadataRecord* metadata);
+
+// Writes distributed snapshot metadata to the given directory. An error is
+// returned if `dir` is unable to be created or if `metadata` is unable to be
+// written.
+Status WriteMetadataFile(
+    Env* env, const string& dir,
+    const experimental::DistributedSnapshotMetadata* metadata);
+
+// Reads snapshot metadata from the given directory.
+Status ReadMetadataFile(Env* env, const string& dir,
+                        experimental::SnapshotMetadataRecord* metadata,
+                        bool* file_exists);
+
+// Reads distributed snapshot metadata from the given directory. If the file
+// doesn't exist in `dir`, `file_exists` is set to true and an ok status is
+// returned. If the file exists in `dir` but is unable to be opened, an error
+// is returned.
+Status ReadMetadataFile(Env* env, const string& dir,
+                        experimental::DistributedSnapshotMetadata* metadata,
+                        bool* file_exists);
+
+// Writes a dataset graph to the given directory.
+Status DumpDatasetGraph(Env* env, const std::string& path, uint64 hash,
+                        const GraphDef* graph);
+
+Status DetermineOpState(const std::string& mode_string, bool file_exists,
+                        const experimental::SnapshotMetadataRecord* metadata,
+                        uint64 pending_snapshot_expiry_seconds, Mode* mode);
+
+// Represents a dataset element or EOF.
+struct ElementOrEOF {
+  std::vector<Tensor> value;
+  bool end_of_sequence = false;
+};
+
+// AsyncWriter provides API for asynchronously writing dataset elements
+// (each represented as a vector of tensors) to a file.
+//
+// The expected use of this API is:
+//
+// std::unique_ptr<AsyncWriter> writer = absl_make_unique<AsyncWriter>(...);
+//
+// while (data_available()) {
+//   std::vector<Tensor> data = read_data()
+//   writer->Write(data);
+// }
+// writer->SignalEOF();
+// writer = nullptr;  // This will block until writes are flushed.
+class AsyncWriter {
+ public:
+  explicit AsyncWriter(Env* env, int64_t file_index,
+                       const std::string& shard_directory, uint64 checkpoint_id,
+                       const std::string& compression, int64_t version,
+                       const DataTypeVector& output_types,
+                       std::function<void(Status)> done);
+
+  // Writes the given tensors. The method is non-blocking and returns without
+  // waiting for the element to be written.
+  void Write(const std::vector<Tensor>& tensors) TF_LOCKS_EXCLUDED(mu_);
+
+  // Signals the end of input. The method is non-blocking and returns without
+  // waiting for the writer to be closed.
+  void SignalEOF() TF_LOCKS_EXCLUDED(mu_);
+
+ private:
+  void Consume(ElementOrEOF* be) TF_LOCKS_EXCLUDED(mu_);
+  bool ElementAvailable() TF_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+  Status WriterThread(Env* env, const std::string& shard_directory,
+                      uint64 checkpoint_id, const std::string& compression,
+                      int64_t version, DataTypeVector output_types);
+
+  mutex mu_;
+  std::deque<ElementOrEOF> deque_ TF_GUARDED_BY(mu_);
+
+  // This has to be last. During destruction, we need to make sure that the
+  // Thread object is destroyed first as its destructor blocks on thread
+  // completion. If there are other member variables after this, they may get
+  // destroyed first before the thread finishes, potentially causing the
+  // thread to access invalid memory.
+  std::unique_ptr<Thread> thread_;
+};
+
+}  // namespace snapshot_util
+}  // namespace data
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DATA_SNAPSHOT_UTILS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/data/split_utils.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/data/split_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..0801d9afd546e752d0dabf63c4cab92125f67cb7
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/data/split_utils.h
@@ -0,0 +1,94 @@
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_DATA_SPLIT_UTILS_H_
+#define TENSORFLOW_CORE_DATA_SPLIT_UTILS_H_
+
+#include <cstdint>
+#include <functional>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "tensorflow/core/framework/dataset.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tsl/platform/mutex.h"
+#include "tsl/platform/thread_annotations.h"
+
+namespace tensorflow {
+namespace data {
+
+// A class which produces splits for a dataset of size N that can be indexed
+// into.
+class IndexSplitProvider : public SplitProvider {
+ public:
+  explicit IndexSplitProvider(int64_t n);
+  absl::Status GetNext(Tensor* split, bool* end_of_splits) override;
+  absl::Status Reset() override;
+  absl::Status Save(std::function<std::string(std::string)> full_name,
+                    IteratorStateWriter* writer) override;
+  absl::Status Restore(std::function<std::string(std::string)> full_name,
+                       IteratorStateReader* reader) override;
+
+ private:
+  tsl::mutex mu_;
+  int64_t i_ TF_GUARDED_BY(mu_);
+  const int64_t n_;
+};
+
+// A SplitProvider which wraps another split provider, but drops all splits
+// where `index != shard_index % num_shards`
+class ShardingSplitProvider : public SplitProvider {
+ public:
+  ShardingSplitProvider(int64_t num_shards, int64_t shard_index,
+                        std::shared_ptr<SplitProvider> split_provider);
+
+  absl::Status GetNext(Tensor* split, bool* end_of_splits) override;
+  absl::Status Reset() override;
+  absl::Status Save(std::function<std::string(std::string)> full_name,
+                    IteratorStateWriter* writer) override;
+  absl::Status Restore(std::function<std::string(std::string)> full_name,
+                       IteratorStateReader* reader) override;
+
+ private:
+  const int64_t num_shards_;
+  const int64_t shard_index_;
+  tsl::mutex mu_;
+  std::shared_ptr<SplitProvider> split_provider_ TF_GUARDED_BY(mu_);
+  int64_t num_to_skip_ TF_GUARDED_BY(mu_);
+};
+
+// Returns split providers for all sources of the given dataset.
+absl::StatusOr<std::vector<std::unique_ptr<SplitProvider>>> GetSplitProviders(
+    const DatasetBase* dataset);
+
+// Gets the single split provider from the context, or returns an error if the
+// context has zero or multiple split providers. The `dataset` argument is used
+// to produce a more useful error message.
+absl::StatusOr<std::shared_ptr<SplitProvider>> GetSingleSplitProvider(
+    IteratorContext* ctx, const DatasetBase* dataset);
+
+// Creates iterator contexts for datasets inputs. The split providers
+// in `ctx` will be divided among the inputs of `dataset`, so that each input
+// gets a number of split providers that matches its number of source datasets.
+// If no split providers are defined, the contexts will be the same as `ctx`.
+absl::StatusOr<std::vector<IteratorContext>> CreateInputIteratorContexts(
+    IteratorContext* ctx, const DatasetBase* dataset);
+
+}  // namespace data
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DATA_SPLIT_UTILS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/data/stats_utils.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/data/stats_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..5fa1eae397b39e9b03dcc1fb6a51f2dbdca7f1f8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/data/stats_utils.h
@@ -0,0 +1,68 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_DATA_STATS_UTILS_H_
+#define TENSORFLOW_CORE_DATA_STATS_UTILS_H_
+
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+namespace data {
+namespace stats_utils {
+extern const char kDelimiter[];
+extern const char kExecutionTime[];
+extern const char kThreadUtilization[];
+extern const char kBufferSize[];
+extern const char kBufferCapacity[];
+extern const char kBufferUtilization[];
+extern const char kFilteredElements[];
+extern const char kDroppedElements[];
+extern const char kFeaturesCount[];
+extern const char kFeatureValuesCount[];
+extern const char kExamplesCount[];
+
+// Name for tf.data function execution time (in ns) histogram metrics.
+string ExecutionTimeHistogramName(const string& prefix);
+
+// Name for thread utilization (ratio of threads being used and maximum number
+// of threads allocated) scalar metrics.
+string ThreadUtilizationScalarName(const string& prefix);
+
+// Name for buffer size scalar metrics.
+string BufferSizeScalarName(const string& prefix);
+
+// Name for buffer capacity (maximum allocated buffer size) scalar metrics.
+string BufferCapacityScalarName(const string& prefix);
+
+// Name for buffer utilization (ratio of buffer size and maximum allocated
+// buffer size.) histogram metrics.
+string BufferUtilizationHistogramName(const string& prefix);
+
+// Name for filtered elements scalar metrics.
+string FilterdElementsScalarName(const string& prefix);
+
+// Name for dropped elements scalar mereics.
+string DroppedElementsScalarName(const string& prefix);
+
+// Name for features count histogram metrics.
+string FeatureHistogramName(const string& prefix);
+
+// Name for feature-values count histogram metrics.
+string FeatureValueHistogramName(const string& prefix);
+
+}  // namespace stats_utils
+}  // namespace data
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DATA_STATS_UTILS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/data/tfdataz_metrics.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/data/tfdataz_metrics.h
new file mode 100644
index 0000000000000000000000000000000000000000..bb59a73f8d04fd40b88a5bb6562390ca4a51ba62
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/data/tfdataz_metrics.h
@@ -0,0 +1,144 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_DATA_TFDATAZ_METRICS_H_
+#define TENSORFLOW_CORE_DATA_TFDATAZ_METRICS_H_
+
+#include <cstdint>
+#include <deque>
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include "absl/container/flat_hash_set.h"
+#include "absl/time/time.h"
+#include "tensorflow/core/framework/dataset.h"
+#include "tensorflow/core/platform/env.h"
+#include "tensorflow/core/platform/mutex.h"
+#include "tensorflow/core/platform/thread_annotations.h"
+
+namespace tensorflow {
+namespace data {
+
+// Calculates the approximate average latency for past 1, 5 and 60 minutes.
+// The implementation uses ring buffers to maintain the cumulative latency
+// values and count for the past 60 minutes.
+class ApproximateLatencyEstimator {
+ public:
+  enum class Duration {
+    kMinute = 1,
+    kFiveMinutes = 5,
+    kSixtyMinutes = 60,
+  };
+
+  explicit ApproximateLatencyEstimator(const Env& env);
+
+  // Records the latency with the current timestamp.
+  void AddLatency(int64_t latency_usec);
+
+  // Returns the average latency for the duration (1,5 and 60 minutes)
+  // specified.
+  absl::Duration GetAverageLatency(Duration duration);
+
+ private:
+  static constexpr int64_t kSecondsPerMinute = 60;
+  static constexpr int64_t kMinutesPerHour = 60;
+  static constexpr int64_t kSlots = kMinutesPerHour;
+
+  // Updates the latency value and count ring buffers with the latest cumulative
+  // value and count. Resets the entire ring buffer with the last cumulative
+  // values stored if the elapsed time duration is greater than 60 minutes.
+  void UpdateRingBuffer() TF_LOCKS_EXCLUDED(mu_);
+  // Moves the `next_slot_` to the next index in the ring buffer.
+  void IncrementNextSlot() TF_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+  // Returns the slot index which is behind the current slot in ring buffer by
+  // `steps` indices.
+  int PrevSlot(int steps) TF_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+
+  const Env& env_;
+
+  // The time when the ring buffer was last updated.
+  int64_t last_updated_time_mins_ TF_GUARDED_BY(mu_);
+
+  mutex mu_;
+
+  // Counters storing the cumulative sums of latency values and counts recorded
+  // so far.
+  int64_t latency_value_counter_ TF_GUARDED_BY(mu_);
+  int64_t latency_count_counter_ TF_GUARDED_BY(mu_);
+
+  // Next slot in the ring buffer.
+  int next_slot_ TF_GUARDED_BY(mu_);
+
+  // Ring buffer storing the cumulative sum of latency values and counts for the
+  // last 60 minutes.
+  int64_t latency_value_[kSlots] TF_GUARDED_BY(mu_);
+  int64_t latency_count_[kSlots] TF_GUARDED_BY(mu_);
+};
+
+// Collects and exports the tf.data performance metrics to /tfdataz.
+class TfDatazMetricsCollector {
+ public:
+  // Constructs a `TfDatazMetricsCollector`.
+  // We only collect metrics for CPU devices. This is a heuristic to avoid
+  // collecting metrics for device-side iterators created by the multi-device
+  // iterator mechanism.
+  TfDatazMetricsCollector(const Env& env, IteratorBase* iterator);
+
+  // Records `GetNext` call latency.
+  void RecordGetNextLatency(int64_t get_next_latency_usec);
+
+  // Returns the average `GetNext` latency for past 1 minute.
+  absl::Duration GetAverageLatencyForLastOneMinute();
+
+  // Returns the average `GetNext` latency for past 5 minutes.
+  absl::Duration GetAverageLatencyForLastFiveMinutes();
+
+  // Returns the average `GetNext` latency for past 60 minutes.
+  absl::Duration GetAverageLatencyForLastSixtyMinutes();
+
+  // Returns the total memory (in bytes) used by the iterator.
+  // Total memory used by the iterator includes the total number of bytes
+  // buffered in all nodes in the subtree.
+  int64_t GetIteratorTotalMemoryUsage();
+
+ private:
+  IteratorBase* iterator_;  // not owned
+  ApproximateLatencyEstimator latency_estimator_;
+};
+
+// Thread-safe global registry for the /tfdataz metrics. All callers to
+// `TfDatazMetricsRegistry` use the same instance to register and deregister
+// iterator's `TfDatazMetricsCollector`.
+class TfDatazMetricsRegistry {
+ public:
+  // Registers the iterator specific `TfDatazMetricsCollector` in the global
+  // TfDatazMetricsRegistry.
+  static void Register(std::shared_ptr<TfDatazMetricsCollector> collector);
+
+  // Deregisters the iterator specific `TfDatazMetricsCollector` from the global
+  // TfDatazMetricsRegistry.
+  static void Deregister(std::shared_ptr<TfDatazMetricsCollector> collector);
+
+  // Returns all the registered `TfDatazMetricsCollector`s.
+  static absl::flat_hash_set<std::shared_ptr<TfDatazMetricsCollector>>
+  GetIteratorMetricCollectors();
+};
+
+}  // namespace data
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DATA_TFDATAZ_METRICS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/data/unbounded_thread_pool.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/data/unbounded_thread_pool.h
new file mode 100644
index 0000000000000000000000000000000000000000..f790c938c050dd59491e614e17b9c5bd524ee31b
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/data/unbounded_thread_pool.h
@@ -0,0 +1,66 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_DATA_UNBOUNDED_THREAD_POOL_H_
+#define TENSORFLOW_CORE_DATA_UNBOUNDED_THREAD_POOL_H_
+
+#include <deque>
+#include <functional>
+#include <memory>
+#include <vector>
+
+#include "tensorflow/core/framework/thread_factory.h"
+#include "tensorflow/core/lib/core/notification.h"
+#include "tensorflow/core/lib/core/threadpool_interface.h"
+#include "tensorflow/core/platform/env.h"
+#include "tensorflow/core/platform/unbounded_work_queue.h"
+
+namespace tensorflow {
+namespace data {
+
+// An `UnboundedThreadPool` provides a mechanism for temporally multiplexing a
+// potentially large number of "logical" threads onto a smaller number of
+// "physical" threads. The multiplexing is achieved by using an
+// `UnboundedWorkQueue`.
+class UnboundedThreadPool : public thread::ThreadPoolInterface {
+ public:
+  UnboundedThreadPool(Env* env, const string& thread_name)
+      : unbounded_work_queue_(env, thread_name) {}
+  UnboundedThreadPool(Env* env, const string& thread_name,
+                      const ThreadOptions& thread_options)
+      : unbounded_work_queue_(env, thread_name, thread_options) {}
+  ~UnboundedThreadPool() override = default;
+
+  // Returns an implementation of `ThreadFactory` that can be used to create
+  // logical threads in this pool.
+  std::shared_ptr<ThreadFactory> get_thread_factory();
+
+  void Schedule(std::function<void()> fn) override;
+  int NumThreads() const override;
+  int CurrentThreadId() const override;
+
+ private:
+  class LogicalThreadFactory;
+  class LogicalThreadWrapper;
+
+  void ScheduleOnWorkQueue(std::function<void()> fn,
+                           std::shared_ptr<Notification> done);
+
+  UnboundedWorkQueue unbounded_work_queue_;
+};
+
+}  // namespace data
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DATA_UNBOUNDED_THREAD_POOL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/data/utils.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/data/utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..d80431c9680ab8f2ce7347ba6c38f4868cf51214
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/data/utils.h
@@ -0,0 +1,54 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_DATA_UTILS_H_
+#define TENSORFLOW_CORE_DATA_UTILS_H_
+
+#include <optional>
+#include <string>
+
+#include "absl/container/flat_hash_map.h"
+#include "absl/status/statusor.h"
+#include "tensorflow/core/protobuf/data_service.pb.h"
+
+namespace tensorflow {
+namespace data {
+
+// Records latency of fetching data from tf.data iterator.
+void AddLatencySample(int64_t microseconds);
+
+// Records bytes produced by a tf.data iterator.
+void IncrementThroughput(int64_t bytes);
+
+// Returns a modified file name that can be used to do implementation specific
+// file name manipulation/optimization.
+std::string TranslateFileName(const std::string& fname);
+
+// Returns the data transfer protocol to use if one is not specified by the
+// user.
+std::string DefaultDataTransferProtocol();
+
+// Returns a path pointing to the same file as `path` with a potential locality
+// optimization.
+std::string LocalityOptimizedPath(const std::string& path);
+
+// Returns `true` if tf.data service compression should be disabled at runtime
+// based on (1) the inputs or (2) the properties of the calling trainer.
+absl::StatusOr<bool> DisableCompressionAtRuntime(
+    const std::string& data_transfer_protocol, DeploymentMode deployment_mode);
+
+}  // namespace data
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DATA_UTILS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/debug/debug_callback_registry.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/debug/debug_callback_registry.h
new file mode 100644
index 0000000000000000000000000000000000000000..94b57401418eb9a9bb454455b716eb356f82b531
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/debug/debug_callback_registry.h
@@ -0,0 +1,71 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DEBUG_DEBUG_CALLBACK_REGISTRY_H_
+#define TENSORFLOW_CORE_DEBUG_DEBUG_CALLBACK_REGISTRY_H_
+
+#include <functional>
+#include <map>
+#include <string>
+#include <vector>
+
+#include "tensorflow/core/debug/debug_node_key.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/platform/mutex.h"
+
+namespace tensorflow {
+
+// Supports exporting observed debug events to clients using registered
+// callbacks.  Users can register a callback for each debug_url stored using
+// DebugTensorWatch.  The callback key be equivalent to what follows
+// "memcbk:///".
+//
+// All events generated for a watched node will be sent to the call back in the
+// order that they are observed.
+//
+// This callback router should not be used in production or training steps.  It
+// is optimized for deep inspection of graph state rather than performance.
+class DebugCallbackRegistry {
+ public:
+  using EventCallback = std::function<void(const DebugNodeKey&, const Tensor&)>;
+
+  // Provides singleton access to the in memory event store.
+  static DebugCallbackRegistry* singleton();
+
+  // Returns the registered callback, or nullptr, for key.
+  EventCallback* GetCallback(const string& key);
+
+  // Associates callback with key.  This must be called by clients observing
+  // nodes to be exported by this callback router before running a session.
+  void RegisterCallback(const string& key, EventCallback callback);
+
+  // Removes the callback associated with key.
+  void UnregisterCallback(const string& key);
+
+ private:
+  DebugCallbackRegistry();
+
+  // Mutex to ensure that keyed events are never updated in parallel.
+  mutex mu_;
+
+  // Maps debug_url keys to callbacks for routing observed tensors.
+  std::map<string, EventCallback> keyed_callback_ TF_GUARDED_BY(mu_);
+
+  static DebugCallbackRegistry* instance_;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DEBUG_DEBUG_CALLBACK_REGISTRY_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/debug/debug_graph_utils.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/debug/debug_graph_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..86dc90a13483fb8cee13ecc5fc1e38994f586235
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/debug/debug_graph_utils.h
@@ -0,0 +1,126 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DEBUG_DEBUG_GRAPH_UTILS_H_
+#define TENSORFLOW_CORE_DEBUG_DEBUG_GRAPH_UTILS_H_
+
+#include <unordered_map>
+#include <vector>
+
+#include "tensorflow/core/common_runtime/debugger_state_interface.h"
+#include "tensorflow/core/common_runtime/device.h"
+#include "tensorflow/core/graph/graph.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/platform/protobuf.h"
+#include "tensorflow/core/protobuf/debug.pb.h"
+
+namespace tensorflow {
+
+class DebugNodeInserter {
+ public:
+  // EXPERIMENTAL: Insert special debug ops (e.g., DebugIdentity) to graph for
+  // debugging. Currently, such ops need to take exactly one input and has the
+  // string attribute "tensor_name" to indicate what tensor it watches.
+  // For example, before the node insertion, the graph may look like:
+  //
+  // A:0 -----------1----------> B
+  //      |
+  //      ---------2-----------> C
+  //
+  // wherein the output slot 0 of node A feeds as the input to nodes B through
+  // edge 1 and to node C through edge 2.
+  // After the node insertion, assuming both B and C have non-Ref input, the
+  // graph becomes:
+  // A:0 ---3---> Copy -----------4----------> B
+  //                       |
+  //                       ---------5--------> C
+  //                       |
+  //                       ---------6--------> X
+  //
+  // If a node (e.g., B) has Ref input, the graph becomes:
+  //
+  //           --------------------------------> B
+  //           |
+  // A:0 ---3-----> Copy -----------4----------> C
+  //                       |
+  //                       -----------5--------> X
+  //
+  // In other words, we do not feed Refs to deep-copies to downstream nodes.
+  //
+  // Copy is the inserted deep-copy node that copies the input tensor on-device
+  // (e.g., CPU-to-CPU or GPU-to-GPU deep copy) that reduces the likelihood of
+  // racy updates during the debug watches. X is the newly created debug node
+  // that transforms the input (copy of the watched tensor) into a debug signal.
+  //
+  // DebugIdentity is the simplest debugging paradigm, in which the debug signal
+  // (i.e., X:0) equals the tensor itself. More sophisticated debug ops can be
+  // used to transform the tensor into other debug signals. An example is the
+  // DebugNanCounter op.
+  //
+  // If the nodes (A, B and C) are located on GPU and the edges from A to B or C
+  // is HOST_MEMORY, then the CopyHost op will be used instead of the Copy op.
+  static Status InsertNodes(
+      const protobuf::RepeatedPtrField<DebugTensorWatch>& watches, Graph* graph,
+      Device* device);
+
+  // Set the parallel_iterations attribute of TensorFlow while loops
+  // (specifically the nodes for which IsEnter() returns true) to 1 to prevent
+  // any node from being executed multiple times concurrently and
+  // generating temporally-overlapping debug Tensor dumps.
+  static void DeparallelizeWhileLoops(Graph* graph, Device* device);
+
+  // Get canonical name of a copy node.
+  static const string GetCopyNodeName(const string& node_name,
+                                      const int output_slot);
+
+  // Get canonical name of a debug node.
+  static const string GetDebugNodeName(const string& tensor_name,
+                                       const int debug_op_num,
+                                       const string& debug_op_name);
+
+ private:
+  static Status CreateCopyNode(
+      Graph* graph, const DeviceType device_type, const bool is_host_memory,
+      const string& src_node_name, const int src_output, const DataType src_dt,
+      const string& tensor_name, const std::vector<string>& debug_ops,
+      const std::vector<string>& debug_urls, Node** copy_node);
+
+  // Parse the debug_op_name string to extract proper op name and attributes.
+  // debug_op_name can be the proper op name only, e.g., "DebugNumericSummary".
+  // It can also contain customizable keys and values. Each key-value pair is
+  // connected with an equal sign ("="). Multiple key-value pairs are separated
+  // with semicolons (";"), which optional whitespace in between, e.g.,
+  // "DebugNumericSummary(mute_if_healthy=true, lower_bound=-100.0)".
+  static Status ParseDebugOpName(
+      const string& debug_op_name, string* debug_op_name_proper,
+      std::unordered_map<string, string>* attributes);
+
+  static Status SetDebugNodeAttributes(
+      Node* debug_node, const std::unordered_map<string, string>& attributes);
+
+  static Status CreateDebugNode(Graph* graph, const Device& device,
+                                const string& src_copy_node_name,
+                                const DataType src_dt,
+                                const string& tensor_name,
+                                const std::vector<string>& debug_urls,
+                                const int debug_op_num,
+                                const string& debug_op_name, Node** debug_node);
+  // TODO(cais): Cut down the number of args to this method.
+
+  friend class DebugGraphUtilsTest;
+};
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DEBUG_DEBUG_GRAPH_UTILS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/debug/debug_io_utils.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/debug/debug_io_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..0f0054eaa03e5d9da62790680e31e174a7b519fb
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/debug/debug_io_utils.h
@@ -0,0 +1,447 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DEBUG_DEBUG_IO_UTILS_H_
+#define TENSORFLOW_CORE_DEBUG_DEBUG_IO_UTILS_H_
+
+#include <cstddef>
+#include <cstdint>
+#include <functional>
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+#include "tensorflow/core/debug/debug_node_key.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/graph/graph.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/lib/gtl/array_slice.h"
+#include "tensorflow/core/platform/env.h"
+#include "tensorflow/core/platform/logging.h"
+#include "tensorflow/core/util/event.pb.h"
+
+namespace tensorflow {
+
+Status ReadEventFromFile(const string& dump_file_path, Event* event);
+
+struct DebugWatchAndURLSpec {
+  DebugWatchAndURLSpec(const string& watch_key, const string& url,
+                       const bool gated_grpc)
+      : watch_key(watch_key), url(url), gated_grpc(gated_grpc) {}
+
+  const string watch_key;
+  const string url;
+  const bool gated_grpc;
+};
+
+// TODO(cais): Put static functions and members in a namespace, not a class.
+class DebugIO {
+ public:
+  static const char* const kDebuggerPluginName;
+
+  static const char* const kCoreMetadataTag;
+  static const char* const kGraphTag;
+  static const char* const kHashTag;
+
+  static const char* const kFileURLScheme;
+  static const char* const kGrpcURLScheme;
+  static const char* const kMemoryURLScheme;
+
+  static Status PublishDebugMetadata(
+      const int64_t global_step, const int64_t session_run_index,
+      const int64_t executor_step_index, const std::vector<string>& input_names,
+      const std::vector<string>& output_names,
+      const std::vector<string>& target_nodes,
+      const std::unordered_set<string>& debug_urls);
+
+  // Publishes a tensor to a debug target URL.
+  //
+  // Args:
+  //   debug_node_key: A DebugNodeKey identifying the debug node. If
+  //     `debug_node_key.io_of_node` is non-empty, publish for node
+  //     inputs/outputs dumping feature.
+  //   tensor: The Tensor object being published.
+  //   wall_time_us: Time stamp for the Tensor. Unit: microseconds (us).
+  //   debug_urls: An array of debug target URLs, e.g.,
+  //     "file:///foo/tfdbg_dump", "grpc://localhost:11011"
+  //   gated_grpc: Whether this call is subject to gRPC gating.
+  //   step_id: Step ID associated with the tensor.
+  static Status PublishDebugTensor(const DebugNodeKey& debug_node_key,
+                                   const Tensor& tensor,
+                                   const uint64 wall_time_us,
+                                   const gtl::ArraySlice<string> debug_urls,
+                                   bool gated_grpc, int64_t step_id = -1);
+
+  // Convenience overload of the method above for no gated_grpc by default.
+  static Status PublishDebugTensor(const DebugNodeKey& debug_node_key,
+                                   const Tensor& tensor,
+                                   const uint64 wall_time_us,
+                                   const gtl::ArraySlice<string> debug_urls);
+
+  // Publishes a graph to a set of debug URLs.
+  //
+  // Args:
+  //   graph: The graph to be published.
+  //   debug_urls: The set of debug URLs to publish the graph to.
+  static Status PublishGraph(const Graph& graph, const string& device_name,
+                             const std::unordered_set<string>& debug_urls);
+
+  // Determines whether a copy node needs to perform deep-copy of input tensor.
+  //
+  // The input arguments contain sufficient information about the attached
+  // downstream debug ops for this method to determine whether all the said
+  // ops are disabled given the current status of the gRPC gating.
+  //
+  // Args:
+  //   specs: A vector of DebugWatchAndURLSpec carrying information about the
+  //     debug ops attached to the Copy node, their debug URLs and whether
+  //     they have the attribute value gated_grpc == True.
+  //
+  // Returns:
+  //   Whether any of the attached downstream debug ops is enabled given the
+  //   current status of the gRPC gating.
+  static bool IsCopyNodeGateOpen(
+      const std::vector<DebugWatchAndURLSpec>& specs);
+
+  // Determines whether a debug node needs to proceed given the current gRPC
+  // gating status.
+  //
+  // Args:
+  //   watch_key: debug tensor watch key, in the format of
+  //     tensor_name:debug_op, e.g., "Weights:0:DebugIdentity".
+  //   debug_urls: the debug URLs of the debug node.
+  //
+  // Returns:
+  //   Whether this debug op should proceed.
+  static bool IsDebugNodeGateOpen(const string& watch_key,
+                                  const std::vector<string>& debug_urls);
+
+  // Determines whether debug information should be sent through a grpc://
+  // debug URL given the current gRPC gating status.
+  //
+  // Args:
+  //   watch_key: debug tensor watch key, in the format of
+  //     tensor_name:debug_op, e.g., "Weights:0:DebugIdentity".
+  //   debug_url: the debug URL, e.g., "grpc://localhost:3333",
+  //     "file:///tmp/tfdbg_1".
+  //
+  // Returns:
+  //   Whether the sending of debug data to the debug_url should
+  //     proceed.
+  static bool IsDebugURLGateOpen(const string& watch_key,
+                                 const string& debug_url);
+
+  static Status CloseDebugURL(const string& debug_url);
+};
+
+// Helper class for debug ops.
+class DebugFileIO {
+ public:
+  // Encapsulates the Tensor in an Event protobuf and write it to a directory.
+  // The actual path of the dump file will be a contactenation of
+  // dump_root_dir, tensor_name, along with the wall_time.
+  //
+  // For example:
+  //   let dump_root_dir = "/tmp/tfdbg_dump",
+  //       node_name = "foo/bar",
+  //       output_slot = 0,
+  //       debug_op = DebugIdentity,
+  //       and wall_time_us = 1467891234512345,
+  // the dump file will be generated at path:
+  //   /tmp/tfdbg_dump/foo/bar_0_DebugIdentity_1467891234512345.
+  //
+  // Args:
+  //   debug_node_key: A DebugNodeKey identifying the debug node.
+  //   wall_time_us: Wall time at which the Tensor is generated during graph
+  //     execution. Unit: microseconds (us).
+  //   dump_root_dir: Root directory for dumping the tensor.
+  //   dump_file_path: The actual dump file path (passed as reference).
+  static Status DumpTensorToDir(const DebugNodeKey& debug_node_key,
+                                const Tensor& tensor, const uint64 wall_time_us,
+                                const string& dump_root_dir,
+                                string* dump_file_path);
+
+  // Similar to the above, but for node inputs/outputs dumping feature.
+  static Status DumpTensorToDirForNodeDumping(
+      const DebugNodeKey& debug_node_key, const Tensor& tensor,
+      uint64 wall_time_us, const string& dump_root_dir, string* dump_file_path,
+      int64_t step_id);
+
+  // Get the full path to the dump file.
+  //
+  // Args:
+  //   dump_root_dir: The dump root directory, e.g., /tmp/tfdbg_dump
+  //   node_name: Name of the node from which the dumped tensor is generated,
+  //     e.g., foo/bar/node_a
+  //   output_slot: Output slot index of the said node, e.g., 0.
+  //   debug_op: Name of the debug op, e.g., DebugIdentity.
+  //   wall_time_us: Time stamp of the dumped tensor, in microseconds (us).
+  static string GetDumpFilePath(const string& dump_root_dir,
+                                const DebugNodeKey& debug_node_key,
+                                const uint64 wall_time_us);
+
+  // Similar to the above, but for node inputs/outputs dumping feature.
+  static string GetDumpFilePathForNodeDumping(
+      const string& dump_root_dir, const DebugNodeKey& debug_node_key,
+      uint64 wall_time_us, int64_t step_id);
+
+  // Dumps an Event proto to a file.
+  //
+  // Args:
+  //   event_prot: The Event proto to be dumped.
+  //   dir_name: Directory path.
+  //   file_name: Base file name.
+  static Status DumpEventProtoToFile(const Event& event_proto,
+                                     const string& dir_name,
+                                     const string& file_name);
+
+  // Request additional bytes to be dumped to the file system.
+  //
+  // Does not actually dump the bytes, but instead just performs the
+  // bookkeeping necessary to prevent the total dumped amount of data from
+  // exceeding the limit (default 100 GBytes or set customly through the
+  // environment variable TFDBG_DISK_BYTES_LIMIT).
+  //
+  // Args:
+  //   bytes: Number of bytes to request.
+  //
+  // Returns:
+  //   Whether the request is approved given the total dumping
+  //   limit.
+  static bool requestDiskByteUsage(uint64 bytes);
+
+  // Reset the disk byte usage to zero.
+  static void resetDiskByteUsage();
+
+  static uint64 global_disk_bytes_limit_;
+
+ private:
+  // Encapsulates the Tensor in an Event protobuf and write it to file.
+  static Status DumpTensorToEventFile(const DebugNodeKey& debug_node_key,
+                                      const Tensor& tensor,
+                                      const uint64 wall_time_us,
+                                      const string& file_path);
+
+  // Implemented ad hoc here for now.
+  // TODO(cais): Replace with shared implementation once http://b/30497715 is
+  // fixed.
+  static Status RecursiveCreateDir(Env* env, const string& dir);
+
+  // Tracks how much disk has been used so far.
+  static uint64 disk_bytes_used_;
+  // Mutex for thread-safe access to disk_bytes_used_.
+  static mutex bytes_mu_;
+  // Default limit for the disk space.
+  static const uint64 kDefaultGlobalDiskBytesLimit;
+
+  friend class DiskUsageLimitTest;
+};
+
+}  // namespace tensorflow
+
+namespace std {
+
+template <>
+struct hash<::tensorflow::DebugNodeKey> {
+  size_t operator()(const ::tensorflow::DebugNodeKey& k) const {
+    return ::tensorflow::Hash64(
+        ::tensorflow::strings::StrCat(k.device_name, ":", k.node_name, ":",
+                                      k.output_slot, ":", k.debug_op, ":"));
+  }
+};
+
+}  // namespace std
+
+// TODO(cais): Support grpc:// debug URLs in open source once Python grpc
+//   genrule becomes available. See b/23796275.
+#ifndef PLATFORM_WINDOWS
+#include "grpcpp/channel.h"
+#include "tensorflow/core/debug/debug_service.grpc.pb.h"
+
+namespace tensorflow {
+
+class DebugGrpcChannel {
+ public:
+  // Constructor of DebugGrpcChannel.
+  //
+  // Args:
+  //   server_stream_addr: Address (host name and port) of the debug stream
+  //     server implementing the EventListener service (see
+  //     debug_service.proto). E.g., "127.0.0.1:12345".
+  explicit DebugGrpcChannel(const string& server_stream_addr);
+
+  virtual ~DebugGrpcChannel() {}
+
+  // Attempt to establish connection with server.
+  //
+  // Args:
+  //   timeout_micros: Timeout (in microseconds) for the attempt to establish
+  //     the connection.
+  //
+  // Returns:
+  //   OK Status iff connection is successfully established before timeout,
+  //   otherwise return an error Status.
+  Status Connect(const int64_t timeout_micros);
+
+  // Write an Event proto to the debug gRPC stream.
+  //
+  // Thread-safety: Safe with respect to other calls to the same method and
+  //   calls to ReadEventReply() and Close().
+  //
+  // Args:
+  //   event: The event proto to be written to the stream.
+  //
+  // Returns:
+  //   True iff the write is successful.
+  bool WriteEvent(const Event& event);
+
+  // Read an EventReply proto from the debug gRPC stream.
+  //
+  // This method blocks and waits for an EventReply from the server.
+  // Thread-safety: Safe with respect to other calls to the same method and
+  //   calls to WriteEvent() and Close().
+  //
+  // Args:
+  //   event_reply: the to-be-modified EventReply proto passed as reference.
+  //
+  // Returns:
+  //   True iff the read is successful.
+  bool ReadEventReply(EventReply* event_reply);
+
+  // Receive and process EventReply protos from the gRPC debug server.
+  //
+  // The processing includes setting debug watch key states using the
+  // DebugOpStateChange fields of the EventReply.
+  //
+  // Args:
+  //   max_replies: Maximum number of replies to receive. Will receive all
+  //     remaining replies iff max_replies == 0.
+  void ReceiveAndProcessEventReplies(size_t max_replies);
+
+  // Receive EventReplies from server (if any) and close the stream and the
+  // channel.
+  Status ReceiveServerRepliesAndClose();
+
+ private:
+  string server_stream_addr_;
+  string url_;
+  ::grpc::ClientContext ctx_;
+  std::shared_ptr<::grpc::Channel> channel_;
+  std::unique_ptr<grpc::EventListener::Stub> stub_;
+  std::unique_ptr<::grpc::ClientReaderWriterInterface<Event, EventReply>>
+      reader_writer_;
+
+  mutex mu_;
+};
+
+class DebugGrpcIO {
+ public:
+  static const size_t kGrpcMessageSizeLimitBytes;
+  static const size_t kGrpcMaxVarintLengthSize;
+
+  // Sends a tensor through a debug gRPC stream.
+  static Status SendTensorThroughGrpcStream(const DebugNodeKey& debug_node_key,
+                                            const Tensor& tensor,
+                                            const uint64 wall_time_us,
+                                            const string& grpc_stream_url,
+                                            const bool gated);
+
+  // Sends an Event proto through a debug gRPC stream.
+  // Thread-safety: Safe with respect to other calls to the same method and
+  // calls to CloseGrpcStream().
+  //
+  // Args:
+  //   event_proto: The Event proto to be sent.
+  //   grpc_stream_url: The grpc:// URL of the stream to use, e.g.,
+  //     "grpc://localhost:11011", "localhost:22022".
+  //   receive_reply: Whether an EventReply proto will be read after event_proto
+  //     is sent and before the function returns.
+  //
+  // Returns:
+  //   The Status of the operation.
+  static Status SendEventProtoThroughGrpcStream(
+      const Event& event_proto, const string& grpc_stream_url,
+      const bool receive_reply = false);
+
+  // Receive an EventReply proto through a debug gRPC stream.
+  static Status ReceiveEventReplyProtoThroughGrpcStream(
+      EventReply* event_reply, const string& grpc_stream_url);
+
+  // Check whether a debug watch key is read-activated at a given gRPC URL.
+  static bool IsReadGateOpen(const string& grpc_debug_url,
+                             const string& watch_key);
+
+  // Check whether a debug watch key is write-activated (i.e., read- and
+  // write-activated) at a given gRPC URL.
+  static bool IsWriteGateOpen(const string& grpc_debug_url,
+                              const string& watch_key);
+
+  // Closes a gRPC stream to the given address, if it exists.
+  // Thread-safety: Safe with respect to other calls to the same method and
+  // calls to SendTensorThroughGrpcStream().
+  static Status CloseGrpcStream(const string& grpc_stream_url);
+
+  // Set the gRPC state of a debug node key.
+  // TODO(cais): Include device information in watch_key.
+  static void SetDebugNodeKeyGrpcState(
+      const string& grpc_debug_url, const string& watch_key,
+      const EventReply::DebugOpStateChange::State new_state);
+
+ private:
+  using DebugNodeName2State =
+      std::unordered_map<string, EventReply::DebugOpStateChange::State>;
+
+  // Returns a global map from grpc debug URLs to the corresponding
+  // DebugGrpcChannels.
+  static std::unordered_map<string, std::unique_ptr<DebugGrpcChannel>>*
+  GetStreamChannels();
+
+  // Get a DebugGrpcChannel object at a given URL, creating one if necessary.
+  //
+  // Args:
+  //   grpc_stream_url: grpc:// URL of the stream, e.g., "grpc://localhost:6064"
+  //   debug_grpc_channel: A pointer to the DebugGrpcChannel object, passed as a
+  //     a pointer to the pointer. The DebugGrpcChannel object is owned
+  //     statically elsewhere, not by the caller of this function.
+  //
+  // Returns:
+  //   Status of this operation.
+  static Status GetOrCreateDebugGrpcChannel(
+      const string& grpc_stream_url, DebugGrpcChannel** debug_grpc_channel);
+
+  // Returns a map from debug URL to a map from debug op name to enabled state.
+  static std::unordered_map<string, DebugNodeName2State>*
+  GetEnabledDebugOpStates();
+
+  // Returns a map from debug op names to enabled state, for a given debug URL.
+  static DebugNodeName2State* GetEnabledDebugOpStatesAtUrl(
+      const string& grpc_debug_url);
+
+  // Clear enabled debug op state from all debug URLs (if any).
+  static void ClearEnabledWatchKeys();
+
+  static mutex streams_mu_;
+  static int64_t channel_connection_timeout_micros_;
+
+  friend class GrpcDebugTest;
+  friend class DebugNumericSummaryOpTest;
+};
+
+}  // namespace tensorflow
+#endif  // #ifndef(PLATFORM_WINDOWS)
+
+#endif  // TENSORFLOW_CORE_DEBUG_DEBUG_IO_UTILS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/debug/debug_node_key.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/debug/debug_node_key.h
new file mode 100644
index 0000000000000000000000000000000000000000..5decb5cc68364359f130ff76ae962789f730b513
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/debug/debug_node_key.h
@@ -0,0 +1,56 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DEBUG_DEBUG_NODE_KEY_H_
+#define TENSORFLOW_CORE_DEBUG_DEBUG_NODE_KEY_H_
+
+#include <string>
+
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+
+// Encapsulates debug information for a node that was observed.
+struct DebugNodeKey {
+  static const char* const kMetadataFilePrefix;
+  static const char* const kDeviceTag;
+
+  DebugNodeKey(const string& device_name, const string& node_name,
+               int32_t output_slot, const string& debug_op,
+               const string& io_of_node = "", bool is_input = false,
+               int32_t io_index = -1);
+
+  // Converts a device name string to a device path string.
+  // E.g., /job:localhost/replica:0/task:0/cpu:0 will be converted to
+  //   ,job_localhost,replica_0,task_0,cpu_0.
+  static const string DeviceNameToDevicePath(const string& device_name);
+
+  bool operator==(const DebugNodeKey& other) const;
+  bool operator!=(const DebugNodeKey& other) const;
+
+  const string device_name;
+  const string node_name;
+  const int32 output_slot;
+  const string debug_op;
+  const string debug_node_name;
+  const string device_path;
+  const string io_of_node;
+  const bool is_input;
+  const int32 io_index;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DEBUG_DEBUG_NODE_KEY_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/debug/debug_service.grpc.pb.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/debug/debug_service.grpc.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..eaa2227279f7b4d830a64ceb3c6f9977361530c7
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/debug/debug_service.grpc.pb.h
@@ -0,0 +1,722 @@
+// Generated by the gRPC C++ plugin.
+// If you make any local change, they will be lost.
+// source: tensorflow/core/debug/debug_service.proto
+// Original file comments:
+// Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// ==============================================================================
+//
+#ifndef GRPC_tensorflow_2fcore_2fdebug_2fdebug_5fservice_2eproto__INCLUDED
+#define GRPC_tensorflow_2fcore_2fdebug_2fdebug_5fservice_2eproto__INCLUDED
+
+#include "tensorflow/core/debug/debug_service.pb.h"
+
+#include <functional>
+#include <grpc/impl/codegen/port_platform.h>
+#include <grpcpp/impl/codegen/async_generic_service.h>
+#include <grpcpp/impl/codegen/async_stream.h>
+#include <grpcpp/impl/codegen/async_unary_call.h>
+#include <grpcpp/impl/codegen/client_callback.h>
+#include <grpcpp/impl/codegen/client_context.h>
+#include <grpcpp/impl/codegen/completion_queue.h>
+#include <grpcpp/impl/codegen/message_allocator.h>
+#include <grpcpp/impl/codegen/method_handler.h>
+#include <grpcpp/impl/codegen/proto_utils.h>
+#include <grpcpp/impl/codegen/rpc_method.h>
+#include <grpcpp/impl/codegen/server_callback.h>
+#include <grpcpp/impl/codegen/server_callback_handlers.h>
+#include <grpcpp/impl/codegen/server_context.h>
+#include <grpcpp/impl/codegen/service_type.h>
+#include <grpcpp/impl/codegen/status.h>
+#include <grpcpp/impl/codegen/stub_options.h>
+#include <grpcpp/impl/codegen/sync_stream.h>
+
+namespace tensorflow {
+
+
+namespace grpc {
+
+// EventListener: Receives Event protos, e.g., from debugged TensorFlow
+// runtime(s).
+class EventListener final {
+ public:
+  static constexpr char const* service_full_name() {
+    return "tensorflow.EventListener";
+  }
+  class StubInterface {
+   public:
+    virtual ~StubInterface() {}
+    // Client(s) can use this RPC method to send the EventListener Event protos.
+    // The Event protos can hold information such as:
+    //   1) intermediate tensors from a debugged graph being executed, which can
+    //      be sent from DebugIdentity ops configured with grpc URLs.
+    //   2) GraphDefs of partition graphs, which can be sent from special debug
+    //      ops that get executed immediately after the beginning of the graph
+    //      execution.
+    std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::tensorflow::Event, ::tensorflow::EventReply>> SendEvents(::grpc::ClientContext* context) {
+      return std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::tensorflow::Event, ::tensorflow::EventReply>>(SendEventsRaw(context));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::tensorflow::Event, ::tensorflow::EventReply>> AsyncSendEvents(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) {
+      return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::tensorflow::Event, ::tensorflow::EventReply>>(AsyncSendEventsRaw(context, cq, tag));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::tensorflow::Event, ::tensorflow::EventReply>> PrepareAsyncSendEvents(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::tensorflow::Event, ::tensorflow::EventReply>>(PrepareAsyncSendEventsRaw(context, cq));
+    }
+    // Send the tracebacks of a TensorFlow execution call.
+    virtual ::grpc::Status SendTracebacks(::grpc::ClientContext* context, const ::tensorflow::CallTraceback& request, ::tensorflow::EventReply* response) = 0;
+    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::tensorflow::EventReply>> AsyncSendTracebacks(::grpc::ClientContext* context, const ::tensorflow::CallTraceback& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::tensorflow::EventReply>>(AsyncSendTracebacksRaw(context, request, cq));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::tensorflow::EventReply>> PrepareAsyncSendTracebacks(::grpc::ClientContext* context, const ::tensorflow::CallTraceback& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::tensorflow::EventReply>>(PrepareAsyncSendTracebacksRaw(context, request, cq));
+    }
+    // Send a collection of source code files being debugged.
+    virtual ::grpc::Status SendSourceFiles(::grpc::ClientContext* context, const ::tensorflow::DebuggedSourceFiles& request, ::tensorflow::EventReply* response) = 0;
+    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::tensorflow::EventReply>> AsyncSendSourceFiles(::grpc::ClientContext* context, const ::tensorflow::DebuggedSourceFiles& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::tensorflow::EventReply>>(AsyncSendSourceFilesRaw(context, request, cq));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::tensorflow::EventReply>> PrepareAsyncSendSourceFiles(::grpc::ClientContext* context, const ::tensorflow::DebuggedSourceFiles& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::tensorflow::EventReply>>(PrepareAsyncSendSourceFilesRaw(context, request, cq));
+    }
+    class experimental_async_interface {
+     public:
+      virtual ~experimental_async_interface() {}
+      // Client(s) can use this RPC method to send the EventListener Event protos.
+      // The Event protos can hold information such as:
+      //   1) intermediate tensors from a debugged graph being executed, which can
+      //      be sent from DebugIdentity ops configured with grpc URLs.
+      //   2) GraphDefs of partition graphs, which can be sent from special debug
+      //      ops that get executed immediately after the beginning of the graph
+      //      execution.
+      #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+      virtual void SendEvents(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::tensorflow::Event,::tensorflow::EventReply>* reactor) = 0;
+      #else
+      virtual void SendEvents(::grpc::ClientContext* context, ::grpc::experimental::ClientBidiReactor< ::tensorflow::Event,::tensorflow::EventReply>* reactor) = 0;
+      #endif
+      // Send the tracebacks of a TensorFlow execution call.
+      virtual void SendTracebacks(::grpc::ClientContext* context, const ::tensorflow::CallTraceback* request, ::tensorflow::EventReply* response, std::function<void(::grpc::Status)>) = 0;
+      virtual void SendTracebacks(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::tensorflow::EventReply* response, std::function<void(::grpc::Status)>) = 0;
+      #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+      virtual void SendTracebacks(::grpc::ClientContext* context, const ::tensorflow::CallTraceback* request, ::tensorflow::EventReply* response, ::grpc::ClientUnaryReactor* reactor) = 0;
+      #else
+      virtual void SendTracebacks(::grpc::ClientContext* context, const ::tensorflow::CallTraceback* request, ::tensorflow::EventReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
+      #endif
+      #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+      virtual void SendTracebacks(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::tensorflow::EventReply* response, ::grpc::ClientUnaryReactor* reactor) = 0;
+      #else
+      virtual void SendTracebacks(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::tensorflow::EventReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
+      #endif
+      // Send a collection of source code files being debugged.
+      virtual void SendSourceFiles(::grpc::ClientContext* context, const ::tensorflow::DebuggedSourceFiles* request, ::tensorflow::EventReply* response, std::function<void(::grpc::Status)>) = 0;
+      virtual void SendSourceFiles(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::tensorflow::EventReply* response, std::function<void(::grpc::Status)>) = 0;
+      #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+      virtual void SendSourceFiles(::grpc::ClientContext* context, const ::tensorflow::DebuggedSourceFiles* request, ::tensorflow::EventReply* response, ::grpc::ClientUnaryReactor* reactor) = 0;
+      #else
+      virtual void SendSourceFiles(::grpc::ClientContext* context, const ::tensorflow::DebuggedSourceFiles* request, ::tensorflow::EventReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
+      #endif
+      #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+      virtual void SendSourceFiles(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::tensorflow::EventReply* response, ::grpc::ClientUnaryReactor* reactor) = 0;
+      #else
+      virtual void SendSourceFiles(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::tensorflow::EventReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
+      #endif
+    };
+    #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+    typedef class experimental_async_interface async_interface;
+    #endif
+    #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+    async_interface* async() { return experimental_async(); }
+    #endif
+    virtual class experimental_async_interface* experimental_async() { return nullptr; }
+  private:
+    virtual ::grpc::ClientReaderWriterInterface< ::tensorflow::Event, ::tensorflow::EventReply>* SendEventsRaw(::grpc::ClientContext* context) = 0;
+    virtual ::grpc::ClientAsyncReaderWriterInterface< ::tensorflow::Event, ::tensorflow::EventReply>* AsyncSendEventsRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) = 0;
+    virtual ::grpc::ClientAsyncReaderWriterInterface< ::tensorflow::Event, ::tensorflow::EventReply>* PrepareAsyncSendEventsRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientAsyncResponseReaderInterface< ::tensorflow::EventReply>* AsyncSendTracebacksRaw(::grpc::ClientContext* context, const ::tensorflow::CallTraceback& request, ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientAsyncResponseReaderInterface< ::tensorflow::EventReply>* PrepareAsyncSendTracebacksRaw(::grpc::ClientContext* context, const ::tensorflow::CallTraceback& request, ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientAsyncResponseReaderInterface< ::tensorflow::EventReply>* AsyncSendSourceFilesRaw(::grpc::ClientContext* context, const ::tensorflow::DebuggedSourceFiles& request, ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientAsyncResponseReaderInterface< ::tensorflow::EventReply>* PrepareAsyncSendSourceFilesRaw(::grpc::ClientContext* context, const ::tensorflow::DebuggedSourceFiles& request, ::grpc::CompletionQueue* cq) = 0;
+  };
+  class Stub final : public StubInterface {
+   public:
+    Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel);
+    std::unique_ptr< ::grpc::ClientReaderWriter< ::tensorflow::Event, ::tensorflow::EventReply>> SendEvents(::grpc::ClientContext* context) {
+      return std::unique_ptr< ::grpc::ClientReaderWriter< ::tensorflow::Event, ::tensorflow::EventReply>>(SendEventsRaw(context));
+    }
+    std::unique_ptr<  ::grpc::ClientAsyncReaderWriter< ::tensorflow::Event, ::tensorflow::EventReply>> AsyncSendEvents(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) {
+      return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::tensorflow::Event, ::tensorflow::EventReply>>(AsyncSendEventsRaw(context, cq, tag));
+    }
+    std::unique_ptr<  ::grpc::ClientAsyncReaderWriter< ::tensorflow::Event, ::tensorflow::EventReply>> PrepareAsyncSendEvents(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::tensorflow::Event, ::tensorflow::EventReply>>(PrepareAsyncSendEventsRaw(context, cq));
+    }
+    ::grpc::Status SendTracebacks(::grpc::ClientContext* context, const ::tensorflow::CallTraceback& request, ::tensorflow::EventReply* response) override;
+    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::tensorflow::EventReply>> AsyncSendTracebacks(::grpc::ClientContext* context, const ::tensorflow::CallTraceback& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::tensorflow::EventReply>>(AsyncSendTracebacksRaw(context, request, cq));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::tensorflow::EventReply>> PrepareAsyncSendTracebacks(::grpc::ClientContext* context, const ::tensorflow::CallTraceback& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::tensorflow::EventReply>>(PrepareAsyncSendTracebacksRaw(context, request, cq));
+    }
+    ::grpc::Status SendSourceFiles(::grpc::ClientContext* context, const ::tensorflow::DebuggedSourceFiles& request, ::tensorflow::EventReply* response) override;
+    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::tensorflow::EventReply>> AsyncSendSourceFiles(::grpc::ClientContext* context, const ::tensorflow::DebuggedSourceFiles& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::tensorflow::EventReply>>(AsyncSendSourceFilesRaw(context, request, cq));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::tensorflow::EventReply>> PrepareAsyncSendSourceFiles(::grpc::ClientContext* context, const ::tensorflow::DebuggedSourceFiles& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::tensorflow::EventReply>>(PrepareAsyncSendSourceFilesRaw(context, request, cq));
+    }
+    class experimental_async final :
+      public StubInterface::experimental_async_interface {
+     public:
+      #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+      void SendEvents(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::tensorflow::Event,::tensorflow::EventReply>* reactor) override;
+      #else
+      void SendEvents(::grpc::ClientContext* context, ::grpc::experimental::ClientBidiReactor< ::tensorflow::Event,::tensorflow::EventReply>* reactor) override;
+      #endif
+      void SendTracebacks(::grpc::ClientContext* context, const ::tensorflow::CallTraceback* request, ::tensorflow::EventReply* response, std::function<void(::grpc::Status)>) override;
+      void SendTracebacks(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::tensorflow::EventReply* response, std::function<void(::grpc::Status)>) override;
+      #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+      void SendTracebacks(::grpc::ClientContext* context, const ::tensorflow::CallTraceback* request, ::tensorflow::EventReply* response, ::grpc::ClientUnaryReactor* reactor) override;
+      #else
+      void SendTracebacks(::grpc::ClientContext* context, const ::tensorflow::CallTraceback* request, ::tensorflow::EventReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
+      #endif
+      #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+      void SendTracebacks(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::tensorflow::EventReply* response, ::grpc::ClientUnaryReactor* reactor) override;
+      #else
+      void SendTracebacks(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::tensorflow::EventReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
+      #endif
+      void SendSourceFiles(::grpc::ClientContext* context, const ::tensorflow::DebuggedSourceFiles* request, ::tensorflow::EventReply* response, std::function<void(::grpc::Status)>) override;
+      void SendSourceFiles(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::tensorflow::EventReply* response, std::function<void(::grpc::Status)>) override;
+      #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+      void SendSourceFiles(::grpc::ClientContext* context, const ::tensorflow::DebuggedSourceFiles* request, ::tensorflow::EventReply* response, ::grpc::ClientUnaryReactor* reactor) override;
+      #else
+      void SendSourceFiles(::grpc::ClientContext* context, const ::tensorflow::DebuggedSourceFiles* request, ::tensorflow::EventReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
+      #endif
+      #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+      void SendSourceFiles(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::tensorflow::EventReply* response, ::grpc::ClientUnaryReactor* reactor) override;
+      #else
+      void SendSourceFiles(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::tensorflow::EventReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
+      #endif
+     private:
+      friend class Stub;
+      explicit experimental_async(Stub* stub): stub_(stub) { }
+      Stub* stub() { return stub_; }
+      Stub* stub_;
+    };
+    class experimental_async_interface* experimental_async() override { return &async_stub_; }
+
+   private:
+    std::shared_ptr< ::grpc::ChannelInterface> channel_;
+    class experimental_async async_stub_{this};
+    ::grpc::ClientReaderWriter< ::tensorflow::Event, ::tensorflow::EventReply>* SendEventsRaw(::grpc::ClientContext* context) override;
+    ::grpc::ClientAsyncReaderWriter< ::tensorflow::Event, ::tensorflow::EventReply>* AsyncSendEventsRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) override;
+    ::grpc::ClientAsyncReaderWriter< ::tensorflow::Event, ::tensorflow::EventReply>* PrepareAsyncSendEventsRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientAsyncResponseReader< ::tensorflow::EventReply>* AsyncSendTracebacksRaw(::grpc::ClientContext* context, const ::tensorflow::CallTraceback& request, ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientAsyncResponseReader< ::tensorflow::EventReply>* PrepareAsyncSendTracebacksRaw(::grpc::ClientContext* context, const ::tensorflow::CallTraceback& request, ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientAsyncResponseReader< ::tensorflow::EventReply>* AsyncSendSourceFilesRaw(::grpc::ClientContext* context, const ::tensorflow::DebuggedSourceFiles& request, ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientAsyncResponseReader< ::tensorflow::EventReply>* PrepareAsyncSendSourceFilesRaw(::grpc::ClientContext* context, const ::tensorflow::DebuggedSourceFiles& request, ::grpc::CompletionQueue* cq) override;
+    const ::grpc::internal::RpcMethod rpcmethod_SendEvents_;
+    const ::grpc::internal::RpcMethod rpcmethod_SendTracebacks_;
+    const ::grpc::internal::RpcMethod rpcmethod_SendSourceFiles_;
+  };
+  static std::unique_ptr<Stub> NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());
+
+  class Service : public ::grpc::Service {
+   public:
+    Service();
+    virtual ~Service();
+    // Client(s) can use this RPC method to send the EventListener Event protos.
+    // The Event protos can hold information such as:
+    //   1) intermediate tensors from a debugged graph being executed, which can
+    //      be sent from DebugIdentity ops configured with grpc URLs.
+    //   2) GraphDefs of partition graphs, which can be sent from special debug
+    //      ops that get executed immediately after the beginning of the graph
+    //      execution.
+    virtual ::grpc::Status SendEvents(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::tensorflow::EventReply, ::tensorflow::Event>* stream);
+    // Send the tracebacks of a TensorFlow execution call.
+    virtual ::grpc::Status SendTracebacks(::grpc::ServerContext* context, const ::tensorflow::CallTraceback* request, ::tensorflow::EventReply* response);
+    // Send a collection of source code files being debugged.
+    virtual ::grpc::Status SendSourceFiles(::grpc::ServerContext* context, const ::tensorflow::DebuggedSourceFiles* request, ::tensorflow::EventReply* response);
+  };
+  template <class BaseClass>
+  class WithAsyncMethod_SendEvents : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithAsyncMethod_SendEvents() {
+      ::grpc::Service::MarkMethodAsync(0);
+    }
+    ~WithAsyncMethod_SendEvents() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status SendEvents(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::tensorflow::EventReply, ::tensorflow::Event>* /*stream*/)  override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    void RequestSendEvents(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter< ::tensorflow::EventReply, ::tensorflow::Event>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncBidiStreaming(0, context, stream, new_call_cq, notification_cq, tag);
+    }
+  };
+  template <class BaseClass>
+  class WithAsyncMethod_SendTracebacks : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithAsyncMethod_SendTracebacks() {
+      ::grpc::Service::MarkMethodAsync(1);
+    }
+    ~WithAsyncMethod_SendTracebacks() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status SendTracebacks(::grpc::ServerContext* /*context*/, const ::tensorflow::CallTraceback* /*request*/, ::tensorflow::EventReply* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    void RequestSendTracebacks(::grpc::ServerContext* context, ::tensorflow::CallTraceback* request, ::grpc::ServerAsyncResponseWriter< ::tensorflow::EventReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag);
+    }
+  };
+  template <class BaseClass>
+  class WithAsyncMethod_SendSourceFiles : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithAsyncMethod_SendSourceFiles() {
+      ::grpc::Service::MarkMethodAsync(2);
+    }
+    ~WithAsyncMethod_SendSourceFiles() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status SendSourceFiles(::grpc::ServerContext* /*context*/, const ::tensorflow::DebuggedSourceFiles* /*request*/, ::tensorflow::EventReply* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    void RequestSendSourceFiles(::grpc::ServerContext* context, ::tensorflow::DebuggedSourceFiles* request, ::grpc::ServerAsyncResponseWriter< ::tensorflow::EventReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncUnary(2, context, request, response, new_call_cq, notification_cq, tag);
+    }
+  };
+  typedef WithAsyncMethod_SendEvents<WithAsyncMethod_SendTracebacks<WithAsyncMethod_SendSourceFiles<Service > > > AsyncService;
+  template <class BaseClass>
+  class ExperimentalWithCallbackMethod_SendEvents : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    ExperimentalWithCallbackMethod_SendEvents() {
+    #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+      ::grpc::Service::
+    #else
+      ::grpc::Service::experimental().
+    #endif
+        MarkMethodCallback(0,
+          new ::grpc_impl::internal::CallbackBidiHandler< ::tensorflow::Event, ::tensorflow::EventReply>(
+            [this](
+    #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+                   ::grpc::CallbackServerContext*
+    #else
+                   ::grpc::experimental::CallbackServerContext*
+    #endif
+                     context) { return this->SendEvents(context); }));
+    }
+    ~ExperimentalWithCallbackMethod_SendEvents() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status SendEvents(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::tensorflow::EventReply, ::tensorflow::Event>* /*stream*/)  override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+    virtual ::grpc::ServerBidiReactor< ::tensorflow::Event, ::tensorflow::EventReply>* SendEvents(
+      ::grpc::CallbackServerContext* /*context*/)
+    #else
+    virtual ::grpc::experimental::ServerBidiReactor< ::tensorflow::Event, ::tensorflow::EventReply>* SendEvents(
+      ::grpc::experimental::CallbackServerContext* /*context*/)
+    #endif
+      { return nullptr; }
+  };
+  template <class BaseClass>
+  class ExperimentalWithCallbackMethod_SendTracebacks : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    ExperimentalWithCallbackMethod_SendTracebacks() {
+    #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+      ::grpc::Service::
+    #else
+      ::grpc::Service::experimental().
+    #endif
+        MarkMethodCallback(1,
+          new ::grpc_impl::internal::CallbackUnaryHandler< ::tensorflow::CallTraceback, ::tensorflow::EventReply>(
+            [this](
+    #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+                   ::grpc::CallbackServerContext*
+    #else
+                   ::grpc::experimental::CallbackServerContext*
+    #endif
+                     context, const ::tensorflow::CallTraceback* request, ::tensorflow::EventReply* response) { return this->SendTracebacks(context, request, response); }));}
+    void SetMessageAllocatorFor_SendTracebacks(
+        ::grpc::experimental::MessageAllocator< ::tensorflow::CallTraceback, ::tensorflow::EventReply>* allocator) {
+    #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+      ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(1);
+    #else
+      ::grpc::internal::MethodHandler* const handler = ::grpc::Service::experimental().GetHandler(1);
+    #endif
+      static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::tensorflow::CallTraceback, ::tensorflow::EventReply>*>(handler)
+              ->SetMessageAllocator(allocator);
+    }
+    ~ExperimentalWithCallbackMethod_SendTracebacks() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status SendTracebacks(::grpc::ServerContext* /*context*/, const ::tensorflow::CallTraceback* /*request*/, ::tensorflow::EventReply* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+    virtual ::grpc::ServerUnaryReactor* SendTracebacks(
+      ::grpc::CallbackServerContext* /*context*/, const ::tensorflow::CallTraceback* /*request*/, ::tensorflow::EventReply* /*response*/)
+    #else
+    virtual ::grpc::experimental::ServerUnaryReactor* SendTracebacks(
+      ::grpc::experimental::CallbackServerContext* /*context*/, const ::tensorflow::CallTraceback* /*request*/, ::tensorflow::EventReply* /*response*/)
+    #endif
+      { return nullptr; }
+  };
+  template <class BaseClass>
+  class ExperimentalWithCallbackMethod_SendSourceFiles : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    ExperimentalWithCallbackMethod_SendSourceFiles() {
+    #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+      ::grpc::Service::
+    #else
+      ::grpc::Service::experimental().
+    #endif
+        MarkMethodCallback(2,
+          new ::grpc_impl::internal::CallbackUnaryHandler< ::tensorflow::DebuggedSourceFiles, ::tensorflow::EventReply>(
+            [this](
+    #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+                   ::grpc::CallbackServerContext*
+    #else
+                   ::grpc::experimental::CallbackServerContext*
+    #endif
+                     context, const ::tensorflow::DebuggedSourceFiles* request, ::tensorflow::EventReply* response) { return this->SendSourceFiles(context, request, response); }));}
+    void SetMessageAllocatorFor_SendSourceFiles(
+        ::grpc::experimental::MessageAllocator< ::tensorflow::DebuggedSourceFiles, ::tensorflow::EventReply>* allocator) {
+    #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+      ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(2);
+    #else
+      ::grpc::internal::MethodHandler* const handler = ::grpc::Service::experimental().GetHandler(2);
+    #endif
+      static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::tensorflow::DebuggedSourceFiles, ::tensorflow::EventReply>*>(handler)
+              ->SetMessageAllocator(allocator);
+    }
+    ~ExperimentalWithCallbackMethod_SendSourceFiles() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status SendSourceFiles(::grpc::ServerContext* /*context*/, const ::tensorflow::DebuggedSourceFiles* /*request*/, ::tensorflow::EventReply* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+    virtual ::grpc::ServerUnaryReactor* SendSourceFiles(
+      ::grpc::CallbackServerContext* /*context*/, const ::tensorflow::DebuggedSourceFiles* /*request*/, ::tensorflow::EventReply* /*response*/)
+    #else
+    virtual ::grpc::experimental::ServerUnaryReactor* SendSourceFiles(
+      ::grpc::experimental::CallbackServerContext* /*context*/, const ::tensorflow::DebuggedSourceFiles* /*request*/, ::tensorflow::EventReply* /*response*/)
+    #endif
+      { return nullptr; }
+  };
+  #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+  typedef ExperimentalWithCallbackMethod_SendEvents<ExperimentalWithCallbackMethod_SendTracebacks<ExperimentalWithCallbackMethod_SendSourceFiles<Service > > > CallbackService;
+  #endif
+
+  typedef ExperimentalWithCallbackMethod_SendEvents<ExperimentalWithCallbackMethod_SendTracebacks<ExperimentalWithCallbackMethod_SendSourceFiles<Service > > > ExperimentalCallbackService;
+  template <class BaseClass>
+  class WithGenericMethod_SendEvents : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithGenericMethod_SendEvents() {
+      ::grpc::Service::MarkMethodGeneric(0);
+    }
+    ~WithGenericMethod_SendEvents() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status SendEvents(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::tensorflow::EventReply, ::tensorflow::Event>* /*stream*/)  override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+  };
+  template <class BaseClass>
+  class WithGenericMethod_SendTracebacks : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithGenericMethod_SendTracebacks() {
+      ::grpc::Service::MarkMethodGeneric(1);
+    }
+    ~WithGenericMethod_SendTracebacks() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status SendTracebacks(::grpc::ServerContext* /*context*/, const ::tensorflow::CallTraceback* /*request*/, ::tensorflow::EventReply* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+  };
+  template <class BaseClass>
+  class WithGenericMethod_SendSourceFiles : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithGenericMethod_SendSourceFiles() {
+      ::grpc::Service::MarkMethodGeneric(2);
+    }
+    ~WithGenericMethod_SendSourceFiles() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status SendSourceFiles(::grpc::ServerContext* /*context*/, const ::tensorflow::DebuggedSourceFiles* /*request*/, ::tensorflow::EventReply* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+  };
+  template <class BaseClass>
+  class WithRawMethod_SendEvents : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithRawMethod_SendEvents() {
+      ::grpc::Service::MarkMethodRaw(0);
+    }
+    ~WithRawMethod_SendEvents() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status SendEvents(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::tensorflow::EventReply, ::tensorflow::Event>* /*stream*/)  override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    void RequestSendEvents(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncBidiStreaming(0, context, stream, new_call_cq, notification_cq, tag);
+    }
+  };
+  template <class BaseClass>
+  class WithRawMethod_SendTracebacks : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithRawMethod_SendTracebacks() {
+      ::grpc::Service::MarkMethodRaw(1);
+    }
+    ~WithRawMethod_SendTracebacks() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status SendTracebacks(::grpc::ServerContext* /*context*/, const ::tensorflow::CallTraceback* /*request*/, ::tensorflow::EventReply* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    void RequestSendTracebacks(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag);
+    }
+  };
+  template <class BaseClass>
+  class WithRawMethod_SendSourceFiles : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithRawMethod_SendSourceFiles() {
+      ::grpc::Service::MarkMethodRaw(2);
+    }
+    ~WithRawMethod_SendSourceFiles() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status SendSourceFiles(::grpc::ServerContext* /*context*/, const ::tensorflow::DebuggedSourceFiles* /*request*/, ::tensorflow::EventReply* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    void RequestSendSourceFiles(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncUnary(2, context, request, response, new_call_cq, notification_cq, tag);
+    }
+  };
+  template <class BaseClass>
+  class ExperimentalWithRawCallbackMethod_SendEvents : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    ExperimentalWithRawCallbackMethod_SendEvents() {
+    #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+      ::grpc::Service::
+    #else
+      ::grpc::Service::experimental().
+    #endif
+        MarkMethodRawCallback(0,
+          new ::grpc_impl::internal::CallbackBidiHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
+            [this](
+    #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+                   ::grpc::CallbackServerContext*
+    #else
+                   ::grpc::experimental::CallbackServerContext*
+    #endif
+                     context) { return this->SendEvents(context); }));
+    }
+    ~ExperimentalWithRawCallbackMethod_SendEvents() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status SendEvents(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::tensorflow::EventReply, ::tensorflow::Event>* /*stream*/)  override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+    virtual ::grpc::ServerBidiReactor< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* SendEvents(
+      ::grpc::CallbackServerContext* /*context*/)
+    #else
+    virtual ::grpc::experimental::ServerBidiReactor< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* SendEvents(
+      ::grpc::experimental::CallbackServerContext* /*context*/)
+    #endif
+      { return nullptr; }
+  };
+  template <class BaseClass>
+  class ExperimentalWithRawCallbackMethod_SendTracebacks : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    ExperimentalWithRawCallbackMethod_SendTracebacks() {
+    #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+      ::grpc::Service::
+    #else
+      ::grpc::Service::experimental().
+    #endif
+        MarkMethodRawCallback(1,
+          new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
+            [this](
+    #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+                   ::grpc::CallbackServerContext*
+    #else
+                   ::grpc::experimental::CallbackServerContext*
+    #endif
+                     context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->SendTracebacks(context, request, response); }));
+    }
+    ~ExperimentalWithRawCallbackMethod_SendTracebacks() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status SendTracebacks(::grpc::ServerContext* /*context*/, const ::tensorflow::CallTraceback* /*request*/, ::tensorflow::EventReply* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+    virtual ::grpc::ServerUnaryReactor* SendTracebacks(
+      ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/)
+    #else
+    virtual ::grpc::experimental::ServerUnaryReactor* SendTracebacks(
+      ::grpc::experimental::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/)
+    #endif
+      { return nullptr; }
+  };
+  template <class BaseClass>
+  class ExperimentalWithRawCallbackMethod_SendSourceFiles : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    ExperimentalWithRawCallbackMethod_SendSourceFiles() {
+    #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+      ::grpc::Service::
+    #else
+      ::grpc::Service::experimental().
+    #endif
+        MarkMethodRawCallback(2,
+          new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
+            [this](
+    #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+                   ::grpc::CallbackServerContext*
+    #else
+                   ::grpc::experimental::CallbackServerContext*
+    #endif
+                     context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->SendSourceFiles(context, request, response); }));
+    }
+    ~ExperimentalWithRawCallbackMethod_SendSourceFiles() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status SendSourceFiles(::grpc::ServerContext* /*context*/, const ::tensorflow::DebuggedSourceFiles* /*request*/, ::tensorflow::EventReply* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+    virtual ::grpc::ServerUnaryReactor* SendSourceFiles(
+      ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/)
+    #else
+    virtual ::grpc::experimental::ServerUnaryReactor* SendSourceFiles(
+      ::grpc::experimental::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/)
+    #endif
+      { return nullptr; }
+  };
+  template <class BaseClass>
+  class WithStreamedUnaryMethod_SendTracebacks : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithStreamedUnaryMethod_SendTracebacks() {
+      ::grpc::Service::MarkMethodStreamed(1,
+        new ::grpc::internal::StreamedUnaryHandler< ::tensorflow::CallTraceback, ::tensorflow::EventReply>(std::bind(&WithStreamedUnaryMethod_SendTracebacks<BaseClass>::StreamedSendTracebacks, this, std::placeholders::_1, std::placeholders::_2)));
+    }
+    ~WithStreamedUnaryMethod_SendTracebacks() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable regular version of this method
+    ::grpc::Status SendTracebacks(::grpc::ServerContext* /*context*/, const ::tensorflow::CallTraceback* /*request*/, ::tensorflow::EventReply* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    // replace default version of method with streamed unary
+    virtual ::grpc::Status StreamedSendTracebacks(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::tensorflow::CallTraceback,::tensorflow::EventReply>* server_unary_streamer) = 0;
+  };
+  template <class BaseClass>
+  class WithStreamedUnaryMethod_SendSourceFiles : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithStreamedUnaryMethod_SendSourceFiles() {
+      ::grpc::Service::MarkMethodStreamed(2,
+        new ::grpc::internal::StreamedUnaryHandler< ::tensorflow::DebuggedSourceFiles, ::tensorflow::EventReply>(std::bind(&WithStreamedUnaryMethod_SendSourceFiles<BaseClass>::StreamedSendSourceFiles, this, std::placeholders::_1, std::placeholders::_2)));
+    }
+    ~WithStreamedUnaryMethod_SendSourceFiles() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable regular version of this method
+    ::grpc::Status SendSourceFiles(::grpc::ServerContext* /*context*/, const ::tensorflow::DebuggedSourceFiles* /*request*/, ::tensorflow::EventReply* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    // replace default version of method with streamed unary
+    virtual ::grpc::Status StreamedSendSourceFiles(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::tensorflow::DebuggedSourceFiles,::tensorflow::EventReply>* server_unary_streamer) = 0;
+  };
+  typedef WithStreamedUnaryMethod_SendTracebacks<WithStreamedUnaryMethod_SendSourceFiles<Service > > StreamedUnaryService;
+  typedef Service SplitStreamedService;
+  typedef WithStreamedUnaryMethod_SendTracebacks<WithStreamedUnaryMethod_SendSourceFiles<Service > > StreamedService;
+};
+
+}  // namespace grpc
+
+}  // namespace tensorflow
+
+
+#endif  // GRPC_tensorflow_2fcore_2fdebug_2fdebug_5fservice_2eproto__INCLUDED
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/debug/debug_service.pb.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/debug/debug_service.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..bcfa50d76a8736a7d22670d58b6361a44aa3103a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/debug/debug_service.pb.h
@@ -0,0 +1,1440 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: tensorflow/core/debug/debug_service.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fdebug_2fdebug_5fservice_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fdebug_2fdebug_5fservice_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3021000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3021009 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/map.h>  // IWYU pragma: export
+#include <google/protobuf/map_entry.h>
+#include <google/protobuf/map_field_inl.h>
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "tensorflow/core/framework/tensor.pb.h"
+#include "tensorflow/core/profiler/tfprof_log.pb.h"
+#include "tensorflow/core/protobuf/debug.pb.h"
+#include "tensorflow/core/util/event.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_tensorflow_2fcore_2fdebug_2fdebug_5fservice_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_tensorflow_2fcore_2fdebug_2fdebug_5fservice_2eproto {
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_tensorflow_2fcore_2fdebug_2fdebug_5fservice_2eproto;
+namespace tensorflow {
+class CallTraceback;
+struct CallTracebackDefaultTypeInternal;
+extern CallTracebackDefaultTypeInternal _CallTraceback_default_instance_;
+class CallTraceback_OriginIdToStringEntry_DoNotUse;
+struct CallTraceback_OriginIdToStringEntry_DoNotUseDefaultTypeInternal;
+extern CallTraceback_OriginIdToStringEntry_DoNotUseDefaultTypeInternal _CallTraceback_OriginIdToStringEntry_DoNotUse_default_instance_;
+class EventReply;
+struct EventReplyDefaultTypeInternal;
+extern EventReplyDefaultTypeInternal _EventReply_default_instance_;
+class EventReply_DebugOpStateChange;
+struct EventReply_DebugOpStateChangeDefaultTypeInternal;
+extern EventReply_DebugOpStateChangeDefaultTypeInternal _EventReply_DebugOpStateChange_default_instance_;
+}  // namespace tensorflow
+PROTOBUF_NAMESPACE_OPEN
+template<> ::tensorflow::CallTraceback* Arena::CreateMaybeMessage<::tensorflow::CallTraceback>(Arena*);
+template<> ::tensorflow::CallTraceback_OriginIdToStringEntry_DoNotUse* Arena::CreateMaybeMessage<::tensorflow::CallTraceback_OriginIdToStringEntry_DoNotUse>(Arena*);
+template<> ::tensorflow::EventReply* Arena::CreateMaybeMessage<::tensorflow::EventReply>(Arena*);
+template<> ::tensorflow::EventReply_DebugOpStateChange* Arena::CreateMaybeMessage<::tensorflow::EventReply_DebugOpStateChange>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace tensorflow {
+
+enum EventReply_DebugOpStateChange_State : int {
+  EventReply_DebugOpStateChange_State_STATE_UNSPECIFIED = 0,
+  EventReply_DebugOpStateChange_State_DISABLED = 1,
+  EventReply_DebugOpStateChange_State_READ_ONLY = 2,
+  EventReply_DebugOpStateChange_State_READ_WRITE = 3,
+  EventReply_DebugOpStateChange_State_EventReply_DebugOpStateChange_State_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
+  EventReply_DebugOpStateChange_State_EventReply_DebugOpStateChange_State_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
+};
+bool EventReply_DebugOpStateChange_State_IsValid(int value);
+constexpr EventReply_DebugOpStateChange_State EventReply_DebugOpStateChange_State_State_MIN = EventReply_DebugOpStateChange_State_STATE_UNSPECIFIED;
+constexpr EventReply_DebugOpStateChange_State EventReply_DebugOpStateChange_State_State_MAX = EventReply_DebugOpStateChange_State_READ_WRITE;
+constexpr int EventReply_DebugOpStateChange_State_State_ARRAYSIZE = EventReply_DebugOpStateChange_State_State_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* EventReply_DebugOpStateChange_State_descriptor();
+template<typename T>
+inline const std::string& EventReply_DebugOpStateChange_State_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, EventReply_DebugOpStateChange_State>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function EventReply_DebugOpStateChange_State_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    EventReply_DebugOpStateChange_State_descriptor(), enum_t_value);
+}
+inline bool EventReply_DebugOpStateChange_State_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, EventReply_DebugOpStateChange_State* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<EventReply_DebugOpStateChange_State>(
+    EventReply_DebugOpStateChange_State_descriptor(), name, value);
+}
+enum CallTraceback_CallType : int {
+  CallTraceback_CallType_UNSPECIFIED = 0,
+  CallTraceback_CallType_GRAPH_EXECUTION = 1,
+  CallTraceback_CallType_EAGER_EXECUTION = 2,
+  CallTraceback_CallType_CallTraceback_CallType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
+  CallTraceback_CallType_CallTraceback_CallType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
+};
+bool CallTraceback_CallType_IsValid(int value);
+constexpr CallTraceback_CallType CallTraceback_CallType_CallType_MIN = CallTraceback_CallType_UNSPECIFIED;
+constexpr CallTraceback_CallType CallTraceback_CallType_CallType_MAX = CallTraceback_CallType_EAGER_EXECUTION;
+constexpr int CallTraceback_CallType_CallType_ARRAYSIZE = CallTraceback_CallType_CallType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CallTraceback_CallType_descriptor();
+template<typename T>
+inline const std::string& CallTraceback_CallType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, CallTraceback_CallType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function CallTraceback_CallType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    CallTraceback_CallType_descriptor(), enum_t_value);
+}
+inline bool CallTraceback_CallType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CallTraceback_CallType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<CallTraceback_CallType>(
+    CallTraceback_CallType_descriptor(), name, value);
+}
+// ===================================================================
+
+class EventReply_DebugOpStateChange final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.EventReply.DebugOpStateChange) */ {
+ public:
+  inline EventReply_DebugOpStateChange() : EventReply_DebugOpStateChange(nullptr) {}
+  ~EventReply_DebugOpStateChange() override;
+  explicit PROTOBUF_CONSTEXPR EventReply_DebugOpStateChange(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  EventReply_DebugOpStateChange(const EventReply_DebugOpStateChange& from);
+  EventReply_DebugOpStateChange(EventReply_DebugOpStateChange&& from) noexcept
+    : EventReply_DebugOpStateChange() {
+    *this = ::std::move(from);
+  }
+
+  inline EventReply_DebugOpStateChange& operator=(const EventReply_DebugOpStateChange& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline EventReply_DebugOpStateChange& operator=(EventReply_DebugOpStateChange&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const EventReply_DebugOpStateChange& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const EventReply_DebugOpStateChange* internal_default_instance() {
+    return reinterpret_cast<const EventReply_DebugOpStateChange*>(
+               &_EventReply_DebugOpStateChange_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(EventReply_DebugOpStateChange& a, EventReply_DebugOpStateChange& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(EventReply_DebugOpStateChange* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(EventReply_DebugOpStateChange* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  EventReply_DebugOpStateChange* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<EventReply_DebugOpStateChange>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const EventReply_DebugOpStateChange& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const EventReply_DebugOpStateChange& from) {
+    EventReply_DebugOpStateChange::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(EventReply_DebugOpStateChange* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.EventReply.DebugOpStateChange";
+  }
+  protected:
+  explicit EventReply_DebugOpStateChange(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef EventReply_DebugOpStateChange_State State;
+  static constexpr State STATE_UNSPECIFIED =
+    EventReply_DebugOpStateChange_State_STATE_UNSPECIFIED;
+  static constexpr State DISABLED =
+    EventReply_DebugOpStateChange_State_DISABLED;
+  static constexpr State READ_ONLY =
+    EventReply_DebugOpStateChange_State_READ_ONLY;
+  static constexpr State READ_WRITE =
+    EventReply_DebugOpStateChange_State_READ_WRITE;
+  static inline bool State_IsValid(int value) {
+    return EventReply_DebugOpStateChange_State_IsValid(value);
+  }
+  static constexpr State State_MIN =
+    EventReply_DebugOpStateChange_State_State_MIN;
+  static constexpr State State_MAX =
+    EventReply_DebugOpStateChange_State_State_MAX;
+  static constexpr int State_ARRAYSIZE =
+    EventReply_DebugOpStateChange_State_State_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  State_descriptor() {
+    return EventReply_DebugOpStateChange_State_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& State_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, State>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function State_Name.");
+    return EventReply_DebugOpStateChange_State_Name(enum_t_value);
+  }
+  static inline bool State_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      State* value) {
+    return EventReply_DebugOpStateChange_State_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNodeNameFieldNumber = 2,
+    kDebugOpFieldNumber = 4,
+    kStateFieldNumber = 1,
+    kOutputSlotFieldNumber = 3,
+  };
+  // string node_name = 2;
+  void clear_node_name();
+  const std::string& node_name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_node_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_node_name();
+  PROTOBUF_NODISCARD std::string* release_node_name();
+  void set_allocated_node_name(std::string* node_name);
+  private:
+  const std::string& _internal_node_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_node_name(const std::string& value);
+  std::string* _internal_mutable_node_name();
+  public:
+
+  // string debug_op = 4;
+  void clear_debug_op();
+  const std::string& debug_op() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_debug_op(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_debug_op();
+  PROTOBUF_NODISCARD std::string* release_debug_op();
+  void set_allocated_debug_op(std::string* debug_op);
+  private:
+  const std::string& _internal_debug_op() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_debug_op(const std::string& value);
+  std::string* _internal_mutable_debug_op();
+  public:
+
+  // .tensorflow.EventReply.DebugOpStateChange.State state = 1;
+  void clear_state();
+  ::tensorflow::EventReply_DebugOpStateChange_State state() const;
+  void set_state(::tensorflow::EventReply_DebugOpStateChange_State value);
+  private:
+  ::tensorflow::EventReply_DebugOpStateChange_State _internal_state() const;
+  void _internal_set_state(::tensorflow::EventReply_DebugOpStateChange_State value);
+  public:
+
+  // int32 output_slot = 3;
+  void clear_output_slot();
+  int32_t output_slot() const;
+  void set_output_slot(int32_t value);
+  private:
+  int32_t _internal_output_slot() const;
+  void _internal_set_output_slot(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.EventReply.DebugOpStateChange)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr node_name_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr debug_op_;
+    int state_;
+    int32_t output_slot_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fdebug_2fdebug_5fservice_2eproto;
+};
+// -------------------------------------------------------------------
+
+class EventReply final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.EventReply) */ {
+ public:
+  inline EventReply() : EventReply(nullptr) {}
+  ~EventReply() override;
+  explicit PROTOBUF_CONSTEXPR EventReply(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  EventReply(const EventReply& from);
+  EventReply(EventReply&& from) noexcept
+    : EventReply() {
+    *this = ::std::move(from);
+  }
+
+  inline EventReply& operator=(const EventReply& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline EventReply& operator=(EventReply&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const EventReply& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const EventReply* internal_default_instance() {
+    return reinterpret_cast<const EventReply*>(
+               &_EventReply_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(EventReply& a, EventReply& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(EventReply* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(EventReply* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  EventReply* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<EventReply>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const EventReply& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const EventReply& from) {
+    EventReply::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(EventReply* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.EventReply";
+  }
+  protected:
+  explicit EventReply(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef EventReply_DebugOpStateChange DebugOpStateChange;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDebugOpStateChangesFieldNumber = 1,
+    kTensorFieldNumber = 2,
+  };
+  // repeated .tensorflow.EventReply.DebugOpStateChange debug_op_state_changes = 1;
+  int debug_op_state_changes_size() const;
+  private:
+  int _internal_debug_op_state_changes_size() const;
+  public:
+  void clear_debug_op_state_changes();
+  ::tensorflow::EventReply_DebugOpStateChange* mutable_debug_op_state_changes(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::EventReply_DebugOpStateChange >*
+      mutable_debug_op_state_changes();
+  private:
+  const ::tensorflow::EventReply_DebugOpStateChange& _internal_debug_op_state_changes(int index) const;
+  ::tensorflow::EventReply_DebugOpStateChange* _internal_add_debug_op_state_changes();
+  public:
+  const ::tensorflow::EventReply_DebugOpStateChange& debug_op_state_changes(int index) const;
+  ::tensorflow::EventReply_DebugOpStateChange* add_debug_op_state_changes();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::EventReply_DebugOpStateChange >&
+      debug_op_state_changes() const;
+
+  // .tensorflow.TensorProto tensor = 2;
+  bool has_tensor() const;
+  private:
+  bool _internal_has_tensor() const;
+  public:
+  void clear_tensor();
+  const ::tensorflow::TensorProto& tensor() const;
+  PROTOBUF_NODISCARD ::tensorflow::TensorProto* release_tensor();
+  ::tensorflow::TensorProto* mutable_tensor();
+  void set_allocated_tensor(::tensorflow::TensorProto* tensor);
+  private:
+  const ::tensorflow::TensorProto& _internal_tensor() const;
+  ::tensorflow::TensorProto* _internal_mutable_tensor();
+  public:
+  void unsafe_arena_set_allocated_tensor(
+      ::tensorflow::TensorProto* tensor);
+  ::tensorflow::TensorProto* unsafe_arena_release_tensor();
+
+  // @@protoc_insertion_point(class_scope:tensorflow.EventReply)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::EventReply_DebugOpStateChange > debug_op_state_changes_;
+    ::tensorflow::TensorProto* tensor_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fdebug_2fdebug_5fservice_2eproto;
+};
+// -------------------------------------------------------------------
+
+class CallTraceback_OriginIdToStringEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<CallTraceback_OriginIdToStringEntry_DoNotUse, 
+    int64_t, std::string,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING> {
+public:
+  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<CallTraceback_OriginIdToStringEntry_DoNotUse, 
+    int64_t, std::string,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING> SuperType;
+  CallTraceback_OriginIdToStringEntry_DoNotUse();
+  explicit PROTOBUF_CONSTEXPR CallTraceback_OriginIdToStringEntry_DoNotUse(
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+  explicit CallTraceback_OriginIdToStringEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  void MergeFrom(const CallTraceback_OriginIdToStringEntry_DoNotUse& other);
+  static const CallTraceback_OriginIdToStringEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const CallTraceback_OriginIdToStringEntry_DoNotUse*>(&_CallTraceback_OriginIdToStringEntry_DoNotUse_default_instance_); }
+  static bool ValidateKey(void*) { return true; }
+  static bool ValidateValue(std::string* s) {
+    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "tensorflow.CallTraceback.OriginIdToStringEntry.value");
+ }
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+  friend struct ::TableStruct_tensorflow_2fcore_2fdebug_2fdebug_5fservice_2eproto;
+};
+
+// -------------------------------------------------------------------
+
+class CallTraceback final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.CallTraceback) */ {
+ public:
+  inline CallTraceback() : CallTraceback(nullptr) {}
+  ~CallTraceback() override;
+  explicit PROTOBUF_CONSTEXPR CallTraceback(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  CallTraceback(const CallTraceback& from);
+  CallTraceback(CallTraceback&& from) noexcept
+    : CallTraceback() {
+    *this = ::std::move(from);
+  }
+
+  inline CallTraceback& operator=(const CallTraceback& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline CallTraceback& operator=(CallTraceback&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const CallTraceback& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const CallTraceback* internal_default_instance() {
+    return reinterpret_cast<const CallTraceback*>(
+               &_CallTraceback_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  friend void swap(CallTraceback& a, CallTraceback& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(CallTraceback* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(CallTraceback* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  CallTraceback* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<CallTraceback>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const CallTraceback& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const CallTraceback& from) {
+    CallTraceback::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(CallTraceback* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.CallTraceback";
+  }
+  protected:
+  explicit CallTraceback(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+
+  typedef CallTraceback_CallType CallType;
+  static constexpr CallType UNSPECIFIED =
+    CallTraceback_CallType_UNSPECIFIED;
+  static constexpr CallType GRAPH_EXECUTION =
+    CallTraceback_CallType_GRAPH_EXECUTION;
+  static constexpr CallType EAGER_EXECUTION =
+    CallTraceback_CallType_EAGER_EXECUTION;
+  static inline bool CallType_IsValid(int value) {
+    return CallTraceback_CallType_IsValid(value);
+  }
+  static constexpr CallType CallType_MIN =
+    CallTraceback_CallType_CallType_MIN;
+  static constexpr CallType CallType_MAX =
+    CallTraceback_CallType_CallType_MAX;
+  static constexpr int CallType_ARRAYSIZE =
+    CallTraceback_CallType_CallType_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  CallType_descriptor() {
+    return CallTraceback_CallType_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& CallType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, CallType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function CallType_Name.");
+    return CallTraceback_CallType_Name(enum_t_value);
+  }
+  static inline bool CallType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      CallType* value) {
+    return CallTraceback_CallType_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kOriginIdToStringFieldNumber = 4,
+    kCallKeyFieldNumber = 2,
+    kOriginStackFieldNumber = 3,
+    kGraphTracebackFieldNumber = 5,
+    kGraphVersionFieldNumber = 6,
+    kCallTypeFieldNumber = 1,
+  };
+  // map<int64, string> origin_id_to_string = 4;
+  int origin_id_to_string_size() const;
+  private:
+  int _internal_origin_id_to_string_size() const;
+  public:
+  void clear_origin_id_to_string();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::Map< int64_t, std::string >&
+      _internal_origin_id_to_string() const;
+  ::PROTOBUF_NAMESPACE_ID::Map< int64_t, std::string >*
+      _internal_mutable_origin_id_to_string();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::Map< int64_t, std::string >&
+      origin_id_to_string() const;
+  ::PROTOBUF_NAMESPACE_ID::Map< int64_t, std::string >*
+      mutable_origin_id_to_string();
+
+  // string call_key = 2;
+  void clear_call_key();
+  const std::string& call_key() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_call_key(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_call_key();
+  PROTOBUF_NODISCARD std::string* release_call_key();
+  void set_allocated_call_key(std::string* call_key);
+  private:
+  const std::string& _internal_call_key() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_call_key(const std::string& value);
+  std::string* _internal_mutable_call_key();
+  public:
+
+  // .tensorflow.tfprof.CodeDef origin_stack = 3;
+  bool has_origin_stack() const;
+  private:
+  bool _internal_has_origin_stack() const;
+  public:
+  void clear_origin_stack();
+  const ::tensorflow::tfprof::CodeDef& origin_stack() const;
+  PROTOBUF_NODISCARD ::tensorflow::tfprof::CodeDef* release_origin_stack();
+  ::tensorflow::tfprof::CodeDef* mutable_origin_stack();
+  void set_allocated_origin_stack(::tensorflow::tfprof::CodeDef* origin_stack);
+  private:
+  const ::tensorflow::tfprof::CodeDef& _internal_origin_stack() const;
+  ::tensorflow::tfprof::CodeDef* _internal_mutable_origin_stack();
+  public:
+  void unsafe_arena_set_allocated_origin_stack(
+      ::tensorflow::tfprof::CodeDef* origin_stack);
+  ::tensorflow::tfprof::CodeDef* unsafe_arena_release_origin_stack();
+
+  // .tensorflow.tfprof.OpLogProto graph_traceback = 5;
+  bool has_graph_traceback() const;
+  private:
+  bool _internal_has_graph_traceback() const;
+  public:
+  void clear_graph_traceback();
+  const ::tensorflow::tfprof::OpLogProto& graph_traceback() const;
+  PROTOBUF_NODISCARD ::tensorflow::tfprof::OpLogProto* release_graph_traceback();
+  ::tensorflow::tfprof::OpLogProto* mutable_graph_traceback();
+  void set_allocated_graph_traceback(::tensorflow::tfprof::OpLogProto* graph_traceback);
+  private:
+  const ::tensorflow::tfprof::OpLogProto& _internal_graph_traceback() const;
+  ::tensorflow::tfprof::OpLogProto* _internal_mutable_graph_traceback();
+  public:
+  void unsafe_arena_set_allocated_graph_traceback(
+      ::tensorflow::tfprof::OpLogProto* graph_traceback);
+  ::tensorflow::tfprof::OpLogProto* unsafe_arena_release_graph_traceback();
+
+  // int64 graph_version = 6;
+  void clear_graph_version();
+  int64_t graph_version() const;
+  void set_graph_version(int64_t value);
+  private:
+  int64_t _internal_graph_version() const;
+  void _internal_set_graph_version(int64_t value);
+  public:
+
+  // .tensorflow.CallTraceback.CallType call_type = 1;
+  void clear_call_type();
+  ::tensorflow::CallTraceback_CallType call_type() const;
+  void set_call_type(::tensorflow::CallTraceback_CallType value);
+  private:
+  ::tensorflow::CallTraceback_CallType _internal_call_type() const;
+  void _internal_set_call_type(::tensorflow::CallTraceback_CallType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.CallTraceback)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::MapField<
+        CallTraceback_OriginIdToStringEntry_DoNotUse,
+        int64_t, std::string,
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64,
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING> origin_id_to_string_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr call_key_;
+    ::tensorflow::tfprof::CodeDef* origin_stack_;
+    ::tensorflow::tfprof::OpLogProto* graph_traceback_;
+    int64_t graph_version_;
+    int call_type_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fdebug_2fdebug_5fservice_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// EventReply_DebugOpStateChange
+
+// .tensorflow.EventReply.DebugOpStateChange.State state = 1;
+inline void EventReply_DebugOpStateChange::clear_state() {
+  _impl_.state_ = 0;
+}
+inline ::tensorflow::EventReply_DebugOpStateChange_State EventReply_DebugOpStateChange::_internal_state() const {
+  return static_cast< ::tensorflow::EventReply_DebugOpStateChange_State >(_impl_.state_);
+}
+inline ::tensorflow::EventReply_DebugOpStateChange_State EventReply_DebugOpStateChange::state() const {
+  // @@protoc_insertion_point(field_get:tensorflow.EventReply.DebugOpStateChange.state)
+  return _internal_state();
+}
+inline void EventReply_DebugOpStateChange::_internal_set_state(::tensorflow::EventReply_DebugOpStateChange_State value) {
+  
+  _impl_.state_ = value;
+}
+inline void EventReply_DebugOpStateChange::set_state(::tensorflow::EventReply_DebugOpStateChange_State value) {
+  _internal_set_state(value);
+  // @@protoc_insertion_point(field_set:tensorflow.EventReply.DebugOpStateChange.state)
+}
+
+// string node_name = 2;
+inline void EventReply_DebugOpStateChange::clear_node_name() {
+  _impl_.node_name_.ClearToEmpty();
+}
+inline const std::string& EventReply_DebugOpStateChange::node_name() const {
+  // @@protoc_insertion_point(field_get:tensorflow.EventReply.DebugOpStateChange.node_name)
+  return _internal_node_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void EventReply_DebugOpStateChange::set_node_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.node_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.EventReply.DebugOpStateChange.node_name)
+}
+inline std::string* EventReply_DebugOpStateChange::mutable_node_name() {
+  std::string* _s = _internal_mutable_node_name();
+  // @@protoc_insertion_point(field_mutable:tensorflow.EventReply.DebugOpStateChange.node_name)
+  return _s;
+}
+inline const std::string& EventReply_DebugOpStateChange::_internal_node_name() const {
+  return _impl_.node_name_.Get();
+}
+inline void EventReply_DebugOpStateChange::_internal_set_node_name(const std::string& value) {
+  
+  _impl_.node_name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* EventReply_DebugOpStateChange::_internal_mutable_node_name() {
+  
+  return _impl_.node_name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* EventReply_DebugOpStateChange::release_node_name() {
+  // @@protoc_insertion_point(field_release:tensorflow.EventReply.DebugOpStateChange.node_name)
+  return _impl_.node_name_.Release();
+}
+inline void EventReply_DebugOpStateChange::set_allocated_node_name(std::string* node_name) {
+  if (node_name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.node_name_.SetAllocated(node_name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.node_name_.IsDefault()) {
+    _impl_.node_name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.EventReply.DebugOpStateChange.node_name)
+}
+
+// int32 output_slot = 3;
+inline void EventReply_DebugOpStateChange::clear_output_slot() {
+  _impl_.output_slot_ = 0;
+}
+inline int32_t EventReply_DebugOpStateChange::_internal_output_slot() const {
+  return _impl_.output_slot_;
+}
+inline int32_t EventReply_DebugOpStateChange::output_slot() const {
+  // @@protoc_insertion_point(field_get:tensorflow.EventReply.DebugOpStateChange.output_slot)
+  return _internal_output_slot();
+}
+inline void EventReply_DebugOpStateChange::_internal_set_output_slot(int32_t value) {
+  
+  _impl_.output_slot_ = value;
+}
+inline void EventReply_DebugOpStateChange::set_output_slot(int32_t value) {
+  _internal_set_output_slot(value);
+  // @@protoc_insertion_point(field_set:tensorflow.EventReply.DebugOpStateChange.output_slot)
+}
+
+// string debug_op = 4;
+inline void EventReply_DebugOpStateChange::clear_debug_op() {
+  _impl_.debug_op_.ClearToEmpty();
+}
+inline const std::string& EventReply_DebugOpStateChange::debug_op() const {
+  // @@protoc_insertion_point(field_get:tensorflow.EventReply.DebugOpStateChange.debug_op)
+  return _internal_debug_op();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void EventReply_DebugOpStateChange::set_debug_op(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.debug_op_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.EventReply.DebugOpStateChange.debug_op)
+}
+inline std::string* EventReply_DebugOpStateChange::mutable_debug_op() {
+  std::string* _s = _internal_mutable_debug_op();
+  // @@protoc_insertion_point(field_mutable:tensorflow.EventReply.DebugOpStateChange.debug_op)
+  return _s;
+}
+inline const std::string& EventReply_DebugOpStateChange::_internal_debug_op() const {
+  return _impl_.debug_op_.Get();
+}
+inline void EventReply_DebugOpStateChange::_internal_set_debug_op(const std::string& value) {
+  
+  _impl_.debug_op_.Set(value, GetArenaForAllocation());
+}
+inline std::string* EventReply_DebugOpStateChange::_internal_mutable_debug_op() {
+  
+  return _impl_.debug_op_.Mutable(GetArenaForAllocation());
+}
+inline std::string* EventReply_DebugOpStateChange::release_debug_op() {
+  // @@protoc_insertion_point(field_release:tensorflow.EventReply.DebugOpStateChange.debug_op)
+  return _impl_.debug_op_.Release();
+}
+inline void EventReply_DebugOpStateChange::set_allocated_debug_op(std::string* debug_op) {
+  if (debug_op != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.debug_op_.SetAllocated(debug_op, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.debug_op_.IsDefault()) {
+    _impl_.debug_op_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.EventReply.DebugOpStateChange.debug_op)
+}
+
+// -------------------------------------------------------------------
+
+// EventReply
+
+// repeated .tensorflow.EventReply.DebugOpStateChange debug_op_state_changes = 1;
+inline int EventReply::_internal_debug_op_state_changes_size() const {
+  return _impl_.debug_op_state_changes_.size();
+}
+inline int EventReply::debug_op_state_changes_size() const {
+  return _internal_debug_op_state_changes_size();
+}
+inline void EventReply::clear_debug_op_state_changes() {
+  _impl_.debug_op_state_changes_.Clear();
+}
+inline ::tensorflow::EventReply_DebugOpStateChange* EventReply::mutable_debug_op_state_changes(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.EventReply.debug_op_state_changes)
+  return _impl_.debug_op_state_changes_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::EventReply_DebugOpStateChange >*
+EventReply::mutable_debug_op_state_changes() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.EventReply.debug_op_state_changes)
+  return &_impl_.debug_op_state_changes_;
+}
+inline const ::tensorflow::EventReply_DebugOpStateChange& EventReply::_internal_debug_op_state_changes(int index) const {
+  return _impl_.debug_op_state_changes_.Get(index);
+}
+inline const ::tensorflow::EventReply_DebugOpStateChange& EventReply::debug_op_state_changes(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.EventReply.debug_op_state_changes)
+  return _internal_debug_op_state_changes(index);
+}
+inline ::tensorflow::EventReply_DebugOpStateChange* EventReply::_internal_add_debug_op_state_changes() {
+  return _impl_.debug_op_state_changes_.Add();
+}
+inline ::tensorflow::EventReply_DebugOpStateChange* EventReply::add_debug_op_state_changes() {
+  ::tensorflow::EventReply_DebugOpStateChange* _add = _internal_add_debug_op_state_changes();
+  // @@protoc_insertion_point(field_add:tensorflow.EventReply.debug_op_state_changes)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::EventReply_DebugOpStateChange >&
+EventReply::debug_op_state_changes() const {
+  // @@protoc_insertion_point(field_list:tensorflow.EventReply.debug_op_state_changes)
+  return _impl_.debug_op_state_changes_;
+}
+
+// .tensorflow.TensorProto tensor = 2;
+inline bool EventReply::_internal_has_tensor() const {
+  return this != internal_default_instance() && _impl_.tensor_ != nullptr;
+}
+inline bool EventReply::has_tensor() const {
+  return _internal_has_tensor();
+}
+inline const ::tensorflow::TensorProto& EventReply::_internal_tensor() const {
+  const ::tensorflow::TensorProto* p = _impl_.tensor_;
+  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::TensorProto&>(
+      ::tensorflow::_TensorProto_default_instance_);
+}
+inline const ::tensorflow::TensorProto& EventReply::tensor() const {
+  // @@protoc_insertion_point(field_get:tensorflow.EventReply.tensor)
+  return _internal_tensor();
+}
+inline void EventReply::unsafe_arena_set_allocated_tensor(
+    ::tensorflow::TensorProto* tensor) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.tensor_);
+  }
+  _impl_.tensor_ = tensor;
+  if (tensor) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.EventReply.tensor)
+}
+inline ::tensorflow::TensorProto* EventReply::release_tensor() {
+  
+  ::tensorflow::TensorProto* temp = _impl_.tensor_;
+  _impl_.tensor_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::tensorflow::TensorProto* EventReply::unsafe_arena_release_tensor() {
+  // @@protoc_insertion_point(field_release:tensorflow.EventReply.tensor)
+  
+  ::tensorflow::TensorProto* temp = _impl_.tensor_;
+  _impl_.tensor_ = nullptr;
+  return temp;
+}
+inline ::tensorflow::TensorProto* EventReply::_internal_mutable_tensor() {
+  
+  if (_impl_.tensor_ == nullptr) {
+    auto* p = CreateMaybeMessage<::tensorflow::TensorProto>(GetArenaForAllocation());
+    _impl_.tensor_ = p;
+  }
+  return _impl_.tensor_;
+}
+inline ::tensorflow::TensorProto* EventReply::mutable_tensor() {
+  ::tensorflow::TensorProto* _msg = _internal_mutable_tensor();
+  // @@protoc_insertion_point(field_mutable:tensorflow.EventReply.tensor)
+  return _msg;
+}
+inline void EventReply::set_allocated_tensor(::tensorflow::TensorProto* tensor) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.tensor_);
+  }
+  if (tensor) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(tensor));
+    if (message_arena != submessage_arena) {
+      tensor = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, tensor, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.tensor_ = tensor;
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.EventReply.tensor)
+}
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// CallTraceback
+
+// .tensorflow.CallTraceback.CallType call_type = 1;
+inline void CallTraceback::clear_call_type() {
+  _impl_.call_type_ = 0;
+}
+inline ::tensorflow::CallTraceback_CallType CallTraceback::_internal_call_type() const {
+  return static_cast< ::tensorflow::CallTraceback_CallType >(_impl_.call_type_);
+}
+inline ::tensorflow::CallTraceback_CallType CallTraceback::call_type() const {
+  // @@protoc_insertion_point(field_get:tensorflow.CallTraceback.call_type)
+  return _internal_call_type();
+}
+inline void CallTraceback::_internal_set_call_type(::tensorflow::CallTraceback_CallType value) {
+  
+  _impl_.call_type_ = value;
+}
+inline void CallTraceback::set_call_type(::tensorflow::CallTraceback_CallType value) {
+  _internal_set_call_type(value);
+  // @@protoc_insertion_point(field_set:tensorflow.CallTraceback.call_type)
+}
+
+// string call_key = 2;
+inline void CallTraceback::clear_call_key() {
+  _impl_.call_key_.ClearToEmpty();
+}
+inline const std::string& CallTraceback::call_key() const {
+  // @@protoc_insertion_point(field_get:tensorflow.CallTraceback.call_key)
+  return _internal_call_key();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void CallTraceback::set_call_key(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.call_key_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.CallTraceback.call_key)
+}
+inline std::string* CallTraceback::mutable_call_key() {
+  std::string* _s = _internal_mutable_call_key();
+  // @@protoc_insertion_point(field_mutable:tensorflow.CallTraceback.call_key)
+  return _s;
+}
+inline const std::string& CallTraceback::_internal_call_key() const {
+  return _impl_.call_key_.Get();
+}
+inline void CallTraceback::_internal_set_call_key(const std::string& value) {
+  
+  _impl_.call_key_.Set(value, GetArenaForAllocation());
+}
+inline std::string* CallTraceback::_internal_mutable_call_key() {
+  
+  return _impl_.call_key_.Mutable(GetArenaForAllocation());
+}
+inline std::string* CallTraceback::release_call_key() {
+  // @@protoc_insertion_point(field_release:tensorflow.CallTraceback.call_key)
+  return _impl_.call_key_.Release();
+}
+inline void CallTraceback::set_allocated_call_key(std::string* call_key) {
+  if (call_key != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.call_key_.SetAllocated(call_key, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.call_key_.IsDefault()) {
+    _impl_.call_key_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.CallTraceback.call_key)
+}
+
+// .tensorflow.tfprof.CodeDef origin_stack = 3;
+inline bool CallTraceback::_internal_has_origin_stack() const {
+  return this != internal_default_instance() && _impl_.origin_stack_ != nullptr;
+}
+inline bool CallTraceback::has_origin_stack() const {
+  return _internal_has_origin_stack();
+}
+inline const ::tensorflow::tfprof::CodeDef& CallTraceback::_internal_origin_stack() const {
+  const ::tensorflow::tfprof::CodeDef* p = _impl_.origin_stack_;
+  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::tfprof::CodeDef&>(
+      ::tensorflow::tfprof::_CodeDef_default_instance_);
+}
+inline const ::tensorflow::tfprof::CodeDef& CallTraceback::origin_stack() const {
+  // @@protoc_insertion_point(field_get:tensorflow.CallTraceback.origin_stack)
+  return _internal_origin_stack();
+}
+inline void CallTraceback::unsafe_arena_set_allocated_origin_stack(
+    ::tensorflow::tfprof::CodeDef* origin_stack) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.origin_stack_);
+  }
+  _impl_.origin_stack_ = origin_stack;
+  if (origin_stack) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.CallTraceback.origin_stack)
+}
+inline ::tensorflow::tfprof::CodeDef* CallTraceback::release_origin_stack() {
+  
+  ::tensorflow::tfprof::CodeDef* temp = _impl_.origin_stack_;
+  _impl_.origin_stack_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::tensorflow::tfprof::CodeDef* CallTraceback::unsafe_arena_release_origin_stack() {
+  // @@protoc_insertion_point(field_release:tensorflow.CallTraceback.origin_stack)
+  
+  ::tensorflow::tfprof::CodeDef* temp = _impl_.origin_stack_;
+  _impl_.origin_stack_ = nullptr;
+  return temp;
+}
+inline ::tensorflow::tfprof::CodeDef* CallTraceback::_internal_mutable_origin_stack() {
+  
+  if (_impl_.origin_stack_ == nullptr) {
+    auto* p = CreateMaybeMessage<::tensorflow::tfprof::CodeDef>(GetArenaForAllocation());
+    _impl_.origin_stack_ = p;
+  }
+  return _impl_.origin_stack_;
+}
+inline ::tensorflow::tfprof::CodeDef* CallTraceback::mutable_origin_stack() {
+  ::tensorflow::tfprof::CodeDef* _msg = _internal_mutable_origin_stack();
+  // @@protoc_insertion_point(field_mutable:tensorflow.CallTraceback.origin_stack)
+  return _msg;
+}
+inline void CallTraceback::set_allocated_origin_stack(::tensorflow::tfprof::CodeDef* origin_stack) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.origin_stack_);
+  }
+  if (origin_stack) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(origin_stack));
+    if (message_arena != submessage_arena) {
+      origin_stack = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, origin_stack, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.origin_stack_ = origin_stack;
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.CallTraceback.origin_stack)
+}
+
+// map<int64, string> origin_id_to_string = 4;
+inline int CallTraceback::_internal_origin_id_to_string_size() const {
+  return _impl_.origin_id_to_string_.size();
+}
+inline int CallTraceback::origin_id_to_string_size() const {
+  return _internal_origin_id_to_string_size();
+}
+inline void CallTraceback::clear_origin_id_to_string() {
+  _impl_.origin_id_to_string_.Clear();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< int64_t, std::string >&
+CallTraceback::_internal_origin_id_to_string() const {
+  return _impl_.origin_id_to_string_.GetMap();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< int64_t, std::string >&
+CallTraceback::origin_id_to_string() const {
+  // @@protoc_insertion_point(field_map:tensorflow.CallTraceback.origin_id_to_string)
+  return _internal_origin_id_to_string();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< int64_t, std::string >*
+CallTraceback::_internal_mutable_origin_id_to_string() {
+  return _impl_.origin_id_to_string_.MutableMap();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< int64_t, std::string >*
+CallTraceback::mutable_origin_id_to_string() {
+  // @@protoc_insertion_point(field_mutable_map:tensorflow.CallTraceback.origin_id_to_string)
+  return _internal_mutable_origin_id_to_string();
+}
+
+// .tensorflow.tfprof.OpLogProto graph_traceback = 5;
+inline bool CallTraceback::_internal_has_graph_traceback() const {
+  return this != internal_default_instance() && _impl_.graph_traceback_ != nullptr;
+}
+inline bool CallTraceback::has_graph_traceback() const {
+  return _internal_has_graph_traceback();
+}
+inline const ::tensorflow::tfprof::OpLogProto& CallTraceback::_internal_graph_traceback() const {
+  const ::tensorflow::tfprof::OpLogProto* p = _impl_.graph_traceback_;
+  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::tfprof::OpLogProto&>(
+      ::tensorflow::tfprof::_OpLogProto_default_instance_);
+}
+inline const ::tensorflow::tfprof::OpLogProto& CallTraceback::graph_traceback() const {
+  // @@protoc_insertion_point(field_get:tensorflow.CallTraceback.graph_traceback)
+  return _internal_graph_traceback();
+}
+inline void CallTraceback::unsafe_arena_set_allocated_graph_traceback(
+    ::tensorflow::tfprof::OpLogProto* graph_traceback) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.graph_traceback_);
+  }
+  _impl_.graph_traceback_ = graph_traceback;
+  if (graph_traceback) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.CallTraceback.graph_traceback)
+}
+inline ::tensorflow::tfprof::OpLogProto* CallTraceback::release_graph_traceback() {
+  
+  ::tensorflow::tfprof::OpLogProto* temp = _impl_.graph_traceback_;
+  _impl_.graph_traceback_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::tensorflow::tfprof::OpLogProto* CallTraceback::unsafe_arena_release_graph_traceback() {
+  // @@protoc_insertion_point(field_release:tensorflow.CallTraceback.graph_traceback)
+  
+  ::tensorflow::tfprof::OpLogProto* temp = _impl_.graph_traceback_;
+  _impl_.graph_traceback_ = nullptr;
+  return temp;
+}
+inline ::tensorflow::tfprof::OpLogProto* CallTraceback::_internal_mutable_graph_traceback() {
+  
+  if (_impl_.graph_traceback_ == nullptr) {
+    auto* p = CreateMaybeMessage<::tensorflow::tfprof::OpLogProto>(GetArenaForAllocation());
+    _impl_.graph_traceback_ = p;
+  }
+  return _impl_.graph_traceback_;
+}
+inline ::tensorflow::tfprof::OpLogProto* CallTraceback::mutable_graph_traceback() {
+  ::tensorflow::tfprof::OpLogProto* _msg = _internal_mutable_graph_traceback();
+  // @@protoc_insertion_point(field_mutable:tensorflow.CallTraceback.graph_traceback)
+  return _msg;
+}
+inline void CallTraceback::set_allocated_graph_traceback(::tensorflow::tfprof::OpLogProto* graph_traceback) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.graph_traceback_);
+  }
+  if (graph_traceback) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(graph_traceback));
+    if (message_arena != submessage_arena) {
+      graph_traceback = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, graph_traceback, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.graph_traceback_ = graph_traceback;
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.CallTraceback.graph_traceback)
+}
+
+// int64 graph_version = 6;
+inline void CallTraceback::clear_graph_version() {
+  _impl_.graph_version_ = int64_t{0};
+}
+inline int64_t CallTraceback::_internal_graph_version() const {
+  return _impl_.graph_version_;
+}
+inline int64_t CallTraceback::graph_version() const {
+  // @@protoc_insertion_point(field_get:tensorflow.CallTraceback.graph_version)
+  return _internal_graph_version();
+}
+inline void CallTraceback::_internal_set_graph_version(int64_t value) {
+  
+  _impl_.graph_version_ = value;
+}
+inline void CallTraceback::set_graph_version(int64_t value) {
+  _internal_set_graph_version(value);
+  // @@protoc_insertion_point(field_set:tensorflow.CallTraceback.graph_version)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace tensorflow
+
+PROTOBUF_NAMESPACE_OPEN
+
+template <> struct is_proto_enum< ::tensorflow::EventReply_DebugOpStateChange_State> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::tensorflow::EventReply_DebugOpStateChange_State>() {
+  return ::tensorflow::EventReply_DebugOpStateChange_State_descriptor();
+}
+template <> struct is_proto_enum< ::tensorflow::CallTraceback_CallType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::tensorflow::CallTraceback_CallType>() {
+  return ::tensorflow::CallTraceback_CallType_descriptor();
+}
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fdebug_2fdebug_5fservice_2eproto
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/debug/debug_service_mock.grpc.pb.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/debug/debug_service_mock.grpc.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..76035d35b1fe5d6fd7247c2c977d0ac63018d21c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/debug/debug_service_mock.grpc.pb.h
@@ -0,0 +1,32 @@
+// Generated by the gRPC C++ plugin.
+// If you make any local change, they will be lost.
+// source: tensorflow/core/debug/debug_service.proto
+
+#include "tensorflow/core/debug/debug_service.pb.h"
+#include "tensorflow/core/debug/debug_service.grpc.pb.h"
+
+#include <grpcpp/impl/codegen/async_stream.h>
+#include <grpcpp/impl/codegen/sync_stream.h>
+#include <gmock/gmock.h>
+namespace tensorflow {
+
+
+namespace grpc {
+
+class MockEventListenerStub : public EventListener::StubInterface {
+ public:
+  MOCK_METHOD1(SendEventsRaw, ::grpc::ClientReaderWriterInterface< ::tensorflow::Event, ::tensorflow::EventReply>*(::grpc::ClientContext* context));
+  MOCK_METHOD3(AsyncSendEventsRaw, ::grpc::ClientAsyncReaderWriterInterface<::tensorflow::Event, ::tensorflow::EventReply>*(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag));
+  MOCK_METHOD2(PrepareAsyncSendEventsRaw, ::grpc::ClientAsyncReaderWriterInterface<::tensorflow::Event, ::tensorflow::EventReply>*(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq));
+  MOCK_METHOD3(SendTracebacks, ::grpc::Status(::grpc::ClientContext* context, const ::tensorflow::CallTraceback& request, ::tensorflow::EventReply* response));
+  MOCK_METHOD3(AsyncSendTracebacksRaw, ::grpc::ClientAsyncResponseReaderInterface< ::tensorflow::EventReply>*(::grpc::ClientContext* context, const ::tensorflow::CallTraceback& request, ::grpc::CompletionQueue* cq));
+  MOCK_METHOD3(PrepareAsyncSendTracebacksRaw, ::grpc::ClientAsyncResponseReaderInterface< ::tensorflow::EventReply>*(::grpc::ClientContext* context, const ::tensorflow::CallTraceback& request, ::grpc::CompletionQueue* cq));
+  MOCK_METHOD3(SendSourceFiles, ::grpc::Status(::grpc::ClientContext* context, const ::tensorflow::DebuggedSourceFiles& request, ::tensorflow::EventReply* response));
+  MOCK_METHOD3(AsyncSendSourceFilesRaw, ::grpc::ClientAsyncResponseReaderInterface< ::tensorflow::EventReply>*(::grpc::ClientContext* context, const ::tensorflow::DebuggedSourceFiles& request, ::grpc::CompletionQueue* cq));
+  MOCK_METHOD3(PrepareAsyncSendSourceFilesRaw, ::grpc::ClientAsyncResponseReaderInterface< ::tensorflow::EventReply>*(::grpc::ClientContext* context, const ::tensorflow::DebuggedSourceFiles& request, ::grpc::CompletionQueue* cq));
+};
+
+} // namespace grpc
+
+} // namespace tensorflow
+
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/debug/debugger_event_metadata.pb.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/debug/debugger_event_metadata.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..dae2ec3229234a89efd1a85e13a09b19fc0d9ae7
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/debug/debugger_event_metadata.pb.h
@@ -0,0 +1,387 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: tensorflow/core/debug/debugger_event_metadata.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fdebug_2fdebugger_5fevent_5fmetadata_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fdebug_2fdebugger_5fevent_5fmetadata_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3021000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3021009 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_tensorflow_2fcore_2fdebug_2fdebugger_5fevent_5fmetadata_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_tensorflow_2fcore_2fdebug_2fdebugger_5fevent_5fmetadata_2eproto {
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_tensorflow_2fcore_2fdebug_2fdebugger_5fevent_5fmetadata_2eproto;
+namespace third_party {
+namespace tensorflow {
+namespace core {
+namespace debug {
+class DebuggerEventMetadata;
+struct DebuggerEventMetadataDefaultTypeInternal;
+extern DebuggerEventMetadataDefaultTypeInternal _DebuggerEventMetadata_default_instance_;
+}  // namespace debug
+}  // namespace core
+}  // namespace tensorflow
+}  // namespace third_party
+PROTOBUF_NAMESPACE_OPEN
+template<> ::third_party::tensorflow::core::debug::DebuggerEventMetadata* Arena::CreateMaybeMessage<::third_party::tensorflow::core::debug::DebuggerEventMetadata>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace third_party {
+namespace tensorflow {
+namespace core {
+namespace debug {
+
+// ===================================================================
+
+class DebuggerEventMetadata final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:third_party.tensorflow.core.debug.DebuggerEventMetadata) */ {
+ public:
+  inline DebuggerEventMetadata() : DebuggerEventMetadata(nullptr) {}
+  ~DebuggerEventMetadata() override;
+  explicit PROTOBUF_CONSTEXPR DebuggerEventMetadata(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DebuggerEventMetadata(const DebuggerEventMetadata& from);
+  DebuggerEventMetadata(DebuggerEventMetadata&& from) noexcept
+    : DebuggerEventMetadata() {
+    *this = ::std::move(from);
+  }
+
+  inline DebuggerEventMetadata& operator=(const DebuggerEventMetadata& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DebuggerEventMetadata& operator=(DebuggerEventMetadata&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const DebuggerEventMetadata& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const DebuggerEventMetadata* internal_default_instance() {
+    return reinterpret_cast<const DebuggerEventMetadata*>(
+               &_DebuggerEventMetadata_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(DebuggerEventMetadata& a, DebuggerEventMetadata& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DebuggerEventMetadata* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(DebuggerEventMetadata* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  DebuggerEventMetadata* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<DebuggerEventMetadata>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const DebuggerEventMetadata& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const DebuggerEventMetadata& from) {
+    DebuggerEventMetadata::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(DebuggerEventMetadata* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "third_party.tensorflow.core.debug.DebuggerEventMetadata";
+  }
+  protected:
+  explicit DebuggerEventMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDeviceFieldNumber = 1,
+    kOutputSlotFieldNumber = 2,
+    kNumChunksFieldNumber = 3,
+    kChunkIndexFieldNumber = 4,
+  };
+  // string device = 1;
+  void clear_device();
+  const std::string& device() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_device(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_device();
+  PROTOBUF_NODISCARD std::string* release_device();
+  void set_allocated_device(std::string* device);
+  private:
+  const std::string& _internal_device() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_device(const std::string& value);
+  std::string* _internal_mutable_device();
+  public:
+
+  // int32 output_slot = 2;
+  void clear_output_slot();
+  int32_t output_slot() const;
+  void set_output_slot(int32_t value);
+  private:
+  int32_t _internal_output_slot() const;
+  void _internal_set_output_slot(int32_t value);
+  public:
+
+  // int32 num_chunks = 3;
+  void clear_num_chunks();
+  int32_t num_chunks() const;
+  void set_num_chunks(int32_t value);
+  private:
+  int32_t _internal_num_chunks() const;
+  void _internal_set_num_chunks(int32_t value);
+  public:
+
+  // int32 chunk_index = 4;
+  void clear_chunk_index();
+  int32_t chunk_index() const;
+  void set_chunk_index(int32_t value);
+  private:
+  int32_t _internal_chunk_index() const;
+  void _internal_set_chunk_index(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:third_party.tensorflow.core.debug.DebuggerEventMetadata)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_;
+    int32_t output_slot_;
+    int32_t num_chunks_;
+    int32_t chunk_index_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fdebug_2fdebugger_5fevent_5fmetadata_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// DebuggerEventMetadata
+
+// string device = 1;
+inline void DebuggerEventMetadata::clear_device() {
+  _impl_.device_.ClearToEmpty();
+}
+inline const std::string& DebuggerEventMetadata::device() const {
+  // @@protoc_insertion_point(field_get:third_party.tensorflow.core.debug.DebuggerEventMetadata.device)
+  return _internal_device();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void DebuggerEventMetadata::set_device(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.device_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:third_party.tensorflow.core.debug.DebuggerEventMetadata.device)
+}
+inline std::string* DebuggerEventMetadata::mutable_device() {
+  std::string* _s = _internal_mutable_device();
+  // @@protoc_insertion_point(field_mutable:third_party.tensorflow.core.debug.DebuggerEventMetadata.device)
+  return _s;
+}
+inline const std::string& DebuggerEventMetadata::_internal_device() const {
+  return _impl_.device_.Get();
+}
+inline void DebuggerEventMetadata::_internal_set_device(const std::string& value) {
+  
+  _impl_.device_.Set(value, GetArenaForAllocation());
+}
+inline std::string* DebuggerEventMetadata::_internal_mutable_device() {
+  
+  return _impl_.device_.Mutable(GetArenaForAllocation());
+}
+inline std::string* DebuggerEventMetadata::release_device() {
+  // @@protoc_insertion_point(field_release:third_party.tensorflow.core.debug.DebuggerEventMetadata.device)
+  return _impl_.device_.Release();
+}
+inline void DebuggerEventMetadata::set_allocated_device(std::string* device) {
+  if (device != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.device_.SetAllocated(device, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.device_.IsDefault()) {
+    _impl_.device_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:third_party.tensorflow.core.debug.DebuggerEventMetadata.device)
+}
+
+// int32 output_slot = 2;
+inline void DebuggerEventMetadata::clear_output_slot() {
+  _impl_.output_slot_ = 0;
+}
+inline int32_t DebuggerEventMetadata::_internal_output_slot() const {
+  return _impl_.output_slot_;
+}
+inline int32_t DebuggerEventMetadata::output_slot() const {
+  // @@protoc_insertion_point(field_get:third_party.tensorflow.core.debug.DebuggerEventMetadata.output_slot)
+  return _internal_output_slot();
+}
+inline void DebuggerEventMetadata::_internal_set_output_slot(int32_t value) {
+  
+  _impl_.output_slot_ = value;
+}
+inline void DebuggerEventMetadata::set_output_slot(int32_t value) {
+  _internal_set_output_slot(value);
+  // @@protoc_insertion_point(field_set:third_party.tensorflow.core.debug.DebuggerEventMetadata.output_slot)
+}
+
+// int32 num_chunks = 3;
+inline void DebuggerEventMetadata::clear_num_chunks() {
+  _impl_.num_chunks_ = 0;
+}
+inline int32_t DebuggerEventMetadata::_internal_num_chunks() const {
+  return _impl_.num_chunks_;
+}
+inline int32_t DebuggerEventMetadata::num_chunks() const {
+  // @@protoc_insertion_point(field_get:third_party.tensorflow.core.debug.DebuggerEventMetadata.num_chunks)
+  return _internal_num_chunks();
+}
+inline void DebuggerEventMetadata::_internal_set_num_chunks(int32_t value) {
+  
+  _impl_.num_chunks_ = value;
+}
+inline void DebuggerEventMetadata::set_num_chunks(int32_t value) {
+  _internal_set_num_chunks(value);
+  // @@protoc_insertion_point(field_set:third_party.tensorflow.core.debug.DebuggerEventMetadata.num_chunks)
+}
+
+// int32 chunk_index = 4;
+inline void DebuggerEventMetadata::clear_chunk_index() {
+  _impl_.chunk_index_ = 0;
+}
+inline int32_t DebuggerEventMetadata::_internal_chunk_index() const {
+  return _impl_.chunk_index_;
+}
+inline int32_t DebuggerEventMetadata::chunk_index() const {
+  // @@protoc_insertion_point(field_get:third_party.tensorflow.core.debug.DebuggerEventMetadata.chunk_index)
+  return _internal_chunk_index();
+}
+inline void DebuggerEventMetadata::_internal_set_chunk_index(int32_t value) {
+  
+  _impl_.chunk_index_ = value;
+}
+inline void DebuggerEventMetadata::set_chunk_index(int32_t value) {
+  _internal_set_chunk_index(value);
+  // @@protoc_insertion_point(field_set:third_party.tensorflow.core.debug.DebuggerEventMetadata.chunk_index)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace debug
+}  // namespace core
+}  // namespace tensorflow
+}  // namespace third_party
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fdebug_2fdebugger_5fevent_5fmetadata_2eproto
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/debug/debugger_state_impl.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/debug/debugger_state_impl.h
new file mode 100644
index 0000000000000000000000000000000000000000..9de9bdc2f290c38d0c552a8261a8b70d079b864a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/debug/debugger_state_impl.h
@@ -0,0 +1,61 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DEBUG_DEBUGGER_STATE_IMPL_H_
+#define TENSORFLOW_CORE_DEBUG_DEBUGGER_STATE_IMPL_H_
+
+#include "tensorflow/core/common_runtime/debugger_state_interface.h"
+
+#include <unordered_set>
+#include <vector>
+
+namespace tensorflow {
+
+class DebuggerState : public DebuggerStateInterface {
+ public:
+  DebuggerState(const DebugOptions& debug_options);
+  virtual ~DebuggerState();
+
+  // Publish metadata about the debugged Session::Run() call.
+  //
+  // See the doc string of DebuggerStateInterface::PublishDebugMetadata() for
+  // details.
+  Status PublishDebugMetadata(const int64_t global_step,
+                              const int64_t session_run_count,
+                              const int64_t executor_step_count,
+                              const std::vector<string>& input_names,
+                              const std::vector<string>& output_names,
+                              const std::vector<string>& target_names) override;
+
+ private:
+  std::unordered_set<string> debug_urls_;
+};
+
+class DebugGraphDecorator : public DebugGraphDecoratorInterface {
+ public:
+  DebugGraphDecorator(const DebugOptions& debug_options)
+      : debug_options_(debug_options) {}
+  virtual ~DebugGraphDecorator() {}
+
+  Status DecorateGraph(Graph* graph, Device* device) override;
+  Status PublishGraph(const Graph& graph, const string& device_name) override;
+
+ private:
+  DebugOptions debug_options_;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DEBUG_DEBUGGER_STATE_IMPL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/base_rendezvous_mgr.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/base_rendezvous_mgr.h
new file mode 100644
index 0000000000000000000000000000000000000000..3b5c99b16988d36e0e8591efa32545a543d2dee3
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/base_rendezvous_mgr.h
@@ -0,0 +1,296 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_BASE_RENDEZVOUS_MGR_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_BASE_RENDEZVOUS_MGR_H_
+
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+
+#include "absl/container/flat_hash_map.h"
+#include "absl/container/flat_hash_set.h"
+#include "tensorflow/core/common_runtime/eager/rendezvous_cache.h"
+#include "tensorflow/core/distributed_runtime/rendezvous_mgr_interface.h"
+#include "tensorflow/core/distributed_runtime/worker_env.h"
+#include "tensorflow/core/distributed_runtime/worker_session.h"
+#include "tensorflow/core/framework/cancellation.h"
+#include "tensorflow/core/framework/control_flow.h"
+#include "tensorflow/core/framework/local_rendezvous.h"
+#include "tensorflow/core/framework/rendezvous.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/lib/hash/hash.h"
+#include "tensorflow/core/platform/macros.h"
+#include "tensorflow/core/platform/mutex.h"
+#include "tensorflow/core/platform/thread_annotations.h"
+#include "tensorflow/core/platform/types.h"
+#include "tensorflow/core/util/device_name_utils.h"
+#include "tsl/platform/refcount.h"
+
+namespace tensorflow {
+
+class BaseRemoteRendezvous;
+class BaseRecvTensorCall;
+
+// RendezvousMgr keeps track of a set of local rendezvous instances.
+// All tensors sent by this worker are buffered in a RendezvousMgr
+// until the tensor is received.  Each global unique "step_id"
+// corresponds to one local rendezvous instance managed by a
+// RendezvousMgr.
+// RendezvousMgr holds weak references to rendezvous. When a rendezvous is
+// destructed, it will create a new instance to fulfill the Find.
+//
+// E.g.,
+//   Rendezvous* rendez = worker_env->rendezvous_mgr->Find(0x8935);
+//   fork execution of a graph executor using "rendez" on thread 1;
+//   fork execution of another graph executor using "rendez" on thread 2;
+//   ...
+//   join threads 1 and 2;
+//
+// In the example above, execution in thread 1 and 2 communicates with
+// each other by send/recv operations through `rendez`.
+//
+// Tensors sent and received through a rendezvous managed by this
+// RendezvousMgr must have keys generated by Rendezvous::CreateKey().
+class BaseRendezvousMgr : public RendezvousMgrInterface {
+ public:
+  explicit BaseRendezvousMgr(const WorkerEnv* worker_env);
+
+  ~BaseRendezvousMgr() override;
+
+  // Returns Rendezvous supporting send and recv among workers in the
+  // "step_id".  The caller takes ownership of one reference on the
+  // returned Rendezvous instance.
+  //
+  // Note: the caller must guarantee to eventually call Initialize on the
+  // returned RemoteRendezvous
+  tsl::core::RefCountPtr<RemoteRendezvous> Find(int64_t step_id) override;
+
+  // Finds the local rendezvous instance for the "step_id".  Runs
+  // "done" when the tensor for "key" is produced or an error occurs.
+  //
+  // This method is used by the rpc handler of RecvTensor.
+  void RecvLocalAsync(int64_t step_id, const Rendezvous::ParsedKey& parsed,
+                      Rendezvous::DoneCallback done) override;
+
+  // Synchronous wrapper for RecvLocalAsync.
+  Status RecvLocal(int64_t step_id, const Rendezvous::ParsedKey& parsed,
+                   Tensor* val, bool* is_dead) override;
+
+  // Removes rendezvous for "step_id".
+  void Cleanup(int64_t step_id) override { cache_->RemoveAndAbort(step_id); }
+
+  // Remove all rendezvous instances owned by the rendezvous_mgr.
+  void CleanupAll() override { cache_->RemoveAll(); }
+
+ protected:
+  virtual tsl::core::RefCountPtr<BaseRemoteRendezvous> Create(
+      int64_t step_id, const WorkerEnv* worker_env) = 0;
+
+ private:
+  tsl::core::RefCountPtr<RendezvousCache<BaseRemoteRendezvous>> cache_;
+
+  // Not owned.
+  const WorkerEnv* const worker_env_;
+
+  tsl::core::RefCountPtr<BaseRemoteRendezvous> FindOrCreate(int64_t step_id);
+
+  BaseRendezvousMgr(const BaseRendezvousMgr&) = delete;
+  void operator=(const BaseRendezvousMgr&) = delete;
+};
+
+// RemoteRendezvous is a Rendezvous which can handle either
+// the producer or consumer being in a remote process.
+//
+// Buffering of Tensor values is delegated to a "local" Rendezvous
+// obtained from NewLocalRendezvous().  This class just adds
+// functionality to coordinate with remote workers.
+class BaseRemoteRendezvous : public RemoteRendezvous {
+ public:
+  BaseRemoteRendezvous(const WorkerEnv* env, int64_t step_id);
+
+  // Upgrades the BaseRemoteRendezvous to full initialization.
+  Status Initialize(WorkerSession* session) override;
+
+  void SetRemoteEagerContextDefault() override {
+    remote_eager_context_default_ = true;
+  }
+  bool IsRemoteEagerContextDefault() override {
+    return remote_eager_context_default_;
+  }
+
+  // Forwards to local_, where the Tensor "val" will be buffered and
+  // any waiting callback stored.
+  Status Send(const ParsedKey& key, const Rendezvous::Args& args,
+              const Tensor& val, const bool is_dead) override;
+
+  // This method is called only by the RecvOp.  It tests to see
+  // whether the value will be produced by a local or remote device
+  // and handles accordingly.  In the local case it forwards to
+  // local_, in the remote case it initiates an RPC request.
+  void RecvAsync(const ParsedKey& key, const Rendezvous::Args& args,
+                 DoneCallback done) override;
+
+  void StartAbort(const Status& status) override;
+
+  // This method is called only by the local Worker, forwarded through
+  // the same method on RendezvousMgr.  This occurs when the Worker
+  // has received a RecvTensor request, either locally or over the
+  // network.  In either case it needs to retrieve a locally buffered
+  // value from local_, and give it to its caller.
+  //
+  // Runs "done" as soon as the tensor for "parsed" is available or an error
+  // is detected.
+  //
+  // REQUIRES: "parsed" is one that will be Saved into the local rendezvous.
+  void RecvLocalAsync(const ParsedKey& parsed, DoneCallback done);
+
+ protected:
+  virtual void RecvFromRemoteAsync(const Rendezvous::ParsedKey& parsed,
+                                   const Rendezvous::Args& args,
+                                   DoneCallback done) = 0;
+
+  // Returns true if "src" and "dst" are located in the same worker,
+  // and hence may use a local rendezvous.
+  virtual bool IsSameWorker(DeviceNameUtils::ParsedName src,
+                            DeviceNameUtils::ParsedName dst);
+
+  // If aborted, aborts "call". Otherwise, adds "call" into calls_.
+  void RegisterCall(BaseRecvTensorCall* call, const Rendezvous::Args& args);
+
+  // Removes "call" from calls_ if "call" is in calls_.
+  void DeregisterCall(BaseRecvTensorCall* call, const Rendezvous::Args& args);
+
+  WorkerSession* session();
+
+  bool is_initialized();
+
+  ~BaseRemoteRendezvous() override;
+
+  const WorkerEnv* const env_;  // Not owned.
+  const int64_t step_id_;
+
+ private:
+  int num_shards_;
+  LocalRendezvous local_;
+  // Indicates whether this remote rendezvous instance is used as the default
+  // rendezvous for remote eager op-by-op execution. Errors in eager op-by-op
+  // execution should not abort the rendezvous since it is a context-wide
+  // instance and needs to be reused; instead, the errors are propagated through
+  // eager executors.
+  bool remote_eager_context_default_ = false;
+
+  mutable mutex mu_;
+  mutable mutex calls_mu_;
+
+  // Status given by StartAbort() if any.
+  Status status_ TF_GUARDED_BY(mu_);
+
+  WorkerSession* session_ TF_GUARDED_BY(mu_);  // Not owned.
+
+  // Data structures to handle calls when partially initialized.
+  struct DeferredCall {
+    const ParsedKey parsed;
+    DoneCallback done;
+
+    // Keeps a reference to the rendezvous, to keep it alive.
+    tsl::core::RefCountPtr<Rendezvous> rendezvous;
+
+    DeferredCall(const ParsedKey& parsed, DoneCallback done,
+                 tsl::core::RefCountPtr<Rendezvous> rendez);
+  };
+  std::vector<DeferredCall> deferred_calls_ TF_GUARDED_BY(mu_);
+
+  struct CallBucket {
+    mutex mu;
+
+    absl::flat_hash_set<BaseRecvTensorCall*> calls TF_GUARDED_BY(mu);
+  };
+
+  struct PendingCalls {
+    PendingCalls(CancellationToken token, int num_calls, int num_buckets,
+                 tsl::core::RefCountPtr<Rendezvous> rendez)
+        : token(token),
+          num_calls(num_calls),
+          buckets(num_buckets),
+          rendezvous(std::move(rendez)) {}
+    CancellationToken token = CancellationManager::kInvalidToken;
+    std::atomic<int> num_calls = 0;
+    std::vector<CallBucket> buckets;
+
+    // Keeps a reference to the rendezvous, to keep it alive.
+    tsl::core::RefCountPtr<Rendezvous> rendezvous;
+  };
+
+  // "CancellationToken" is stored here so that when there's no active
+  // RecvTensorCalls, we can de-register the callback in the cancellation
+  // manager. RecvTensorCalls are managed in multiple buckets since in large
+  // scaled distributed training, lots of Send/Recv may be triggered
+  // concurrently.
+  //
+  // Note: pointer to CancellationManager can be nullptr in certain use cases.
+  absl::flat_hash_map<CancellationManager*, std::unique_ptr<PendingCalls>>
+      calls_ TF_GUARDED_BY(calls_mu_);
+
+  // Callback for CancellationManager.
+  void CancelledByManager(CancellationManager* cm);
+
+  bool is_initialized_locked() TF_SHARED_LOCKS_REQUIRED(mu_) {
+    return session_ != nullptr;
+  }
+
+  // If "is_src" is true, checks that the rendezvous key "parsed"'s
+  // source is in this process. If "is_src" is false, checks that the
+  // rendezvous key "parsed"'s destination is in this process.
+  Status ValidateDevices(const Rendezvous::ParsedKey& parsed, bool is_src);
+
+  // Callback handling the case when a rendezvous has been
+  // accomplished in local_ and the consumer is local to this process.
+  // Tensor "in" will be copied into "out". The key "parsed" encodes
+  // the src and dst devices.
+  void SameWorkerRecvDone(const Rendezvous::ParsedKey& parsed,
+                          const Rendezvous::Args& in_args,
+                          const Rendezvous::Args& out_args, const Tensor& in,
+                          Tensor* out, StatusCallback done);
+
+  // Must be called only if fully initialized.
+  void RecvLocalAsyncInternal(const ParsedKey& parsed, DoneCallback done);
+
+  BaseRemoteRendezvous(const BaseRemoteRendezvous&) = delete;
+  void operator=(const BaseRemoteRendezvous&) = delete;
+};
+
+class BaseRecvTensorCall {
+ public:
+  BaseRecvTensorCall() {}
+  virtual ~BaseRecvTensorCall() {}
+
+  virtual void Start(std::function<void()> recv_done) = 0;
+
+  virtual void StartAbort(const Status& s) = 0;
+
+  virtual Status status() const = 0;
+
+ private:
+  BaseRecvTensorCall(const BaseRecvTensorCall&) = delete;
+  void operator=(const BaseRecvTensorCall&) = delete;
+};
+
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_BASE_RENDEZVOUS_MGR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/call_options.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/call_options.h
new file mode 100644
index 0000000000000000000000000000000000000000..3cff6ccd0f8ad4a3e402ed8f8a096598ebb9602a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/call_options.h
@@ -0,0 +1,27 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_CALL_OPTIONS_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_CALL_OPTIONS_H_
+
+#include "tsl/distributed_runtime/call_options.h"
+
+namespace tensorflow {
+// NOLINTBEGIN(misc-unused-using-decls)
+using tsl::CallOptions;
+// NOLINTEND(misc-unused-using-decls)
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_CALL_OPTIONS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/cancellable_call.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/cancellable_call.h
new file mode 100644
index 0000000000000000000000000000000000000000..7311c8e3a44f4202c84171c03213feb67aacb69f
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/cancellable_call.h
@@ -0,0 +1,61 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_CANCELLABLE_CALL_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_CANCELLABLE_CALL_H_
+
+#include <string>
+#include "tensorflow/core/distributed_runtime/call_options.h"
+#include "tensorflow/core/distributed_runtime/worker_cache.h"
+#include "tensorflow/core/framework/cancellation.h"
+#include "tensorflow/core/platform/mutex.h"
+
+namespace tensorflow {
+
+// Supports client side cancellation of WorkerInterface calls via
+// registration with a CancellationManager.
+class CancellableCall {
+ public:
+  CancellableCall(CancellationManager* cancel_mgr, const string& remote_worker,
+                  WorkerCacheInterface* wc)
+      : is_cancelled_(false),
+        cancel_mgr_(cancel_mgr),
+        remote_worker_(remote_worker),
+        wc_(wc),
+        wi_(wc_->GetOrCreateWorker(remote_worker_)) {}
+
+  virtual ~CancellableCall() { wc_->ReleaseWorker(remote_worker_, wi_); }
+
+  virtual void IssueCall(const StatusCallback& done) = 0;
+
+  void Start(const StatusCallback& done);
+
+  // Cancels the RPC if it's not cancelled yet. This must be called after
+  // Start(). This is normally used if there's a needed to cancel the RPC from a
+  // sideband. If appliable, pass a cancellation manager to the constructor
+  // instead of using this method.
+  void Cancel() TF_LOCKS_EXCLUDED(mu_);
+
+ protected:
+  mutex mu_;
+  bool is_cancelled_;
+  CancellationManager* const cancel_mgr_;  // Not owned
+  const string remote_worker_;
+  WorkerCacheInterface* const wc_;  // Not owned
+  WorkerInterface* const wi_;       // Owned by wc_, must be released.
+  CallOptions opts_;
+};
+
+}  // namespace tensorflow
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_CANCELLABLE_CALL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/cluster_function_library_runtime.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/cluster_function_library_runtime.h
new file mode 100644
index 0000000000000000000000000000000000000000..eaad4301576570c37a36854dc10ee6468a12ec71
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/cluster_function_library_runtime.h
@@ -0,0 +1,106 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_CLUSTER_FUNCTION_LIBRARY_RUNTIME_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_CLUSTER_FUNCTION_LIBRARY_RUNTIME_H_
+
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include "absl/types/optional.h"
+#include "tensorflow/core/distributed_runtime/worker_cache.h"
+#include "tensorflow/core/distributed_runtime/worker_interface.h"
+#include "tensorflow/core/framework/function.h"
+
+namespace tensorflow {
+
+class WorkerSession;
+
+// ClusterFunctionLibraryRuntime contains methods to Instantiate and Run
+// functions across processes by making RPCs through worker service.
+class ClusterFunctionLibraryRuntime : public DistributedFunctionLibraryRuntime {
+ public:
+  ClusterFunctionLibraryRuntime(WorkerSession* worker_session,
+                                bool create_worker_session_called,
+                                DeviceMgr* remote_device_mgr)
+      : worker_session_(worker_session),
+        create_worker_session_called_(create_worker_session_called),
+        remote_device_mgr_(remote_device_mgr) {}
+
+  ~ClusterFunctionLibraryRuntime() override;
+
+  void Instantiate(const string& function_name,
+                   const FunctionLibraryDefinition& lib_def, AttrSlice attrs,
+                   const FunctionLibraryRuntime::InstantiateOptions& options,
+                   FunctionLibraryRuntime::LocalHandle* handle,
+                   FunctionLibraryRuntime::DoneCallback done) override;
+
+  void Run(const FunctionLibraryRuntime::Options& opts,
+           FunctionLibraryRuntime::LocalHandle handle,
+           gtl::ArraySlice<Tensor> args, std::vector<Tensor>* rets,
+           FunctionLibraryRuntime::DoneCallback done) override;
+
+  void Run(const FunctionLibraryRuntime::Options& opts,
+           FunctionLibraryRuntime::LocalHandle handle,
+           gtl::ArraySlice<FunctionArg> args, std::vector<FunctionRet>* rets,
+           FunctionLibraryRuntime::DoneCallback done) override;
+
+  void CleanUp(uint64 step_id, FunctionLibraryRuntime::LocalHandle handle,
+               FunctionLibraryRuntime::DoneCallback done) override;
+
+  DeviceMgr* remote_device_mgr() const override { return remote_device_mgr_; }
+
+ private:
+  static Status ConstructFunctionGraph(
+      const OpDef& sig, AttrSlice attrs,
+      const FunctionLibraryRuntime::InstantiateOptions& options,
+      const FunctionLibraryDefinition& flib_def, GraphDef* g,
+      std::vector<string>* send_keys, std::vector<string>* recv_keys);
+  friend class ClusterFunctionLibraryRuntimeTest;
+
+  mutable mutex mu_;
+  WorkerSession* const worker_session_ = nullptr;  // not owned.
+  const bool create_worker_session_called_;
+
+  DeviceMgr* remote_device_mgr_;  // not owned.
+
+  struct FunctionData {
+    const string graph_handle;
+    const string target;
+    // Hold a shared pointer to the underlying worker cache to avoid it being
+    // deleted in potential cluster update.
+    const std::shared_ptr<WorkerCacheInterface> worker_cache;
+    WorkerInterface* wi = nullptr;
+    const std::vector<string> send_keys;
+    const std::vector<string> recv_keys;
+
+    FunctionData(const string& graph_handle, const string& target,
+                 std::shared_ptr<WorkerCacheInterface> worker_cache,
+                 WorkerInterface* wi, const std::vector<string>& send_keys,
+                 const std::vector<string>& recv_keys)
+        : graph_handle(graph_handle),
+          target(target),
+          worker_cache(std::move(worker_cache)),
+          wi(wi),
+          send_keys(send_keys),
+          recv_keys(recv_keys) {}
+  };
+
+  std::vector<FunctionData> function_data_ TF_GUARDED_BY(mu_);
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_CLUSTER_FUNCTION_LIBRARY_RUNTIME_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/collective_param_resolver_distributed.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/collective_param_resolver_distributed.h
new file mode 100644
index 0000000000000000000000000000000000000000..4d75e9d4e18e2f11e2239e23c0cc553cd2fe73a8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/collective_param_resolver_distributed.h
@@ -0,0 +1,96 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_COLLECTIVE_PARAM_RESOLVER_DISTRIBUTED_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_COLLECTIVE_PARAM_RESOLVER_DISTRIBUTED_H_
+
+#include "tensorflow/core/common_runtime/collective_param_resolver_local.h"
+#include "tensorflow/core/framework/cancellation.h"
+#include "tensorflow/core/framework/device_attributes.pb.h"
+#include "tensorflow/core/platform/status.h"
+
+namespace tensorflow {
+class ConfigProto;
+class WorkerCacheInterface;
+class DeviceResolverDistributed;
+class DeviceMgr;
+
+class CollectiveParamResolverDistributed : public CollectiveParamResolverLocal {
+ public:
+  CollectiveParamResolverDistributed(
+      const ConfigProto& config, const DeviceMgr* dev_mgr,
+      DeviceResolverDistributed* dev_resolver,
+      NcclCommunicatorInterface* nccl_communicator,
+      WorkerCacheInterface* worker_cache, const string& task_name);
+
+  void CompleteParamsAsync(const DeviceAttributes& device, CollectiveParams* cp,
+                           CancellationManager* cancel_mgr,
+                           const StatusCallback& done) override;
+
+  void CompleteGroupAsync(const DeviceAttributes& device,
+                          CollGroupParams* group_params,
+                          CancellationManager* cancel_mgr,
+                          const StatusCallback& done) override;
+
+  void CompleteInstanceAsync(const CompleteInstanceRequest* request,
+                             CompleteInstanceResponse* response,
+                             CancellationManager* cancel_mgr,
+                             const StatusCallback& done) override;
+
+  void StartAbort(const Status& s) override;
+
+ protected:
+  // Returns the cached group iff there's an entry for this group_key in the
+  // local group_table_; returns nullptr otherwise.
+  GroupRec* GetCachedGroup(int32_t group_key) TF_LOCKS_EXCLUDED(group_mu_);
+
+  // Updates group_table_ with contents of resp.
+  Status UpdateGroupCache(const CompleteGroupResponse& resp)
+      TF_LOCKS_EXCLUDED(group_mu_);
+
+  // Finds the GroupRec that corresponds to cp->group_key and also
+  // populates cp->group from that GroupRec.
+  //
+  // Semantics are like those of CompleteGroupLocal but will make a
+  // remote call to the group leader if necessary.
+  void CompleteGroupDistributed(const DeviceAttributes& device,
+                                CollGroupParams* group_params,
+                                CancellationManager* cancel_mgr,
+                                const StatusCallback& done);
+
+  // Returns true iff there's an entry for this instance_key in the
+  // local instance_table_.
+  bool InstanceIsCached(int32_t group_key, const CollInstanceParams& instance)
+      TF_LOCKS_EXCLUDED(instance_mu_);
+
+  // Updates instance_table_ with contents of resp.
+  Status UpdateInstanceCache(CollectiveParams* cp,
+                             const CompleteInstanceResponse& resp)
+      TF_LOCKS_EXCLUDED(instance_mu_, group_mu_);
+
+  // Finish populating *cp.  Semantics are like those of
+  // CompleteInstanceLocal but will make a remote call to the group
+  // leader if necessary.
+  void CompleteInstanceDistributed(const string& device, CollectiveParams* cp,
+                                   CancellationManager* cancel_mgr,
+                                   const StatusCallback& done)
+      TF_LOCKS_EXCLUDED(instance_mu_, group_mu_);
+
+  WorkerCacheInterface* worker_cache_;  // Not owned
+  const string group_leader_;
+  CancellationManager abortion_cancel_mgr_;
+};
+
+}  // namespace tensorflow
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_COLLECTIVE_PARAM_RESOLVER_DISTRIBUTED_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/collective_rma_distributed.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/collective_rma_distributed.h
new file mode 100644
index 0000000000000000000000000000000000000000..31eab9dba2f904477ca05073919cc706c26a1838
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/collective_rma_distributed.h
@@ -0,0 +1,64 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_COLLECTIVE_RMA_DISTRIBUTED_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_COLLECTIVE_RMA_DISTRIBUTED_H_
+
+#include "tensorflow/core/common_runtime/collective_rma_local.h"
+#include "tensorflow/core/framework/cancellation.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/platform/unbounded_work_queue.h"
+
+namespace tensorflow {
+class WorkerCacheInterface;
+
+// Extend CollectiveRemoteAccessLocal with access to remote peers.
+class CollectiveRemoteAccessDistributed : public CollectiveRemoteAccessLocal {
+ public:
+  CollectiveRemoteAccessDistributed(
+      const DeviceMgr* dev_mgr, DeviceResolverInterface* dev_resolver,
+      std::shared_ptr<UnboundedWorkQueue> work_queue,
+      WorkerCacheInterface* worker_cache, int64_t step_id, string task_name)
+      : CollectiveRemoteAccessLocal(dev_mgr, dev_resolver, step_id),
+        worker_cache_(worker_cache),
+        work_queue_(std::move(work_queue)),
+        task_name_(std::move(task_name)) {}
+
+  ~CollectiveRemoteAccessDistributed() override {}
+
+  void RecvFromPeer(const string& peer_device, const string& peer_task,
+                    bool peer_is_local, const string& key, Device* to_device,
+                    DeviceContext* to_device_ctx,
+                    const AllocatorAttributes& to_alloc_attr, Tensor* to_tensor,
+                    const DeviceLocality& client_locality,
+                    int dev_to_dev_stream_index,
+                    CancellationManager* cancellation_manager,
+                    const StatusCallback& done) override;
+
+  void CheckPeerHealth(const string& peer_task, int64_t timeout_in_ms,
+                       const StatusCallback& done) override;
+
+  void StartAbort(const Status& s) override;
+
+ protected:
+  WorkerCacheInterface* worker_cache_;  // Not owned
+  // Ownership of `work_queue_` is shared between `this` and
+  // `CollectiveExecutorMgr`.
+  std::shared_ptr<UnboundedWorkQueue> work_queue_;
+  CancellationManager abortion_cancel_mgr_;
+  string task_name_;
+};
+
+}  // namespace tensorflow
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_COLLECTIVE_RMA_DISTRIBUTED_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/coordination/coordination_client.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/coordination/coordination_client.h
new file mode 100644
index 0000000000000000000000000000000000000000..95907778e7012b442c169eae10756188975a1a28
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/coordination/coordination_client.h
@@ -0,0 +1,31 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_COORDINATION_COORDINATION_CLIENT_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_COORDINATION_COORDINATION_CLIENT_H_
+
+#include <memory>
+#include <string>
+
+#include "tsl/distributed_runtime/coordination/coordination_client.h"
+
+namespace tensorflow {
+// NOLINTBEGIN(misc-unused-using-decls)
+using tsl::CoordinationClient;
+using tsl::CoordinationClientCache;
+// NOLINTEND(misc-unused-using-decls)
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_COORDINATION_COORDINATION_CLIENT_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/coordination/coordination_service_error_util.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/coordination/coordination_service_error_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..bbc263e1deb82662bd8ab01e464b73ff05a17fae
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/coordination/coordination_service_error_util.h
@@ -0,0 +1,27 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_COORDINATION_COORDINATION_SERVICE_ERROR_UTIL_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_COORDINATION_COORDINATION_SERVICE_ERROR_UTIL_H_
+
+#include "tsl/distributed_runtime/coordination/coordination_service_error_util.h"
+
+namespace tensorflow {
+// NOLINTBEGIN(misc-unused-using-decls)
+using ::tsl::CoordinationErrorPayloadKey;
+using ::tsl::MakeCoordinationError;
+// NOLINTEND(misc-unused-using-decls)
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_COORDINATION_COORDINATION_SERVICE_ERROR_UTIL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/device_resolver_distributed.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/device_resolver_distributed.h
new file mode 100644
index 0000000000000000000000000000000000000000..299cbc95b01f9bb9eeba801db34a1657fcad00f5
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/device_resolver_distributed.h
@@ -0,0 +1,50 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_DEVICE_RESOLVER_DISTRIBUTED_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_DEVICE_RESOLVER_DISTRIBUTED_H_
+
+#include <string>
+#include <vector>
+
+#include "absl/container/flat_hash_map.h"
+#include "tensorflow/core/framework/collective.h"
+#include "tensorflow/core/framework/device_attributes.pb.h"
+#include "tensorflow/core/platform/status.h"
+
+namespace tensorflow {
+class DeviceMgr;
+class WorkerCacheInterface;
+
+class DeviceResolverDistributed : public DeviceResolverInterface {
+ public:
+  explicit DeviceResolverDistributed(const DeviceMgr* dev_mgr);
+
+  Status GetDeviceAttributes(const string& device,
+                             DeviceAttributes* attributes) override;
+
+  Status GetAllDeviceAttributes(
+      const string& task, std::vector<DeviceAttributes>* attributes) override;
+
+  Status UpdateDeviceAttributes(
+      const std::vector<DeviceAttributes>& attributes) override;
+
+ protected:
+  const string task_name_;
+  mutex mu_;
+  absl::flat_hash_map<string, DeviceAttributes> attr_table_ TF_GUARDED_BY(mu_);
+};
+
+}  // namespace tensorflow
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_DEVICE_RESOLVER_DISTRIBUTED_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/eager/cluster_function_library_runtime.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/eager/cluster_function_library_runtime.h
new file mode 100644
index 0000000000000000000000000000000000000000..ed0cb32348f3d57a352c23f0b84c509ca75051c9
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/eager/cluster_function_library_runtime.h
@@ -0,0 +1,115 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_EAGER_CLUSTER_FUNCTION_LIBRARY_RUNTIME_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_EAGER_CLUSTER_FUNCTION_LIBRARY_RUNTIME_H_
+
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include "absl/types/optional.h"
+#include "tensorflow/core/common_runtime/device_mgr.h"
+#include "tensorflow/core/common_runtime/eager/context.h"
+#include "tensorflow/core/common_runtime/eager/eager_operation.h"
+#include "tensorflow/core/framework/function.h"
+#include "tensorflow/core/protobuf/remote_tensor_handle.pb.h"
+
+namespace tensorflow {
+
+class WorkerSession;
+
+namespace eager {
+
+// EagerClusterFunctionLibraryRuntime contains methods to Instantiate and Run
+// functions across processes by making RPCs through eager service.
+class EagerClusterFunctionLibraryRuntime
+    : public DistributedFunctionLibraryRuntime {
+ public:
+  EagerClusterFunctionLibraryRuntime(const uint64 context_id, EagerContext* ctx,
+                                     DeviceMgr* remote_device_mgr)
+      : context_id_(context_id),
+        ctx_(ctx),
+        remote_device_mgr_(remote_device_mgr) {}
+
+  ~EagerClusterFunctionLibraryRuntime() override{};
+
+  // Register a partition (i.e., component function) of a multi-device function
+  // on the remote target specified in `options.target`. This should be
+  // triggered as part of instantiating a multi-device function in
+  // ProcessFunctionLibraryRuntime.
+  void Instantiate(const string& function_name,
+                   const FunctionLibraryDefinition& lib_def, AttrSlice attrs,
+                   const FunctionLibraryRuntime::InstantiateOptions& options,
+                   FunctionLibraryRuntime::LocalHandle* handle,
+                   FunctionLibraryRuntime::DoneCallback done) override;
+
+  // Execute the component function specified by `handle` on its instantiated
+  // remote target. This should be triggered as part of driving a multi-device
+  // function execution in ProcessFunctionLibraryRuntime. Running the component
+  // function remotely is purely asynchronous, and multiple component functions
+  // with the same remote target are not executed in any particular ordering.
+  // The main function side must wait for all component functions to finish
+  // (i.e., the done callbacks triggered) before finishing its execution.
+  void Run(const FunctionLibraryRuntime::Options& opts,
+           FunctionLibraryRuntime::LocalHandle handle,
+           gtl::ArraySlice<Tensor> args, std::vector<Tensor>* rets,
+           FunctionLibraryRuntime::DoneCallback done) override;
+
+  // The component function inputs `args` and outputs `rets` may refer to remote
+  // tensors on a remote device, which will be lazily resolved remotely where
+  // the inputs/outputs are actually consumed.
+  void Run(const FunctionLibraryRuntime::Options& opts,
+           FunctionLibraryRuntime::LocalHandle handle,
+           gtl::ArraySlice<FunctionArg> args, std::vector<FunctionRet>* rets,
+           FunctionLibraryRuntime::DoneCallback done) override;
+
+  void CleanUp(uint64 step_id, FunctionLibraryRuntime::LocalHandle handle,
+               FunctionLibraryRuntime::DoneCallback done) override;
+
+  DeviceMgr* remote_device_mgr() const override { return remote_device_mgr_; }
+
+ private:
+  const uint64 context_id_;
+  EagerContext* ctx_;
+  DeviceMgr* remote_device_mgr_;  // not owned.
+
+  struct FunctionData {
+    const string target;
+    const absl::optional<std::vector<int>> ret_indices;
+    core::RefCountPtr<EagerClient> eager_client;
+    std::unique_ptr<EagerOperation> op;
+
+    FunctionData(const string& target,
+                 const absl::optional<std::vector<int>>& ret_indices,
+                 EagerClient* eager_client, std::unique_ptr<EagerOperation> op)
+        : target(target),
+          ret_indices(ret_indices),
+          eager_client(core::RefCountPtr<EagerClient>(eager_client)),
+          op(std::move(op)) {
+      eager_client->Ref();
+    }
+  };
+
+  mutable mutex mu_;
+  std::vector<FunctionData> function_data_ TF_GUARDED_BY(mu_);
+};
+
+DistributedFunctionLibraryRuntime* CreateClusterFLR(
+    const uint64 context_id, EagerContext* ctx, WorkerSession* worker_session);
+
+}  // namespace eager
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_EAGER_CLUSTER_FUNCTION_LIBRARY_RUNTIME_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/eager/destroy_tensor_handle_node.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/eager/destroy_tensor_handle_node.h
new file mode 100644
index 0000000000000000000000000000000000000000..45aab6e5f840ea8c01ff385aa1d9beae90cbb54c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/eager/destroy_tensor_handle_node.h
@@ -0,0 +1,90 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_EAGER_DESTROY_TENSOR_HANDLE_NODE_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_EAGER_DESTROY_TENSOR_HANDLE_NODE_H_
+
+#include <memory>
+#include <utility>
+
+#include "absl/status/status.h"
+#include "tensorflow/core/common_runtime/eager/eager_executor.h"
+#include "tensorflow/core/distributed_runtime/eager/eager_client.h"
+#include "tensorflow/core/protobuf/eager_service.pb.h"
+
+namespace tensorflow {
+namespace eager {
+
+// DestroyTensorHandleNode is an implementation of EagerNode which enqueues a
+// request to destroy a remote tensor handle.
+class DestroyTensorHandleNode : public tensorflow::AsyncEagerNode {
+ public:
+  DestroyTensorHandleNode(std::unique_ptr<EnqueueRequest> request,
+                          core::RefCountPtr<EagerClient> eager_client,
+                          bool ready)
+      : tensorflow::AsyncEagerNode(),
+        request_(std::move(request)),
+        eager_client_(std::move(eager_client)),
+        ready_(ready) {}
+
+  ~DestroyTensorHandleNode() override {}
+
+  void RunAsync(StatusCallback done) override {
+    EnqueueResponse* response = new EnqueueResponse;
+    bool ready = ready_;
+    // NOTE(fishx): Don't use StreamingEnqueueAsync here. When a
+    // StreamingEnqueueAsync request fails all following requests will fail as
+    // well. We don't want this request poison following requests since it is
+    // safe to ignore a failing destroy tensor handle request.
+    eager_client_->EnqueueAsync(
+        /*call_opts=*/nullptr, request_.get(), response,
+        [response, ready, done](const tensorflow::Status& s) {
+          // Omit the warning if:
+          // 1. The remote tensor isn't ready.
+          // 2. Lost connection to remote worker. In this case client will
+          //    crash. We don't want to spam user with redundant warning logs.
+          if (!s.ok() && ready && !absl::IsUnavailable(s)) {
+            LOG_EVERY_N_SEC(WARNING, 60)
+                << "Ignoring an error encountered when deleting "
+                   "remote tensors handles: "
+                << s.ToString();
+          }
+          done(OkStatus());
+          delete response;
+        });
+  }
+
+  void Abort(Status status) override {}
+
+  // Remote node deletions are best effort
+  bool Fatal() const override { return false; }
+
+  string DebugString() const override {
+    string out = "[DestroyTensorHandleNode]";
+    strings::StrAppend(&out, " request: ", request_->DebugString());
+    return out;
+  }
+
+ private:
+  std::unique_ptr<EnqueueRequest> request_;
+  core::RefCountPtr<EagerClient> eager_client_;
+  const string remote_task_;
+  bool ready_;
+};
+
+}  // namespace eager
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_EAGER_DESTROY_TENSOR_HANDLE_NODE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/eager/eager_client.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/eager/eager_client.h
new file mode 100644
index 0000000000000000000000000000000000000000..a2265d51a1f5d3e5f477661836843b6a7a7d34c1
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/eager/eager_client.h
@@ -0,0 +1,102 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_EAGER_EAGER_CLIENT_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_EAGER_EAGER_CLIENT_H_
+
+#include <cstdint>
+
+#include "tensorflow/core/distributed_runtime/call_options.h"
+#include "tensorflow/core/platform/refcount.h"
+#include "tensorflow/core/platform/status.h"
+#include "tensorflow/core/protobuf/eager_service.pb.h"
+
+namespace tensorflow {
+namespace eager {
+
+// This is a base class that can be implemented by a variety of
+// transports (e.g. gRPC which for each of the client methods makes an RPC).
+class EagerClient : public core::RefCounted {
+ public:
+  ~EagerClient() override {}
+#define CLIENT_METHOD(method)                                \
+  virtual void method##Async(const method##Request* request, \
+                             method##Response* response,     \
+                             StatusCallback done) = 0;
+
+  CLIENT_METHOD(CreateContext);
+  CLIENT_METHOD(UpdateContext);
+  CLIENT_METHOD(WaitQueueDone);
+  CLIENT_METHOD(KeepAlive);
+  CLIENT_METHOD(CloseContext);
+
+#undef CLIENT_METHOD
+
+#define CLIENT_METHOD_WITH_TIMEOUT_AND_RETRIES(method)                        \
+  virtual void method##Async(const method##Request* request,                  \
+                             method##Response* response, StatusCallback done, \
+                             int64_t init_timeout_in_ms, int retries) = 0;
+
+  CLIENT_METHOD_WITH_TIMEOUT_AND_RETRIES(CreateContext);
+
+#undef CLIENT_METHOD_WITH_TIMEOUT_AND_RETRIES
+
+#define CLIENT_CANCELABLE_METHOD(method)                      \
+  virtual void method##Async(                                 \
+      CallOptions* call_opts, const method##Request* request, \
+      method##Response* response, StatusCallback done) = 0;
+
+  CLIENT_CANCELABLE_METHOD(Enqueue);
+  CLIENT_CANCELABLE_METHOD(RunComponentFunction);
+
+#undef CLIENT_CANCELABLE_METHOD
+
+  // Feeds `request` into the request stream of EagerService::StreamingEnqueue.
+  // `response` will be filled with the response for this `request`. The
+  // 1-to-1 correspondence between requests and responses is a property
+  // of the current service implementation. When the response is received,
+  // `done` is invoked with the current status of the StreamingEnqueue call.
+  // The status can contain an error because of an earlier request in the
+  // current streaming call.
+  // The client initiates a streaming call the first time StreamingEnqueueAsync
+  // is invoked and keeps it open until some error condition.
+  // Similarly to the methods above, the request can be deleted as soon as
+  // StreamingEnqueueAsync returns.
+  virtual void StreamingEnqueueAsync(bool enable_streaming_enqueue,
+                                     CallOptions* call_opts,
+                                     const EnqueueRequest* request,
+                                     EnqueueResponse* response,
+                                     StatusCallback done) = 0;
+
+  virtual bool allow_multiple_pending_requests() const = 0;
+};
+
+// Simple wrapper class that can be used to retrieve EagerClients.
+class EagerClientCache {
+ public:
+  virtual ~EagerClientCache() {}
+
+  // If the `target` exists, assign the EagerClient pointer to `client` and
+  // increment the refcount of the client. The reference ownership is
+  // transferred to the caller, and the unref should automatically happen when
+  // destructing the RefCountPtr object from the caller's side.
+  virtual Status GetClient(const string& target,
+                           core::RefCountPtr<EagerClient>* client) = 0;
+};
+
+}  // namespace eager
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_EAGER_EAGER_CLIENT_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/eager/eager_service_impl.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/eager/eager_service_impl.h
new file mode 100644
index 0000000000000000000000000000000000000000..8239b361b48ef572270b899d5aeb9affe427834e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/eager/eager_service_impl.h
@@ -0,0 +1,242 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_EAGER_EAGER_SERVICE_IMPL_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_EAGER_EAGER_SERVICE_IMPL_H_
+
+#include <memory>
+#include <unordered_map>
+#include <utility>
+
+#include "tensorflow/core/common_runtime/eager/context.h"
+#include "tensorflow/core/distributed_runtime/eager/remote_mgr.h"
+#include "tensorflow/core/distributed_runtime/eager/remote_tensor_handle.h"
+#include "tensorflow/core/distributed_runtime/worker_env.h"
+
+namespace tensorflow {
+namespace eager {
+
+// A TensorFlow Eager Worker runs ops and supports worker to worker
+// Tensor transfer.
+//
+// See eager_service.proto for more details about each method.
+// This class can be wrapped by specific classes that implement rpc transports
+// over this (e.g. gRPC).
+class EagerServiceImpl {
+ public:
+  explicit EagerServiceImpl(WorkerEnv* env) : env_(env) {
+    gc_thread_.reset(
+        env_->env->StartThread({}, "EagerServiceContextGC", [this]() {
+          while (true) {
+            {
+              mutex_lock l(gc_thread_shutdown_mu_);
+              gc_thread_cv_.wait_for(l, std::chrono::seconds(1));
+
+              if (shutting_down_) {
+                return;
+              }
+            }
+            {
+              mutex_lock l(contexts_mu_);
+              for (auto it = contexts_.begin(); it != contexts_.end();) {
+                if (it->second->IsStale()) {
+                  it->second->Unref();
+                  it = contexts_.erase(it);
+                } else {
+                  it++;
+                }
+              }
+            }
+          }
+        }));
+  }
+  virtual ~EagerServiceImpl() {
+    {
+      mutex_lock l(gc_thread_shutdown_mu_);
+      shutting_down_ = true;
+      gc_thread_cv_.notify_all();
+    }
+    gc_thread_.reset();
+
+    mutex_lock l(contexts_mu_);
+    for (auto& entry : contexts_) {
+      entry.second->Unref();
+    }
+  }
+
+  Status CreateContext(const CreateContextRequest* request,
+                       CreateContextResponse* response);
+
+  Status UpdateContext(const UpdateContextRequest* request,
+                       UpdateContextResponse* response);
+
+  // Create a ServerContext for master eager context.
+  Status CreateMasterContext(const tensorflow::uint64 context_id,
+                             EagerContext* context);
+
+  static constexpr uint64 kInvalidStreamId = 0;
+
+  // Used by both Enqueue and StreamingEnqueue RPCs.
+  Status Enqueue(CallOptions* call_opts, const EnqueueRequest* request,
+                 EnqueueResponse* response,
+                 uint64 stream_id = kInvalidStreamId);
+
+  Status WaitQueueDone(const WaitQueueDoneRequest* request,
+                       WaitQueueDoneResponse* response);
+
+  void RunComponentFunction(CallOptions* call_opts,
+                            const RunComponentFunctionRequest* request,
+                            RunComponentFunctionResponse* response,
+                            StatusCallback done);
+
+  Status KeepAlive(const KeepAliveRequest* request,
+                   KeepAliveResponse* response);
+
+  Status CloseContext(const CloseContextRequest* request,
+                      CloseContextResponse* response);
+
+ protected:
+  // This is the server-side execution context. All state regarding execution of
+  // a client's ops is held in this server-side context (all generated tensors,
+  // and the EagerContext).
+  class ServerContext : public core::RefCounted {
+   public:
+    // Create a ServerContext for local master.
+    static ServerContext* CreateMasterContext(tensorflow::EagerContext* ctx,
+                                              const WorkerEnv* env) {
+      return new ServerContext(ctx, -1, env, /* is_master= */ true);
+    }
+
+    explicit ServerContext(tensorflow::EagerContext* ctx,
+                           int64_t destroy_after_secs, const WorkerEnv* env,
+                           const bool is_master = false)
+        : ctx_(ctx), env_(env), is_master_(is_master) {
+      ctx->Ref();
+      destroy_after_micros_ =
+          destroy_after_secs * tensorflow::EnvTime::kSecondsToMicros;
+      RecordAccess();
+    }
+
+    ~ServerContext() override {
+      // TFE_Context is responsible for shutting down master eager context.
+      if (!is_master_) {
+        ctx_->WaitForAndCloseRemoteContexts();
+      }
+      // ctx_->RefCountIsOne() should be true here when is_master_ = false.
+      // TODO(iga): Remove EagerContext refcounting.
+      ctx_->Unref();
+    }
+
+    tensorflow::EagerContext* Context() const { return ctx_; }
+
+    void RecordAccess() {
+      mutex_lock l(last_accessed_mu_);
+      last_accessed_micros_ = env_->env->NowMicros();
+    }
+
+    bool IsStale() {
+      mutex_lock l(last_accessed_mu_);
+      const int64_t time_passed =
+          env_->env->NowMicros() - last_accessed_micros_;
+      return (destroy_after_micros_ > 0 && time_passed > destroy_after_micros_);
+    }
+
+   private:
+    // The context for this execution.
+    tensorflow::EagerContext* ctx_;
+
+    const WorkerEnv* const env_;  // Not owned.
+
+    mutex last_accessed_mu_;
+    int64_t last_accessed_micros_ TF_GUARDED_BY(last_accessed_mu_);
+    int64_t destroy_after_micros_;
+
+    const bool is_master_;
+  };
+  // The returned ServerContext will need to be Unrefed.
+  tensorflow::Status GetServerContext(uint64, ServerContext**);
+
+  class ClientTensorHandleDeleteNode : public EagerNode {
+   public:
+    ClientTensorHandleDeleteNode(
+        ServerContext* context,
+        std::unique_ptr<RemoteTensorHandleInternal> handle_to_delete)
+        : tensorflow::EagerNode(),
+          context_(context),
+          handle_to_delete_(std::move(handle_to_delete)) {
+      context_->Ref();
+    }
+
+    ~ClientTensorHandleDeleteNode() override { context_->Unref(); }
+
+    Status Run() override {
+      VLOG(3) << "ServerContext: Deleting tensor handle "
+              << handle_to_delete_->op_id << ":"
+              << handle_to_delete_->output_num;
+      return context_->Context()->RemoteMgr()->DeleteTensorHandle(
+          *handle_to_delete_);
+    }
+
+    void Abort(Status status) override {}
+
+    // Remote node deletions are best effort
+    bool Fatal() const override { return false; }
+
+    string DebugString() const override {
+      string out = "[ClientTensorHandleDeleteNode]";
+      strings::StrAppend(&out, " op_id: ", handle_to_delete_->op_id);
+      strings::StrAppend(&out, ", output_num: ", handle_to_delete_->output_num);
+      return out;
+    }
+
+   private:
+    // Owns one reference.
+    ServerContext* const context_;
+    const std::unique_ptr<RemoteTensorHandleInternal> handle_to_delete_;
+  };
+
+ private:
+  Status ExecuteOp(CallOptions* call_opts, const Operation& operation,
+                   EagerContext* eager_context, EagerExecutor* eager_executor,
+                   QueueResponse* queue_response);
+  Status SendTensor(const SendTensorOp& send_tensor,
+                    EagerContext* eager_context);
+  Status SendPackedHandle(const SendPackedHandleOp& send_packed_handle,
+                          EagerContext* eager_context);
+  Status RegisterFunction(const RegisterFunctionOp& register_function,
+                          EagerContext* eager_context);
+  Status RemoveFunction(const RemoveFunctionOp& remove_function,
+                        EagerContext* eager_context);
+  Status CleanupFunction(const CleanupFunctionOp& cleanup_function);
+
+  WorkerEnv* const env_;  // Not owned.
+
+  mutex contexts_mu_;
+  std::unordered_map<uint64, ServerContext*> contexts_
+      TF_GUARDED_BY(contexts_mu_);
+
+  std::unique_ptr<Thread> gc_thread_;
+  mutex gc_thread_shutdown_mu_;
+  condition_variable gc_thread_cv_;
+  bool shutting_down_ TF_GUARDED_BY(gc_thread_shutdown_mu_) = false;
+
+  EagerServiceImpl(const EagerServiceImpl&) = delete;
+  void operator=(const EagerServiceImpl&) = delete;
+};
+
+}  // namespace eager
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_EAGER_EAGER_SERVICE_IMPL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/eager/remote_copy_node.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/eager/remote_copy_node.h
new file mode 100644
index 0000000000000000000000000000000000000000..0f5297e855933e00c8832818c6d3ebfcd00a3e14
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/eager/remote_copy_node.h
@@ -0,0 +1,179 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_EAGER_REMOTE_COPY_NODE_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_EAGER_REMOTE_COPY_NODE_H_
+
+#include <memory>
+#include <vector>
+
+#include "tensorflow/core/common_runtime/eager/eager_executor.h"
+#include "tensorflow/core/common_runtime/eager/eager_operation.h"
+#include "tensorflow/core/common_runtime/eager/tensor_handle.h"
+#include "tensorflow/core/framework/cancellation.h"
+#include "tensorflow/core/framework/tensor.h"
+
+namespace tensorflow {
+namespace eager {
+
+// This node supports copying a tensor in the following way:
+// - Remote -> Local:
+//   We don't block on the remote _Send op and start executing the local
+//   _Recv immediately after issuing the remote _Send. The local _Recv
+//   kernel (or rather the special _Recv handling in KernelAndDeviceOp::Run)
+//   blocks until the tensor is received. If the remote _Send (or some op
+//   before it) fails, the local callback we give to EnqueueAsync will run
+//   and call CancellationManager.StartCancel(). The blocked local _Recv will
+//   get this notification and return with a cancelled error.
+//
+// - Local -> Remote:
+//   The local _Send op is synchronous and non-blocking, thus it should complete
+//   quickly. We issue remote _Recv RPC only after local _Send completes
+//   successfully. At this point, the tensor to be sent is in the local
+//   Rendezvous, hence, remote _Recv op will not deadlock waiting for the tensor
+//   to appear.
+//   When ctx->UseSendTensorRPC() is true, we use EagerService::Enqueue
+//   SendTensor instead of _Send/_Recv.
+//
+// - Remote -> Remote:
+//   We could issue both remote ops asynchronously, but if remote _Send (or some
+//   op before it) fails, we don't have a good way of cancelling the remote
+//   _Recv. The remote _Recv will deadlock in this case. The current approach
+//   to deal with this issue is to wait for remote _Send to complete before
+//   issuing remote _Recv RPC. Another option is to close the whole streaming
+//   RPC that contains the deadlocked remote _Recv. This would not unblock the
+//   deadlocked RPC on the remote machine without some extra code. Luckily, the
+//   remote -> remote case seems to be fairly rare at this point. So, the
+//   current partially synchronous approach seems fine.
+//
+// To copy a tensor within a host, please use copy_to_device_node instead.
+class RemoteCopyNode : public AsyncEagerNode {
+ public:
+  RemoteCopyNode(EagerContext* ctx, EagerExecutor* executor, TensorHandle* src,
+                 TensorHandle* dst, Device* recv_device, uint64 recv_op_id);
+
+  ~RemoteCopyNode() override;
+
+  Status Prepare() override;
+
+  void RunAsync(StatusCallback done) override;
+
+  void Abort(Status status) override;
+
+  string DebugString() const override {
+    string out = "[RemoteCopyNode]";
+    strings::StrAppend(&out, " send_device: ", send_device_->name());
+    strings::StrAppend(&out, ", recv_device: ", recv_device_->name());
+    strings::StrAppend(&out, ", send_tensor: ", src_->DebugString());
+    strings::StrAppend(
+        &out, ", recv_tensor: ", captured_state_->dst()->DebugString());
+    return out;
+  }
+
+ private:
+  // Runs the _Send operation locally or remotely.
+  // StartSend() makes sure that captured_state_->send_status_ is set to the
+  // final _Send status after captured_state->send_done_.WaitForNotification()
+  // returns.
+  void StartSend();
+
+  // Synchronously runs local send `op` and returns its status.
+  Status RunLocalSend(EagerOperation* op);
+
+  // Runs the _Recv operation locally or remotely.
+  // An error return value indicates that _Recv did not run successfully. It
+  // does not indicate that _Send op has completed since StartRecv could have
+  // encountered an error before waiting for _Send's completion.
+  // An OK return value does NOT necessarily indicate that _Recv has completed
+  // successfully (it does now, but won't when streaming RPCs are turned on).
+  // StartRecv() makes sure that dst_ tensor handle is handled correctly
+  // (potentially after this methods returns); a tensor is set in the local
+  // case, a remote shape is set in the remote case, the dst_ handle is
+  // poisoned in either case if there is an error.
+  void StartRecv(StatusCallback done);
+
+  // Synchronously runs local receive `op` and returns its status.
+  // Does not wait for the send to complete before running receive.
+  Status RunLocalRecv(EagerOperation* op, std::vector<Tensor>* outputs);
+
+  // Waits for send to complete, then issues remote receive `op` and
+  // returns its status.
+  void RunRemoteRecv(EagerOperation* op, StatusCallback done);
+
+  // When !ctx->UseSendTensorRPC(), then tensors are shipped between remote
+  // devices by the receiver invoking the WorkerService.RecvTensor RPC *on the
+  // sender* (Rendezvous::RecvAsync() invoked by the _Recv kernel).
+  //
+  // However, in some configurations the node that has the tensor to be copied
+  // isn't running a server (WorkerService RPC interface). For such cases,
+  // this function enables sending tensors using the EagerService.Enqueue
+  // SendTensor RPC *on the receiver*.
+  void StartRemoteSendTensor(StatusCallback done);
+
+  // Send a local packed TensorHandle to a remote device.
+  void StartSendPackedHandle(StatusCallback done);
+
+  // State that is captured by Send and/or Recv callbacks (depending on which
+  // one(s) is remote) and outlives this node in the case of remote->remote
+  // copy.
+  class CapturedSharedState {
+   public:
+    explicit CapturedSharedState(TensorHandle* d) : dst_(d) { dst_->Ref(); }
+    ~CapturedSharedState() { dst_->Unref(); }
+
+    void SetSendStatus(Status status) {
+      send_status_.Update(status);
+      send_done_.Notify();
+    }
+
+    Status GetSendStatus() {
+      send_done_.WaitForNotification();
+      return send_status_;
+    }
+
+    // src_shape_ is not thread-safe. It should only be set in one thread.
+    void SetSrcShape(const TensorShape& shape) { src_shape_ = shape; }
+
+    const TensorShape& GetSrcShape() { return src_shape_; }
+
+    TensorHandle* dst() { return dst_; }
+    CancellationManager* recv_cancellation() { return &recv_cancellation_; }
+
+   private:
+    TensorHandle* const dst_;
+    CancellationManager recv_cancellation_;
+    // send_status_ is safe to read only after send_done_.WaitForNotification()
+    // has returned.
+    Status send_status_;
+    Notification send_done_;
+    TensorShape src_shape_;
+  };
+
+  TensorHandle* const src_;
+  EagerContext* const ctx_;
+  EagerExecutor* const executor_;
+  Device* const send_device_;
+  Device* const recv_device_;
+  const string wire_id_;
+  const uint64 recv_op_id_;
+
+  std::shared_ptr<CapturedSharedState> captured_state_;
+  bool started_;
+};
+
+}  // namespace eager
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_EAGER_REMOTE_COPY_NODE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/eager/remote_execute_node.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/eager/remote_execute_node.h
new file mode 100644
index 0000000000000000000000000000000000000000..6aabf3ce209d7d4fefc59d59cf9fa9f20901cd0c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/eager/remote_execute_node.h
@@ -0,0 +1,142 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_EAGER_REMOTE_EXECUTE_NODE_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_EAGER_REMOTE_EXECUTE_NODE_H_
+
+#include <cstddef>
+#include <memory>
+#include <utility>
+
+#include "absl/types/span.h"
+#include "tensorflow/core/common_runtime/eager/eager_executor.h"
+#include "tensorflow/core/common_runtime/eager/shape_inference.h"
+#include "tensorflow/core/common_runtime/eager/tensor_handle.h"
+#include "tensorflow/core/distributed_runtime/eager/eager_client.h"
+#include "tensorflow/core/framework/cancellation.h"
+#include "tensorflow/core/framework/function.h"
+#include "tensorflow/core/framework/node_def.pb.h"
+#include "tensorflow/core/lib/gtl/inlined_vector.h"
+#include "tensorflow/core/protobuf/eager_service.pb.h"
+
+namespace tensorflow {
+namespace eager {
+
+// RemoteExecuteNode is an implementation of EagerNode which enqueues
+// an operation via RPC in a remote EagerService.
+class RemoteExecuteNode : public AsyncRemoteExecuteNode {
+ public:
+  RemoteExecuteNode(EagerContext* eager_context,
+                    std::unique_ptr<EnqueueRequest> request, Device* device,
+                    uint64 context_view_id, EagerClient* eager_client,
+                    CancellationManager* cancellation_manager,
+                    const NodeDef& ndef, FunctionLibraryDefinition* lib_def,
+                    const gtl::InlinedVector<TensorHandle*, 4>& inputs,
+                    absl::Span<TensorHandle*> retvals)
+      : AsyncRemoteExecuteNode(),
+        eager_context_(eager_context),
+        request_(std::move(request)),
+        device_(device),
+        context_view_id_(context_view_id),
+        eager_client_(eager_client),
+        cancellation_manager_(cancellation_manager),
+        ndef_(ndef),
+        lib_def_(lib_def),
+        inputs_(inputs) {
+    // Copy the output handles, since the container for them might get
+    // destroyed.
+    for (auto handle : retvals) {
+      handle->Ref();
+      retvals_.push_back(handle);
+    }
+
+    // This is required to ensure that the tensor handles stay alive across the
+    // execution.
+    for (auto handle : inputs_) {
+      handle->Ref();
+    }
+    eager_client_->Ref();
+
+    needs_remote_inputs_ = false;
+    for (const TensorHandle* input : inputs_) {
+      // TODO(bramandia): Should this be op_device() instead?
+      if (input->resource_device() != nullptr &&
+          input->resource_device() != device_) {
+        needs_remote_inputs_ = true;
+        break;
+      }
+    }
+  }
+
+  ~RemoteExecuteNode() override {
+    for (auto handle : retvals_) {
+      handle->Unref();
+    }
+
+    for (auto handle : inputs_) {
+      handle->Unref();
+    }
+    eager_client_->Unref();
+  }
+
+  Status Prepare() override {
+    return RunShapeInference(ndef_, *lib_def_, inputs_, retvals_);
+  }
+
+  void RunAsync(StatusCallback done) override;
+
+  Status SyncExecutors() override { return eager_context_->SyncExecutors(); }
+
+  void Abort(Status status) override {
+    int i = 0;
+    for (auto handle : retvals_) {
+      handle->PoisonRemote(status, device_, context_view_id_);
+      ++i;
+    }
+  }
+
+  const EagerClient* eager_client() const override { return eager_client_; }
+
+  bool needs_remote_inputs() const override { return needs_remote_inputs_; }
+
+  bool allow_multiple_pending_requests() const override {
+    return eager_client_->allow_multiple_pending_requests();
+  }
+
+  string DebugString() const override {
+    string out = "[RemoteExecuteNode]";
+    strings::StrAppend(&out, " request: ", request_->DebugString());
+    strings::StrAppend(&out, ", target_device: ", device_->name());
+    return out;
+  }
+
+ private:
+  EagerContext* eager_context_;  // Not owned, and must outlive this node.
+  std::unique_ptr<EnqueueRequest> request_;
+  Device* device_;             // Not owned
+  uint64 context_view_id_;
+  bool needs_remote_inputs_;
+  EagerClient* eager_client_;  // Not owned, and must outlive this node.
+  CancellationManager* cancellation_manager_;
+  const NodeDef ndef_;
+  const FunctionLibraryDefinition* lib_def_;
+  gtl::InlinedVector<TensorHandle*, 4> inputs_;
+  gtl::InlinedVector<TensorHandle*, 2> retvals_;
+};
+
+}  // namespace eager
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_EAGER_REMOTE_EXECUTE_NODE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/eager/remote_mgr.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/eager/remote_mgr.h
new file mode 100644
index 0000000000000000000000000000000000000000..06893b54399d7f2f5742809848568789549f4c60
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/eager/remote_mgr.h
@@ -0,0 +1,136 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_EAGER_REMOTE_MGR_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_EAGER_REMOTE_MGR_H_
+
+#include <unordered_map>
+#include <vector>
+
+#include "tensorflow/core/common_runtime/eager/eager_executor.h"
+#include "tensorflow/core/common_runtime/eager/tensor_handle.h"
+#include "tensorflow/core/distributed_runtime/eager/remote_tensor_handle.h"
+#include "tensorflow/core/platform/mutex.h"
+
+namespace tensorflow {
+namespace eager {
+
+// This class manages the states required to setup an eager cluster.
+// TODO(fishx): Move remote state from context to this class.
+class RemoteMgr {
+ public:
+  RemoteMgr(bool is_master, EagerContext* ctx)
+      : is_master_(is_master), parent_(ctx) {}
+
+  ~RemoteMgr() {
+    for (const auto& entry : remote_tensor_handle_map_) {
+      entry.second->Unref();
+    }
+  }
+
+  bool IsMaster() { return is_master_; }
+
+  void AddOperationOutputs(
+      const gtl::ArraySlice<tensorflow::TensorHandle*> handles,
+      int64_t operation_id);
+
+  void AddOperationOutput(tensorflow::TensorHandle* handles,
+                          int64_t operation_id, int32_t output_num);
+
+  Status GetTensorHandle(const RemoteTensorHandleInternal& remote_handle,
+                         tensorflow::TensorHandle** handle);
+
+  Status DeleteTensorHandle(const RemoteTensorHandleInternal& remote_handle);
+
+  // Helper function to create monotonically increasing ids unique to this
+  // context.
+  uint64 NextOpId() {
+    DCHECK(is_master_);
+    mutex_lock l(next_id_mutex_);
+    return next_op_id_++;
+  }
+
+  // Serialize a remote TensorHandle to a RemoteTensorHandle.
+  // If wait_until_ready is true, block until the remote handle is ready on a
+  // remote worker.
+  Status SerializeRemoteTensorHandle(
+      TensorHandle* in, const bool wait_until_ready, RemoteTensorHandle* out,
+      Device* device, const string& device_name,
+      const bool serialize_resource_dtype_and_shape = false);
+
+  // Deserialize a RemoteTensorHandle to a TensorHandle(local/remote).
+  // The output holds a reference to the TensorHandle.
+  Status DeserializeRemoteTensorHandle(const RemoteTensorHandle& in,
+                                       TensorHandle** out);
+
+  EagerExecutor& GetOrCreateExecutorForStream(uint64 stream_id);
+
+  void DeleteExecutorForStream(uint64 stream_id);
+
+ protected:
+  mutex next_id_mutex_;
+  uint64 next_op_id_ TF_GUARDED_BY(next_id_mutex_) = 1;
+
+ private:
+  // Returns the op_id and output_num if the given local TensorHandle exists in
+  // remote_tensor_handle_map_.
+  Status GetRemoteTensorHandle(const tensorflow::TensorHandle* handle,
+                               const bool wait_until_ready, int64_t* op_id,
+                               int32* output_num)
+      TF_SHARED_LOCKS_REQUIRED(remote_tensor_handle_mu_);
+
+  Status GetTensorHandleImpl(const RemoteTensorHandleInternal& remote_handle,
+                             tensorflow::TensorHandle** handle)
+      TF_SHARED_LOCKS_REQUIRED(remote_tensor_handle_mu_);
+
+  Status GetMirroredResourceShape(
+      const RemoteTensorHandleInternal& remote_handle,
+      std::vector<DtypeAndPartialTensorShape>* handle);
+
+  bool is_master_;
+
+  using RemoteTensorHandleMap =
+      gtl::FlatMap<RemoteTensorHandleInternal, tensorflow::TensorHandle*,
+                   RemoteTensorHandleInternalHash,
+                   RemoteTensorHandleInternalEquals>;
+  using MirroredResourceShapeMap = gtl::FlatMap<
+      RemoteTensorHandleInternal, std::vector<DtypeAndPartialTensorShape>,
+      RemoteTensorHandleInternalHash, RemoteTensorHandleInternalEquals>;
+
+  mutex remote_tensor_handle_mu_;
+  // This map maintains the TensorHandles that are required by remote workers
+  // in the cluster. Each map key is generated by the master, so it should be
+  // globally unique. This map owns references on the handles it contains.
+  RemoteTensorHandleMap remote_tensor_handle_map_
+      TF_GUARDED_BY(remote_tensor_handle_mu_);
+
+  mutex mirrored_resource_shape_mu_;
+  // This map maintains the data types and shapes of resource variables required
+  // by remote workers in the cluster. Each map key is generated by the master,
+  // so it should be globally unique.
+  MirroredResourceShapeMap mirrored_resource_shape_map_
+      TF_GUARDED_BY(mirrored_resource_shape_mu_);
+
+  EagerContext* parent_;  // not owned.
+
+  mutex executor_map_mu_;
+  std::unordered_map<uint64, EagerExecutor> executor_map_
+      TF_GUARDED_BY(executor_map_mu_);
+};
+
+}  // namespace eager
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_EAGER_REMOTE_MGR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/eager/remote_tensor_handle.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/eager/remote_tensor_handle.h
new file mode 100644
index 0000000000000000000000000000000000000000..903d019172a45756ff9292a1ab20816a91735fa1
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/eager/remote_tensor_handle.h
@@ -0,0 +1,50 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_EAGER_REMOTE_TENSOR_HANDLE_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_EAGER_REMOTE_TENSOR_HANDLE_H_
+
+#include "tensorflow/core/platform/fingerprint.h"
+#include "tensorflow/core/protobuf/remote_tensor_handle.pb.h"
+
+namespace tensorflow {
+namespace eager {
+
+struct RemoteTensorHandleInternal {
+  explicit RemoteTensorHandleInternal(const RemoteTensorHandle& tensor_handle)
+      : op_id(tensor_handle.op_id()), output_num(tensor_handle.output_num()) {}
+  RemoteTensorHandleInternal(int64_t op_id, int32_t output_num)
+      : op_id(op_id), output_num(output_num) {}
+  int64_t op_id;
+  int32 output_num;
+};
+
+struct RemoteTensorHandleInternalHash {
+  std::size_t operator()(const RemoteTensorHandleInternal& handle) const {
+    return FingerprintCat64(handle.op_id, handle.output_num);
+  }
+};
+
+struct RemoteTensorHandleInternalEquals {
+  bool operator()(const RemoteTensorHandleInternal& first,
+                  const RemoteTensorHandleInternal& second) const {
+    return first.op_id == second.op_id && first.output_num == second.output_num;
+  }
+};
+
+}  // namespace eager
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_EAGER_REMOTE_TENSOR_HANDLE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/eager/remote_tensor_handle_data.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/eager/remote_tensor_handle_data.h
new file mode 100644
index 0000000000000000000000000000000000000000..85a30913760d88f59b7ec5196420f0b148f05fe6
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/eager/remote_tensor_handle_data.h
@@ -0,0 +1,84 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_EAGER_REMOTE_TENSOR_HANDLE_DATA_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_EAGER_REMOTE_TENSOR_HANDLE_DATA_H_
+
+#include "tensorflow/core/common_runtime/eager/context.h"
+#include "tensorflow/core/platform/status.h"
+
+namespace tensorflow {
+
+// Remote Tensor Handle: A handle to a Tensor on a remote host. Note that only
+// the shape is known.
+class RemoteTensorHandleData {
+ public:
+  // Constructor for lazy remote handles. A lazy remote handle is created on
+  // a remote worker with an op_id and an output_num. It doesn't control the
+  // lifetime of a remote handle that it refers to. If it refers to a remote
+  // function input, it's sent by a client which won't serialize it until
+  // the corresponding remote tensor is ready. So the remote tensor should be
+  // ready when we create a lazy remote handle. If it refers to a remote output,
+  // it's not ready until the shape is set.
+  RemoteTensorHandleData(int64_t op_id, int output_num, uint64 context_view_id,
+                         bool is_ready);
+  // Constructor for unshaped remote handles. It controls the lifetime of a
+  // remote handel that it refers to.
+  RemoteTensorHandleData(int64_t op_id, int output_num,
+                         const string& remote_task, EagerContext* ctx);
+  ~RemoteTensorHandleData();
+
+  // A remote tensor handle does not have a Tensor object, hence it can only
+  // support the shape requests.
+  Status Shape(TensorShape* shape) const;
+  Status NumDims(int* num_dims) const;
+  Status Dim(int dim_index, int64_t* dim) const;
+  Status NumElements(int64_t* num_elements) const;
+  Status Unprotect() { return OkStatus(); }
+
+  bool IsReady() const;
+  Status WaitReady(const char* caller) const;
+  Status SetShape(const TensorShape& shape);
+  Status SetShapeAndRemoteTask(const TensorShape& shape,
+                               const string& remote_task);
+  void Poison(Status status);
+  Status IsPoisoned() const;
+
+  string DebugString() const;
+
+  // Return the op id and output num. If wait_util_ready is true, block until
+  // the remote tensor is ready on a remote worker.
+  Status OpIdAndOutputNum(const bool wait_util_ready, int64_t* op_id,
+                          int32* output_num) const;
+
+  uint64 context_view_id() const { return context_view_id_; }
+
+ private:
+  mutable mutex mu_;
+  bool is_ready_ TF_GUARDED_BY(mu_);
+  Status is_poisoned_ TF_GUARDED_BY(mu_);
+  TensorShape shape_ TF_GUARDED_BY(mu_);
+
+  // IDs required when this class is representing a remote tensor handle.
+  const int64_t op_id_;
+  const int32 output_num_;
+  string remote_task_ TF_GUARDED_BY(mu_);
+  uint64 context_id_;
+  uint64 context_view_id_;
+  EagerContext* ctx_;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_EAGER_REMOTE_TENSOR_HANDLE_DATA_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/error_payloads.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/error_payloads.h
new file mode 100644
index 0000000000000000000000000000000000000000..ae3b3e5e8013e13b5054405c68b1f7796e521b68
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/error_payloads.h
@@ -0,0 +1,34 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_ERROR_PAYLOADS_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_ERROR_PAYLOADS_H_
+
+// This file lists the proto payloads that may be inserted  by the code within
+// `tensorflow/core/distributed_runtime/` into Status instances.
+
+namespace tensorflow {
+// Proto: tensorflow::distributed_runtime::WorkerPossiblyRestarted
+// Location: tensorflow/core/protobuf/distributed_runtime_payloads.proto
+// Usage: Flags the Status to be a possible outcome of a worker restart.
+constexpr char kWorkerPossiblyRestarted[] =
+    "type.googleapis.com/"
+    "tensorflow.distributed_runtime.WorkerPossiblyRestarted";
+
+constexpr char kWorkerPreemption[] =
+    "type.googleapis.com/tensorflow.distributed_runtime.WorkerPreemption";
+
+}  // namespace tensorflow
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_ERROR_PAYLOADS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/graph_mgr.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/graph_mgr.h
new file mode 100644
index 0000000000000000000000000000000000000000..d394178f597554760609f3fb4ad3500d3627c8d2
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/graph_mgr.h
@@ -0,0 +1,203 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_GRAPH_MGR_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_GRAPH_MGR_H_
+
+#include <unordered_map>
+#include <vector>
+
+#include "tensorflow/core/common_runtime/costmodel_manager.h"
+#include "tensorflow/core/common_runtime/executor.h"
+#include "tensorflow/core/common_runtime/process_function_library_runtime.h"
+#include "tensorflow/core/distributed_runtime/message_wrappers.h"
+#include "tensorflow/core/distributed_runtime/worker_env.h"
+#include "tensorflow/core/framework/cancellation.h"
+#include "tensorflow/core/framework/collective.h"
+#include "tensorflow/core/framework/cost_graph.pb.h"
+#include "tensorflow/core/framework/function.h"
+#include "tensorflow/core/lib/core/refcount.h"
+#include "tensorflow/core/platform/logging.h"
+#include "tensorflow/core/platform/macros.h"
+#include "tensorflow/core/platform/mutex.h"
+#include "tensorflow/core/platform/types.h"
+#include "tensorflow/core/protobuf/config.pb.h"
+#include "tensorflow/core/protobuf/debug.pb.h"
+#include "tensorflow/core/protobuf/worker.pb.h"
+
+namespace tsl {
+class CoordinationServiceAgent;
+}
+
+namespace tensorflow {
+
+class ExecutorOpts;
+class StepStatsCollector;
+class RendezvousMgrInterface;
+class DeviceMgr;
+class WorkerSession;
+
+// GraphMgr keeps track of a set of graphs that are registered with a
+// TensorFlow worker. Each registered graph is identified by a handle
+// that is generated by GraphMgr and returned to the caller.
+//
+// After a successful registration, the caller executes a graph using
+// the graph handle. Each execution is distinguished from others by a
+// caller generated global unique id "step_id". Multiple executions
+// can use the same graph concurrently and independently as long as
+// "step_id" used are different.
+//
+// Multiple threads can call GraphMgr methods concurrently.
+//
+// E.g.,
+//   GraphMgr gmgr(worker_env);
+//   string handle;
+//   TF_CHECK_OK(gmgr.Register("session", { graph computes c = a + b },
+//   &handle));
+//   GraphMgr::NamedTensors in = { { "a", Tensor({1, 2}) },
+//                                { "b", Tensor({3, 4}) } };
+//   GraphMgr::NamedTensors out = { { "c", Tensor() } };
+//   TF_CHECK_OK(gmgr.Execute(handle, 0x0001, in, &out));
+//   EXPECT_EQ(out["c"], Tensor({4, 6}));
+class GraphMgr {
+ public:
+  explicit GraphMgr(const WorkerEnv* worker_env, const DeviceMgr* device_mgr);
+  ~GraphMgr();
+
+  // Registers a graph. Fills in "handle". The registered graph retains a
+  // reference to cluster_flr to do cross process function calls.
+  Status Register(const string& handle, const GraphDef& gdef,
+                  const GraphOptions& graph_options,
+                  const DebugOptions& debug_options,
+                  const ConfigProto& config_proto, int64_t collective_graph_key,
+                  WorkerSession* session,
+                  DistributedFunctionLibraryRuntime* cluster_flr,
+                  string* graph_handle);
+
+  // Executes one step of a registered graph "handle".
+  //
+  // If "out" is not nullptr, "out" specifies all keys the execution
+  // should receive upon finish.
+  typedef std::map<string, Tensor> NamedTensors;
+  typedef std::function<void(const Status&)> StatusCallback;
+  void ExecuteAsync(const string& handle, const int64_t step_id,
+                    const ExecutorOpts& opts, const NamedTensors& in,
+                    WorkerSession* session, StepStatsCollector* collector,
+                    MutableRunGraphResponseWrapper* response,
+                    CancellationManager* cancellation_manager,
+                    tsl::CoordinationServiceAgent* coordination_service_agent,
+                    StatusCallback done);
+
+  Status SendInputs(const int64_t step_id, const NamedTensors& in);
+  Status RecvOutputs(const int64_t step_id, NamedTensors* out);
+  void RecvOutputsAsync(const int64_t step_id, NamedTensors* out,
+                        StatusCallback done);
+
+  // Deregisters a graph.
+  Status Deregister(const string& handle);
+
+  // Deregister all graphs.
+  Status DeregisterAll();
+
+ private:
+  typedef GraphMgr ME;
+
+  struct ExecutionUnit {
+    std::unique_ptr<Graph> graph = nullptr;
+    Device* device = nullptr;               // not owned.
+    Executor* root = nullptr;               // not owned.
+    FunctionLibraryRuntime* lib = nullptr;  // not owned.
+    // Build the cost model if this value is strictly positive.
+    int64_t build_cost_model = 0;
+  };
+
+  struct Item : public core::RefCounted {
+    // TODO(zhifengc): Keeps a copy of the original graph if the need arises.
+    // TODO(zhifengc): Stats, updated by multiple runs potentially.
+    // TODO(zhifengc): Dup-detection. Ensure step_id only run once.
+    ~Item() override;
+
+    // Session handle.
+    string session;
+
+    // Graph handle.
+    string handle;
+
+    std::unique_ptr<FunctionLibraryDefinition> lib_def;
+    // Owns the FunctionLibraryRuntime objects needed to execute functions, one
+    // per device.
+    std::unique_ptr<ProcessFunctionLibraryRuntime> proc_flr;
+    // A graph is partitioned over multiple devices.  Each partition
+    // has a root executor which may call into the runtime library.
+    std::vector<ExecutionUnit> units;
+
+    // Used to deregister a cost model when cost model is required in graph
+    // manager.
+    GraphMgr* graph_mgr;
+
+    int64_t collective_graph_key;
+  };
+
+  const WorkerEnv* worker_env_;  // Not owned.
+  const DeviceMgr* device_mgr_;
+
+  CostModelManager cost_model_manager_;
+
+  // Owned.
+  mutex mu_;
+  int64_t next_id_ TF_GUARDED_BY(mu_) = 0;
+
+  // If true, blocks until device has finished all queued operations in a step.
+  bool sync_on_finish_ = true;
+
+  // Table mapping graph handles to registered graphs.
+  //
+  // TODO(zhifengc): If the client does not call Deregister, we'll
+  // lose memory over time. We should implement a timeout-based
+  // mechanism to gc these graphs.
+  std::unordered_map<string, Item*> table_;
+
+  void StartParallelExecutors(
+      const string& handle, int64_t step_id, Item* item, Rendezvous* rendezvous,
+      CollectiveExecutor::Handle* ce_handle, StepStatsCollector* collector,
+      CostGraphDef* cost_graph, CancellationManager* cancellation_manager,
+      WorkerSession* session, int64_t start_time_usecs,
+      tsl::CoordinationServiceAgent* coordination_service_agent,
+      StatusCallback done);
+
+  // Don't attempt to process cost models unless explicitly requested for at
+  // least one of the items.
+  bool skip_cost_models_ = true;
+
+  void BuildCostModel(Item* item, StepStatsCollector* collector,
+                      CostGraphDef* cost_graph);
+
+  Status InitItem(const string& handle, const GraphDef& gdef,
+                  const GraphOptions& graph_options,
+                  const DebugOptions& debug_options,
+                  const ConfigProto& config_proto, int64_t collective_graph_key,
+                  WorkerSession* session,
+                  DistributedFunctionLibraryRuntime* cluster_flr, Item* item);
+
+  Status DecorateAndPublishGraphForDebug(const DebugOptions& debug_options,
+                                         Graph* graph, Device* device);
+
+  GraphMgr(const GraphMgr&) = delete;
+  void operator=(const GraphMgr&) = delete;
+};
+
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_GRAPH_MGR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/local_master.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/local_master.h
new file mode 100644
index 0000000000000000000000000000000000000000..32b8e7cc065eb9db7b733ec49fb99f4a402cfac1
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/local_master.h
@@ -0,0 +1,112 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_LOCAL_MASTER_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_LOCAL_MASTER_H_
+
+#include <memory>
+
+#include "tensorflow/core/distributed_runtime/master_interface.h"
+
+namespace tensorflow {
+
+class Master;
+
+// An implementation of the TensorFlow master interface that enables direct
+// intraprocess communication between the client and the master implementation.
+//
+// This master implementation is intended to provide more efficient access to
+// a master service that has been created in the same process as the client.
+//
+// TODO(mrry): Add methods that avoid protobuf encoding the request/response
+// objects where this affects performance.
+// TODO(mrry): Avoid closure creation/context switch overhead for synchronous
+// invocation of Master methods.
+// TODO(mrry): Make all potentially blocking Master methods take CallOptions
+// for cancellation.
+class LocalMaster : public MasterInterface {
+ public:
+  ~LocalMaster() {}
+
+  Status CreateSession(CallOptions* call_options,
+                       const CreateSessionRequest* request,
+                       CreateSessionResponse* response) override;
+
+  Status ExtendSession(CallOptions* call_options,
+                       const ExtendSessionRequest* request,
+                       ExtendSessionResponse* response) override;
+
+  Status PartialRunSetup(CallOptions* call_options,
+                         const PartialRunSetupRequest* request,
+                         PartialRunSetupResponse* response) override;
+
+  Status RunStep(CallOptions* call_options, RunStepRequestWrapper* request,
+                 MutableRunStepResponseWrapper* response) override;
+
+  MutableRunStepRequestWrapper* CreateRunStepRequest() override;
+
+  MutableRunStepResponseWrapper* CreateRunStepResponse() override;
+
+  Status CloseSession(CallOptions* call_options,
+                      const CloseSessionRequest* request,
+                      CloseSessionResponse* response) override;
+
+  Status ListDevices(CallOptions* call_options,
+                     const ListDevicesRequest* request,
+                     ListDevicesResponse* response) override;
+
+  // See tensorflow::Reset() and the comment on ResetRequest.
+  Status Reset(CallOptions* call_options, const ResetRequest* request,
+               ResetResponse* response) override;
+
+  Status MakeCallable(CallOptions* call_options,
+                      const MakeCallableRequest* request,
+                      MakeCallableResponse* response) override;
+  Status RunCallable(CallOptions* call_options,
+                     const RunCallableRequest* request,
+                     RunCallableResponse* response) override;
+  Status ReleaseCallable(CallOptions* call_options,
+                         const ReleaseCallableRequest* request,
+                         ReleaseCallableResponse* response) override;
+
+  // Registers the mapping from the given `target` to the given `master`.
+  //
+  // WARNING: The `master` pointer remains owned by the caller. It is
+  // the responsibility of the caller to ensure that `master` outlives
+  // any LocalMaster objects that may wrap this master. There is no
+  // corresponding deregister method, since clean server shutdown is
+  // not currently implemented for any server type.
+  static void Register(const string& target, Master* master,
+                       int64_t default_timeout_in_ms);
+
+  // Returns a pointer to the local master associated with the given
+  // `target`, or nullptr if none exists.
+  static std::unique_ptr<LocalMaster> Lookup(const string& target);
+
+ private:
+  Master* master_impl_;  // Not owned.
+  const int64_t default_timeout_in_ms_;
+
+  // See `LocalMaster::Lookup` for the factory function that creates
+  // objects of this type.
+  LocalMaster(Master* master_impl, const int64_t default_timeout_in_ms);
+
+  LocalMaster(const LocalMaster&) = delete;
+  void operator=(const LocalMaster&) = delete;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_LOCAL_MASTER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/master.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/master.h
new file mode 100644
index 0000000000000000000000000000000000000000..8cdbe6fccedd0a986f9b2ccdfadfb60a77177913
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/master.h
@@ -0,0 +1,118 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_MASTER_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_MASTER_H_
+
+#include <unordered_map>
+
+#include "tensorflow/core/common_runtime/device.h"
+#include "tensorflow/core/distributed_runtime/call_options.h"
+#include "tensorflow/core/distributed_runtime/master_env.h"
+#include "tensorflow/core/distributed_runtime/master_session.h"
+#include "tensorflow/core/distributed_runtime/recent_request_ids.h"
+#include "tensorflow/core/lib/core/notification.h"
+#include "tensorflow/core/lib/gtl/map_util.h"
+#include "tensorflow/core/platform/macros.h"
+#include "tensorflow/core/platform/mutex.h"
+#include "tensorflow/core/platform/types.h"
+#include "tensorflow/core/protobuf/master.pb.h"
+#include "tensorflow/core/util/util.h"
+
+namespace tensorflow {
+
+class Master {
+ public:
+  explicit Master(MasterEnv* env, double session_gc_seconds);
+  virtual ~Master();
+
+  // Convenient typedef for a closure passing a Status.
+  typedef std::function<void(const Status&)> MyClosure;
+
+  void CreateSession(const CreateSessionRequest* req,
+                     CreateSessionResponse* resp, MyClosure done);
+
+  void ExtendSession(const ExtendSessionRequest* req,
+                     ExtendSessionResponse* resp, MyClosure done);
+
+  void PartialRunSetup(const PartialRunSetupRequest* req,
+                       PartialRunSetupResponse* resp, MyClosure done);
+
+  void RunStep(CallOptions* opts, const RunStepRequestWrapper* req,
+               MutableRunStepResponseWrapper* resp, MyClosure done);
+
+  void CloseSession(const CloseSessionRequest* req, CloseSessionResponse* resp,
+                    MyClosure done);
+
+  void ListDevices(const ListDevicesRequest* req, ListDevicesResponse* resp,
+                   MyClosure done);
+
+  // See tensorflow::Reset() and the comment on ResetRequest.
+  void Reset(const ResetRequest* req, ResetResponse* resp, MyClosure done);
+
+  void MakeCallable(const MakeCallableRequest* req, MakeCallableResponse* resp,
+                    MyClosure done);
+  void RunCallable(CallOptions* opts, const RunCallableRequest* req,
+                   RunCallableResponse* resp, MyClosure done);
+  void ReleaseCallable(const ReleaseCallableRequest* req,
+                       ReleaseCallableResponse* resp, MyClosure done);
+
+ private:
+  typedef Master ME;
+
+  // Not owned.
+  MasterEnv* env_ = nullptr;
+
+  // Owned.
+  mutex mu_;
+
+  // shutdown_ is set to true by the dtor.
+  condition_variable shutdown_cv_;
+  bool shutdown_ TF_GUARDED_BY(mu_) = false;
+  Thread* gc_thread_;
+
+  // Maps session handles to sessions.
+  std::unordered_map<string, MasterSession*> sessions_ TF_GUARDED_BY(mu_);
+
+  // Moving average of step times.
+  MovingAverage last_1000_steps_ TF_GUARDED_BY(mu_);
+
+  // Cumulative number of steps executed.
+  int64_t step_count_ TF_GUARDED_BY(mu_);
+
+  // If a session is not active for this many seconds, it will be
+  // closed automatically.
+  const double session_gc_seconds_;
+
+  // Used to track ids for incoming requests so we can detect duplicates.
+  RecentRequestIds recent_request_ids_;
+
+  // Call CleanupAll on all workers.
+  void CleanupWorkers(const ResetRequest& reset);
+
+  // Cleanup unused session.
+  void GC();
+
+  // Find master session by session handle, and increments the reference count
+  // on the returned MasterSession if not null.
+  MasterSession* FindMasterSession(const string& handle);
+
+  Master(const Master&) = delete;
+  void operator=(const Master&) = delete;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_MASTER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/master_env.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/master_env.h
new file mode 100644
index 0000000000000000000000000000000000000000..633e21df361386226f3cc8d58317adc9f068287f
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/master_env.h
@@ -0,0 +1,113 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_MASTER_ENV_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_MASTER_ENV_H_
+
+#include <functional>
+#include <vector>
+
+#include "tensorflow/core/distributed_runtime/worker_cache.h"
+#include "tensorflow/core/protobuf/cluster.pb.h"
+#include "tensorflow/core/protobuf/config.pb.h"
+#include "tensorflow/core/protobuf/tensorflow_server.pb.h"
+#include "tensorflow/core/public/session_options.h"
+#include "tsl/protobuf/rpc_options.pb.h"
+
+namespace tsl {
+class Env;
+}  // namespace tsl
+namespace tensorflow {
+using Env = tsl::Env;
+
+class CollectiveExecutorMgrInterface;
+class Device;
+class DeviceSet;
+class MasterSession;
+class OpRegistryInterface;
+
+// Options passed to the worker_cache_factory function.
+struct WorkerCacheFactoryOptions {
+  ClusterDef cluster_def;
+  string job_name;
+  int task_index;
+  int replica_index = 0;
+  RPCOptions rpc_options;
+
+  explicit WorkerCacheFactoryOptions() = default;
+
+  // Construct from a ServerDef proto.
+  explicit WorkerCacheFactoryOptions(const ServerDef& server_def) {
+    if (server_def.has_cluster() && !server_def.job_name().empty()) {
+      cluster_def = server_def.cluster();
+      job_name = server_def.job_name();
+      task_index = server_def.task_index();
+      rpc_options = server_def.default_session_config().rpc_options();
+      replica_index = server_def.replica();
+    }
+  }
+};
+
+// The master environment class, which holds a bag of pointers to
+// per-master state.
+//
+// MasterEnv does not own its member pointers.
+struct MasterEnv {
+  Env* env = nullptr;
+
+  // Object from which WorkerInterface instances can be obtained. Not owned.
+  WorkerCacheInterface* worker_cache = nullptr;
+
+  // The operation definitions to use.  Must be filled before use.
+  const OpRegistryInterface* ops = nullptr;
+
+  // Local devices co-located with this master.  Devices are not owned
+  // by the master service.
+  //
+  // REQUIRES: !local_devices.empty().
+  std::vector<Device*> local_devices;
+
+  // In large scaled distributed training, many singleton components (e.g.
+  // Rendezvous) can becomes the bottleneck of the system. This field allows
+  // us to shard the single components. This number will scale up with number
+  // of tasks in this cluster. It is always greater than 1.
+  int experimental_num_shards = 1;
+
+  // Factory for creating master sessions, given session options and a
+  // vector of devices.
+  //
+  // The caller of the function takes ownership of the returned
+  // `MasterSession`, which may not be null. Ownership of the
+  // `MasterEnv*` is retained by the caller.
+  std::function<MasterSession*(
+      SessionOptions, MasterEnv*,
+      std::unique_ptr<std::vector<std::unique_ptr<Device>>>,
+      std::unique_ptr<WorkerCacheInterface>,
+      std::unique_ptr<DeviceSet> device_set,
+      std::vector<string> filtered_worker_list)>
+      master_session_factory;
+
+  std::function<Status(const WorkerCacheFactoryOptions&,
+                       WorkerCacheInterface**)>
+      worker_cache_factory;
+
+  // Generates per-step CollectiveExecutors and has access to utilities
+  // supporting collective operations. Not owned.
+  CollectiveExecutorMgrInterface* collective_executor_mgr = nullptr;
+};
+
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_MASTER_ENV_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/master_interface.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/master_interface.h
new file mode 100644
index 0000000000000000000000000000000000000000..cde47fb9caf55f35db481fec8ae69ad6e6fcd8ed
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/master_interface.h
@@ -0,0 +1,117 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_MASTER_INTERFACE_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_MASTER_INTERFACE_H_
+
+#include "tensorflow/core/distributed_runtime/call_options.h"
+#include "tensorflow/core/distributed_runtime/message_wrappers.h"
+#include "tensorflow/core/distributed_runtime/request_id.h"
+#include "tensorflow/core/lib/core/errors.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/protobuf/master.pb.h"
+
+namespace tensorflow {
+
+// Abstract interface for communicating with the TensorFlow Master service.
+//
+// This interface supports both RPC-based master implementations, and
+// in-process master implementations that do not require an RPC
+// roundtrip.
+class MasterInterface {
+ public:
+  virtual ~MasterInterface() {}
+  virtual Status CreateSession(CallOptions* call_options,
+                               const CreateSessionRequest* request,
+                               CreateSessionResponse* response) = 0;
+
+  virtual Status ExtendSession(CallOptions* call_options,
+                               const ExtendSessionRequest* request,
+                               ExtendSessionResponse* response) = 0;
+
+  virtual Status PartialRunSetup(CallOptions* call_options,
+                                 const PartialRunSetupRequest* request,
+                                 PartialRunSetupResponse* response) {
+    return errors::Unimplemented("Partial run not implemented for this master");
+  }
+
+  virtual Status RunStep(CallOptions* call_options,
+                         RunStepRequestWrapper* request,
+                         MutableRunStepResponseWrapper* response) = 0;
+
+  virtual Status RunStep(CallOptions* call_options,
+                         const RunStepRequest* request,
+                         RunStepResponse* response) {
+    std::unique_ptr<RunStepRequestWrapper> wrapped_request(
+        new ProtoRunStepRequest(request));
+    std::unique_ptr<MutableRunStepResponseWrapper> wrapped_response(
+        new NonOwnedProtoRunStepResponse(response));
+    return RunStep(call_options, wrapped_request.get(), wrapped_response.get());
+  }
+
+  // Returns a request object for use in calls to
+  // `RunStep()`. Ownership is transferred to the caller.
+  //
+  // The message returned from this method must only be used in a
+  // `RunStep()` call on the same `MasterInterface` instance.
+  virtual MutableRunStepRequestWrapper* CreateRunStepRequest() {
+    MutableProtoRunStepRequest* ret = new MutableProtoRunStepRequest;
+    ret->request_.set_request_id(GetUniqueRequestId());
+    return ret;
+  }
+
+  // Returns a response object for use in calls to
+  // `RunStep()`. Ownership is transferred to the caller.
+  //
+  // The message returned from this method must only be used in a
+  // `RunStep()` call on the same `MasterInterface` instance.
+  virtual MutableRunStepResponseWrapper* CreateRunStepResponse() {
+    return new OwnedProtoRunStepResponse;
+  }
+
+  virtual Status CloseSession(CallOptions* call_options,
+                              const CloseSessionRequest* request,
+                              CloseSessionResponse* response) = 0;
+
+  virtual Status ListDevices(CallOptions* call_options,
+                             const ListDevicesRequest* request,
+                             ListDevicesResponse* response) = 0;
+
+  virtual Status Reset(CallOptions* call_options, const ResetRequest* request,
+                       ResetResponse* response) = 0;
+
+  virtual Status MakeCallable(CallOptions* call_options,
+                              const MakeCallableRequest* request,
+                              MakeCallableResponse* response) = 0;
+  virtual Status RunCallable(CallOptions* call_options,
+                             const RunCallableRequest* request,
+                             RunCallableResponse* response) = 0;
+  virtual Status ReleaseCallable(CallOptions* call_options,
+                                 const ReleaseCallableRequest* request,
+                                 ReleaseCallableResponse* response) = 0;
+
+ protected:
+  // NOTE: This should only be called by implementations of this
+  // interface whose CreateRunStepResponse() method returns a
+  // proto-based wrappers for the RunStepResponse message.
+  RunStepResponse* get_proto_from_wrapper(
+      MutableRunStepResponseWrapper* wrapper) {
+    return wrapper->get_proto();
+  }
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_MASTER_INTERFACE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/master_session.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/master_session.h
new file mode 100644
index 0000000000000000000000000000000000000000..ab63dea86842e21afe6438a62b8a726609adc96b
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/master_session.h
@@ -0,0 +1,263 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_MASTER_SESSION_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_MASTER_SESSION_H_
+
+#include <atomic>
+#include <vector>
+
+#include "tensorflow/core/common_runtime/debugger_state_interface.h"
+#include "tensorflow/core/common_runtime/device_set.h"
+#include "tensorflow/core/common_runtime/graph_execution_state.h"
+#include "tensorflow/core/common_runtime/stats_publisher_interface.h"
+#include "tensorflow/core/distributed_runtime/call_options.h"
+#include "tensorflow/core/distributed_runtime/master_env.h"
+#include "tensorflow/core/distributed_runtime/message_wrappers.h"
+#include "tensorflow/core/distributed_runtime/worker_cache.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/platform/types.h"
+#include "tensorflow/core/protobuf/master.pb.h"
+#include "tensorflow/core/public/session_options.h"
+
+namespace tensorflow {
+
+class Device;
+struct MasterEnv;
+
+// A session encapsulates a graph computation (resource allocation,
+// placement, execution, etc.).
+class MasterSession : public core::RefCounted {
+ public:
+  // This session encapsulates the graph computation for a graph.
+  //
+  // The session places nodes on devices in "remote_devs" and executes
+  // operations on these devices.
+  //
+  // The caller takes ownership of all remote devices.
+  MasterSession(
+      const SessionOptions& options, const MasterEnv* env,
+      std::unique_ptr<std::vector<std::unique_ptr<Device>>> remote_devs,
+      std::unique_ptr<WorkerCacheInterface> worker_cache,
+      std::unique_ptr<DeviceSet> device_set,
+      std::vector<string> filtered_worker_list,
+      StatsPublisherFactory stats_publisher_factory);
+
+  // Initialize the MasterSession for "def".  Must be called before Extend(),
+  // Run(), or Close().
+  Status Create(GraphDef&& def, const ClusterDef& cluster_def);
+
+  // Returns the session handle.
+  const string& handle() const { return handle_; }
+
+  // Returns the last access time (the number of micro-seconds since
+  // some fixed point in time) of this session.
+  uint64 last_access_time_usec() const { return last_access_time_usec_.load(); }
+
+  // Attempt to extend the graph according to the given "req".
+  // (See master.proto for details of valid extensions.)
+  //
+  // PRECONDITION: The current version of this session's graph
+  //   is "req->current_graph_version".
+  //
+  // POSTCONDITION: The current version of this session's graph
+  //   is "resp->new_graph_version".
+  //
+  // Extend() may block the caller thread for a long time.
+  Status Extend(const ExtendSessionRequest* req, ExtendSessionResponse* resp);
+
+  // Setup a partial run call.
+  Status PartialRunSetup(const PartialRunSetupRequest* req,
+                         PartialRunSetupResponse* resp);
+
+  // Run one step.
+  Status Run(CallOptions* opts, const RunStepRequestWrapper& req,
+             MutableRunStepResponseWrapper* resp);
+
+  Status ListDevices(ListDevicesResponse* resp) const;
+
+  Status MakeCallable(const MakeCallableRequest& req,
+                      MakeCallableResponse* resp);
+
+  Status RunCallable(CallOptions* opts, const RunCallableRequest& req,
+                     RunCallableResponse* resp);
+
+  Status ReleaseCallable(const ReleaseCallableRequest& req,
+                         ReleaseCallableResponse* resp);
+
+  // Close this session and delete "*this". Returns OK if all known
+  // states are cleanup successfully.
+  //
+  // Close() may block the caller thread for a long time.
+  Status Close();
+
+  // Close this session and release a reference on "*this".
+  //
+  // Note that, unlike Close(), this method does not block on the
+  // completion of all work.
+  void GarbageCollect();
+
+ private:
+  SessionOptions session_opts_;
+
+  // Not owned.
+  const MasterEnv* env_;
+
+  // The opaque session handle.
+  const string handle_;
+
+  std::unique_ptr<std::vector<std::unique_ptr<Device>>> remote_devs_;
+
+  // The optional session-specific worker cluster.
+  // TODO(saeta): Convert to std::optional when available.
+  const std::unique_ptr<WorkerCacheInterface> worker_cache_;
+  // Retrieves either worker_cache_ or the env_->worker_cache as appropriate.
+  WorkerCacheInterface* get_worker_cache() const;
+
+  // The device set used by this session.
+  std::unique_ptr<DeviceSet> devices_;
+
+  // The (partial device) names of remote worker tasks that this
+  // session will contact.
+  const std::vector<string> filtered_worker_list_;
+
+  StatsPublisherFactory stats_publisher_factory_;
+
+  std::atomic_ulong last_access_time_usec_;
+
+  std::atomic<int64_t> partial_run_handle_counter_ = {0};
+
+  uint64 NewStepId(int64_t graph_key);
+
+  mutex mu_;
+  std::unique_ptr<GraphExecutionState> execution_state_ TF_GUARDED_BY(mu_);
+  int64_t graph_version_;
+
+  // We keep a map from a signature of a run request to the
+  // ReffedClientGraph the can execute it.  We keep up to one old copy
+  // of each ReffedClientGraph around because if it gets deallocated
+  // before a new substitute has been created, Variables can go out of
+  // scope and lose their state.
+  class ReffedClientGraph;
+  typedef std::unordered_map<uint64, ReffedClientGraph*> RCGMap;
+  RCGMap run_graphs_ TF_GUARDED_BY(mu_);
+  RCGMap partial_run_graphs_ TF_GUARDED_BY(mu_);
+  int64_t next_callable_handle_ TF_GUARDED_BY(mu_) = 0;
+  RCGMap callables_ TF_GUARDED_BY(mu_);
+
+  struct PerStepState {
+    bool collect_costs = false;
+    bool collect_timeline = false;
+    bool collect_rpcs = false;
+    bool collect_partition_graphs = false;
+    bool report_tensor_allocations_upon_oom = false;
+    Microseconds start_micros = Microseconds(0);
+    Microseconds end_micros = Microseconds(0);
+    std::vector<StepStats> step_stats;  // per partition
+    StepStats rpc_stats;                // for RPC layer
+    CostGraphDef cost_graph;
+  };
+
+  struct RunState {
+    std::unordered_map<string, bool> pending_inputs;   // true if fed
+    std::unordered_map<string, bool> pending_outputs;  // true if fetched
+    ReffedClientGraph* rcg = nullptr;
+    uint64 step_id;
+    int64_t collective_graph_key;
+    int64_t count = 0;
+    PerStepState pss;
+    std::unique_ptr<ProfileHandler> ph;
+    bool step_started = false;
+
+    RunState(const std::vector<string>& input_names,
+             const std::vector<string>& output_names, ReffedClientGraph* rcg,
+             const uint64 step_id, const int64_t count);
+
+    bool PendingDone() const;
+
+    ~RunState();
+  };
+  std::unordered_map<string, std::unique_ptr<RunState>> partial_runs_
+      TF_GUARDED_BY(mu_);
+
+  // Active RunStep calls.
+  condition_variable num_running_is_zero_;
+  int32 num_running_ TF_GUARDED_BY(mu_) = 0;
+
+  bool closed_ TF_GUARDED_BY(mu_) = false;
+  bool garbage_collected_ TF_GUARDED_BY(mu_) = false;
+
+  std::unordered_map<uint64, int64_t> subgraph_execution_counts_
+      TF_GUARDED_BY(mu_);
+
+  // We need to ensure that certain nodes added (e.g., send and recv
+  // nodes) are unique across all sub-graphs within this session.
+  int64_t next_node_id_ TF_GUARDED_BY(mu_) = 0;
+
+  // Used to cancel running steps on Close().
+  CancellationManager cancellation_manager_;
+
+  // Private dtor. The client must call Close().
+  virtual ~MasterSession();
+
+  // Creates sessions on all workers.
+  //
+  // If this session is operating using the new ClusterSpec propagation behavior
+  // call this method in order to propagate the cluster membership to all
+  // workers.
+  Status CreateWorkerSessions(const ClusterDef& cluster_def);
+
+  bool should_delete_worker_sessions_ = false;
+  Status DeleteWorkerSessions();
+
+  Status StartStep(const BuildGraphOptions& opts, bool is_partial,
+                   ReffedClientGraph** out_rcg, int64_t* out_count);
+  void ClearRunsTable(std::vector<ReffedClientGraph*>* to_unref,
+                      RCGMap* rcg_map) TF_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+  void FillPerStepState(MasterSession::ReffedClientGraph* rcg,
+                        const RunOptions& run_options, uint64 step_id,
+                        int64_t count, PerStepState* out_pss,
+                        std::unique_ptr<ProfileHandler>* out_ph);
+  Status DoRunWithLocalExecution(CallOptions* opts,
+                                 const RunStepRequestWrapper& req,
+                                 MutableRunStepResponseWrapper* resp);
+  Status DoPartialRun(CallOptions* opts, const RunStepRequestWrapper& req,
+                      MutableRunStepResponseWrapper* resp);
+  Status DoRunCallable(CallOptions* opts, ReffedClientGraph* rcg,
+                       const RunCallableRequest& req,
+                       RunCallableResponse* resp);
+  Status PostRunCleanup(MasterSession::ReffedClientGraph* rcg, uint64 step_id,
+                        const RunOptions& run_options, PerStepState* pss,
+                        const std::unique_ptr<ProfileHandler>& ph,
+                        const Status& run_status,
+                        RunMetadata* out_run_metadata);
+
+  void MarkRunCompletion();
+  void UpdateLastAccessTime();
+
+  Status BuildAndRegisterPartitions(ReffedClientGraph* rcg);
+
+  Status CreateDebuggerState(
+      const DebugOptions& debug_options, const RunStepRequestWrapper& req,
+      int64_t rcg_execution_count,
+      std::unique_ptr<DebuggerStateInterface>* debugger_state);
+
+  MasterSession(const MasterSession&) = delete;
+  void operator=(const MasterSession&) = delete;
+};
+
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_MASTER_SESSION_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/message_wrappers.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/message_wrappers.h
new file mode 100644
index 0000000000000000000000000000000000000000..5370df8a06c54a72f87c1147dfec8923e93b7e1d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/message_wrappers.h
@@ -0,0 +1,746 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_MESSAGE_WRAPPERS_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_MESSAGE_WRAPPERS_H_
+
+#include "absl/status/status.h"
+#include "tensorflow/core/framework/allocator.h"
+#include "tensorflow/core/framework/cost_graph.pb.h"
+#include "tensorflow/core/framework/graph.pb.h"
+#include "tensorflow/core/framework/step_stats.pb.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/tensor.pb.h"
+#include "tensorflow/core/framework/versions.pb.h"
+#include "tensorflow/core/protobuf/config.pb.h"
+#include "tensorflow/core/protobuf/master.pb.h"
+#include "tensorflow/core/protobuf/worker.pb.h"
+
+namespace tensorflow {
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// Wrapper classes for the `MasterService.RunStep` request message.
+//
+// The `RunStepRequest` message can contain potentially large tensor
+// data as part of its `feed` submessages. Here we provide specialized
+// wrappers that avoid copying the tensor data wherever possible.
+//
+// See `RunStepRequest` in tensorflow/core/protobuf/master.proto for the
+// protocol buffer definition.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+// Abstract interface for an immutable RunStepRequest message.
+//
+// This interface is typically used by server-side components in the
+// TensorFlow master.
+class RunStepRequestWrapper {
+ public:
+  virtual ~RunStepRequestWrapper() {}
+
+  // REQUIRED: session_handle must be returned by a CreateSession call
+  // to the same master service.
+  virtual const string& session_handle() const = 0;
+
+  // Partial run handle (optional). If specified, this will be a partial run
+  // execution, run up to the specified fetches.
+  virtual const string& partial_run_handle() const = 0;
+
+  // Tensors to be fed in the step. Each feed is a named tensor.
+  virtual size_t num_feeds() const = 0;
+  virtual const string& feed_name(size_t i) const = 0;
+
+  // Stores the content of the feed value at index `i` in `tensor`.
+  virtual Status FeedValue(size_t i, Tensor* out_tensor) const = 0;
+  virtual Status FeedValue(size_t i, TensorProto* out_tensor) const = 0;
+
+  // Fetches. A list of tensor names. The caller expects a tensor to
+  // be returned for each fetch[i] (see RunStepResponse.tensor). The
+  // order of specified fetches does not change the execution order.
+  virtual size_t num_fetches() const = 0;
+  virtual const string& fetch_name(size_t i) const = 0;
+
+  // Target Nodes. A list of node names. The named nodes will be run
+  // to but their outputs will not be fetched.
+  virtual size_t num_targets() const = 0;
+  virtual const string& target_name(size_t i) const = 0;
+
+  // Options for the run call.
+  virtual const RunOptions& options() const = 0;
+
+  // If true then some errors, e.g., execution errors that have long
+  // error messages, may return an OK RunStepResponse with the actual
+  // error saved in the status_code/status_error_message fields of the
+  // response body. This is a workaround since the RPC subsystem may
+  // truncate long metadata messages.
+  virtual bool store_errors_in_response_body() const = 0;
+
+  // Unique identifier for this request. Every RunGraphRequest must have a
+  // unique request_id, and retried RunGraphRequests must have the same
+  // request_id. If request_id is zero, retry detection is disabled.
+  virtual int64_t request_id() const = 0;
+
+  // Returns a human-readable representation of this message for debugging.
+  virtual string DebugString() const = 0;
+
+  // Returns the wrapped data as a protocol buffer message.
+  virtual const RunStepRequest& ToProto() const = 0;
+};
+
+// Abstract interface for a mutable RunStepRequest message.
+//
+// See `RunStepRequestWrapper` above for a description of the fields.
+class MutableRunStepRequestWrapper : public RunStepRequestWrapper {
+ public:
+  virtual void set_session_handle(const string& handle) = 0;
+  virtual void set_partial_run_handle(const string& handle) = 0;
+  virtual void add_feed(const string& name, const Tensor& value) = 0;
+  virtual void add_fetch(const string& name) = 0;
+  virtual void add_target(const string& name) = 0;
+  virtual RunOptions* mutable_options() = 0;
+  virtual void set_store_errors_in_response_body(bool store_errors) = 0;
+};
+
+// Specialized (and mutable) wrapper for RunStep requests between a client and
+// master in the same address space.
+class InMemoryRunStepRequest : public MutableRunStepRequestWrapper {
+ public:
+  // RunStepRequestWrapper methods.
+  const string& session_handle() const override;
+  const string& partial_run_handle() const override;
+  size_t num_feeds() const override;
+  const string& feed_name(size_t i) const override;
+  Status FeedValue(size_t i, Tensor* out_tensor) const override;
+  Status FeedValue(size_t i, TensorProto* out_tensor) const override;
+  size_t num_fetches() const override;
+  const string& fetch_name(size_t i) const override;
+  size_t num_targets() const override;
+  const string& target_name(size_t i) const override;
+  const RunOptions& options() const override;
+  string DebugString() const override;
+  const RunStepRequest& ToProto() const override;
+  bool store_errors_in_response_body() const override;
+  int64_t request_id() const override;
+
+  // MutableRunStepRequestWrapper methods.
+  void set_session_handle(const string& handle) override;
+  void set_partial_run_handle(const string& handle) override;
+  void add_feed(const string& name, const Tensor& value) override;
+  void add_fetch(const string& name) override;
+  void add_target(const string& name) override;
+  RunOptions* mutable_options() override;
+  void set_store_errors_in_response_body(bool store_errors) override;
+
+ private:
+  string session_handle_;
+  string partial_run_handle_;
+  gtl::InlinedVector<std::pair<string, Tensor>, 4> feeds_;
+  gtl::InlinedVector<string, 4> fetches_;
+  gtl::InlinedVector<string, 4> targets_;
+  RunOptions options_;
+  bool store_errors_in_response_body_ = false;
+
+  // Holds a cached and owned representation of the proto
+  // representation of this request, if needed, so that `ToProto()`
+  // can return a const RunStepRequest&.
+  // NOTE(mrry): Although calls to `ToProto()` on this class are
+  // expected to be rare, retaining ownership of the returned message
+  // makes it easier to return a reference from the proto-backed
+  // representations.
+  mutable std::unique_ptr<RunStepRequest> proto_version_;
+};
+
+// Wrapper for mutable RunStep requests that uses a protobuf message.
+//
+// This wrapper class should be used for RunStep requests between a
+// client and master in different address spaces.
+class MutableProtoRunStepRequest : public MutableRunStepRequestWrapper {
+ public:
+  // RunStepRequestWrapper methods.
+  const string& session_handle() const override;
+  const string& partial_run_handle() const override;
+  size_t num_feeds() const override;
+  const string& feed_name(size_t i) const override;
+  Status FeedValue(size_t i, Tensor* out_tensor) const override;
+  Status FeedValue(size_t i, TensorProto* out_tensor) const override;
+  size_t num_fetches() const override;
+  const string& fetch_name(size_t i) const override;
+  size_t num_targets() const override;
+  const string& target_name(size_t i) const override;
+  const RunOptions& options() const override;
+  string DebugString() const override;
+  const RunStepRequest& ToProto() const override;
+  bool store_errors_in_response_body() const override;
+  int64_t request_id() const override;
+
+  // MutableRunStepRequestWrapper methods.
+  void set_session_handle(const string& handle) override;
+  void set_partial_run_handle(const string& handle) override;
+  void add_feed(const string& name, const Tensor& value) override;
+  void add_fetch(const string& name) override;
+  void add_target(const string& name) override;
+  RunOptions* mutable_options() override;
+  void set_store_errors_in_response_body(bool store_errors) override;
+
+ private:
+  RunStepRequest request_;
+  friend class MasterInterface;
+};
+
+// Wrapper for immutable RunStep requests that use a non-owned
+// protobuf message.
+//
+// This interface is typically used by server-side components in the
+// TensorFlow master, where the incoming message is a (possibly const)
+// `RunStepRequest*`.
+class ProtoRunStepRequest : public RunStepRequestWrapper {
+ public:
+  ProtoRunStepRequest(const RunStepRequest* request);
+
+  // RunStepRequestWrapper methods.
+  const string& session_handle() const override;
+  const string& partial_run_handle() const override;
+  size_t num_feeds() const override;
+  const string& feed_name(size_t i) const override;
+  Status FeedValue(size_t i, Tensor* out_tensor) const override;
+  Status FeedValue(size_t i, TensorProto* out_tensor) const override;
+  size_t num_fetches() const override;
+  const string& fetch_name(size_t i) const override;
+  size_t num_targets() const override;
+  const string& target_name(size_t i) const override;
+  const RunOptions& options() const override;
+  string DebugString() const override;
+  const RunStepRequest& ToProto() const override;
+  bool store_errors_in_response_body() const override;
+  int64_t request_id() const override;
+
+ private:
+  const RunStepRequest* const request_;  // Not owned.
+};
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// Wrapper classes for the `WorkerService.RunGraph` request message.
+//
+// The `RunGraphRequest` message can contain potentially large tensor
+// data as part of its `send` submessages. Here we provide specialized
+// wrappers that avoid copying the tensor data wherever possible.
+//
+// See `RunGraphRequest` in tensorflow/core/protobuf/worker.proto for the
+// protocol buffer definition.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+// Abstract interface for an immutable RunGraphRequest message.
+//
+// This interface is typically used by server-side components in the
+// TensorFlow worker.
+class RunGraphRequestWrapper {
+ public:
+  virtual ~RunGraphRequestWrapper() {}
+
+  // The session handle used to register the graph. If empty, a single global
+  // namespace is used.
+  virtual const string& session_handle() const = 0;
+
+  // Set to true if `CreateWorkerSession` was called for `session_handle`.
+  virtual bool create_worker_session_called() const = 0;
+
+  // REQUIRED: graph_handle must be returned by a RegisterGraph call
+  // to the same WorkerService.
+  virtual const string& graph_handle() const = 0;
+
+  // A unique ID to distinguish different runs of the same graph.
+  //
+  // The master generates a global unique `step_id` to distinguish
+  // different runs of the graph computation. Subgraphs communicate
+  // (e.g., send/recv ops) with each other using `step_id` to
+  // distinguish tensors generated by different runs.
+  virtual int64_t step_id() const = 0;
+
+  // Options for this step.
+  virtual const ExecutorOpts& exec_opts() const = 0;
+
+  // Sends the tensors in "send" into the graph before the run.
+  virtual size_t num_sends() const = 0;
+  virtual const string& send_key(size_t i) const = 0;
+  virtual Status SendValue(size_t i, Tensor* out_tensor) const = 0;
+
+  // Fetches the keys into `RunGraphResponse.recv` after the run.
+  virtual size_t num_recvs() const = 0;
+  virtual const string& recv_key(size_t i) const = 0;
+
+  // True if the RunGraphRequest is a partial run request.
+  virtual bool is_partial() const = 0;
+
+  // True if this is the last partial run request in a sequence of requests.
+  virtual bool is_last_partial_run() const = 0;
+
+  // If true then some errors, e.g., execution errors that have long
+  // error messages, may return an OK RunStepResponse with the actual
+  // error saved in the status_code/status_error_message fields of the
+  // response body. This is a workaround since the RPC subsystem may
+  // truncate long metadata messages.
+  virtual bool store_errors_in_response_body() const = 0;
+
+  virtual int64_t request_id() const = 0;
+
+  // Returns the wrapped data as a protocol buffer message.
+  virtual const RunGraphRequest& ToProto() const = 0;
+};
+
+// Abstract interface for a mutable RunGraphRequest message.
+//
+// See `RunGraphRequestWrapper` above for a description of the fields.
+class MutableRunGraphRequestWrapper : public RunGraphRequestWrapper {
+ public:
+  virtual void set_session_handle(const string& handle) = 0;
+  virtual void set_create_worker_session_called(bool called) = 0;
+  virtual void set_graph_handle(const string& handle) = 0;
+  virtual void set_step_id(int64_t step_id) = 0;
+  virtual ExecutorOpts* mutable_exec_opts() = 0;
+
+  // Stores the i^{th} feed value in `run_step_request` in this
+  // request with the given `send_key`.
+  virtual Status AddSendFromRunStepRequest(
+      const RunStepRequestWrapper& run_step_request, size_t i,
+      const string& send_key) = 0;
+  virtual Status AddSendFromRunCallableRequest(
+      const RunCallableRequest& run_callable_request, size_t i,
+      const string& send_key) = 0;
+
+  virtual void add_recv_key(const string& recv_key) = 0;
+  virtual void set_is_partial(bool is_partial) = 0;
+  virtual void set_is_last_partial_run(bool is_last_partial_run) = 0;
+  virtual void set_store_errors_in_response_body(bool store_errors) = 0;
+  virtual void set_request_id(int64_t request_id) = 0;
+};
+
+class InMemoryRunGraphRequest : public MutableRunGraphRequestWrapper {
+ public:
+  // RunGraphRequestWrapper methods.
+  const string& session_handle() const override;
+  const string& graph_handle() const override;
+  bool create_worker_session_called() const override;
+  int64_t step_id() const override;
+  const ExecutorOpts& exec_opts() const override;
+  size_t num_sends() const override;
+  const string& send_key(size_t i) const override;
+  Status SendValue(size_t i, Tensor* out_tensor) const override;
+  size_t num_recvs() const override;
+  const string& recv_key(size_t i) const override;
+  bool is_partial() const override;
+  bool is_last_partial_run() const override;
+  const RunGraphRequest& ToProto() const override;
+  bool store_errors_in_response_body() const override;
+  int64_t request_id() const override;
+
+  // MutableRunGraphRequestWrapper methods.
+  void set_session_handle(const string& handle) override;
+  void set_create_worker_session_called(bool called) override;
+  void set_graph_handle(const string& handle) override;
+  void set_step_id(int64_t step_id) override;
+  ExecutorOpts* mutable_exec_opts() override;
+  Status AddSendFromRunStepRequest(
+      const RunStepRequestWrapper& run_step_request, size_t i,
+      const string& send_key) override;
+  Status AddSendFromRunCallableRequest(
+      const RunCallableRequest& run_callable_request, size_t i,
+      const string& send_key) override;
+  void add_recv_key(const string& recv_key) override;
+  void set_is_partial(bool is_partial) override;
+  void set_is_last_partial_run(bool is_last_partial_run) override;
+  void set_store_errors_in_response_body(bool store_errors) override;
+  void set_request_id(int64_t request_id) override;
+
+ private:
+  string session_handle_;
+  bool create_worker_session_called_ = false;
+  string graph_handle_;
+  int64_t step_id_;
+  ExecutorOpts exec_opts_;
+  gtl::InlinedVector<std::pair<string, Tensor>, 4> sends_;
+  gtl::InlinedVector<string, 4> recvs_;
+  bool is_partial_ = false;
+  bool is_last_partial_run_ = false;
+  bool store_errors_in_response_body_ = false;
+  int64_t request_id_ = 0;
+
+  // Holds a cached and owned representation of the proto
+  // representation of this request, if needed, so that `ToProto()`
+  // can return a const RunGraphRequest&.
+  // NOTE(mrry): Although calls to `ToProto()` on this class are
+  // expected to be rare, retaining ownership of the returned message
+  // makes it easier to return a reference from the proto-backed
+  // representations.
+  mutable std::unique_ptr<RunGraphRequest> proto_version_;
+};
+
+class MutableProtoRunGraphRequest : public MutableRunGraphRequestWrapper {
+ public:
+  // RunGraphRequestWrapper methods.
+  const string& session_handle() const override;
+  bool create_worker_session_called() const override;
+  const string& graph_handle() const override;
+  int64_t step_id() const override;
+  const ExecutorOpts& exec_opts() const override;
+  size_t num_sends() const override;
+  const string& send_key(size_t i) const override;
+  Status SendValue(size_t i, Tensor* out_tensor) const override;
+  size_t num_recvs() const override;
+  const string& recv_key(size_t i) const override;
+  bool is_partial() const override;
+  bool is_last_partial_run() const override;
+  bool store_errors_in_response_body() const override;
+  int64_t request_id() const override;
+  const RunGraphRequest& ToProto() const override;
+
+  // MutableRunGraphRequestWrapper methods.
+  void set_session_handle(const string& handle) override;
+  void set_create_worker_session_called(bool called) override;
+  void set_graph_handle(const string& handle) override;
+  void set_step_id(int64_t step_id) override;
+  ExecutorOpts* mutable_exec_opts() override;
+  Status AddSendFromRunStepRequest(
+      const RunStepRequestWrapper& run_step_request, size_t i,
+      const string& send_key) override;
+  Status AddSendFromRunCallableRequest(
+      const RunCallableRequest& run_callable_request, size_t i,
+      const string& send_key) override;
+  void add_recv_key(const string& recv_key) override;
+  void set_is_partial(bool is_partial) override;
+  void set_is_last_partial_run(bool is_last_partial_run) override;
+  void set_store_errors_in_response_body(bool store_errors) override;
+  void set_request_id(int64_t request_id) override;
+
+ private:
+  RunGraphRequest request_;
+};
+
+class ProtoRunGraphRequest : public RunGraphRequestWrapper {
+ public:
+  ProtoRunGraphRequest(const RunGraphRequest* request);
+
+  // RunGraphRequestWrapper methods.
+  const string& session_handle() const override;
+  bool create_worker_session_called() const override;
+  const string& graph_handle() const override;
+  int64_t step_id() const override;
+  const ExecutorOpts& exec_opts() const override;
+  size_t num_sends() const override;
+  const string& send_key(size_t i) const override;
+  Status SendValue(size_t i, Tensor* out_tensor) const override;
+  size_t num_recvs() const override;
+  const string& recv_key(size_t i) const override;
+  bool is_partial() const override;
+  bool is_last_partial_run() const override;
+  bool store_errors_in_response_body() const override;
+  int64_t request_id() const override;
+  const RunGraphRequest& ToProto() const override;
+
+ private:
+  const RunGraphRequest* const request_;  // Not owned.
+};
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// Wrapper classes for the `WorkerService.RunGraph` response message.
+//
+// The `RunGraphResponse` message can contain potentially large tensor
+// data as part of its `recv` submessages. Here we provide specialized
+// wrappers that avoid copying the tensor data wherever possible.
+//
+// See `RunGraphResponse` in tensorflow/core/protobuf/worker.proto for the
+// protocol buffer definition.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+// Abstract interface for a mutable RunGraphResponse message.
+//
+// Note that there is no corresponding (immutable)
+// RunGraphResponseWrapper class, because the RunGraphResponse object
+// is always used as a mutable pointer.
+class MutableRunGraphResponseWrapper {
+ public:
+  virtual ~MutableRunGraphResponseWrapper() {}
+
+  // A list of tensors corresponding to those requested by
+  // `RunGraphRequest.recv_key`.
+  virtual size_t num_recvs() const = 0;
+  virtual const string& recv_key(size_t i) const = 0;
+  // NOTE: The following methods may perform a destructive read, for
+  // efficiency.
+  virtual Status RecvValue(size_t i, TensorProto* out_tensor) = 0;
+  virtual Status RecvValue(size_t i, Tensor* out_tensor) = 0;
+  virtual void AddRecv(const string& key, const Tensor& value) = 0;
+
+  // Submessages that store performance statistics about the subgraph
+  // execution, if necessary.
+  virtual StepStats* mutable_step_stats() = 0;
+  virtual CostGraphDef* mutable_cost_graph() = 0;
+  virtual size_t num_partition_graphs() const = 0;
+  virtual GraphDef* mutable_partition_graph(size_t i) = 0;
+  virtual void AddPartitionGraph(const GraphDef& partition_graph) = 0;
+
+  // Returned status if requested.
+  virtual Status status() const = 0;
+  virtual absl::StatusCode status_code() const = 0;
+  virtual void set_status(const Status& status) = 0;
+
+ protected:
+  // Returns a mutable protobuf message that represents the contents of
+  // this wrapper, for passing to an RPC subsystem that will populate
+  // the message.
+  //
+  // NOTE: Only `WorkerInterface` subclasses may call this method. The
+  // `InMemoryRunGraphResponse` subclass does not implement this
+  // method, and attempts to call it will fail with a fatal
+  // error. However, as long as callers always call
+  // `WorkerInterface::RunGraphAsync()` with a wrapper object returned
+  // from `WorkerInterface::CreateRunGraphResponse()` called on the
+  // *same* WorkerInterface object, this error will never trigger.
+  virtual RunGraphResponse* get_proto() = 0;
+  friend class WorkerInterface;
+};
+
+class InMemoryRunGraphResponse : public MutableRunGraphResponseWrapper {
+ public:
+  // MutableRunGraphResponseWrapper methods.
+  size_t num_recvs() const override;
+  const string& recv_key(size_t i) const override;
+  Status RecvValue(size_t i, TensorProto* out_tensor) override;
+  Status RecvValue(size_t i, Tensor* out_tensor) override;
+  void AddRecv(const string& key, const Tensor& value) override;
+  StepStats* mutable_step_stats() override;
+  CostGraphDef* mutable_cost_graph() override;
+  size_t num_partition_graphs() const override;
+  GraphDef* mutable_partition_graph(size_t i) override;
+  void AddPartitionGraph(const GraphDef& partition_graph) override;
+  Status status() const override;
+  absl::StatusCode status_code() const override;
+  void set_status(const Status& status) override;
+
+ protected:
+  // NOTE: This method is not implemented. See
+  // MutableRunGraphResponseWrapper for an explanation.
+  RunGraphResponse* get_proto() override;
+
+ private:
+  gtl::InlinedVector<std::pair<string, Tensor>, 4> recvs_;
+  StepStats step_stats_;
+  CostGraphDef cost_graph_;
+  std::vector<GraphDef> partition_graphs_;
+  // Store the code and message separately so that they can be updated
+  // independently by setters.
+  Status status_;
+};
+
+// Proto-based message wrapper for use on the client side of the RunGraph RPC.
+class OwnedProtoRunGraphResponse : public MutableRunGraphResponseWrapper {
+ public:
+  // MutableRunGraphResponseWrapper methods.
+  size_t num_recvs() const override;
+  const string& recv_key(size_t i) const override;
+  Status RecvValue(size_t i, TensorProto* out_tensor) override;
+  Status RecvValue(size_t i, Tensor* out_tensor) override;
+  void AddRecv(const string& key, const Tensor& value) override;
+  StepStats* mutable_step_stats() override;
+  CostGraphDef* mutable_cost_graph() override;
+  size_t num_partition_graphs() const override;
+  GraphDef* mutable_partition_graph(size_t i) override;
+  void AddPartitionGraph(const GraphDef& partition_graph) override;
+  Status status() const override;
+  absl::StatusCode status_code() const override;
+  void set_status(const Status& status) override;
+
+ protected:
+  RunGraphResponse* get_proto() override;
+
+ private:
+  RunGraphResponse response_;
+};
+
+// Proto-based message wrapper for use on the server side of the RunGraph RPC.
+class NonOwnedProtoRunGraphResponse : public MutableRunGraphResponseWrapper {
+ public:
+  NonOwnedProtoRunGraphResponse(RunGraphResponse* response);
+
+  // MutableRunGraphResponseWrapper methods.
+  size_t num_recvs() const override;
+  const string& recv_key(size_t i) const override;
+  Status RecvValue(size_t i, TensorProto* out_tensor) override;
+  Status RecvValue(size_t i, Tensor* out_tensor) override;
+  void AddRecv(const string& key, const Tensor& value) override;
+  StepStats* mutable_step_stats() override;
+  CostGraphDef* mutable_cost_graph() override;
+  size_t num_partition_graphs() const override;
+  GraphDef* mutable_partition_graph(size_t i) override;
+  void AddPartitionGraph(const GraphDef& partition_graph) override;
+  Status status() const override;
+  absl::StatusCode status_code() const override;
+  void set_status(const Status& status) override;
+
+ protected:
+  RunGraphResponse* get_proto() override;
+
+ private:
+  RunGraphResponse* const response_;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// Wrapper classes for the `MasterService.RunStep` response message.
+//
+// The `RunStepResponse` message can contain potentially large tensor
+// data as part of its `tensor` submessages. Here we provide specialized
+// wrappers that avoid copying the tensor data wherever possible.
+//
+// See `RunStepResponse` in tensorflow/core/protobuf/master.proto for the
+// protocol buffer definition.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+// Abstract interface for a mutable RunStepResponse message.
+//
+// Note that there is no corresponding (immutable)
+// RunStepResponseWrapper class, because the RunStepResponse object is
+// always used as a mutable pointer.
+class MutableRunStepResponseWrapper {
+ public:
+  virtual ~MutableRunStepResponseWrapper();
+
+  // The values of the tensors whose fetching was requested in the
+  // RunStep call.
+  //
+  // NOTE: The order of the returned tensors may or may not match
+  // the fetch order specified in RunStepRequest.
+  virtual size_t num_tensors() const = 0;
+  virtual const string& tensor_name(size_t i) const = 0;
+  virtual Status TensorValue(size_t i, Tensor* out_tensor) const = 0;
+
+  // Stores the i^{th} recv value in `run_graph_response` in this
+  // response with the given `name`.
+  virtual Status AddTensorFromRunGraphResponse(
+      const string& name, MutableRunGraphResponseWrapper* run_graph_response,
+      size_t i) = 0;
+
+  // Returned metadata if requested in the options.
+  virtual const RunMetadata& metadata() const = 0;
+  virtual RunMetadata* mutable_metadata() = 0;
+
+  // Returned status if requested.
+  virtual Status status() const = 0;
+  virtual absl::StatusCode status_code() const = 0;
+  virtual void set_status(const Status& status) = 0;
+
+ protected:
+  // Returns a mutable protobuf message that represents the contents of
+  // this wrapper, for passing to an RPC subsystem that will populate
+  // the message.
+  //
+  // NOTE: Only `MasterInterface` subclasses may call this method. The
+  // `InMemoryRunStepResponse` subclass does not implement this
+  // method, and attempts to call it will fail with a fatal
+  // error. However, as long as callers always call
+  // `MasterInterface::RunStep()` with a wrapper object returned
+  // from `MasterInterface::CreateRunStepResponse()` called on the
+  // *same* MasterInterface object, this error will never trigger.
+  virtual RunStepResponse* get_proto() = 0;
+  friend class MasterInterface;
+};
+
+class InMemoryRunStepResponse : public MutableRunStepResponseWrapper {
+ public:
+  // MutableRunStepResponseWrapper methods.
+  size_t num_tensors() const override;
+  const string& tensor_name(size_t i) const override;
+  Status TensorValue(size_t i, Tensor* out_tensor) const override;
+  Status AddTensorFromRunGraphResponse(
+      const string& name, MutableRunGraphResponseWrapper* run_graph_response,
+      size_t i) override;
+  const RunMetadata& metadata() const override;
+  RunMetadata* mutable_metadata() override;
+  Status status() const override;
+  absl::StatusCode status_code() const override;
+  void set_status(const Status& status) override;
+
+ protected:
+  // NOTE: This method is not implemented. See
+  // MutableRunGraphResponseWrapper for an explanation.
+  RunStepResponse* get_proto() override;
+
+ private:
+  gtl::InlinedVector<std::pair<string, Tensor>, 4> tensors_;
+  RunMetadata metadata_;
+  // Store the code and message separately so that they can be updated
+  // independently by setters.
+  Status status_;
+};
+
+// Proto-based message wrapper for use on the client side of the RunStep RPC.
+class OwnedProtoRunStepResponse : public MutableRunStepResponseWrapper {
+ public:
+  // MutableRunStepResponseWrapper methods.
+  size_t num_tensors() const override;
+  const string& tensor_name(size_t i) const override;
+  Status TensorValue(size_t i, Tensor* out_tensor) const override;
+  Status AddTensorFromRunGraphResponse(
+      const string& name, MutableRunGraphResponseWrapper* run_graph_response,
+      size_t i) override;
+  const RunMetadata& metadata() const override;
+  RunMetadata* mutable_metadata() override;
+  Status status() const override;
+  absl::StatusCode status_code() const override;
+  void set_status(const Status& status) override;
+
+ protected:
+  RunStepResponse* get_proto() override;
+
+ private:
+  RunStepResponse response_;
+};
+
+// Proto-based message wrapper for use on the server side of the RunStep RPC.
+class NonOwnedProtoRunStepResponse : public MutableRunStepResponseWrapper {
+ public:
+  NonOwnedProtoRunStepResponse(RunStepResponse* response);
+
+  // MutableRunStepResponseWrapper methods.
+  size_t num_tensors() const override;
+  const string& tensor_name(size_t i) const override;
+  Status TensorValue(size_t i, Tensor* out_tensor) const override;
+  Status AddTensorFromRunGraphResponse(
+      const string& name, MutableRunGraphResponseWrapper* run_graph_response,
+      size_t i) override;
+  const RunMetadata& metadata() const override;
+  RunMetadata* mutable_metadata() override;
+  Status status() const override;
+  absl::StatusCode status_code() const override;
+  void set_status(const Status& status) override;
+
+ protected:
+  RunStepResponse* get_proto() override;
+
+ private:
+  RunStepResponse* response_;  // Not owned.
+};
+
+bool ParseTensorProtoToTensor(const TensorProto& tensor_proto,
+                              Tensor* out_tensor);
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_MESSAGE_WRAPPERS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/partial_run_mgr.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/partial_run_mgr.h
new file mode 100644
index 0000000000000000000000000000000000000000..5c1041250296916835c379f94b65cd50d98ad024
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/partial_run_mgr.h
@@ -0,0 +1,87 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_PARTIAL_RUN_MGR_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_PARTIAL_RUN_MGR_H_
+
+#include <unordered_map>
+
+#include "tensorflow/core/distributed_runtime/worker_interface.h"
+#include "tensorflow/core/framework/cancellation.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/platform/macros.h"
+#include "tensorflow/core/platform/mutex.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+
+// PartialRunMgr keeps track of pending partial run requests, and ensures that
+// the partial run is only marked complete when the corresponding executor is
+// run to completion.
+//
+// In tensorflow workers, the executor runs operations asynchronously until
+// specified fetches (operations that return tensors) or targets (operations
+// that don't return tensors) are reached. A PartialRun has two components: a
+// setup which specifies all desired fetches and targets, and run calls that
+// specify fetch values (from the setup calls) to retrieve.
+// On the last partial run call, it is possible to satisfy the
+// required fetches before the executor has completed running the graph to all
+// the desired targets.
+// PartialRunMgr is used to ensure that we don't complete and return the final
+// partial run call to the user until both the partial run and executor have
+// completed.
+//
+// PartialRunMgr is thread-safe.
+class PartialRunMgr {
+ public:
+  // Find or create the CancellationManager associated with step_id.
+  // The PartialRunMgr owns the cancellation_manager.
+  // Returns true if a new CancellationManager was created
+  // (i.e this is a new partial run).
+  bool FindOrCreate(int step_id, CancellationManager** cancellation_manager);
+
+  // Calls the final callback if the PartialRunRequest has already completed.
+  // Otherwise stores the executor_status to be propagated when the
+  // PartialRunRequest completes (PartialRunDone has been called).
+  void ExecutorDone(int step_id, const Status& executor_status);
+
+  // Calls done if the executor has already completed (ExecutorDone has been
+  // called). Otherwise, stores the status and done callback, calling them when
+  // ExecutorDone is called. The callback will either be called by the calling
+  // thread of either PartialRunDone or ExecutorDone.
+  // If executor_status in ExecutorDone is not OK, it takes precedence over
+  // status and is passed to the done callback.
+  void PartialRunDone(int step_id, StatusCallback done, const Status& status);
+
+ private:
+  // PartialRunState stores state associated with a pending partial run request.
+  // This is protected by the mutex in PartialRunMgr.
+  struct PartialRunState {
+    std::unique_ptr<CancellationManager> cancellation_manager;
+
+    bool executor_done = false;
+    StatusCallback final_callback = nullptr;
+    Status final_status;
+  };
+
+  mutex mu_;
+
+  std::unordered_map<int, std::unique_ptr<PartialRunState>>
+      step_id_to_partial_run_ TF_GUARDED_BY(mu_);
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_PARTIAL_RUN_MGR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/recent_request_ids.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/recent_request_ids.h
new file mode 100644
index 0000000000000000000000000000000000000000..5cb8b82634f82dd302a2a8b1f7e1fb01fb9a3adf
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/recent_request_ids.h
@@ -0,0 +1,104 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RECENT_REQUEST_IDS_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RECENT_REQUEST_IDS_H_
+
+#include <string>
+#include <unordered_set>
+#include <vector>
+
+#include "absl/container/flat_hash_set.h"
+#include "tensorflow/core/distributed_runtime/message_wrappers.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/platform/mutex.h"
+#include "tensorflow/core/platform/protobuf.h"
+#include "tensorflow/core/platform/thread_annotations.h"
+#include "tensorflow/core/platform/types.h"
+#include "tensorflow/core/protobuf/worker.pb.h"
+
+namespace tensorflow {
+
+// RecentRequestIds tracks recent 64-bit request_ids. When maximum capacity is
+// reached, the oldest request_id is evicted. Thread safe.
+//
+// Some RPCs like RecvTensor are unsafe to retry. For example, RecvTensor pairs
+// one sender and one receiver, and the receiver waits for the sender's tensor.
+// Retried RecvTensor requests are problematic, because the original RecvTensor
+// request may have consumed the sender's tensor, so a retried request might
+// block forever. RecentRequestIds identifies retried requests, so we can fail
+// them instead of blocking forever.
+//
+// Internally, recent request_ids are stored in two data structures: a set and a
+// circular buffer. The set is used for efficient lookups, and the circular
+// buffer tracks the oldest request_id. When the buffer is full, the new
+// request_id replaces the oldest request_id in the circular buffer, and the
+// oldest request_id is removed from the set.
+class RecentRequestIds {
+ public:
+  // num_tracked_request_ids should be much larger than the number of RPCs that
+  // can be received in a small time window. For example, we observed a peak RPC
+  // rate of ~700 RecvTensor RPC/s when training inception v3 on TPUs, so we
+  // currently set num_tracked_request_ids to 100,000 for RecvTensor.
+  // Having a large `num_shars` can prevent run into lock contention in this
+  // class.
+  explicit RecentRequestIds(int num_tracked_request_ids, int num_shards = 1);
+
+  // Returns OK iff request_id has not been seen in the last
+  // num_tracked_request_ids insertions. For backwards compatibility, this
+  // always returns OK for request_id 0. The method_name and the request's
+  // ShortDebugString are added to returned errors.
+  Status TrackUnique(int64_t request_id, const string& method_name,
+                     const protobuf::Message& request);
+  // Overloaded version of the above function for wrapped protos.
+  template <typename RequestWrapper>
+  Status TrackUnique(int64_t request_id, const string& method_name,
+                     const RequestWrapper* wrapper);
+
+ private:
+  bool Insert(int64_t request_id);
+
+  struct IndexBucket {
+    mutex mu;
+    // next_index indexes into circular_buffer_, and points to the next storage
+    // space to use. When the buffer is full, next_index_ points at the oldest
+    // request_id.
+    int next_index TF_GUARDED_BY(mu) = 0;
+    std::vector<int64_t> circular_buffer TF_GUARDED_BY(mu);
+    absl::flat_hash_set<int64_t> set TF_GUARDED_BY(mu);
+  };
+
+  // This vector is immutable so we don't need to use a mutex to protect it.
+  std::vector<IndexBucket> index_buckets_;
+};
+
+// Implementation details
+
+template <typename RequestWrapper>
+Status RecentRequestIds::TrackUnique(int64_t request_id,
+                                     const string& method_name,
+                                     const RequestWrapper* wrapper) {
+  if (Insert(request_id)) {
+    return OkStatus();
+  } else {
+    return errors::Aborted("The same ", method_name,
+                           " request was received twice. ",
+                           wrapper->ToProto().ShortDebugString());
+  }
+}
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RECENT_REQUEST_IDS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/remote_device.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/remote_device.h
new file mode 100644
index 0000000000000000000000000000000000000000..2b7a8eb55b5d12b6fae15b8011845c79394ee99d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/remote_device.h
@@ -0,0 +1,72 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_REMOTE_DEVICE_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_REMOTE_DEVICE_H_
+
+#include <functional>
+#include <string>
+#include <vector>
+
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/platform/protobuf.h"
+#include "tensorflow/core/platform/stringpiece.h"
+
+namespace tsl {
+class Env;
+}  // namespace tsl
+namespace tensorflow {
+using Env = tsl::Env;
+class DeviceAttributes;
+class Device;
+class WorkerCacheInterface;
+
+// This callback should have the same definition as DeviceMgr::LookupDevice
+// It assigns *device with pointer to Device of the given 'name', where 'name'
+// is either a full device name, or just the replica-local suffix.
+typedef std::function<Status(StringPiece name, Device** device)>
+    LookupLocalDevice;
+
+// Creates Remote Devices for the provided device attributes. Helpful when the
+// list of attributes is known, and doesn't need to be discovered via RPC.
+void AsRemoteDevices(
+    Env* env,
+    const protobuf::RepeatedPtrField<DeviceAttributes>& device_attributes,
+    LookupLocalDevice lookup_local_device,
+    std::vector<std::unique_ptr<Device>>* remote_devices);
+
+// NewRemoteDevices discovers available devices on the
+// 'worker_name'.  The implementation uses 'channel_cache' to
+// discover how to communicate with the 'worker_name' (via gRPC, for
+// example).
+//
+// NewRemoteDevices does not block.
+//
+// On success, the 'done' callback is given the OK status and a vector
+// of Device*. The caller should take ownership of these devices.
+//
+// Otherwise, the 'done' callback is given an error status and the
+// vector is empty.
+typedef std::function<void(const Status&, std::vector<Device*>*)>
+    NewRemoteDevicesDone;
+void NewRemoteDevices(Env* env, WorkerCacheInterface* worker_cache,
+                      const string& worker_name, NewRemoteDevicesDone done);
+
+// Create Remote Device based on the given attributes.
+std::unique_ptr<Device> NewRemoteDevice(Env* env,
+                                        DeviceAttributes device_attribute);
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_REMOTE_DEVICE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rendezvous_mgr_interface.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rendezvous_mgr_interface.h
new file mode 100644
index 0000000000000000000000000000000000000000..2308d8abc9c46d5eb32dcd80b67b5217e3419376
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rendezvous_mgr_interface.h
@@ -0,0 +1,109 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RENDEZVOUS_MGR_INTERFACE_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RENDEZVOUS_MGR_INTERFACE_H_
+
+#include <string>
+
+#include "tensorflow/core/distributed_runtime/worker_env.h"
+#include "tensorflow/core/framework/rendezvous.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+
+class WorkerSession;
+
+// RemoteRendezvous follow a 2-part initialization. First the objects are
+// constructed. Eventually, they will be initialized. Clients of the
+// RendezvousMgrInterface must guarantee to call Initialize on the returned
+// RemoteRendezvous eventually.
+//
+// Partially initialized RemoteRendezvous must respect the Rendezvous interface
+// (i.e. Send() must never block), however implementations are not expected to
+// actually perform the underlying operations until after the RemoteRendezvous
+// has been Initialize'd.
+class RemoteRendezvous : public Rendezvous {
+ public:
+  // Fully construct the RemoteRendezvous.
+  virtual Status Initialize(WorkerSession* session) = 0;
+
+  // In remote eager, set current instance as context default rendezvous which
+  // will be used for eager op-by-op execution.
+  virtual void SetRemoteEagerContextDefault() = 0;
+  // In remote eager, get if current instance is context default rendezvous.
+  virtual bool IsRemoteEagerContextDefault() = 0;
+
+ protected:
+  bool is_cross_process() override { return true; }
+};
+
+// RendezvousMgr keeps track of a set of local rendezvous instances.
+// All tensors sent by this worker are buffered in a RendezvousMgr
+// until the tensor is received.  Each global unique "step_id"
+// corresponds to one local rendezvous instance managed by a
+// RendezvousMgr.
+//
+// E.g.,
+//   Rendezvous* rendez = worker_env->rendezvous_mgr->Find(0x8935);
+//   fork execution of an graph executor using "rendez"  on thread 1;
+//   fork execution of another graph executor using "rendez" on thread 2;
+//   ...
+//   join threads 1 and 2;
+//
+// In the example above, execution in thread 1 and 2 communicates with
+// each other by send/recv operations through the "rend".
+//
+// Tensors sent and recved through rendezvous managed by this
+// RendezvousMgr must have keys generated by Rendezvous::CreateKey.
+class RendezvousMgrInterface {
+ public:
+  RendezvousMgrInterface() = default;
+  virtual ~RendezvousMgrInterface() {}
+
+  // Returns Rendezvous supporting send and recv among workers in the
+  // "step_id".  The caller takes ownership of one reference on the
+  // returned Rendezvous instance.
+  //
+  // Note: the caller must guarantee to eventually call Initialize on the
+  // returned RemoteRendezvous
+  virtual tsl::core::RefCountPtr<RemoteRendezvous> Find(int64_t step_id) = 0;
+
+  // Finds the local rendezvous instance for the "step_id".  Runs
+  // "done" when the tensor for "key" is produced or an error occurs.
+  //
+  // This method is used by the rpc handler of RecvTensor.
+  virtual void RecvLocalAsync(int64_t step_id,
+                              const Rendezvous::ParsedKey& parsed,
+                              Rendezvous::DoneCallback done) = 0;
+
+  // Synchronous wrapper for RecvLocalAsync.
+  virtual Status RecvLocal(int64_t step_id, const Rendezvous::ParsedKey& parsed,
+                           Tensor* val, bool* is_dead) = 0;
+
+  // Removes rendezvous for "step_id".
+  //
+  // TODO(zhifengc): Have a background thread in worker that
+  // periodically calls CleanupAll().
+  virtual void Cleanup(int64_t step_id) = 0;
+
+  // Remove all rendezvous instances owned by the rendezvous_mgr.
+  virtual void CleanupAll() = 0;
+};
+
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RENDEZVOUS_MGR_INTERFACE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/request_id.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/request_id.h
new file mode 100644
index 0000000000000000000000000000000000000000..2f7b3b462c3d24f7aedb9a61815e372c7dd8f2be
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/request_id.h
@@ -0,0 +1,31 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_REQUEST_ID_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_REQUEST_ID_H_
+
+#include "tensorflow/core/platform/types.h"
+#include "tsl/platform/random.h"
+
+namespace tensorflow {
+
+// Returns a request_id for use with RecentRequestIds. This number will not be
+// zero, and must be unique over RecentRequestIds' window of
+// num_tracked_request_ids. See recent_request_ids.h for more details.
+int64_t GetUniqueRequestId();
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_REQUEST_ID_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rpc/coordination/grpc_coordination_client.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rpc/coordination/grpc_coordination_client.h
new file mode 100644
index 0000000000000000000000000000000000000000..4d301ee8018e37b588f36b3f84ae205949235654
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rpc/coordination/grpc_coordination_client.h
@@ -0,0 +1,31 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RPC_COORDINATION_GRPC_COORDINATION_CLIENT_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RPC_COORDINATION_GRPC_COORDINATION_CLIENT_H_
+
+#include <memory>
+
+#include "tsl/distributed_runtime/rpc/coordination/grpc_coordination_client.h"
+
+namespace tensorflow {
+// NOLINTBEGIN(misc-unused-using-decls)
+using tsl::NewGrpcCoordinationClient;
+using tsl::NewGrpcCoordinationClientCache;
+// NOLINTEND(misc-unused-using-decls)
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RPC_COORDINATION_GRPC_COORDINATION_CLIENT_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rpc/coordination/grpc_coordination_service_impl.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rpc/coordination/grpc_coordination_service_impl.h
new file mode 100644
index 0000000000000000000000000000000000000000..d914583c44c2183f59b523c8e378f8248374c00f
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rpc/coordination/grpc_coordination_service_impl.h
@@ -0,0 +1,27 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RPC_COORDINATION_GRPC_COORDINATION_SERVICE_IMPL_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RPC_COORDINATION_GRPC_COORDINATION_SERVICE_IMPL_H_
+
+#include "tsl/distributed_runtime/rpc/coordination/grpc_coordination_service_impl.h"
+
+namespace tensorflow {
+// NOLINTBEGIN(misc-unused-using-decls)
+using tsl::GrpcCoordinationServiceImpl;
+// NOLINTEND(misc-unused-using-decls)
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RPC_COORDINATION_GRPC_COORDINATION_SERVICE_IMPL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rpc/eager/grpc_eager_client.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rpc/eager/grpc_eager_client.h
new file mode 100644
index 0000000000000000000000000000000000000000..8a926da488477b3c88b11b822ef6d332457e3cc0
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rpc/eager/grpc_eager_client.h
@@ -0,0 +1,30 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RPC_EAGER_GRPC_EAGER_CLIENT_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RPC_EAGER_GRPC_EAGER_CLIENT_H_
+
+#include "tensorflow/core/distributed_runtime/eager/eager_client.h"
+#include "tensorflow/core/distributed_runtime/rpc/grpc_channel.h"
+
+namespace tensorflow {
+namespace eager {
+// The GrpcChannelCache is not owned.
+EagerClientCache* NewGrpcEagerClientCache(
+    std::shared_ptr<tensorflow::GrpcChannelCache> channel);
+}  // namespace eager
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RPC_EAGER_GRPC_EAGER_CLIENT_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rpc/eager/grpc_eager_service.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rpc/eager/grpc_eager_service.h
new file mode 100644
index 0000000000000000000000000000000000000000..4ef8131feef362eea7a6c07fc001580528568d03
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rpc/eager/grpc_eager_service.h
@@ -0,0 +1,22 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RPC_EAGER_GRPC_EAGER_SERVICE_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RPC_EAGER_GRPC_EAGER_SERVICE_H_
+
+#include "xla/stream_executor/platform/port.h"
+#include "tensorflow/core/protobuf/eager_service.grpc.pb.h"
+
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RPC_EAGER_GRPC_EAGER_SERVICE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rpc/eager/grpc_eager_service_impl.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rpc/eager/grpc_eager_service_impl.h
new file mode 100644
index 0000000000000000000000000000000000000000..d310424c92f5886fa11d8e2fcb05c5ebf6ea760b
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rpc/eager/grpc_eager_service_impl.h
@@ -0,0 +1,170 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RPC_EAGER_GRPC_EAGER_SERVICE_IMPL_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RPC_EAGER_GRPC_EAGER_SERVICE_IMPL_H_
+
+#include "grpcpp/alarm.h"
+#include "grpcpp/completion_queue.h"
+#include "grpcpp/server_builder.h"
+#include "tensorflow/core/distributed_runtime/eager/eager_service_impl.h"
+#include "tensorflow/core/distributed_runtime/rpc/eager/grpc_eager_service.h"
+#include "tensorflow/core/distributed_runtime/rpc/grpc_util.h"
+#include "tsl/distributed_runtime/rpc/async_service_interface.h"
+#include "tsl/distributed_runtime/rpc/grpc_call.h"
+
+namespace tensorflow {
+namespace eager {
+
+// This class is a wrapper that handles communication for gRPC.
+class GrpcEagerServiceImpl : public tsl::AsyncServiceInterface {
+ public:
+  template <class RequestMessage, class ResponseMessage>
+  using EagerCall =
+      tsl::Call<GrpcEagerServiceImpl, grpc::EagerService::AsyncService,
+                RequestMessage, ResponseMessage>;
+  template <class RequestMessage, class ResponseMessage>
+  using StreamingCall =
+      tsl::ServerBidirectionalStreamingCall<GrpcEagerServiceImpl,
+                                            grpc::EagerService::AsyncService,
+                                            RequestMessage, ResponseMessage>;
+
+  GrpcEagerServiceImpl(WorkerEnv* env, ::grpc::ServerBuilder* server_builder);
+  virtual ~GrpcEagerServiceImpl() {}
+
+  // Create a master context in eager service.
+  Status CreateMasterContext(const tensorflow::uint64 context_id,
+                             EagerContext* context);
+
+  void HandleRPCsLoop() override;
+  void Shutdown() override;
+
+ private:
+#define HANDLER(method)                                                       \
+  void method##Handler(EagerCall<method##Request, method##Response>* call) {  \
+    env_->compute_pool->Schedule([this, call]() {                             \
+      call->SendResponse(                                                     \
+          ToGrpcStatus(local_impl_.method(&call->request, &call->response))); \
+    });                                                                       \
+    tsl::Call<GrpcEagerServiceImpl, grpc::EagerService::AsyncService,         \
+              method##Request, method##Response>::                            \
+        EnqueueRequest(&service_, cq_.get(),                                  \
+                       &grpc::EagerService::AsyncService::Request##method,    \
+                       &GrpcEagerServiceImpl::method##Handler, false);        \
+  }
+  HANDLER(CreateContext);
+  HANDLER(UpdateContext);
+  HANDLER(WaitQueueDone);
+  HANDLER(KeepAlive);
+  HANDLER(CloseContext);
+#undef HANDLER
+
+  void EnqueueHandler(EagerCall<EnqueueRequest, EnqueueResponse>* call) {
+    env_->compute_pool->Schedule([this, call]() {
+      auto call_opts = std::make_shared<CallOptions>();
+      call->SetCancelCallback([call_opts]() { call_opts->StartCancel(); });
+      call->SendResponse(ToGrpcStatus(local_impl_.Enqueue(
+          call_opts.get(), &call->request, &call->response)));
+    });
+    tsl::Call<GrpcEagerServiceImpl, grpc::EagerService::AsyncService,
+              EnqueueRequest, EnqueueResponse>::
+        EnqueueRequest(&service_, cq_.get(),
+                       &grpc::EagerService::AsyncService::RequestEnqueue,
+                       &GrpcEagerServiceImpl::EnqueueHandler,
+                       /*supports_cancel=*/true);
+  }
+
+  void RunComponentFunctionHandler(
+      EagerCall<RunComponentFunctionRequest, RunComponentFunctionResponse>*
+          call) {
+    env_->compute_pool->Schedule([this, call]() {
+      auto call_opts = std::make_shared<CallOptions>();
+      call->SetCancelCallback([call_opts]() { call_opts->StartCancel(); });
+      local_impl_.RunComponentFunction(call_opts.get(), &call->request,
+                                       &call->response,
+                                       [call, call_opts](const Status& s) {
+                                         call->ClearCancelCallback();
+                                         call->SendResponse(ToGrpcStatus(s));
+                                       });
+    });
+    tsl::Call<GrpcEagerServiceImpl, grpc::EagerService::AsyncService,
+              RunComponentFunctionRequest, RunComponentFunctionResponse>::
+        EnqueueRequest(
+            &service_, cq_.get(),
+            &grpc::EagerService::AsyncService::RequestRunComponentFunction,
+            &GrpcEagerServiceImpl::RunComponentFunctionHandler,
+            /*supports_cancel=*/true);
+  }
+
+  // Called when a new request has been received as part of a StreamingEnqueue
+  // call.
+  // StreamingEnqueueHandler gets the request from the `call` and fills the
+  // response (also found in `call`) by invoking the local EagerServiceImpl.
+  // The local EagerServiceImpl is invoked in a single-threaded thread pool. We
+  // do this to preserve request order. The local service can parallelize based
+  // on context_id in request if necessary. Remote contexts are created in async
+  // mode by default, so the local service impl just puts the request on eager
+  // executor queue.
+  void StreamingEnqueueHandler(
+      StreamingCall<EnqueueRequest, EnqueueResponse>* call) {
+    call->Ref();
+    enqueue_streaming_thread_.Schedule([this, call]() {
+      if (call->RefCountIsOne()) {
+        // This StreamingCall has already been shutdown. Don't need to anything.
+        call->Unref();
+        return;
+      }
+      // NOTE(fishx): Use the address of StreamingCall as the stream_id since we
+      // reuse the same StreamingCall for multiple requests in the same
+      // streaming connection.
+      Status status = local_impl_.Enqueue(
+          /*call_opts=*/nullptr, &call->request(), call->mutable_response(),
+          reinterpret_cast<uint64>(static_cast<void*>(call)));
+
+      if (status.ok()) {
+        VLOG(1) << "local_impl_.Enqueue completed successfully";
+        call->SendResponse();
+      } else {
+        VLOG(1) << "local_impl_.Enqueue failed with " << status.ToString()
+                << " on request " << call->request().DebugString();
+        call->Finish(ToGrpcStatus(status));
+      }
+      call->Unref();
+
+      // We do not tell gRPC to accept a new StreamingEnqueue request because
+      // this method can be called multiple times for a given streaming call.
+      // The StreamingCall does this per call instead, after a call has been
+      // opened.
+    });
+  }
+
+  WorkerEnv* const env_;  // Not owned.
+  EagerServiceImpl local_impl_;
+
+  // A single-threaded thread pool to handle streaming enqueue rpc request.
+  thread::ThreadPool enqueue_streaming_thread_;
+  std::unique_ptr<::grpc::Alarm> shutdown_alarm_;
+
+  std::unique_ptr<::grpc::ServerCompletionQueue> cq_;
+  grpc::EagerService::AsyncService service_;
+
+  GrpcEagerServiceImpl(const GrpcEagerServiceImpl&) = delete;
+  void operator=(const GrpcEagerServiceImpl&) = delete;
+};
+
+}  // namespace eager
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RPC_EAGER_GRPC_EAGER_SERVICE_IMPL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rpc/grpc_channel.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rpc/grpc_channel.h
new file mode 100644
index 0000000000000000000000000000000000000000..c98ad7a074dd6fbc33b27ed86b846de3a5c46fbf
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rpc/grpc_channel.h
@@ -0,0 +1,33 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RPC_GRPC_CHANNEL_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RPC_GRPC_CHANNEL_H_
+
+#include "tsl/distributed_runtime/rpc/grpc_channel.h"
+
+namespace tensorflow {
+// NOLINTBEGIN(misc-unused-using-decls)
+using tsl::ChannelCreationFunction;
+using tsl::ConvertToChannelCreationFunction;
+using tsl::GetChannelArguments;
+using tsl::GrpcChannelCache;
+using tsl::GrpcChannelSpec;
+using tsl::NewGrpcChannelCache;
+using tsl::NewHostPortGrpcChannel;
+// NOLINTEND(misc-unused-using-decls)
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RPC_GRPC_CHANNEL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rpc/grpc_client_cq_tag.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rpc/grpc_client_cq_tag.h
new file mode 100644
index 0000000000000000000000000000000000000000..accb50857d579e7950ce02e79d572c3bb3e3753c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rpc/grpc_client_cq_tag.h
@@ -0,0 +1,27 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RPC_GRPC_CLIENT_CQ_TAG_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RPC_GRPC_CLIENT_CQ_TAG_H_
+
+#include "tsl/distributed_runtime/rpc/grpc_client_cq_tag.h"
+
+namespace tensorflow {
+// NOLINTBEGIN(misc-unused-using-decls)
+using tsl::GrpcClientCQTag;
+// NOLINTEND(misc-unused-using-decls)
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RPC_GRPC_CLIENT_CQ_TAG_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rpc/grpc_master_service.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rpc/grpc_master_service.h
new file mode 100644
index 0000000000000000000000000000000000000000..bd2031639e960872f4f07dc576b391c6be548680
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rpc/grpc_master_service.h
@@ -0,0 +1,36 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RPC_GRPC_MASTER_SERVICE_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RPC_GRPC_MASTER_SERVICE_H_
+
+#include <memory>
+#include "grpcpp/server_builder.h"
+#include "tensorflow/core/platform/types.h"
+#include "tensorflow/core/protobuf/master.pb.h"
+
+namespace tsl {
+class AsyncServiceInterface;
+}
+namespace tensorflow {
+class Master;
+
+tsl::AsyncServiceInterface* NewGrpcMasterService(
+    Master* master, const ConfigProto& default_session_config,
+    ::grpc::ServerBuilder* builder);
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RPC_GRPC_MASTER_SERVICE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rpc/grpc_master_service_impl.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rpc/grpc_master_service_impl.h
new file mode 100644
index 0000000000000000000000000000000000000000..bdf683fd939219f11bf342423077ff3787491e46
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rpc/grpc_master_service_impl.h
@@ -0,0 +1,218 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RPC_GRPC_MASTER_SERVICE_IMPL_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RPC_GRPC_MASTER_SERVICE_IMPL_H_
+
+#include "grpcpp/impl/codegen/async_stream.h"
+#include "grpcpp/impl/codegen/async_unary_call.h"
+#include "grpcpp/impl/codegen/client_context.h"
+#include "grpcpp/impl/codegen/completion_queue.h"
+#include "grpcpp/impl/codegen/proto_utils.h"
+#include "grpcpp/impl/codegen/rpc_method.h"
+#include "grpcpp/impl/codegen/server_context.h"
+#include "grpcpp/impl/codegen/service_type.h"
+#include "grpcpp/impl/codegen/status.h"
+#include "grpcpp/impl/codegen/stub_options.h"
+#include "grpcpp/impl/codegen/sync_stream.h"
+#include "tensorflow/core/protobuf/master.pb.h"
+
+namespace tensorflow {
+
+namespace grpc {
+
+// Implementation of `tensorflow.MasterService`, based on the
+// definition in "//tensorflow/core/protobuf/master_service.proto",
+// and the gRPC generated stub and service classes.
+// See that file for the definition of methods and messages.
+class MasterService final {
+ public:
+  class StubInterface {
+   public:
+    virtual ~StubInterface() {}
+    virtual ::grpc::Status CreateSession(::grpc::ClientContext* context,
+                                         const CreateSessionRequest& request,
+                                         CreateSessionResponse* response) = 0;
+    virtual ::grpc::Status ExtendSession(::grpc::ClientContext* context,
+                                         const ExtendSessionRequest& request,
+                                         ExtendSessionResponse* response) = 0;
+    virtual ::grpc::Status PartialRunSetup(
+        ::grpc::ClientContext* context, const PartialRunSetupRequest& request,
+        PartialRunSetupResponse* response) = 0;
+    virtual ::grpc::Status RunStep(::grpc::ClientContext* context,
+                                   const RunStepRequest& request,
+                                   RunStepResponse* response) = 0;
+    virtual ::grpc::Status CloseSession(::grpc::ClientContext* context,
+                                        const CloseSessionRequest& request,
+                                        CloseSessionResponse* response) = 0;
+    virtual ::grpc::Status ListDevices(::grpc::ClientContext* context,
+                                       const ListDevicesRequest& request,
+                                       ListDevicesResponse* response) = 0;
+    virtual ::grpc::Status Reset(::grpc::ClientContext* context,
+                                 const ResetRequest& request,
+                                 ResetResponse* response) = 0;
+    virtual ::grpc::Status MakeCallable(::grpc::ClientContext* context,
+                                        const MakeCallableRequest& request,
+                                        MakeCallableResponse* response) = 0;
+    virtual ::grpc::Status RunCallable(::grpc::ClientContext* context,
+                                       const RunCallableRequest& request,
+                                       RunCallableResponse* response) = 0;
+    virtual ::grpc::Status ReleaseCallable(
+        ::grpc::ClientContext* context, const ReleaseCallableRequest& request,
+        ReleaseCallableResponse* response) = 0;
+  };
+  class Stub final : public StubInterface {
+   public:
+    Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel);
+    ::grpc::Status CreateSession(::grpc::ClientContext* context,
+                                 const CreateSessionRequest& request,
+                                 CreateSessionResponse* response) override;
+    ::grpc::Status ExtendSession(::grpc::ClientContext* context,
+                                 const ExtendSessionRequest& request,
+                                 ExtendSessionResponse* response) override;
+    ::grpc::Status PartialRunSetup(::grpc::ClientContext* context,
+                                   const PartialRunSetupRequest& request,
+                                   PartialRunSetupResponse* response) override;
+    ::grpc::Status RunStep(::grpc::ClientContext* context,
+                           const RunStepRequest& request,
+                           RunStepResponse* response) override;
+    ::grpc::Status CloseSession(::grpc::ClientContext* context,
+                                const CloseSessionRequest& request,
+                                CloseSessionResponse* response) override;
+    ::grpc::Status ListDevices(::grpc::ClientContext* context,
+                               const ListDevicesRequest& request,
+                               ListDevicesResponse* response) override;
+    ::grpc::Status Reset(::grpc::ClientContext* context,
+                         const ResetRequest& request,
+                         ResetResponse* response) override;
+    ::grpc::Status MakeCallable(::grpc::ClientContext* context,
+                                const MakeCallableRequest& request,
+                                MakeCallableResponse* response) override;
+    ::grpc::Status RunCallable(::grpc::ClientContext* context,
+                               const RunCallableRequest& request,
+                               RunCallableResponse* response) override;
+    ::grpc::Status ReleaseCallable(::grpc::ClientContext* context,
+                                   const ReleaseCallableRequest& request,
+                                   ReleaseCallableResponse* response) override;
+
+   private:
+    std::shared_ptr< ::grpc::ChannelInterface> channel_;
+    const ::grpc::internal::RpcMethod rpcmethod_CreateSession_;
+    const ::grpc::internal::RpcMethod rpcmethod_ExtendSession_;
+    const ::grpc::internal::RpcMethod rpcmethod_PartialRunSetup_;
+    const ::grpc::internal::RpcMethod rpcmethod_RunStep_;
+    const ::grpc::internal::RpcMethod rpcmethod_CloseSession_;
+    const ::grpc::internal::RpcMethod rpcmethod_ListDevices_;
+    const ::grpc::internal::RpcMethod rpcmethod_Reset_;
+    const ::grpc::internal::RpcMethod rpcmethod_MakeCallable_;
+    const ::grpc::internal::RpcMethod rpcmethod_RunCallable_;
+    const ::grpc::internal::RpcMethod rpcmethod_ReleaseCallable_;
+  };
+  static std::unique_ptr<Stub> NewStub(
+      const std::shared_ptr< ::grpc::ChannelInterface>& channel,
+      const ::grpc::StubOptions& options = ::grpc::StubOptions());
+
+  class AsyncService : public ::grpc::Service {
+   public:
+    AsyncService();
+    virtual ~AsyncService();
+    void RequestCreateSession(
+        ::grpc::ServerContext* context, CreateSessionRequest* request,
+        ::grpc::ServerAsyncResponseWriter<CreateSessionResponse>* response,
+        ::grpc::CompletionQueue* new_call_cq,
+        ::grpc::ServerCompletionQueue* notification_cq, void* tag) {
+      ::grpc::Service::RequestAsyncUnary(0, context, request, response,
+                                         new_call_cq, notification_cq, tag);
+    }
+    void RequestExtendSession(
+        ::grpc::ServerContext* context, ExtendSessionRequest* request,
+        ::grpc::ServerAsyncResponseWriter<ExtendSessionResponse>* response,
+        ::grpc::CompletionQueue* new_call_cq,
+        ::grpc::ServerCompletionQueue* notification_cq, void* tag) {
+      ::grpc::Service::RequestAsyncUnary(1, context, request, response,
+                                         new_call_cq, notification_cq, tag);
+    }
+    void RequestPartialRunSetup(
+        ::grpc::ServerContext* context, PartialRunSetupRequest* request,
+        ::grpc::ServerAsyncResponseWriter<PartialRunSetupResponse>* response,
+        ::grpc::CompletionQueue* new_call_cq,
+        ::grpc::ServerCompletionQueue* notification_cq, void* tag) {
+      ::grpc::Service::RequestAsyncUnary(2, context, request, response,
+                                         new_call_cq, notification_cq, tag);
+    }
+    void RequestRunStep(
+        ::grpc::ServerContext* context, RunStepRequest* request,
+        ::grpc::ServerAsyncResponseWriter<RunStepResponse>* response,
+        ::grpc::CompletionQueue* new_call_cq,
+        ::grpc::ServerCompletionQueue* notification_cq, void* tag) {
+      ::grpc::Service::RequestAsyncUnary(3, context, request, response,
+                                         new_call_cq, notification_cq, tag);
+    }
+    void RequestCloseSession(
+        ::grpc::ServerContext* context, CloseSessionRequest* request,
+        ::grpc::ServerAsyncResponseWriter<CloseSessionResponse>* response,
+        ::grpc::CompletionQueue* new_call_cq,
+        ::grpc::ServerCompletionQueue* notification_cq, void* tag) {
+      ::grpc::Service::RequestAsyncUnary(4, context, request, response,
+                                         new_call_cq, notification_cq, tag);
+    }
+    void RequestListDevices(
+        ::grpc::ServerContext* context, ListDevicesRequest* request,
+        ::grpc::ServerAsyncResponseWriter<ListDevicesResponse>* response,
+        ::grpc::CompletionQueue* new_call_cq,
+        ::grpc::ServerCompletionQueue* notification_cq, void* tag) {
+      ::grpc::Service::RequestAsyncUnary(5, context, request, response,
+                                         new_call_cq, notification_cq, tag);
+    }
+    void RequestReset(
+        ::grpc::ServerContext* context, ResetRequest* request,
+        ::grpc::ServerAsyncResponseWriter<ResetResponse>* response,
+        ::grpc::CompletionQueue* new_call_cq,
+        ::grpc::ServerCompletionQueue* notification_cq, void* tag) {
+      ::grpc::Service::RequestAsyncUnary(6, context, request, response,
+                                         new_call_cq, notification_cq, tag);
+    }
+    void RequestMakeCallable(
+        ::grpc::ServerContext* context, MakeCallableRequest* request,
+        ::grpc::ServerAsyncResponseWriter<MakeCallableResponse>* response,
+        ::grpc::CompletionQueue* new_call_cq,
+        ::grpc::ServerCompletionQueue* notification_cq, void* tag) {
+      ::grpc::Service::RequestAsyncUnary(7, context, request, response,
+                                         new_call_cq, notification_cq, tag);
+    }
+    void RequestRunCallable(
+        ::grpc::ServerContext* context, RunCallableRequest* request,
+        ::grpc::ServerAsyncResponseWriter<RunCallableResponse>* response,
+        ::grpc::CompletionQueue* new_call_cq,
+        ::grpc::ServerCompletionQueue* notification_cq, void* tag) {
+      ::grpc::Service::RequestAsyncUnary(8, context, request, response,
+                                         new_call_cq, notification_cq, tag);
+    }
+    void RequestReleaseCallable(
+        ::grpc::ServerContext* context, ReleaseCallableRequest* request,
+        ::grpc::ServerAsyncResponseWriter<ReleaseCallableResponse>* response,
+        ::grpc::CompletionQueue* new_call_cq,
+        ::grpc::ServerCompletionQueue* notification_cq, void* tag) {
+      ::grpc::Service::RequestAsyncUnary(9, context, request, response,
+                                         new_call_cq, notification_cq, tag);
+    }
+  };
+};
+
+}  // namespace grpc
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RPC_GRPC_MASTER_SERVICE_IMPL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rpc/grpc_remote_worker.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rpc/grpc_remote_worker.h
new file mode 100644
index 0000000000000000000000000000000000000000..97e590e0ad180006d4538409c0addea715c7dd50
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rpc/grpc_remote_worker.h
@@ -0,0 +1,37 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RPC_GRPC_REMOTE_WORKER_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RPC_GRPC_REMOTE_WORKER_H_
+
+#include <memory>
+
+#include "grpcpp/completion_queue.h"
+#include "tensorflow/core/distributed_runtime/rpc/grpc_util.h"
+#include "tensorflow/core/lib/core/threadpool.h"
+
+namespace tensorflow {
+class WorkerCacheLogger;
+class WorkerInterface;
+
+WorkerInterface* NewGrpcRemoteWorker(SharedGrpcChannelPtr channel,
+                                     ::grpc::CompletionQueue* completion_queue,
+                                     thread::ThreadPool* callback_threadpool,
+                                     WorkerCacheLogger* logger,
+                                     const string& target);
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RPC_GRPC_REMOTE_WORKER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rpc/grpc_server_lib.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rpc/grpc_server_lib.h
new file mode 100644
index 0000000000000000000000000000000000000000..f588f291960a37e5a815c74f68738fc9cca2134f
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rpc/grpc_server_lib.h
@@ -0,0 +1,241 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RPC_GRPC_SERVER_LIB_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RPC_GRPC_SERVER_LIB_H_
+
+// GrpcServer manages the lifecycle of an Eager, Worker and Master service.
+
+#include <map>
+#include <memory>
+#include <string>
+
+#include "grpcpp/grpcpp.h"
+#include "grpcpp/security/credentials.h"
+#include "tensorflow/core/common_runtime/eager/context.h"
+#include "tensorflow/core/common_runtime/process_util.h"
+#include "tensorflow/core/common_runtime/stats_publisher_interface.h"
+#include "tensorflow/core/distributed_runtime/master_env.h"
+#include "tensorflow/core/distributed_runtime/rpc/grpc_channel.h"
+#include "tensorflow/core/distributed_runtime/rpc/grpc_worker_cache.h"
+#include "tensorflow/core/distributed_runtime/rpc/grpc_worker_service.h"
+#include "tensorflow/core/distributed_runtime/server_lib.h"
+#include "tensorflow/core/distributed_runtime/session_mgr.h"
+#include "tensorflow/core/distributed_runtime/worker_env.h"
+#include "tensorflow/core/framework/collective.h"
+#include "tensorflow/core/framework/op.h"
+#include "tensorflow/core/platform/env.h"
+#include "tsl/distributed_runtime/rpc/async_service_interface.h"
+#include "tsl/profiler/protobuf/profiler_service.grpc.pb.h"
+
+namespace tensorflow {
+
+class GrpcWorker;
+class Master;
+
+// function that creates a RendezvousMgr.
+typedef std::function<RendezvousMgrInterface*(const WorkerEnv*)>
+    RendezvousMgrCreationFunction;
+
+// function that creates a CollectiveExecutorMgr.
+typedef std::function<CollectiveExecutorMgrInterface*(
+    const ConfigProto&, const WorkerEnv*, WorkerCacheInterface*)>
+    CollectiveMgrCreationFunction;
+
+// function that registers a service to the server. The service needs to
+// be registered before builder.BuildAndStart().
+typedef std::function<void(const WorkerEnv*, ::grpc::ServerBuilder*)>
+    ServiceInitFunction;
+
+// function that creates a grpc based worker implementation.
+typedef std::function<std::unique_ptr<GrpcWorker>(WorkerEnv*,
+                                                  const ConfigProto& config)>
+    WorkerCreationFunction;
+
+struct GrpcServerOptions {
+  ServiceInitFunction service_func = nullptr;
+  RendezvousMgrCreationFunction rendezvous_mgr_func = nullptr;
+  CollectiveMgrCreationFunction collective_mgr_func = nullptr;
+  WorkerCreationFunction worker_func = nullptr;
+  StatsPublisherFactory stats_factory = CreateNoOpStatsPublisher;
+  GrpcWorkerServiceOptions worker_service_options;
+  DeviceMgr* local_device_mgr = nullptr;
+};
+
+class GrpcServer : public ServerInterface {
+ protected:
+  GrpcServer(const ServerDef& server_def, Env* env);
+  GrpcServer(const ServerDef& server_def, DeviceMgr* local_device_mgr,
+             Env* env);
+  // Allow children classes to override this and provide custom args to the
+  // server before it is constructed. Default behavior is to do nothing.
+  // requested_port provides the port requested by caller as bound_port() is
+  // not available till BuildAndStart has been called.
+  virtual void MaybeMutateBuilder(::grpc::ServerBuilder* builder,
+                                  int requested_port) {}
+
+ public:
+  static Status Create(const ServerDef& server_def, Env* env,
+                       std::unique_ptr<ServerInterface>* out_server);
+  static Status Create(const ServerDef& server_def, Env* env,
+                       std::unique_ptr<GrpcServer>* out_server);
+  // Reuse the local_device_mgr.
+  static Status Create(const ServerDef& server_def, Env* env,
+                       DeviceMgr* local_device_mgr,
+                       std::unique_ptr<ServerInterface>* out_server);
+
+  // Destruction is only supported in the factory method. Clean
+  // shutdown is not currently implemented for this server type.
+  virtual ~GrpcServer();
+
+  // Implementations of ServerInterface methods.
+  Status Start() override;
+  Status Stop() override;
+  Status Join() override;
+  const string target() const override;
+
+  WorkerEnv* worker_env() override { return &worker_env_; }
+  MasterEnv* master_env() override { return &master_env_; }
+
+  // Add master eager context to local eager service in order to handle enqueue
+  // requests from remote workers.
+  Status AddMasterEagerContextToEagerService(
+      const tensorflow::uint64 context_id,
+      tensorflow::EagerContext* context) override;
+  // Update the set of workers that can be reached by the GRPC server
+  Status UpdateServerDef(const ServerDef& server_def) override;
+  // Pass coordination service agent instance to server's RPC handler
+  Status SetCoordinationServiceAgentInstance(
+      tsl::CoordinationServiceAgent* agent) override;
+  // TODO(hanyangtay): Remove this method once gRPC server clean shutdown is
+  // supported.
+  Status StopCoordinationService() override;
+
+ protected:
+  virtual Status GetHostAndPort(const ServerDef& server_def, string* host_name,
+                                int* port) const;
+  Status Init(const GrpcServerOptions& opts = GrpcServerOptions());
+
+  // A subclass can override this method to support secure credentials.
+  virtual std::shared_ptr<::grpc::ServerCredentials> GetServerCredentials(
+      const ServerDef& server_def) const;
+
+  virtual ChannelCreationFunction GetChannelCreationFunction() const;
+
+  virtual std::unique_ptr<Master> CreateMaster(MasterEnv* master_env);
+
+  // Creates a WorkerCacheInterface for a session.
+  virtual Status WorkerCacheFactory(const WorkerCacheFactoryOptions& options,
+                                    WorkerCacheInterface** worker_cache);
+
+  // Override to return extra services to be brought up and managed along with
+  // the standard {master, worker, eager} services. The map key is an aribtrary
+  // string and the value is a pointer to the service to be brought up.
+  // Ownership of the pointer is transferred to GrpcServer after this call
+  // returns, and the service will be destroyed during the destruction of
+  // GrpcServer. Each service will have its HandleRPCsLoop called in a separate
+  // thread. An example usage would be to add a RDMA based partial worker
+  // service to offload tensor and data buffer transfers.
+  virtual std::map<std::string, tsl::AsyncServiceInterface*> ExtraServices(
+      ::grpc::ServerBuilder*) {
+    return {};
+  }
+
+  virtual std::map<std::string, tsl::AsyncServiceInterface*>
+  GetExtraServices() {
+    return extra_services_;
+  }
+
+  // Parses a WorkerCacheFactoryOptions into a GrpcChannelSpec.
+  Status ParseChannelSpec(const WorkerCacheFactoryOptions& options,
+                          GrpcChannelSpec* channel_spec);
+
+  // Returns the port to which this server is bound.
+  // This method may only be called after `this->Init()` returns successfully.
+  int bound_port() const { return bound_port_; }
+
+  // Returns hostname.
+  const string& host_name() const { return host_name_; }
+
+  const ServerDef& server_def() const { return server_def_; }
+  GrpcWorker* worker_impl() const { return worker_impl_.get(); }
+  GrpcWorkerEnv* grpc_worker_env() const { return grpc_worker_env_.get(); }
+
+  Status SetCoordinationServiceInstance(
+      tsl::CoordinationServiceInterface* service);
+
+ private:
+  Env* env_;
+
+  // The port to which this server is bound.
+  int bound_port_ = 0;
+
+  // The host name of this server
+  string host_name_;
+
+  // Guards server configuration, server, and state.
+  mutex mu_;
+
+  // Represents the current state of the server, which changes as follows:
+  //
+  //                 Join()            Join()
+  //                  ___               ___
+  //      Start()     \ /    Stop()     \ /
+  // NEW ---------> STARTED --------> STOPPED
+  //   \                          /
+  //    \________________________/
+  //            Stop(), Join()
+  enum State { NEW, STARTED, STOPPED };
+  State state_ TF_GUARDED_BY(mu_);
+
+  // Implementation of a TensorFlow master, and RPC polling thread.
+  MasterEnv master_env_;
+  std::unique_ptr<Master> master_impl_;
+  tsl::AsyncServiceInterface* master_service_ = nullptr;
+  std::unique_ptr<Thread> master_thread_ TF_GUARDED_BY(mu_);
+
+  std::map<std::string, tsl::AsyncServiceInterface*> extra_services_;
+  std::vector<std::unique_ptr<Thread>> extra_service_threads_
+      TF_GUARDED_BY(mu_);
+
+  // Implementation of a TensorFlow worker, and RPC polling thread.
+  WorkerEnv worker_env_;
+  std::unique_ptr<const DeviceMgr> owned_device_manager_;
+  std::unique_ptr<GrpcWorker> worker_impl_;
+  tsl::AsyncServiceInterface* worker_service_ = nullptr;
+  std::unique_ptr<Thread> worker_thread_ TF_GUARDED_BY(mu_);
+  std::unique_ptr<GrpcWorkerEnv> grpc_worker_env_;
+
+  // TensorFlow Eager implementation, and RPC polling thread.
+  tsl::AsyncServiceInterface* eager_service_ = nullptr;
+  std::unique_ptr<Thread> eager_thread_ TF_GUARDED_BY(mu_);
+  std::shared_ptr<WorkerSession> worker_session_;
+
+  // Experimental coordination service implementation, and RPC polling thread.
+  tsl::AsyncServiceInterface* coordination_service_ = nullptr;
+  std::unique_ptr<Thread> coordination_thread_ TF_GUARDED_BY(mu_);
+
+  // TensorFlow profiler service implementation.
+  std::unique_ptr<grpc::ProfilerService::Service> profiler_service_ = nullptr;
+
+  // The overall server configuration.
+  ServerDef server_def_ TF_GUARDED_BY(mu_);
+
+  std::unique_ptr<::grpc::Server> server_ TF_GUARDED_BY(mu_);
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RPC_GRPC_SERVER_LIB_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rpc/grpc_state.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rpc/grpc_state.h
new file mode 100644
index 0000000000000000000000000000000000000000..bcf044ff0b87c40fb3da27f90f286347e1fbf293
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rpc/grpc_state.h
@@ -0,0 +1,541 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RPC_GRPC_STATE_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RPC_GRPC_STATE_H_
+
+#include <queue>
+#include <utility>
+
+#include "grpcpp/generic/generic_stub.h"
+#include "grpcpp/grpcpp.h"
+#include "tensorflow/core/distributed_runtime/call_options.h"
+#include "tensorflow/core/distributed_runtime/rpc/grpc_client_cq_tag.h"
+#include "tensorflow/core/distributed_runtime/rpc/grpc_util.h"
+#include "tensorflow/core/distributed_runtime/tensor_coding.h"
+#include "tensorflow/core/lib/core/refcount.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/lib/core/threadpool.h"
+#include "tensorflow/core/lib/strings/strcat.h"
+#include "tensorflow/core/platform/errors.h"
+#include "tensorflow/core/platform/mutex.h"
+#include "tensorflow/core/platform/notification.h"
+#include "tensorflow/core/util/env_var.h"
+#include "tsl/distributed_runtime/rpc/grpc_state.h"
+
+namespace tensorflow {
+// NOLINTBEGIN(misc-unused-using-decls)
+using tsl::RPCState;
+// NOLINTEND(misc-unused-using-decls)
+
+// Represents state associated with one streaming RPC call.
+// Similarly to above, we extract the methods of StreamingRPCState that don't
+// need to be templated into this abstract class.
+// Currently, *StreamingRPCState does not support client closing the call as
+// there is no use case for it - current clients keep the streaming call open
+// as long as possible. If/when the need arises, support can be added
+// by calling GenericClientAsyncReaderWriter::WritesDone with a new tag
+// TagType::kClientFinished and handling the completion in a new callback.
+class UntypedStreamingRPCState : public core::RefCounted {
+ public:
+  virtual void CallStarted(bool ok) = 0;
+  virtual void RequestWriteCompleted(bool ok) = 0;
+  virtual void ResponseReadCompleted(bool ok) = 0;
+  virtual void CallFinished(bool ok) = 0;
+
+  virtual string DebugString() const = 0;
+
+  class Tag : public GrpcClientCQTag {
+   public:
+    // One enum value per supported callback.
+    enum class TagType {
+      kCallStarted,
+      kRequestWriteCompleted,
+      kResponseReadCompleted,
+      kCallFinished,
+    };
+
+    Tag(UntypedStreamingRPCState* streaming_state, Tag::TagType type);
+
+    // Calls the callback associated with this tag and Unrefs
+    // `this->streaming_state_`.
+    void OnCompleted(bool ok) override;
+
+   private:
+    // OnCompleted() consumes on reference each time it is called.
+    UntypedStreamingRPCState* const streaming_state_;
+    const Tag::TagType type_;
+  };
+};
+
+const char* ToString(UntypedStreamingRPCState::Tag::TagType tag_type);
+
+// Represents a single request/response exchange between client and the server.
+// A single streaming call contains a sequence of exchanges. Besides the
+// messages, exchange contains:
+//  - the user callback to invoke when exchange completes (response is received
+//    or an error occurs).
+//  - The current state of the exchange.
+class Exchange {
+ public:
+  enum class State {
+    kExchangeCreated,
+    kRequestWriteIssued,
+    kRequestWriteCompleted,
+    kResponseReadIssued,
+  };
+
+  Exchange(const ::grpc::ByteBuffer& request_buf, protobuf::Message* response,
+           StatusCallback cb, string debug_string)
+      : state_(State::kExchangeCreated),
+        request_buf_(request_buf),
+        response_(response),
+        cb_(std::move(cb)),
+        debug_string_(std::move(debug_string)) {}
+
+  const ::grpc::ByteBuffer& request_buf() { return request_buf_; }
+  ::grpc::ByteBuffer* response_buf() { return &response_buf_; }
+
+  void MarkRequestWriteIssued() {
+    DCHECK(state_ == State::kExchangeCreated);
+    state_ = State::kRequestWriteIssued;
+  }
+  void MarkRequestWriteCompleted() {
+    DCHECK(state_ == State::kRequestWriteIssued);
+    state_ = State::kRequestWriteCompleted;
+  }
+  void MarkResponseReadIssued() {
+    DCHECK(state_ == State::kRequestWriteCompleted);
+    state_ = State::kResponseReadIssued;
+  }
+
+  // If `status` is success, completes this exchange by parsing the
+  // response_buf_ and invoking cb_ with OkStatus(). Else, invokes the
+  // callback with `status`.
+  void Complete(Status status);
+
+  const State& state() const { return state_; }
+
+  string DebugString() const;
+
+ private:
+  State state_;
+  ::grpc::ByteBuffer request_buf_;
+  ::grpc::ByteBuffer response_buf_;
+  protobuf::Message* response_;
+  StatusCallback cb_;
+  string debug_string_;
+};
+
+const char* ToString(Exchange::State s);
+
+std::ostream& operator<<(std::ostream& os, const Exchange::State& state);
+
+// Represents a queue of exchanges.
+// When a client sends a new request a new exchange is created and added to the
+// end of the queue. Completed exchanges are popped from the front of the queue.
+// An explicit exchange queue is needed to brdige the client, which can send new
+// requests at any time, with gRPC infrastructure, which can handle a single
+// read and a single write request at a time.
+//
+// As the exchange progresses (request sending initiated, request sending
+// completed, response reading initiated) the queue helps to make sure that the
+// right operation is issued on the right exchange at the right time.
+//
+// To satisfy gRPC constraints, the states of exchanges must be as follows
+// starting from the front of the queue:
+//  - 0 or 1 exchange in kResponseReadIssued state
+//  - 0 or more exchanges in kRequestWriteCompleted state
+//  - 0 or 1 exchange in kRequestWriteIssued state
+//  - 0 or more exchanges in kExchangeCreated state
+//
+// Thread-compatible.
+class ExchangeQueue {
+ public:
+  // Creates a new exchange and adds it to the end of the queue.
+  void Emplace(const ::grpc::ByteBuffer& request_buf,
+               protobuf::Message* response, StatusCallback cb,
+               std::string debug_string);
+
+  // Returns an exchange for which we can initiate request writing, if any.
+  // Returns nullptr if there is no such exchange.
+  Exchange* GetReadyForRequestWriting();
+
+  // Returns an exchange for which we can initiate response reading, if any.
+  // Returns nullptr if there is no such exchange.
+  Exchange* GetReadyForResponseReading();
+
+  // Changes the state of the exchange that is current in kRequestWriteIssued
+  // state to kRequestWriteCompleted state.
+  // REQUIRES: There is an exchange in kRequestWriteIssued state.
+  void MarkRequestWriteCompleted();
+
+  // Returns the exchange at the front of the queue.
+  // REQUIRES: ExchangeQueue is not empty.
+  Exchange& GetFront();
+
+  // Removes the exchange at the front of the queue.
+  // REQUIRES: ExchangeQueue is not empty.
+  void PopFront();
+
+  // Returns a string containing addresses and states of all exchanges in this
+  // queue.
+  string DebugString() const;
+
+  // Swaps the contents of this and `other`.
+  void Swap(ExchangeQueue* other);
+
+  // Completes all exchanges in this with `status`.
+  void CompleteAll(Status status);
+
+  void CallStarted() { call_started_ = true; }
+
+ private:
+  // Does nothing by default. Turn on VLOG(5) to enable.
+  // Checks that this ExchangeQueue is in a valid state.
+  // Kills the process if not.
+  void CheckInvariants();
+
+  // We can't process any exchanges until the call has started.
+  bool call_started_ = false;
+
+  // std::queue is based on std::deque by default. std::deque provides
+  // fairly strong iterator stability.
+  std::deque<Exchange> exchanges_;
+};  // namespace tensorflow
+
+// Represents state associated with one streaming RPC call.
+// Thread-safe
+template <class Response>
+class StreamingRPCState : public UntypedStreamingRPCState {
+ public:
+  // Default behavior is to set fail_fast = False and handle timeouts
+  // manually.
+  StreamingRPCState(
+      std::unique_ptr<::grpc::GenericClientAsyncReaderWriter> call,
+      const std::shared_ptr<::grpc::ClientContext>& context)
+      : context_(context), call_(std::move(call)), call_state_(State::kActive) {
+    Ref();
+    VLOG(3) << "Created new StreamingRPCState " << this;
+    VLOG(3) << "StreamingRPCState(" << this << ") calling grpc::StartCall";
+    call_->StartCall(&call_started_tag_);
+  }
+
+  ~StreamingRPCState() override {
+    VLOG(3) << "Destructing StreamingRPCState " << this;
+  }
+
+  // Attempts to send the next request. `done` is invoked when
+  // `response` has been filled with the data from the server, or if there
+  // is an error. `done` can be invoked before SendNextRequest returns.
+  // Return `true` if the call is alive and the `done` callback has or
+  // will be invoked. If the call is dead, returns `false`. `done` callback
+  // will not be invoked in this case.
+  // REQUIRES: The call has been started, i.e. WaitForCallStarted() has
+  // returned.
+  bool SendNextRequest(const protobuf::Message& request, Response* response,
+                       const StatusCallback& done) {
+    ::grpc::ByteBuffer request_buf;
+    ::grpc::Status s = tsl::GrpcMaybeUnparseProto(request, &request_buf);
+    if (!s.ok()) {
+      Status status = FromGrpcStatus(s);
+      LOG(ERROR) << "GrpcMaybeUnparseProto returned with non-ok status: "
+                 << status.ToString();
+      done(status);
+      return true;
+    }
+
+    mutex_lock l(mu_);
+    if (call_state_ != State::kActive) {
+      // `done` is not invoked intentionally.
+      return false;
+    }
+    if (VLOG_IS_ON(3)) {
+      // If vlog 3 is enabled, include first 100 chars of request as debug
+      // string.
+      exchanges_.Emplace(request_buf, response, done,
+                         request.ShortDebugString().substr(0, 100));
+    } else {
+      exchanges_.Emplace(request_buf, response, done, "");
+    }
+    MaybeIssueRequestWriteLocked();
+    return true;
+  }
+
+  void CallStarted(bool ok) override {
+    VLOG(3) << "StreamingRPCState(" << this << ")::CallStarted(ok=" << ok
+            << ")";
+    mutex_lock l(mu_);
+    if (!ok) {
+      call_state_ = State::kDone;
+      return;
+    }
+    exchanges_.CallStarted();
+    // Now that the call has started, we can write our first request, if any.
+    MaybeIssueRequestWriteLocked();
+  }
+
+  void RequestWriteCompleted(bool ok) override {
+    VLOG(3) << "StreamingRPCState(" << this
+            << ")::RequestWriteCompleted(ok=" << ok << ")";
+    mu_.lock();
+    if (call_state_ != State::kActive) {
+      mu_.unlock();
+      return;
+    }
+    exchanges_.MarkRequestWriteCompleted();
+    // Issue ResponseRead regardless of OK status on completing RequestWrite.
+    // If the underlying completion queue is in Not-OK status due to previous
+    // request failuress (i.e., `ok` from `Next` call on completion queue is
+    // False), delay the error in ResponseRead so we can get the remote error
+    // message from response buffer.
+    MaybeIssueResponseReadLocked();
+
+    if (ok) {
+      MaybeIssueRequestWriteLocked();
+    }
+    mu_.unlock();
+  }
+
+  void ResponseReadCompleted(bool ok) override {
+    VLOG(3) << "StreamingRPCState(" << this
+            << ")::ResponseReadCompleted(ok=" << ok << ")";
+    mu_.lock();
+    if (call_state_ != State::kActive) {
+      mu_.unlock();
+      return;
+    }
+    if (!ok) {
+      IssueCallFinishLocked();
+      mu_.unlock();
+      return;
+    }
+
+    // Complete the exchange without holding the lock because user's
+    // callback can call back into this RPC code resulting in a deadlock.
+    // No other thread can pop this exchange while we release the lock because
+    // this is the only method that pops exchanges and it is called from a
+    // single thread that waits on completion queue events.
+    Exchange* e;
+    e = &exchanges_.GetFront();
+    mu_.unlock();
+
+    e->Complete(OkStatus());
+
+    {
+      mutex_lock l(mu_);
+      exchanges_.PopFront();
+      MaybeIssueResponseReadLocked();
+    }
+  }
+
+  void CallFinished(bool ok) override {
+    VLOG(3) << "StreamingRPCState(" << this << ")::CallFinished(ok=" << ok
+            << ")";
+    mu_.lock();
+    DCHECK(call_state_ != State::kActive);
+    if (call_state_ != State::kFinishing) {
+      mu_.unlock();
+      return;
+    }
+
+    Status s = FromGrpcStatus(call_status_);
+    if (s.ok() && !ok) {
+      s.Update(
+          errors::Internal("GRPC status is okay but CompletionQueueStatus is "
+                           "not.  This should never happen.",
+                           context_->debug_error_string()));
+    }
+    // unlocks mu_
+    MarkDoneAndCompleteExchanges(s);
+  }
+
+  string DebugString() const override {
+    mutex_lock l(mu_);
+    return exchanges_.DebugString();
+  }
+
+ private:
+  enum class State {
+    kActive,
+    kFinishing,
+    kDone,
+  };
+
+  void MarkDoneAndCompleteExchanges(Status status)
+      TF_EXCLUSIVE_LOCKS_REQUIRED(mu_) TF_UNLOCK_FUNCTION(mu_) {
+    call_state_ = State::kDone;
+    VLOG(2) << "Ending gRPC streaming call on the client side due to "
+            << status.ToString();
+    // Swap the exchanges_ into a temporary ExchangeQueue so that we can
+    // complete all exchanges without holding mu_ in case user callback
+    // reach back into this. This should be impossible now, but safer for
+    // the future.
+    ExchangeQueue queue;
+    exchanges_.Swap(&queue);
+    mu_.unlock();
+    queue.CompleteAll(status);
+  }
+
+  void MaybeIssueRequestWriteLocked() TF_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
+    Exchange* exchange = exchanges_.GetReadyForRequestWriting();
+    if (exchange == nullptr) {
+      // There are no queued exchanges, there is already an outstanding write,
+      // or there are no just created exchanges.
+      return;
+    }
+    exchange->MarkRequestWriteIssued();
+    Ref();
+    VLOG(3) << "StreamingRPCState(" << this << ") calling grpc::Write";
+    call_->Write(exchange->request_buf(), &request_write_completed_tag_);
+  }
+
+  void MaybeIssueResponseReadLocked() TF_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
+    Exchange* exchange = exchanges_.GetReadyForResponseReading();
+    if (exchange == nullptr) {
+      return;
+    }
+    exchange->MarkResponseReadIssued();
+    Ref();
+    VLOG(3) << "StreamingRPCState(" << this << ") calling grpc::Read";
+    call_->Read(exchange->response_buf(), &response_read_completed_tag_);
+  }
+
+  void IssueCallFinishLocked() TF_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
+    call_state_ = State::kFinishing;
+    Ref();
+    VLOG(3) << "StreamingRPCState(" << this << ") calling grpc::Finish";
+    // We call finish in response to completed (with error) response reading tag
+    // on some exchange. We let this exchange hang in ResponseReadIssued state.
+    // ExchangeQueue makes sure that there is at most one exchange in this
+    // state. So, no new reads will be issued.
+    call_->Finish(&call_status_, &finished_tag_);
+  }
+
+  // Holds state for a single request/response exchange between the client
+  // and the server.
+  typedef typename UntypedStreamingRPCState::Tag Tag;
+
+  // Order of context_ and call_ is important because context_ must outlive
+  // call_.
+  const std::shared_ptr<const ::grpc::ClientContext> context_;
+  std::unique_ptr<::grpc::GenericClientAsyncReaderWriter> call_;
+
+  mutable mutex mu_;
+  ExchangeQueue exchanges_ TF_GUARDED_BY(mu_);
+  State call_state_ TF_GUARDED_BY(mu_);
+  ::grpc::Status call_status_ TF_GUARDED_BY(mu_);
+
+  // We can get away with having single instances of these tags per
+  // StreamingRPCState because we make sure (as gRPC requires) that
+  // there is at most one outstanding Read and at most one outstanding Write
+  // in the completion queue.
+  // Tags are immutable. No need to guard them.
+  Tag call_started_tag_{this, Tag::TagType::kCallStarted};
+  Tag request_write_completed_tag_{this, Tag::TagType::kRequestWriteCompleted};
+  Tag response_read_completed_tag_{this, Tag::TagType::kResponseReadCompleted};
+  Tag finished_tag_{this, Tag::TagType::kCallFinished};
+};
+
+// Creates streaming calls and dispatches requests to them.
+// In the common case, the client would create a StreamingRPCDispatcher for
+// each bidirectional streaming RPC it might want to make. The first time, it
+// calls SendNextRequest, a streaming call is initiated and the request is
+// sent within this call. Initiation of the call blocks the client. If there are
+// no errors, subsequent calls to SendNextRequest would use the already active
+// call. If there was an error, the call object will be destroyed after all
+// the callbacks for outstanding requests have been invoked. The next call to
+// SendNextRequest will initiate a new call.
+//
+// Callbacks that are part of the same call, are invoked in the order they were
+// provided, but callbacks across calls (a failed and a new one) can be invoked
+// in any order.
+//
+// Thread-safe.
+template <class Response>
+class StreamingRPCDispatcher {
+ public:
+  StreamingRPCDispatcher(::grpc::GenericStub* stub, ::grpc::CompletionQueue* cq,
+                         const ::grpc::string& method)
+      : stub_(stub), cq_(cq), method_(method) {}
+
+  // Attempts to send the next request. If there is no active streaming call,
+  // starts one and sends the request on top of it. `done` is invoked when
+  // `response` has been filled with the data from the server, or if there
+  // is an error. `done` can be invoked before SendNextRequest returns.
+  void SendNextRequest(const protobuf::Message& request, Response* response,
+                       StatusCallback done) {
+    mutex_lock l(mu_);
+    if (state_ == nullptr) {
+      CreateStreamingState();
+    }
+
+    bool is_call_alive = state_->SendNextRequest(request, response, done);
+    if (is_call_alive) {
+      return;
+    }
+
+    // The attempt to send failed because the call was dead, create a new
+    // call and try again. When the call is dead SendNextRequest does not call
+    // `done`.
+    CreateStreamingState();
+
+    is_call_alive = state_->SendNextRequest(request, response, done);
+    if (!is_call_alive) {
+      // Consider retrying to create and start a call few more times.
+      done(errors::Unknown("gRPC call failed right after it was created"));
+    }
+  }
+
+  // Request to cancel the current streaming call. Non-blocking.
+  void CancelCall() {
+    mutex_lock l(mu_);
+    if (state_ == nullptr) {
+      return;
+    }
+    context_->TryCancel();
+    state_ = nullptr;
+  }
+
+ private:
+  void CreateStreamingState() TF_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
+    // ClientContext cannot be reused across calls.
+    context_ = std::make_shared<::grpc::ClientContext>();
+    // Don't immediately fail StartCall if the channel is not ready. Wait for
+    // the channel to become ready.
+    context_->set_wait_for_ready(true);
+
+    std::unique_ptr<::grpc::GenericClientAsyncReaderWriter> call =
+        stub_->PrepareCall(context_.get(), method_, cq_);
+
+    state_.reset(new StreamingRPCState<Response>(std::move(call), context_));
+  }
+
+  mutable mutex mu_;
+
+  // Both are thread-safe
+  ::grpc::GenericStub* const stub_;
+  ::grpc::CompletionQueue* const cq_;
+
+  // Does not need synchronization since it is constant.
+  const ::grpc::string method_;
+
+  std::shared_ptr<::grpc::ClientContext> context_ TF_GUARDED_BY(mu_);
+  core::RefCountPtr<StreamingRPCState<Response>> state_ TF_GUARDED_BY(mu_);
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RPC_GRPC_STATE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rpc/grpc_tensor_coding.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rpc/grpc_tensor_coding.h
new file mode 100644
index 0000000000000000000000000000000000000000..ffcc4a2bbfa7f48a9475e6345162ec997a4b51e5
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rpc/grpc_tensor_coding.h
@@ -0,0 +1,55 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RPC_GRPC_TENSOR_CODING_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RPC_GRPC_TENSOR_CODING_H_
+
+#include "grpcpp/impl/codegen/byte_buffer.h"
+
+namespace tensorflow {
+class Tensor;
+class RecvTensorResponse;
+
+// TODO(jeff,sanjay): this should not be grpc specific.  Instead of
+// grpc::ByteBuffer*, it should accept an object of an interface type
+// to which owned byte-arrays can be added.
+namespace grpc {
+
+// Encode a RecvTensorResponse protocol buffer into a byte buffer in a
+// format that is parseable as a RecvTensorResponse protocol buffer
+// holding "proto".
+//
+// Discards original contents of *result.
+void EncodeRecvTensorResponseToByteBuffer(const RecvTensorResponse& proto,
+                                          ::grpc::ByteBuffer* result);
+
+// Encode a Tensor into a byte buffer in a format that is parseable
+// as a RecvTensorResponse protocol buffer holding "val".
+//
+// "is_dead" is the value to encode for "RecvTensorResponse::is_dead"
+// (tensor is the output of a dead node and content is invalid because
+// control flow operations elsewhere caused the path on which this
+// Tensor exists to not be taken).
+//
+// "val" holds the tensor value to be encoded.
+//
+// Discards original contents of *result.
+void EncodeTensorToByteBuffer(bool is_dead, const Tensor& val, bool require_ack,
+                              ::grpc::ByteBuffer* result);
+
+}  // namespace grpc
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RPC_GRPC_TENSOR_CODING_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rpc/grpc_util.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rpc/grpc_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..a54dfec1542411771137ccd6c7b26c212886d948
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rpc/grpc_util.h
@@ -0,0 +1,73 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RPC_GRPC_UTIL_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RPC_GRPC_UTIL_H_
+
+#include <memory>
+#include <string>
+
+#include "grpcpp/grpcpp.h"
+#include "grpcpp/impl/codegen/proto_utils.h"
+#include "grpcpp/support/byte_buffer.h"
+#include "tensorflow/core/distributed_runtime/tensor_coding.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/lib/strings/stringprintf.h"
+#include "tensorflow/core/platform/protobuf.h"
+#include "tsl/distributed_runtime/rpc/grpc_util.h"
+
+namespace tensorflow {
+// NOLINTBEGIN(misc-unused-using-decls)
+using tsl::ComputeBackoffMicroseconds;
+using tsl::FromGrpcStatus;
+using tsl::SharedGrpcChannelPtr;
+using tsl::ToGrpcStatus;
+// NOLINTEND(misc-unused-using-decls)
+
+// Thin wrapper around ::grpc::ProtoBufferReader to give TensorResponse
+// an efficient byte reader from which to decode a RecvTensorResponse.
+class GrpcByteSource : public TensorResponse::Source {
+ public:
+  explicit GrpcByteSource(::grpc::ByteBuffer* buffer) : buffer_(buffer) {}
+  ~GrpcByteSource() override { DeleteStream(); }
+
+  typedef ::grpc::ProtoBufferReader Reader;
+
+  protobuf::io::ZeroCopyInputStream* contents() override {
+    DeleteStream();
+    stream_ = new (&space_) Reader(buffer_);
+    return stream_;
+  }
+
+ private:
+  void DeleteStream() {
+    if (stream_) {
+      stream_->~Reader();
+    }
+  }
+
+  ::grpc::ByteBuffer* buffer_;  // Not owned
+  Reader* stream_ = nullptr;    // Points into space_ if non-nullptr
+  char space_[sizeof(Reader)];
+};
+
+inline string GrpcIdKey() { return "tf-rpc"; }
+
+// Decode a TensorResponse without extra copying. This function is an optimized
+// variant of tsl::GrpcMaybeParseProto.
+bool GrpcMaybeParseTensorResponse(::grpc::ByteBuffer* src, TensorResponse* dst);
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RPC_GRPC_UTIL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rpc/grpc_worker_cache.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rpc/grpc_worker_cache.h
new file mode 100644
index 0000000000000000000000000000000000000000..2dfbc79aa8aad68a48e2f3a2dd3d12eecccf85df
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rpc/grpc_worker_cache.h
@@ -0,0 +1,76 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RPC_GRPC_WORKER_CACHE_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RPC_GRPC_WORKER_CACHE_H_
+
+#include "tensorflow/core/distributed_runtime/rpc/grpc_channel.h"
+#include "tensorflow/core/distributed_runtime/rpc/grpc_client_cq_tag.h"
+#include "tensorflow/core/distributed_runtime/worker_cache.h"
+#include "tensorflow/core/platform/env.h"
+#include "tensorflow/core/platform/threadpool.h"
+
+namespace tensorflow {
+
+class GrpcWorkerEnv {
+ public:
+  GrpcWorkerEnv(size_t num_completion_queues, size_t num_threads);
+
+  ~GrpcWorkerEnv();
+
+  thread::ThreadPool* GetThreadPool() const { return threadpool_.get(); }
+
+  size_t CompletionQueueSize() const { return threads_.size(); }
+
+  ::grpc::CompletionQueue* GetCompletionQueue(size_t index) const {
+    return threads_.at(index).completion_queue();
+  }
+
+ private:
+  // Thread wrapping class that drives work over a single gRPC
+  // CompletionQueue.
+  class GrpcWorkerCacheThread {
+   public:
+    GrpcWorkerCacheThread();
+
+    ~GrpcWorkerCacheThread();
+
+    ::grpc::CompletionQueue* completion_queue() const {
+      return &completion_queue_;
+    }
+
+   private:
+    mutable ::grpc::CompletionQueue completion_queue_;
+    std::unique_ptr<Thread> thread_;
+  };
+
+  std::unique_ptr<thread::ThreadPool> threadpool_;
+  std::vector<GrpcWorkerCacheThread> threads_;
+};
+
+// Create a GrpcWorkerEnv instance that can be used as argument to create
+// gRPC worker cache. Caller should take the ownership of the returned instance.
+GrpcWorkerEnv* CreateGrpcWorkerEnv();
+
+// The returned WorkerCacheInterface object takes the ownership of "cc".
+WorkerCacheInterface* NewGrpcWorkerCache(std::shared_ptr<GrpcChannelCache> cc,
+                                         GrpcWorkerEnv* worker_env);
+
+WorkerCacheInterface* NewGrpcWorkerCacheWithLocalWorker(
+    std::shared_ptr<GrpcChannelCache> cc, GrpcWorkerEnv* worker_env,
+    WorkerInterface* local_worker, const string& local_target);
+
+}  // namespace tensorflow
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RPC_GRPC_WORKER_CACHE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rpc/grpc_worker_service.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rpc/grpc_worker_service.h
new file mode 100644
index 0000000000000000000000000000000000000000..6fd9f6ba61c40113c1abca1ad735931143337112
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rpc/grpc_worker_service.h
@@ -0,0 +1,92 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RPC_GRPC_WORKER_SERVICE_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RPC_GRPC_WORKER_SERVICE_H_
+
+#include <memory>
+#include <unordered_map>
+
+#include "grpcpp/server_builder.h"
+#include "tensorflow/core/distributed_runtime/rpc/grpc_worker_service_impl.h"
+#include "tensorflow/core/distributed_runtime/rpc/rpc_response_cache.h"
+#include "tensorflow/core/distributed_runtime/worker.h"
+#include "tensorflow/core/protobuf/worker.pb.h"
+#include "tsl/distributed_runtime/rpc/async_service_interface.h"
+
+namespace grpc {
+class ByteBuffer;
+}  // namespace grpc
+
+namespace tsl {
+class AsyncServiceInterface;
+}
+
+namespace tensorflow {
+
+class ConfigProto;
+struct WorkerEnv;
+class WorkerSession;
+class RpcResponseCache;
+
+class GrpcWorker : public Worker {
+ public:
+  GrpcWorker(WorkerEnv* env, const ConfigProto& config);
+
+  // Specialized version of RecvTensor for gRPC, which avoids a copy.
+  virtual void GrpcRecvTensorAsync(CallOptions* opts,
+                                   const RecvTensorRequest* request,
+                                   ::grpc::ByteBuffer* response,
+                                   StatusCallback done);
+
+  void LoggingAsync(const LoggingRequest* request, LoggingResponse* response,
+                    StatusCallback done) override;
+
+  void RecvBufAsync(CallOptions* opts, const RecvBufRequest* request,
+                    RecvBufResponse* response, StatusCallback done) override;
+
+  void CleanupGraphAsync(const CleanupGraphRequest* request,
+                         CleanupGraphResponse* response,
+                         StatusCallback done) override;
+
+  WorkerEnv* env();
+
+  void EnableResponseCache();
+
+  void RemoveCacheEntryForId(int64_t request_id);
+
+ private:
+  std::unique_ptr<RpcResponseCache> response_cache_;
+  const int32 recv_buf_max_chunk_;
+};
+
+std::unique_ptr<GrpcWorker> NewGrpcWorker(WorkerEnv* worker_env,
+                                          const ConfigProto& config);
+
+struct GrpcWorkerServiceOptions {
+  // Map from GrpcWorkerMethod id to queue depth.  If set this overrides the
+  // default queue depth for a method.
+  std::unordered_map<int, int> queue_depth;
+  int num_serving_threads = 8;
+};
+
+// Returns an implementation of WorkerService rpc service.
+std::unique_ptr<tsl::AsyncServiceInterface> NewGrpcWorkerService(
+    GrpcWorker* worker, ::grpc::ServerBuilder* builder,
+    GrpcWorkerServiceOptions options = GrpcWorkerServiceOptions());
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RPC_GRPC_WORKER_SERVICE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rpc/grpc_worker_service_impl.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rpc/grpc_worker_service_impl.h
new file mode 100644
index 0000000000000000000000000000000000000000..25f5ec9774dfcdc3a9d673c15568292e9b9a8f9f
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rpc/grpc_worker_service_impl.h
@@ -0,0 +1,118 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RPC_GRPC_WORKER_SERVICE_IMPL_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RPC_GRPC_WORKER_SERVICE_IMPL_H_
+
+#include "grpcpp/impl/codegen/async_stream.h"
+#include "grpcpp/impl/codegen/async_unary_call.h"
+#include "grpcpp/impl/codegen/proto_utils.h"
+#include "grpcpp/impl/codegen/rpc_method.h"
+#include "grpcpp/impl/codegen/service_type.h"
+#include "grpcpp/impl/codegen/status.h"
+#include "grpcpp/impl/codegen/stub_options.h"
+#include "grpcpp/impl/codegen/sync_stream.h"
+#include "grpcpp/support/byte_buffer.h"
+
+#include "tensorflow/core/distributed_runtime/rpc/grpc_util.h"
+#include "tensorflow/core/distributed_runtime/tensor_coding.h"
+#include "tensorflow/core/protobuf/worker.pb.h"
+
+namespace grpc {
+
+// Support parsing/unparsing of tensorflow::TensorResponse.
+// Wire-format is identical to RecvTensorResponse.
+// This is specializing an existing template, so it's okay to do this in a
+// namespace that we don't own.
+template <>
+class SerializationTraits<tensorflow::TensorResponse> {
+ public:
+  static Status Serialize(const tensorflow::TensorResponse& msg, ByteBuffer* bp,
+                          bool* own_buffer) {
+    LOG(FATAL) << "TODO(sanjay,jeff): Implement";
+    return Status();
+  }
+  static Status Deserialize(ByteBuffer* buffer,
+                            tensorflow::TensorResponse* msg) {
+    if (buffer == nullptr) {
+      return Status(StatusCode::INTERNAL, "No payload");
+    }
+    Status result = Status::OK;
+    if (result.ok()) {
+      ::tensorflow::GrpcByteSource source(buffer);
+      auto s = msg->ParseFrom(&source);
+      if (!s.ok()) {
+        result = Status(StatusCode::INTERNAL,
+                        ::tensorflow::strings::StrCat(
+                            "TensorResponse parse error", s.message()));
+      }
+    }
+    buffer->Clear();
+    return result;
+  }
+};
+
+}  // namespace grpc
+
+namespace tensorflow {
+
+// Names of worker methods.
+enum class GrpcWorkerMethod {
+  kGetStatus,
+  kCreateWorkerSession,
+  kDeleteWorkerSession,
+  kRegisterGraph,
+  kDeregisterGraph,
+  kRunGraph,
+  kCleanupGraph,
+  kCleanupAll,
+  kRecvTensor,
+  kRecvBuf,
+  kLogging,
+  kTracing,
+  kCompleteGroup,
+  kCompleteInstance,
+  kGetStepSequence,
+  kMarkRecvFinished,
+};
+
+static const int kGrpcNumWorkerMethods =
+    static_cast<int>(GrpcWorkerMethod::kMarkRecvFinished) + 1;
+
+const char* GrpcWorkerMethodName(GrpcWorkerMethod id);
+
+namespace grpc {
+
+// Implementation of `tensorflow.WorkerService`, based on the
+// definition in "//tensorflow/core/protobuf/worker_service.proto",
+// and the gRPC generated stub and service classes.
+// See the proto file for the definition of methods and messages.
+class WorkerService final {
+ public:
+  class AsyncService : public ::grpc::Service {
+   public:
+    AsyncService();
+    virtual ~AsyncService();
+
+    // Make RequestAsyncUnary public for grpc_call.h
+    using ::grpc::Service::RequestAsyncUnary;
+  };
+};
+
+}  // namespace grpc
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RPC_GRPC_WORKER_SERVICE_IMPL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rpc/rpc_rendezvous_mgr.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rpc/rpc_rendezvous_mgr.h
new file mode 100644
index 0000000000000000000000000000000000000000..42eda4ea71aef7cdf2bf8ea06928ed25169360f1
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rpc/rpc_rendezvous_mgr.h
@@ -0,0 +1,60 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RPC_RPC_RENDEZVOUS_MGR_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RPC_RPC_RENDEZVOUS_MGR_H_
+
+#include "tensorflow/core/distributed_runtime/base_rendezvous_mgr.h"
+#include "tensorflow/core/distributed_runtime/worker_env.h"
+#include "tensorflow/core/platform/macros.h"
+
+namespace tensorflow {
+
+class DeviceMgr;
+
+// RendezvousMgr keeps track of a set of local rendezvous instances.
+// All tensors sent by this worker are buffered in a RendezvousMgr
+// until the tensor is received.  Each global unique "step_id"
+// corresponds to one local rendezvous instance managed by a
+// RendezvousMgr.
+//
+// E.g.,
+//   Rendezvous* rendez = worker_env->rendezvous_mgr->Find(0x8935);
+//   fork execution of an graph executor using "rendez"  on thread 1;
+//   fork execution of another graph executor using "rendez" on thread 2;
+//   ...
+//   join threads 1 and 2;
+//
+// In the example above, execution in thread 1 and 2 communicates with
+// each other by send/recv operations through the "rend".
+//
+// Tensors sent and recved through rendezvous managed by this
+// RendezvousMgr must have keys generated by Rendezvous::CreateKey.
+class RpcRendezvousMgr : public BaseRendezvousMgr {
+ public:
+  explicit RpcRendezvousMgr(const WorkerEnv* env);
+
+ protected:
+  tsl::core::RefCountPtr<BaseRemoteRendezvous> Create(
+      int64_t step_id, const WorkerEnv* worker_env) override;
+
+ private:
+  RpcRendezvousMgr(const RpcRendezvousMgr&) = delete;
+  void operator=(const RpcRendezvousMgr&) = delete;
+};
+
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RPC_RPC_RENDEZVOUS_MGR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rpc/rpc_response_cache.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rpc/rpc_response_cache.h
new file mode 100644
index 0000000000000000000000000000000000000000..c7c7567fa2ba2f6fa6ea4ccd09b15e0aa49164c9
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rpc/rpc_response_cache.h
@@ -0,0 +1,97 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RPC_RPC_RESPONSE_CACHE_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RPC_RPC_RESPONSE_CACHE_H_
+
+#include <memory>
+#include <unordered_map>
+#include <vector>
+
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/lib/core/errors.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/lib/gtl/flatmap.h"
+#include "tensorflow/core/platform/mutex.h"
+
+// gRPC response caching.  Most WorkerService methods cannot be retried directly
+// as they will fail or deadlock.  To enable retrying, we can instead cache
+// responses and reply to duplicate requests from the cache. The cache will be
+// cleaned when the MarkRecvFinishedRequest is received from the receiver or the
+// session step is completed.
+namespace tensorflow {
+
+// Track and cache the state of worker service RPCs.  An RPC can be in 3 states:
+//
+// * PENDING: this is the first call of the RPC, and it will transition to
+// * ACTIVE: another thread is active processing this RPC
+// * FINISHED: the worker has finished processing the method
+
+class RpcResponseCache {
+ public:
+  using FinishResponseCB = std::function<void(
+      const Tensor& tensor, bool is_dead, const Status& status)>;
+
+  // Add the given request to the cache.
+  // If the request is in the cache,
+  //    If it is finished, invoke `cb` immediately
+  //    If active, cb will be invoked when the current call completes.
+  //    In either case, return true.
+  // Otherwise, store the request and cb in the cache, and return false.
+  // Note FinishResponseCB is assumed to be thread-safe.
+  bool QueueRequest(int64_t request_id, int64_t step_id,
+                    const FinishResponseCB& cb);
+
+  // Fill the response cache for the given request_id and respond to all
+  // pending request.
+  void RequestFinished(int64_t request_id, const Tensor& tensor, bool is_dead,
+                       const Status& status);
+
+  // Erase the cache entry with the given request_id
+  void EraseRequestId(int64_t request_id);
+
+  // Erase cache entries with the given step_id
+  void CleanEntriesForStep(int64_t step_id);
+
+  int64_t size();
+
+ private:
+  struct ResponseCacheEntry {
+    enum class State {
+      PENDING = 0,
+      ACTIVE = 1,
+      FINISHED = 2,
+    };
+
+    State state = State::PENDING;
+    int64_t step_id = -1;
+    Tensor tensor;
+    bool is_dead = false;
+    Status response_status;
+
+    void FinishResponse(const FinishResponseCB& cb) const {
+      cb(tensor, is_dead, response_status);
+    }
+    std::vector<FinishResponseCB> callbacks;
+  };
+
+  mutex mu_;
+  // response_cache_ is expected to be small, as entries are cleared immediately
+  // on ack from the receiver.
+  gtl::FlatMap<int64_t, ResponseCacheEntry> response_cache_ TF_GUARDED_BY(mu_);
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RPC_RPC_RESPONSE_CACHE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rpc_collective_executor_mgr.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rpc_collective_executor_mgr.h
new file mode 100644
index 0000000000000000000000000000000000000000..0e775093813e31d8c294d69b65adbedeee9a679d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/rpc_collective_executor_mgr.h
@@ -0,0 +1,94 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RPC_COLLECTIVE_EXECUTOR_MGR_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RPC_COLLECTIVE_EXECUTOR_MGR_H_
+
+#include "tensorflow/core/common_runtime/collective_executor_mgr.h"
+#include "tensorflow/core/framework/collective.h"
+
+namespace tensorflow {
+class CollectiveParamResolverDistributed;
+class ConfigProto;
+class DeviceMgr;
+class DeviceResolverDistributed;
+class WorkerCacheInterface;
+class StepSequenceRequest;
+class StepSequenceResponse;
+
+// An implementation of CollectiveExecutorMgr for a distributed environment
+// that uses WorkerInterface::RecvBufAsync to route data transfers over RPCs.
+//
+// In some execution environments it may be possible to implement a
+// higher-performance solution and use it in place of this class.
+class RpcCollectiveExecutorMgr : public CollectiveExecutorMgr {
+ public:
+  RpcCollectiveExecutorMgr(
+      const ConfigProto& config, const DeviceMgr* dev_mgr,
+      std::unique_ptr<DeviceResolverDistributed> dev_resolver,
+      std::unique_ptr<CollectiveParamResolverDistributed> param_resolver,
+      std::unique_ptr<NcclCommunicatorInterface> nccl_communicator,
+      WorkerCacheInterface* worker_cache, const string& task_name);
+
+  virtual ~RpcCollectiveExecutorMgr();
+
+  // This function should only be called at the group_leader, by an RPC.
+  // Other needs for StepIds should be satisfied by NextStepId.
+  void GetStepSequenceAsync(const GetStepSequenceRequest* request,
+                            GetStepSequenceResponse* response,
+                            const StatusCallback& done) override;
+
+  void RefreshStepIdSequenceAsync(int64_t graph_key,
+                                  const StatusCallback& done) override;
+
+  int64_t NextStepId(int64_t graph_key) override;
+
+  void RetireStepId(int64_t graph_key, int64_t step_id) override;
+
+ protected:
+  virtual CollectiveExecutor* Create(int64_t step_id) override;
+
+  WorkerCacheInterface* const worker_cache_;  // Not owned.
+  const string task_name_;
+  string group_leader_;
+  friend class RpcCollectiveExecutorMgrTest;
+
+ private:
+  Status UpdateStepSequences(const GetStepSequenceResponse& resp);
+
+  // This class maintains the step_id sequencing for a single
+  // collective_graph_key.
+  struct GraphKeySequence {
+    explicit GraphKeySequence(int64_t k)
+        : graph_key_(k), next_step_id_(CollectiveExecutor::kInvalidId) {}
+
+    const int64_t graph_key_;
+    int64_t next_step_id_;
+  };
+
+  mutex sequence_mu_;
+  gtl::FlatMap<int64_t, GraphKeySequence*> sequence_table_
+      TF_GUARDED_BY(sequence_mu_);
+};
+
+// Creates a distributed CollectiveExecutorMgr with production implementations
+// of each components. Cases that need to inject other implementations of these
+// components should call CollectiveExecutorMgr constructor directly.
+std::unique_ptr<RpcCollectiveExecutorMgr> CreateProdRpcCollectiveExecutorMgr(
+    const ConfigProto& config, const DeviceMgr* device_mgr,
+    std::unique_ptr<NcclCommunicatorInterface> nccl_communicator,
+    WorkerCacheInterface* worker_cache, const string& default_worker_name);
+
+}  // namespace tensorflow
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_RPC_COLLECTIVE_EXECUTOR_MGR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/scheduler.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/scheduler.h
new file mode 100644
index 0000000000000000000000000000000000000000..4385db786ff38ac75aa883ea2a67455562ac1ddc
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/scheduler.h
@@ -0,0 +1,121 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_SCHEDULER_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_SCHEDULER_H_
+
+#include <deque>
+#include <functional>
+#include <map>
+#include <unordered_map>
+#include <vector>
+
+#include "tensorflow/core/common_runtime/device.h"
+#include "tensorflow/core/common_runtime/device_set.h"
+#include "tensorflow/core/graph/costmodel.h"
+
+namespace tensorflow {
+
+class SlackAnalysis {
+ public:
+  SlackAnalysis(const Graph* g, const CostModel* cost_model);
+
+  ~SlackAnalysis() {}
+
+  // Compute the earliest possible start time for each node, based on
+  // a given cost model. 'asap_time' is indexed by node id.
+  Microseconds ComputeAsap(std::vector<Microseconds>* asap_times);
+
+  // Compute the latest possible start time for each node, based on
+  // a given cost model. 'alap_time' is indexed by node id.
+  Microseconds ComputeAlap(std::vector<Microseconds>* alap_times);
+
+  // Compute the "slack" of each node. 'slacks' is indexed by node id.
+  void ComputeSlack(std::vector<int64_t>* slacks);
+
+ private:
+  const Graph* graph_;
+  const CostModel* cost_model_;
+
+  SlackAnalysis(const SlackAnalysis&) = delete;
+  void operator=(const SlackAnalysis&) = delete;
+};
+
+class GreedyScheduler {
+ public:
+  struct Sim {
+    int degree_parallelism;
+    int num_running;
+    std::vector<const Node*> ready_nodes;
+  };
+
+  struct Event {
+    const Node* node;
+    Microseconds time;
+    bool is_completion;
+
+    bool operator<(const Event& other) const { return time < other.time; }
+  };
+
+  GreedyScheduler(const DeviceSet* devices, const CostModel* cost_model,
+                  const Graph* g, std::vector<int64_t>* priority);
+
+  ~GreedyScheduler();
+
+  // Computes the start time of each node given the priorities of
+  // the nodes.
+  Microseconds ComputeSchedule(std::vector<Microseconds>* start_times);
+
+ private:
+  // Returns the ready node with the highest priority for a sim.
+  const Node* GetNodeWithHighestPriority(const std::vector<const Node*>& nodes);
+
+  const DeviceSet* devices_;
+  const CostModel* cost_model_;
+  const Graph* graph_;
+  std::vector<int64_t>* priority_;
+  std::unordered_map<string, Sim*> device_states_;
+
+  GreedyScheduler(const GreedyScheduler&) = delete;
+  void operator=(const GreedyScheduler&) = delete;
+};
+
+class PriorityScheduler {
+ public:
+  PriorityScheduler(const DeviceSet* devices, const CostModel* cost_model,
+                    const Graph* g);
+
+  ~PriorityScheduler() {}
+
+  // Computes a schedule of the ideal start time for each node.
+  // Returns the makespan (the total running time).
+  Microseconds ComputeSchedule(std::vector<Microseconds>* start_times);
+
+  // Computes a schedule and assigns priorities to the nodes based on
+  // the schedule. Returns the makespan.
+  Microseconds AssignPriorities(std::vector<int64_t>* priorities);
+
+ private:
+  const DeviceSet* devices_;
+  const CostModel* cost_model_;
+  const Graph* graph_;
+
+  PriorityScheduler(const PriorityScheduler&) = delete;
+  void operator=(const PriorityScheduler&) = delete;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_SCHEDULER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/server_lib.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/server_lib.h
new file mode 100644
index 0000000000000000000000000000000000000000..3a5ca1853889bc387789ecd36dfd610b437093da
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/server_lib.h
@@ -0,0 +1,134 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_SERVER_LIB_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_SERVER_LIB_H_
+
+#include <memory>
+
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/platform/macros.h"
+#include "tensorflow/core/protobuf/tensorflow_server.pb.h"
+
+namespace tsl {
+class CoordinationServiceAgent;
+}  // namespace tsl
+
+namespace tensorflow {
+
+class DeviceMgr;
+class EagerContext;
+class WorkerEnv;
+class MasterEnv;
+
+// This library supports a registration/factory-based mechanism for
+// creating TensorFlow server objects. Each server implementation must
+// have an accompanying implementation of ServerFactory, and create a
+// static "registrar" object that calls `ServerFactory::Register()`
+// with an instance of the factory class. See "rpc/grpc_server_lib.cc"
+// for an example.
+
+// Represents a single TensorFlow server that exports Master and Worker
+// services.
+class ServerInterface {
+ public:
+  ServerInterface() {}
+  virtual ~ServerInterface() {}
+
+  // Starts the server running asynchronously. Returns OK on success, otherwise
+  // returns an error.
+  virtual Status Start() = 0;
+
+  // Stops the server asynchronously. Returns OK on success, otherwise returns
+  // an error.
+  //
+  // After calling `Stop()`, the caller may call `Join()` to block until the
+  // server has stopped.
+  virtual Status Stop() = 0;
+
+  // Blocks until the server has stopped. Returns OK on success, otherwise
+  // returns an error.
+  virtual Status Join() = 0;
+
+  // Returns a target string that can be used to connect to this server using
+  // `tensorflow::NewSession()`.
+  virtual const string target() const = 0;
+
+  virtual WorkerEnv* worker_env() = 0;
+  virtual MasterEnv* master_env() = 0;
+
+  // Update the set of workers that can be reached by the server
+  virtual Status UpdateServerDef(const ServerDef& server_def) = 0;
+
+  // Functions to operate on service-specific properties.
+  //
+  // Add master eager context to local eager service in order to handle enqueue
+  // requests from remote workers.
+  virtual Status AddMasterEagerContextToEagerService(
+      const tensorflow::uint64 context_id, EagerContext* context) = 0;
+  // Set coordination service agent instance to coordination service RPC handler
+  virtual Status SetCoordinationServiceAgentInstance(
+      tsl::CoordinationServiceAgent* agent) = 0;
+  // TODO(hanyangtay): Remove this method once gRPC server clean shutdown is
+  // supported.
+  virtual Status StopCoordinationService() = 0;
+
+ private:
+  ServerInterface(const ServerInterface&) = delete;
+  void operator=(const ServerInterface&) = delete;
+};
+
+class ServerFactory {
+ public:
+  struct Options {
+    // Local DeviceMgr to use.
+    tensorflow::DeviceMgr* local_device_mgr;
+  };
+  // Creates a new server based on the given `server_def`, and stores
+  // it in `*out_server`. Returns OK on success, otherwise returns an
+  // error.
+  virtual Status NewServer(const ServerDef& server_def, const Options& options,
+                           std::unique_ptr<ServerInterface>* out_server) = 0;
+
+  // Returns true if and only if this factory can create a server
+  // based on the given `server_def`.
+  virtual bool AcceptsOptions(const ServerDef& server_def) = 0;
+
+  virtual ~ServerFactory() {}
+
+  // For each `ServerFactory` subclass, an instance of that class must
+  // be registered by calling this method.
+  //
+  // The `server_type` must be unique to the server factory.
+  static void Register(const string& server_type, ServerFactory* factory);
+
+  // Looks up a factory that can create a server based on the given
+  // `server_def`, and stores it in `*out_factory`. Returns OK on
+  // success, otherwise returns an error.
+  static Status GetFactory(const ServerDef& server_def,
+                           ServerFactory** out_factory);
+};
+
+// Creates a server based on the given `server_def`, and stores it in
+// `*out_server`. Returns OK on success, otherwise returns an error.
+Status NewServer(const ServerDef& server_def,
+                 std::unique_ptr<ServerInterface>* out_server);
+Status NewServerWithOptions(const ServerDef& server_def,
+                            const ServerFactory::Options& options,
+                            std::unique_ptr<ServerInterface>* out_server);
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_SERVER_LIB_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/session_mgr.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/session_mgr.h
new file mode 100644
index 0000000000000000000000000000000000000000..fc16faa9ccbc2bf540f6fbb567df1ad3e0795657
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/session_mgr.h
@@ -0,0 +1,164 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_SESSION_MGR_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_SESSION_MGR_H_
+
+#include <functional>
+#include <string>
+
+#include "tensorflow/core/distributed_runtime/worker_session.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/platform/mutex.h"
+#include "tensorflow/core/platform/thread_annotations.h"
+#include "tensorflow/core/protobuf/tensorflow_server.pb.h"
+#include "tensorflow/core/protobuf/worker.pb.h"
+#include "tsl/distributed_runtime/coordination/coordination_service.h"
+#include "tsl/distributed_runtime/coordination/coordination_service_agent.h"
+#include "tsl/distributed_runtime/coordination/coordination_service_rpc_handler.h"
+
+namespace tensorflow {
+
+class WorkerCacheInterface;
+struct WorkerEnv;
+
+// SessionMgr keeps track of information related to a given session.
+//
+// SessionMgr runs on the workers.
+//
+// SessionMgr is threadsafe.
+class SessionMgr {
+ public:
+  typedef std::function<Status(const ServerDef&, WorkerCacheInterface**)>
+      WorkerCacheFactory;
+
+  explicit SessionMgr(
+      WorkerEnv* worker_env, const std::string& default_worker_name,
+      std::unique_ptr<WorkerCacheInterface> default_worker_cache,
+      WorkerCacheFactory worker_cache_factory,
+      tsl::CoordinationServiceRpcHandler* coordination_handler);
+  ~SessionMgr() {}
+
+  // Allocates state for a new session.
+  Status CreateSession(
+      const std::string& session, const ServerDef& server_def,
+      bool isolate_session_state,
+      StatusCallback coordination_error_callback = [](Status s) {
+        LOG(ERROR) << "Coordination agent is set to error: " << s;
+      });
+  Status CreateSession(
+      const std::string& session, const ServerDef& server_def,
+      const protobuf::RepeatedPtrField<DeviceAttributes>& device_attributes,
+      bool isolate_session_state);
+
+  // Create WorkerSession from the master with the given `master_task` and
+  // `master_incarnation`. We first look for existing WorkerSessions associated
+  // with the specified master task. If there are sessions created by the same
+  // master but with a different incarnation, it indicates that the remote
+  // master has restarted before deleting the sessions on worker. When it
+  // happens, old sessions associated with the master will be automatically
+  // removed before the new session is created.
+  Status CreateSession(
+      const std::string& session, const ServerDef& server_def,
+      const protobuf::RepeatedPtrField<DeviceAttributes>& device_attributes,
+      bool isolate_session_state, std::string master_task,
+      int64_t master_incarnation,
+      StatusCallback coordination_error_callback = [](Status s) {
+        LOG(ERROR) << "Coordination agent is set to error: " << s;
+      });
+
+  void ResetDefaultWorkerCache(WorkerCacheInterface* worker_cache);
+
+  // Updates state (worker cache, devices) of worker session identified by
+  // session name (`session`) based on a new server_def and set of devices.
+  Status UpdateSession(const std::string& session, const ServerDef& server_def,
+                       const protobuf::RepeatedPtrField<DeviceAttributes>&
+                           cluster_device_attributes);
+
+  // Locates the worker session for a given session handle
+  Status WorkerSessionForSession(const std::string& session_handle,
+                                 std::shared_ptr<WorkerSession>* out_session);
+  std::shared_ptr<WorkerSession> LegacySession();
+
+  Status DeleteSession(const std::string& session);
+
+  // Provides access to the coordination service agent. This method should only
+  // be called after the agent has been initialized during session creation, or
+  // an invalid nullptr is returned. Note: the agent is thread-safe and mutable.
+  tsl::CoordinationServiceAgent* GetCoordinationServiceAgent();
+
+  static std::string WorkerNameFromServerDef(const ServerDef& server_def);
+
+  void SetLogging(bool active);
+
+  void RetrieveLogs(int64_t step_id, LoggingResponse* response);
+
+  void ClearLogs();
+
+  // Agent should be torn down before service as it needs to disconnect first.
+  void TeardownCoordinationServiceAgent();
+  void TeardownCoordinationService();
+
+ private:
+  WorkerEnv* const worker_env_;  // Not owned.
+
+  // A note about destruction:
+  // We must delete graph_mgr before device_mgr, due to shared
+  // ownership of OpKernels in the executors. (The graph_mgr will
+  // free all stateless OpKernels, and pass over borrowed stateful
+  // OpKernels, which are also held in their respective devices'
+  // OpSegments.)
+  //
+  // legacy_session_ owns the worker_env_.device_mgr, and so we must ensure
+  // that sessions_'s WorkerSessions are deleted (which do not own the
+  // underlying devices, but instead own RenamedDevices) before
+  // legacy_session_ is deleted. Further, we must ensure that WorkerSession's
+  // device_mgr is deleted after WorkerSession's graph_mgr.
+
+  std::unique_ptr<WorkerCacheInterface> default_worker_cache_;
+  std::shared_ptr<WorkerSession> legacy_session_;
+  std::unique_ptr<tsl::CoordinationServiceInterface> coordination_service_;
+  std::unique_ptr<tsl::CoordinationServiceAgent> coordination_service_agent_;
+
+  bool is_logging_active_ = false;
+
+  const WorkerCacheFactory worker_cache_factory_;
+
+  // Not owned. And should only be used for setting the coordination service.
+  tsl::CoordinationServiceRpcHandler* coordination_handler_ = nullptr;
+
+  Status WorkerSessionForSessionLocked(
+      const std::string& session_handle,
+      std::shared_ptr<WorkerSession>* out_session)
+      TF_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+
+  mutex mu_;
+  // A map from session identifier to internal session structure.
+  std::map<std::string, std::shared_ptr<WorkerSession>> sessions_
+      TF_GUARDED_BY(mu_);
+
+  // Incarnation and WorkerSession handle associated with a master task.
+  struct MasterAssociatedSession {
+    const int64_t master_incarnation;
+    const std::string session_handle;
+  };
+  // A map from master task name to its associated worker sessions.
+  std::unordered_multimap<std::string, MasterAssociatedSession>
+      master_to_associated_sessions_ TF_GUARDED_BY(mu_);
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_SESSION_MGR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/tensor_coding.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/tensor_coding.h
new file mode 100644
index 0000000000000000000000000000000000000000..b517bac4222956e2e87efbae188b9339ae1efabd
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/tensor_coding.h
@@ -0,0 +1,110 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_TENSOR_CODING_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_TENSOR_CODING_H_
+
+#include "tensorflow/core/framework/allocator.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/platform/protobuf.h"
+#include "tensorflow/core/platform/types.h"
+#include "tensorflow/core/protobuf/worker.pb.h"
+
+namespace tensorflow {
+
+class DeviceBase;
+class TensorProto;
+
+// TensorResponse can be used as the destination of an RPC that returns
+// a RecvTensorResponse.  It efficiently decodes the incoming data
+// into Tensor contents as well as associated metadata.
+class TensorResponse {
+ public:
+  TensorResponse() {}
+
+  // Reset to initial state.
+  void Clear();
+
+  // Clear just tensor_ and meta_ members without setting allocation
+  // related members.
+  void ClearTensor();
+
+  // Initialize memory allocation related members.
+  void InitAlloc(DeviceBase* d, const AllocatorAttributes& aa);
+
+  // Source provides a way for a particular RPC implementation to provide
+  // received data to ParseFrom.
+  class Source {
+   public:
+    virtual ~Source();
+
+    // Return the stream that contains the data to be parsed.
+    // Note that this method might be invoked more than once if
+    // ParseFrom needs to fall back to a more expensive parsing method.
+    // Every call must return a stream pointing at the beginning of
+    // the serialized RecvTensorResponse.
+    //
+    // Note that a subsequent call to contents() invalidates previous
+    // results of contents().
+    //
+    // Ownership of the returned stream is retained by the Source and
+    // should not be deleted by the caller.
+    virtual ::tensorflow::protobuf::io::ZeroCopyInputStream* contents() = 0;
+  };
+
+  // Parse the RecvTensorResponse encoded in the data yielded by
+  // source->contents() into *this.
+  Status ParseFrom(Source* source);
+
+  // Initialize tensor from *response.
+  // Leaves *response with unspecified contents.
+  Status InitFrom(RecvTensorResponse* response);
+
+  // Initialize tensor metadata from response and allocate
+  // uninitialized backing storage for actual contents.
+  void InitPartial(const RecvTensorResponse& response,
+                   const AllocationAttributes& allocation_attr);
+
+  // Return a reference to the parsed tensor.  The tensor will remain
+  // live only until *this is destroyed or modified.
+  const Tensor& tensor() const { return tensor_; }
+
+  // Return a reference to the parsed tensor metadata (no contents).
+  // The result will remain live only until *this is destroyed or
+  // modified.
+  const RecvTensorResponse& metadata() const { return meta_; }
+
+  // Return pointer to the device hosting the tensor.
+  DeviceBase* device() const { return device_; }
+
+ private:
+  bool ParseTensorSubmessage(protobuf::io::CodedInputStream* input,
+                             TensorProto* tensor_meta);
+  bool ParseFast(Source* source);
+  bool ParseSlow(Source* source);
+
+  bool on_host_ = false;
+  DeviceBase* device_ = nullptr;
+  AllocatorAttributes alloc_attrs_;
+  Allocator* allocator_ = nullptr;
+  bool already_used_ = false;
+  Tensor tensor_;
+  RecvTensorResponse meta_;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_TENSOR_CODING_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/worker.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/worker.h
new file mode 100644
index 0000000000000000000000000000000000000000..780976dcab3b190a67990b2139aa43e7198577d7
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/worker.h
@@ -0,0 +1,143 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_WORKER_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_WORKER_H_
+
+#include <unordered_map>
+
+#include "tensorflow/core/distributed_runtime/graph_mgr.h"
+#include "tensorflow/core/distributed_runtime/partial_run_mgr.h"
+#include "tensorflow/core/distributed_runtime/recent_request_ids.h"
+#include "tensorflow/core/distributed_runtime/session_mgr.h"
+#include "tensorflow/core/distributed_runtime/worker_interface.h"
+#include "tensorflow/core/framework/cancellation.h"
+
+namespace tensorflow {
+
+class Device;
+struct WorkerEnv;
+class WorkerSession;
+
+// A TensorFlow Worker runs registered graphs and supports worker-to-worker
+// Tensor transfer.
+//
+// See `../protobuf/worker_service.proto` for more details about each method.
+//
+// This class may be subclassed to provide specialized implementations of
+// particular methods for different transport mechanism. For example,
+// `GrpcWorker` specializes the `RecvTensorAsync()` method to support a more
+// efficient gRPC data structure for handling large binary data.
+class Worker : public WorkerInterface {
+ public:
+  Worker(WorkerEnv* env);
+  virtual ~Worker() {}
+
+  void GetStatusAsync(CallOptions* opts, const GetStatusRequest* request,
+                      GetStatusResponse* response, bool fail_fast,
+                      StatusCallback done) override;
+
+  void CreateWorkerSessionAsync(const CreateWorkerSessionRequest* request,
+                                CreateWorkerSessionResponse* response,
+                                StatusCallback done) override;
+
+  void DeleteWorkerSessionAsync(CallOptions* opts,
+                                const DeleteWorkerSessionRequest* request,
+                                DeleteWorkerSessionResponse* response,
+                                StatusCallback done) override;
+
+  void RegisterGraphAsync(const RegisterGraphRequest* request,
+                          RegisterGraphResponse* response,
+                          StatusCallback done) override;
+
+  void DeregisterGraphAsync(const DeregisterGraphRequest* request,
+                            DeregisterGraphResponse* response,
+                            StatusCallback done) override;
+
+  void RunGraphAsync(CallOptions* opts, RunGraphRequestWrapper* request,
+                     MutableRunGraphResponseWrapper* response,
+                     StatusCallback done) override;
+
+  MutableRunGraphRequestWrapper* CreateRunGraphRequest() override;
+
+  MutableRunGraphResponseWrapper* CreateRunGraphResponse() override;
+
+  void CleanupGraphAsync(const CleanupGraphRequest* request,
+                         CleanupGraphResponse* response,
+                         StatusCallback done) override;
+
+  void CleanupAllAsync(const CleanupAllRequest* request,
+                       CleanupAllResponse* response,
+                       StatusCallback done) override;
+
+  void RecvTensorAsync(CallOptions* opts, const RecvTensorRequest* request,
+                       TensorResponse* response, StatusCallback done) override;
+
+  void LoggingAsync(const LoggingRequest* request, LoggingResponse* response,
+                    StatusCallback done) override;
+
+  void TracingAsync(const TracingRequest* request, TracingResponse* response,
+                    StatusCallback done) override;
+
+  void RecvBufAsync(CallOptions* opts, const RecvBufRequest* request,
+                    RecvBufResponse* response, StatusCallback done) override;
+
+  void CompleteGroupAsync(CallOptions* opts,
+                          const CompleteGroupRequest* request,
+                          CompleteGroupResponse* response,
+                          StatusCallback done) override;
+
+  void CompleteInstanceAsync(CallOptions* opts,
+                             const CompleteInstanceRequest* request,
+                             CompleteInstanceResponse* response,
+                             StatusCallback done) override;
+
+  void GetStepSequenceAsync(const GetStepSequenceRequest* request,
+                            GetStepSequenceResponse* response,
+                            StatusCallback done) override;
+
+ protected:
+  WorkerEnv* const env_;  // Not owned.
+  RecentRequestIds recent_request_ids_;
+
+  Status PrepareRecvTensor(const Rendezvous::ParsedKey& parsed,
+                           Device** src_dev);
+
+  void AbortStep(int64_t);
+
+ private:
+  PartialRunMgr partial_run_mgr_;
+
+  CancellationManager cancellation_manager_;
+
+  Status PrepareRunGraph(RunGraphRequestWrapper* req,
+                         GraphMgr::NamedTensors* in,
+                         GraphMgr::NamedTensors* out);
+
+  void DoRunGraph(CallOptions* opts, RunGraphRequestWrapper* request,
+                  MutableRunGraphResponseWrapper* response,
+                  StatusCallback done);
+
+  void DoPartialRunGraph(CallOptions* opts, RunGraphRequestWrapper* request,
+                         MutableRunGraphResponseWrapper* response,
+                         StatusCallback done);
+
+  Worker(const Worker&) = delete;
+  void operator=(const Worker&) = delete;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_WORKER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/worker_cache.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/worker_cache.h
new file mode 100644
index 0000000000000000000000000000000000000000..542ac79334da1753a958b5552dc6a8095f5c6432
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/worker_cache.h
@@ -0,0 +1,96 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_WORKER_CACHE_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_WORKER_CACHE_H_
+
+#include <string>
+#include <vector>
+
+#include "tensorflow/core/distributed_runtime/coordination/coordination_client.h"
+#include "tensorflow/core/distributed_runtime/eager/eager_client.h"
+#include "tensorflow/core/distributed_runtime/worker_interface.h"
+#include "tensorflow/core/framework/device_attributes.pb.h"  // for DeviceLocality
+#include "tensorflow/core/lib/core/status.h"
+
+namespace tensorflow {
+typedef std::function<void(const Status&)> StatusCallback;
+
+class ChannelCache;
+class StepStats;
+
+class WorkerCacheInterface {
+ public:
+  virtual ~WorkerCacheInterface() {}
+
+  // Updates *workers with strings naming the remote worker tasks to
+  // which open channels have been established.
+  virtual void ListWorkers(std::vector<string>* workers) const = 0;
+  virtual void ListWorkersInJob(const string& job_name,
+                                std::vector<string>* workers) const = 0;
+
+  // If "target" names a remote task for which an RPC channel exists
+  // or can be constructed, returns a pointer to a WorkerInterface object
+  // wrapping that channel. The returned value must be destroyed by
+  // calling `this->ReleaseWorker(target, ret)`
+  virtual WorkerInterface* GetOrCreateWorker(const string& target) = 0;
+
+  // Release a worker previously returned by this->GetOrCreateWorker(target).
+  //
+  // TODO(jeff,sanjay): Consider moving target into WorkerInterface.
+  // TODO(jeff,sanjay): Unify all worker-cache impls and factor out a
+  //                    per-rpc-subsystem WorkerInterface creator.
+  virtual void ReleaseWorker(const string& target, WorkerInterface* worker) {
+    // Subclasses may override to reuse worker objects.
+    delete worker;
+  }
+
+  // Set *locality with the DeviceLocality of the specified remote device
+  // within its local environment.  Returns true if *locality
+  // was set, using only locally cached data.  Returns false
+  // if status data for that device was not available.  Never blocks.
+  virtual bool GetDeviceLocalityNonBlocking(const string& device,
+                                            DeviceLocality* locality) = 0;
+
+  // Set *locality with the DeviceLocality of the specified remote device
+  // within its local environment.  Callback gets Status::OK if *locality
+  // was set.
+  virtual void GetDeviceLocalityAsync(const string& device,
+                                      DeviceLocality* locality,
+                                      StatusCallback done) = 0;
+
+  // TODO(b/189159585): Define a general client cache maker function to
+  // construct client cache of different types sharing the same underling RPC
+  // channels, to replace the eager and coordination cache function.
+  // Build and return a EagerClientCache object wrapping that channel.
+  virtual Status GetEagerClientCache(
+      std::unique_ptr<eager::EagerClientCache>* eager_client_cache) = 0;
+
+  // Build and return a CoordinationClientCache object wrapping that channel.
+  virtual Status GetCoordinationClientCache(
+      std::unique_ptr<CoordinationClientCache>* coordination_client_cache) = 0;
+
+  // Start/stop logging activity.
+  virtual void SetLogging(bool active) {}
+
+  // Discard any saved log data.
+  virtual void ClearLogs() {}
+
+  // Return logs for the identified step in *ss.  Any returned data will no
+  // longer be stored.
+  virtual bool RetrieveLogs(int64_t step_id, StepStats* ss) { return false; }
+};
+}  // namespace tensorflow
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_WORKER_CACHE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/worker_cache_logger.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/worker_cache_logger.h
new file mode 100644
index 0000000000000000000000000000000000000000..f5ef19bf6646f7c32291b70f03f5391c79a1117e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/worker_cache_logger.h
@@ -0,0 +1,89 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_WORKER_CACHE_LOGGER_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_WORKER_CACHE_LOGGER_H_
+
+#include <string>
+#include <unordered_map>
+
+#include "tensorflow/core/framework/step_stats.pb.h"
+#include "tensorflow/core/platform/mutex.h"
+#include "tensorflow/core/platform/thread_annotations.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+class StepStatsCollector;
+
+// WorkerCacheLogger is a thread-safe utility for use by a WorkerCache
+// to optionally log some selected RPC activity.  A single instance
+// should be owned by a WorkerCache, for use by its RemoteWorker
+// instances.
+
+class WorkerCacheLogger {
+ public:
+  // Start/Stop logging activity.  This function increments/decrements
+  // a counter so that if two separate steps turn logging on/off,
+  // logging should be on for the union of the durations of both,
+  // regardless of relative timing.
+  void SetLogging(bool v);
+
+  // Discard any saved log data.
+  void ClearLogs();
+
+  // Return logs for the identified step in *ss.  Any returned data will no
+  // longer be stored.  Returns true iff *ss was modified.
+  bool RetrieveLogs(int64_t step_id, StepStats* ss);
+
+  // Return true if there is any outstanding request for logging on
+  // the RPC channels.
+  bool LoggingActive() {
+    mutex_lock l(count_mu_);
+    return want_logging_count_ > 0;
+  }
+
+  // Generates a NodeExecStats record with the given data, and saves for
+  // later retrieval by RetrieveLogs().
+  void RecordRecvTensor(int64_t step_id, int64_t start_usecs, int64_t end_usecs,
+                        const string& tensor_name, const string& src_device,
+                        const string& dst_device, int64_t bytes);
+
+  // Generates a NodeExecStats record with the given data, and saves for
+  // later retrieval by RetrieveLogs().
+  void RecordDataTransfer(int64_t step_id, int64_t start_usecs,
+                          int64_t end_usecs, const string& tensor_name,
+                          const string& src_device, const string& dst_device,
+                          int64_t bytes, const string& details,
+                          const string& transfer_method_name);
+
+ private:
+  mutex count_mu_;
+  int32 want_logging_count_ TF_GUARDED_BY(count_mu_) = 0;
+
+  struct StepLog {
+    StepStats step_stats;
+    StepStatsCollector* collector;
+  };
+  typedef std::unordered_map<int64_t, StepLog> LogMap;
+  mutex mu_;
+  LogMap log_map_ TF_GUARDED_BY(mu_);
+
+  // Records "ns" in log_map_ under the given device and step.
+  void Save(const string& device, int64_t step_id, NodeExecStats* ns);
+
+  void ClearLogsWithLock() TF_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+};
+}  // namespace tensorflow
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_WORKER_CACHE_LOGGER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/worker_cache_partial.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/worker_cache_partial.h
new file mode 100644
index 0000000000000000000000000000000000000000..57f2aca898bef632f8ecc8ddbd6ccaec7cae2c97
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/worker_cache_partial.h
@@ -0,0 +1,57 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_WORKER_CACHE_PARTIAL_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_WORKER_CACHE_PARTIAL_H_
+
+#include <string>
+#include <unordered_map>
+
+#include "tensorflow/core/distributed_runtime/worker_cache.h"
+#include "tensorflow/core/platform/mutex.h"
+#include "tensorflow/core/platform/thread_annotations.h"
+#include "tensorflow/core/platform/types.h"
+#include "tensorflow/core/protobuf/worker.pb.h"
+
+namespace tensorflow {
+
+// Implements the part of the interface that caches and returns remote
+// device status attributes.
+class WorkerCachePartial : public WorkerCacheInterface {
+ public:
+  bool GetDeviceLocalityNonBlocking(const string& device,
+                                    DeviceLocality* locality) override;
+
+  void GetDeviceLocalityAsync(const string& device, DeviceLocality* locality,
+                              StatusCallback) override;
+
+  ~WorkerCachePartial() override {}
+
+  // Clear all entries from the DeviceStatus cache.
+  void FlushStatusCache();
+
+ private:
+  mutex mu_;
+
+  // Initiate a GetStatusAsync to the remote task named by "task", and
+  // update the cache with all the DeviceAttributes reported.
+  Status RefreshDeviceStatus(const string& device_name);
+
+  typedef std::unordered_map<string, DeviceAttributes> StatusMap;
+  StatusMap device_status_cache_ TF_GUARDED_BY(mu_);
+};
+
+}  // namespace tensorflow
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_WORKER_CACHE_PARTIAL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/worker_cache_wrapper.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/worker_cache_wrapper.h
new file mode 100644
index 0000000000000000000000000000000000000000..195da534b45ce62c45347d2e384a86d546c55c28
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/worker_cache_wrapper.h
@@ -0,0 +1,100 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_WORKER_CACHE_WRAPPER_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_WORKER_CACHE_WRAPPER_H_
+
+#include <string>
+#include <vector>
+
+#include "tensorflow/core/distributed_runtime/worker_cache.h"
+
+namespace tensorflow {
+
+class WorkerCacheWrapper : public WorkerCacheInterface {
+ public:
+  WorkerCacheWrapper(WorkerCacheInterface* wrapped) : wrapped_(wrapped) {}
+
+  // Updates *workers with strings naming the remote worker tasks to
+  // which open channels have been established.
+  void ListWorkers(std::vector<string>* workers) const override {
+    return wrapped_->ListWorkers(workers);
+  }
+  void ListWorkersInJob(const string& job_name,
+                        std::vector<string>* workers) const override {
+    return wrapped_->ListWorkersInJob(job_name, workers);
+  }
+
+  // If "target" names a remote task for which an RPC channel exists
+  // or can be constructed, returns a pointer to a WorkerInterface object
+  // wrapping that channel. The returned value must be destroyed by
+  // calling `this->ReleaseWorker(target, ret)`
+  WorkerInterface* GetOrCreateWorker(const string& target) override {
+    return wrapped_->GetOrCreateWorker(target);
+  }
+
+  // Release a worker previously returned by this->GetOrCreateWorker(target).
+  //
+  // TODO(jeff,sanjay): Consider moving target into WorkerInterface.
+  // TODO(jeff,sanjay): Unify all worker-cache impls and factor out a
+  //                    per-rpc-subsystem WorkerInterface creator.
+  void ReleaseWorker(const string& target, WorkerInterface* worker) override {
+    return wrapped_->ReleaseWorker(target, worker);
+  }
+
+  Status GetEagerClientCache(
+      std::unique_ptr<eager::EagerClientCache>* eager_client_cache) override {
+    return wrapped_->GetEagerClientCache(eager_client_cache);
+  }
+
+  Status GetCoordinationClientCache(std::unique_ptr<CoordinationClientCache>*
+                                        coordination_client_cache) override {
+    return wrapped_->GetCoordinationClientCache(coordination_client_cache);
+  }
+
+  // Set *locality with the DeviceLocality of the specified remote device
+  // within its local environment.  Returns true if *locality
+  // was set, using only locally cached data.  Returns false
+  // if status data for that device was not available.  Never blocks.
+  bool GetDeviceLocalityNonBlocking(const string& device,
+                                    DeviceLocality* locality) override {
+    return wrapped_->GetDeviceLocalityNonBlocking(device, locality);
+  }
+
+  // Set *locality with the DeviceLocality of the specified remote device
+  // within its local environment.  Callback gets Status::OK if *locality
+  // was set.
+  void GetDeviceLocalityAsync(const string& device, DeviceLocality* locality,
+                              StatusCallback done) override {
+    return wrapped_->GetDeviceLocalityAsync(device, locality, std::move(done));
+  }
+
+  // Start/stop logging activity.
+  void SetLogging(bool active) override { wrapped_->SetLogging(active); }
+
+  // Discard any saved log data.
+  void ClearLogs() override { wrapped_->ClearLogs(); }
+
+  // Return logs for the identified step in *ss.  Any returned data will no
+  // longer be stored.
+  bool RetrieveLogs(int64_t step_id, StepStats* ss) override {
+    return wrapped_->RetrieveLogs(step_id, ss);
+  }
+
+ private:
+  WorkerCacheInterface* wrapped_;  // Not owned.
+};
+}  // namespace tensorflow
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_WORKER_CACHE_WRAPPER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/worker_env.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/worker_env.h
new file mode 100644
index 0000000000000000000000000000000000000000..350c3e5fa16399743baa55d0a2e717efb79985d4
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/worker_env.h
@@ -0,0 +1,79 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_WORKER_ENV_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_WORKER_ENV_H_
+
+#include <vector>
+
+#include "tensorflow/core/platform/types.h"
+
+namespace tsl {
+class Env;
+namespace thread {
+class ThreadPool;
+}  // namespace thread
+}  // namespace tsl
+namespace tensorflow {
+using Env = tsl::Env;
+
+namespace thread {
+using tsl::thread::ThreadPool;
+}  // namespace thread
+
+class CollectiveExecutorMgrInterface;
+class Device;
+class DeviceMgr;
+class RendezvousMgrInterface;
+class SessionMgr;
+
+// The worker environment class, which holds a bag of pointers to
+// per-worker singletons.
+//
+// WorkerEnv does not own its member pointers.
+struct WorkerEnv {
+  Env* env = nullptr;
+
+  // session_mgr encapsulates state for each session.
+  SessionMgr* session_mgr = nullptr;
+
+  // In large scaled distributed training, many singleton components (e.g.
+  // Rendezvous) can becomes the bottleneck of the system. This field allows
+  // us to shard the single components. This number will scale up with number
+  // of tasks in this cluster. It is always greater than 1.
+  int experimental_num_shards = 1;
+
+  // device_mgr manages local devices (cpu and gpu). The WorkerService
+  // is the network interface for managed devices.
+  //
+  // Note: Please use the device_mgr associated with your session if appropriate
+  // instead of this one. Using this device_mgr does not support ClusterSpec
+  // propagated sessions.
+  DeviceMgr* device_mgr = nullptr;
+
+  // A set of rendezvous keyed by step ids.
+  RendezvousMgrInterface* rendezvous_mgr = nullptr;
+
+  // Generates per-step CollectiveExecutors and has access to utilities
+  // supporting collective operations.
+  std::unique_ptr<CollectiveExecutorMgrInterface> collective_executor_mgr;
+
+  // A pool of threads for scheduling compute work.
+  thread::ThreadPool* compute_pool = nullptr;
+};
+
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_WORKER_ENV_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/worker_interface.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/worker_interface.h
new file mode 100644
index 0000000000000000000000000000000000000000..7b759eef95b9dfbe8f9a57df8b82c09a16823b88
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/worker_interface.h
@@ -0,0 +1,234 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_WORKER_INTERFACE_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_WORKER_INTERFACE_H_
+
+#include <functional>
+
+#include "tensorflow/core/distributed_runtime/call_options.h"
+#include "tensorflow/core/distributed_runtime/message_wrappers.h"
+#include "tensorflow/core/lib/core/notification.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/platform/types.h"
+#include "tensorflow/core/protobuf/worker.pb.h"
+
+namespace tensorflow {
+
+// Status callback.
+typedef std::function<void(const Status&)> StatusCallback;
+
+// Custom decoder for a response to RecvTensorAsync.
+class TensorResponse;
+
+// Interface for talking with the TensorFlow Worker service.
+class WorkerInterface {
+ public:
+  virtual void GetStatusAsync(CallOptions* opts,
+                              const GetStatusRequest* request,
+                              GetStatusResponse* response, bool fail_fast,
+                              StatusCallback done) = 0;
+
+  virtual void CreateWorkerSessionAsync(
+      const CreateWorkerSessionRequest* request,
+      CreateWorkerSessionResponse* response, StatusCallback done) = 0;
+
+  virtual void DeleteWorkerSessionAsync(
+      CallOptions* opts, const DeleteWorkerSessionRequest* request,
+      DeleteWorkerSessionResponse* response, StatusCallback done) = 0;
+
+  virtual void RegisterGraphAsync(const RegisterGraphRequest* request,
+                                  RegisterGraphResponse* response,
+                                  StatusCallback done) = 0;
+
+  virtual void DeregisterGraphAsync(const DeregisterGraphRequest* request,
+                                    DeregisterGraphResponse* response,
+                                    StatusCallback done) = 0;
+
+  virtual void RunGraphAsync(CallOptions* opts, RunGraphRequestWrapper* request,
+                             MutableRunGraphResponseWrapper* response,
+                             StatusCallback done) = 0;
+
+  virtual void RunGraphAsync(CallOptions* opts, const RunGraphRequest* request,
+                             RunGraphResponse* response, StatusCallback done) {
+    RunGraphRequestWrapper* wrapped_request = new ProtoRunGraphRequest(request);
+    MutableRunGraphResponseWrapper* wrapped_response =
+        new NonOwnedProtoRunGraphResponse(response);
+    RunGraphAsync(opts, wrapped_request, wrapped_response,
+                  [wrapped_request, wrapped_response,
+                   done = std::move(done)](const Status& s) {
+                    done(s);
+                    delete wrapped_request;
+                    delete wrapped_response;
+                  });
+  }
+
+  // Returns a request object for use in calls to
+  // `RunGraphAsync()`. Ownership is transferred to the caller.
+  //
+  // The message returned from this method must only be used in a
+  // `RunGraph()` call on the same `WorkerInterface` instance.
+  virtual MutableRunGraphRequestWrapper* CreateRunGraphRequest() {
+    return new MutableProtoRunGraphRequest;
+  }
+
+  // Returns a response object for use in calls to
+  // `RunGraphAsync()`. Ownership is transferred to the caller.
+  //
+  // The message returned from this method must only be used in a
+  // `RunGraph()` call on the same `WorkerInterface` instance.
+  virtual MutableRunGraphResponseWrapper* CreateRunGraphResponse() {
+    return new OwnedProtoRunGraphResponse;
+  }
+
+  virtual void CleanupGraphAsync(const CleanupGraphRequest* request,
+                                 CleanupGraphResponse* response,
+                                 StatusCallback done) = 0;
+
+  virtual void CleanupAllAsync(const CleanupAllRequest* request,
+                               CleanupAllResponse* response,
+                               StatusCallback done) = 0;
+
+  virtual void RecvTensorAsync(CallOptions* opts,
+                               const RecvTensorRequest* request,
+                               TensorResponse* response,
+                               StatusCallback done) = 0;
+
+  virtual void LoggingAsync(const LoggingRequest* request,
+                            LoggingResponse* response, StatusCallback done) = 0;
+
+  virtual void TracingAsync(const TracingRequest* request,
+                            TracingResponse* response, StatusCallback done) = 0;
+
+  virtual void RecvBufAsync(CallOptions* opts, const RecvBufRequest* request,
+                            RecvBufResponse* response, StatusCallback done) = 0;
+
+  virtual void CompleteGroupAsync(CallOptions* opts,
+                                  const CompleteGroupRequest* request,
+                                  CompleteGroupResponse* response,
+                                  StatusCallback done) = 0;
+
+  virtual void CompleteInstanceAsync(CallOptions* ops,
+                                     const CompleteInstanceRequest* request,
+                                     CompleteInstanceResponse* response,
+                                     StatusCallback done) = 0;
+
+  virtual void GetStepSequenceAsync(const GetStepSequenceRequest* request,
+                                    GetStepSequenceResponse* response,
+                                    StatusCallback done) = 0;
+
+  Status GetStatus(const GetStatusRequest* request,
+                   GetStatusResponse* response) {
+    Status ret;
+    Notification n;
+    GetStatusAsync(/*opts=*/nullptr, request, response, /*fail_fast=*/true,
+                   [&ret, &n](const Status& s) {
+                     ret = s;
+                     n.Notify();
+                   });
+    n.WaitForNotification();
+    return ret;
+  }
+
+  Status CreateWorkerSession(const CreateWorkerSessionRequest* request,
+                             CreateWorkerSessionResponse* response) {
+    return CallAndWait(&ME::CreateWorkerSessionAsync, request, response);
+  }
+
+  Status DeleteWorkerSession(const DeleteWorkerSessionRequest* request,
+                             DeleteWorkerSessionResponse* response) {
+    return CallAndWaitWithOptions(&ME::DeleteWorkerSessionAsync, request,
+                                  response);
+  }
+
+  Status RegisterGraph(const RegisterGraphRequest* request,
+                       RegisterGraphResponse* response) {
+    return CallAndWait(&ME::RegisterGraphAsync, request, response);
+  }
+
+  Status DeregisterGraph(const DeregisterGraphRequest* request,
+                         DeregisterGraphResponse* response) {
+    return CallAndWait(&ME::DeregisterGraphAsync, request, response);
+  }
+
+  Status CleanupGraph(const CleanupGraphRequest* request,
+                      CleanupGraphResponse* response) {
+    return CallAndWait(&ME::CleanupGraphAsync, request, response);
+  }
+
+  Status CleanupAll(const CleanupAllRequest* request,
+                    CleanupAllResponse* response) {
+    return CallAndWait(&ME::CleanupAllAsync, request, response);
+  }
+
+  Status Logging(const LoggingRequest* request, LoggingResponse* response) {
+    return CallAndWait(&ME::LoggingAsync, request, response);
+  }
+
+  Status Tracing(const TracingRequest* request, TracingResponse* response) {
+    return CallAndWait(&ME::TracingAsync, request, response);
+  }
+
+  Status GetStepSequence(const GetStepSequenceRequest* request,
+                         GetStepSequenceResponse* response) {
+    return CallAndWait(&ME::GetStepSequenceAsync, request, response);
+  }
+
+ protected:
+  // Instances of WorkerInterface must be deleted by a call to
+  // WorkerCacheInterface::ReleaseWorker().
+  virtual ~WorkerInterface() {}
+  friend class WorkerCacheInterface;
+
+  // NOTE: This should only be called by implementations of this
+  // interface whose CreateRunGraphResponse() method returns a
+  // proto-based wrappers for the RunGraphResponse message.
+  RunGraphResponse* get_proto_from_wrapper(
+      MutableRunGraphResponseWrapper* wrapper) {
+    return wrapper->get_proto();
+  }
+
+ private:
+  typedef WorkerInterface ME;
+
+  template <typename Method, typename Req, typename Resp>
+  Status CallAndWait(Method func, const Req* req, Resp* resp) {
+    Status ret;
+    Notification n;
+    (this->*func)(req, resp, [&ret, &n](const Status& s) {
+      ret = s;
+      n.Notify();
+    });
+    n.WaitForNotification();
+    return ret;
+  }
+
+  template <typename Method, typename Req, typename Resp>
+  Status CallAndWaitWithOptions(Method func, const Req* req, Resp* resp) {
+    CallOptions call_opts;
+    Status ret;
+    Notification n;
+    (this->*func)(&call_opts, req, resp, [&ret, &n](const Status& s) {
+      ret = s;
+      n.Notify();
+    });
+    n.WaitForNotification();
+    return ret;
+  }
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_WORKER_INTERFACE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/worker_session.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/worker_session.h
new file mode 100644
index 0000000000000000000000000000000000000000..b97fe1a99292d9428d4d34ccf72d4b6de5033194
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/distributed_runtime/worker_session.h
@@ -0,0 +1,134 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_WORKER_SESSION_H_
+#define TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_WORKER_SESSION_H_
+
+#include <functional>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "tensorflow/core/common_runtime/device_mgr.h"
+#include "tensorflow/core/distributed_runtime/graph_mgr.h"
+#include "tensorflow/core/distributed_runtime/worker_cache.h"
+#include "tensorflow/core/framework/function.h"
+
+namespace tensorflow {
+
+class ClusterFunctionLibraryRuntime;
+class GraphMgr;
+class WorkerCacheInterface;
+
+// WorkerSession encapsulates all of the state relating to a given session.
+class WorkerSession {
+ public:
+  using DistributedFunctionLibraryRuntimeCreator =
+      std::function<std::unique_ptr<DistributedFunctionLibraryRuntime>(
+          WorkerSession* worker_session, bool create_worker_session_called,
+          DeviceMgr* remote_device_mgr)>;
+
+  // Collection of local devices. These devices are typically
+  // RenamedDevices in all except the SessionMgr.legacy_session_ and
+  // sessions created with `isolate_session_state == false`. In the
+  // those cases, this method returns a pointer to a borrowed
+  // DeviceMgr (typically the `worker_env.device_mgr`).
+  DeviceMgr* device_mgr() {
+    return device_mgr_ ? device_mgr_.get() : borrowed_device_mgr_;
+  }
+
+  DynamicDeviceMgr* remote_device_mgr() { return remote_device_mgr_.get(); }
+
+  const string& session_name() const { return session_name_; }
+  const string& worker_name() const { return worker_name_; }
+
+  WorkerCacheInterface* worker_cache() const {
+    tf_shared_lock l(worker_session_state_mu_);
+    return worker_cache_.get();
+  }
+  GraphMgr* graph_mgr() const { return graph_mgr_.get(); }
+
+  DistributedFunctionLibraryRuntime* cluster_flr() const {
+    return cluster_flr_.get();
+  }
+
+  WorkerSession(const string& session_name, const string& worker_name,
+                std::unique_ptr<WorkerCacheInterface> worker_cache,
+                std::unique_ptr<DeviceMgr> device_mgr,
+                std::unique_ptr<GraphMgr> graph_mgr,
+                std::unique_ptr<DynamicDeviceMgr> remote_device_mgr,
+                DistributedFunctionLibraryRuntimeCreator cluster_flr_creator);
+
+  static std::shared_ptr<WorkerSession> CreateWithBorrowedDeviceMgr(
+      const string& session_name, const string& worker_name,
+      std::unique_ptr<WorkerCacheInterface> worker_cache,
+      DeviceMgr* borrowed_device_mgr, std::unique_ptr<GraphMgr> graph_mgr,
+      std::unique_ptr<DynamicDeviceMgr> remote_device_mgr,
+      DistributedFunctionLibraryRuntimeCreator cluster_flr_creator);
+
+  // In the eager runtime we allow WorkerSession to be updated, where the
+  // worker cache will be recreated. If WorkerSession upate is expected and a
+  // worker in the cache is used in RPCs, the caller should hold a shared
+  // pointer to avoid the workers getting deleted.
+  std::shared_ptr<WorkerCacheInterface> GetSharedWorkerCache() {
+    tf_shared_lock l(worker_session_state_mu_);
+    return worker_cache_;
+  }
+
+  // Update an existing worker session with new set of remote workers and
+  // devices. Added devices will be owned by the worker session, and removed
+  // devices will be freed by their names.
+  Status UpdateWorkerCacheAndDevices(
+      std::unique_ptr<WorkerCacheInterface> new_worker_cache,
+      std::vector<std::unique_ptr<Device>> added_remote_devices,
+      const std::vector<Device*>& removed_remote_devices);
+
+  ~WorkerSession();
+
+ private:
+  WorkerSession(const string& session_name, const string& worker_name,
+                std::unique_ptr<WorkerCacheInterface> worker_cache,
+                DeviceMgr* borrowed_device_mgr,
+                std::unique_ptr<GraphMgr> graph_mgr,
+                std::unique_ptr<DynamicDeviceMgr> remote_device_mgr,
+                DistributedFunctionLibraryRuntimeCreator cluster_flr_creator);
+
+  // The name of the session.
+  const string session_name_;
+
+  // The name of the worker. E.g., /job:mnist/replica:0/task:1.
+  const string worker_name_;
+
+  mutable mutex worker_session_state_mu_;
+  // Object from which WorkerInterface instances can be obtained.
+  std::shared_ptr<WorkerCacheInterface> worker_cache_
+      TF_GUARDED_BY(worker_session_state_mu_);
+
+  // graph_mgr keeps track of the registered graphs of this session.
+  //
+  // Note: graph_mgr must be deleted before rendezvous_mgr!
+  // Note: graph_mgr must be deleted before device_mgr!
+  const std::unique_ptr<GraphMgr> graph_mgr_;
+
+  std::unique_ptr<DistributedFunctionLibraryRuntime> cluster_flr_;
+
+  const std::unique_ptr<DeviceMgr> device_mgr_;
+  DeviceMgr* const borrowed_device_mgr_;  // Not owned.
+  std::unique_ptr<DynamicDeviceMgr> remote_device_mgr_;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_DISTRIBUTED_RUNTIME_WORKER_SESSION_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/example/example.pb.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/example/example.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..f673e27ee05554399e18dd7ae59b71d5a9b8336b
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/example/example.pb.h
@@ -0,0 +1,679 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: tensorflow/core/example/example.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fexample_2fexample_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fexample_2fexample_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3021000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3021009 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+#include "tensorflow/core/example/feature.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_tensorflow_2fcore_2fexample_2fexample_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_tensorflow_2fcore_2fexample_2fexample_2eproto {
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_tensorflow_2fcore_2fexample_2fexample_2eproto;
+namespace tensorflow {
+class Example;
+struct ExampleDefaultTypeInternal;
+extern ExampleDefaultTypeInternal _Example_default_instance_;
+class SequenceExample;
+struct SequenceExampleDefaultTypeInternal;
+extern SequenceExampleDefaultTypeInternal _SequenceExample_default_instance_;
+}  // namespace tensorflow
+PROTOBUF_NAMESPACE_OPEN
+template<> ::tensorflow::Example* Arena::CreateMaybeMessage<::tensorflow::Example>(Arena*);
+template<> ::tensorflow::SequenceExample* Arena::CreateMaybeMessage<::tensorflow::SequenceExample>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace tensorflow {
+
+// ===================================================================
+
+class Example final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.Example) */ {
+ public:
+  inline Example() : Example(nullptr) {}
+  ~Example() override;
+  explicit PROTOBUF_CONSTEXPR Example(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Example(const Example& from);
+  Example(Example&& from) noexcept
+    : Example() {
+    *this = ::std::move(from);
+  }
+
+  inline Example& operator=(const Example& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Example& operator=(Example&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Example& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Example* internal_default_instance() {
+    return reinterpret_cast<const Example*>(
+               &_Example_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(Example& a, Example& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Example* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Example* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Example* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Example>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Example& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Example& from) {
+    Example::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Example* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.Example";
+  }
+  protected:
+  explicit Example(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kFeaturesFieldNumber = 1,
+  };
+  // .tensorflow.Features features = 1;
+  bool has_features() const;
+  private:
+  bool _internal_has_features() const;
+  public:
+  void clear_features();
+  const ::tensorflow::Features& features() const;
+  PROTOBUF_NODISCARD ::tensorflow::Features* release_features();
+  ::tensorflow::Features* mutable_features();
+  void set_allocated_features(::tensorflow::Features* features);
+  private:
+  const ::tensorflow::Features& _internal_features() const;
+  ::tensorflow::Features* _internal_mutable_features();
+  public:
+  void unsafe_arena_set_allocated_features(
+      ::tensorflow::Features* features);
+  ::tensorflow::Features* unsafe_arena_release_features();
+
+  // @@protoc_insertion_point(class_scope:tensorflow.Example)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::tensorflow::Features* features_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fexample_2fexample_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SequenceExample final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.SequenceExample) */ {
+ public:
+  inline SequenceExample() : SequenceExample(nullptr) {}
+  ~SequenceExample() override;
+  explicit PROTOBUF_CONSTEXPR SequenceExample(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SequenceExample(const SequenceExample& from);
+  SequenceExample(SequenceExample&& from) noexcept
+    : SequenceExample() {
+    *this = ::std::move(from);
+  }
+
+  inline SequenceExample& operator=(const SequenceExample& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SequenceExample& operator=(SequenceExample&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SequenceExample& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SequenceExample* internal_default_instance() {
+    return reinterpret_cast<const SequenceExample*>(
+               &_SequenceExample_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(SequenceExample& a, SequenceExample& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SequenceExample* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SequenceExample* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SequenceExample* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SequenceExample>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SequenceExample& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const SequenceExample& from) {
+    SequenceExample::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SequenceExample* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.SequenceExample";
+  }
+  protected:
+  explicit SequenceExample(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kContextFieldNumber = 1,
+    kFeatureListsFieldNumber = 2,
+  };
+  // .tensorflow.Features context = 1;
+  bool has_context() const;
+  private:
+  bool _internal_has_context() const;
+  public:
+  void clear_context();
+  const ::tensorflow::Features& context() const;
+  PROTOBUF_NODISCARD ::tensorflow::Features* release_context();
+  ::tensorflow::Features* mutable_context();
+  void set_allocated_context(::tensorflow::Features* context);
+  private:
+  const ::tensorflow::Features& _internal_context() const;
+  ::tensorflow::Features* _internal_mutable_context();
+  public:
+  void unsafe_arena_set_allocated_context(
+      ::tensorflow::Features* context);
+  ::tensorflow::Features* unsafe_arena_release_context();
+
+  // .tensorflow.FeatureLists feature_lists = 2;
+  bool has_feature_lists() const;
+  private:
+  bool _internal_has_feature_lists() const;
+  public:
+  void clear_feature_lists();
+  const ::tensorflow::FeatureLists& feature_lists() const;
+  PROTOBUF_NODISCARD ::tensorflow::FeatureLists* release_feature_lists();
+  ::tensorflow::FeatureLists* mutable_feature_lists();
+  void set_allocated_feature_lists(::tensorflow::FeatureLists* feature_lists);
+  private:
+  const ::tensorflow::FeatureLists& _internal_feature_lists() const;
+  ::tensorflow::FeatureLists* _internal_mutable_feature_lists();
+  public:
+  void unsafe_arena_set_allocated_feature_lists(
+      ::tensorflow::FeatureLists* feature_lists);
+  ::tensorflow::FeatureLists* unsafe_arena_release_feature_lists();
+
+  // @@protoc_insertion_point(class_scope:tensorflow.SequenceExample)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::tensorflow::Features* context_;
+    ::tensorflow::FeatureLists* feature_lists_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fexample_2fexample_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// Example
+
+// .tensorflow.Features features = 1;
+inline bool Example::_internal_has_features() const {
+  return this != internal_default_instance() && _impl_.features_ != nullptr;
+}
+inline bool Example::has_features() const {
+  return _internal_has_features();
+}
+inline const ::tensorflow::Features& Example::_internal_features() const {
+  const ::tensorflow::Features* p = _impl_.features_;
+  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::Features&>(
+      ::tensorflow::_Features_default_instance_);
+}
+inline const ::tensorflow::Features& Example::features() const {
+  // @@protoc_insertion_point(field_get:tensorflow.Example.features)
+  return _internal_features();
+}
+inline void Example::unsafe_arena_set_allocated_features(
+    ::tensorflow::Features* features) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.features_);
+  }
+  _impl_.features_ = features;
+  if (features) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.Example.features)
+}
+inline ::tensorflow::Features* Example::release_features() {
+  
+  ::tensorflow::Features* temp = _impl_.features_;
+  _impl_.features_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::tensorflow::Features* Example::unsafe_arena_release_features() {
+  // @@protoc_insertion_point(field_release:tensorflow.Example.features)
+  
+  ::tensorflow::Features* temp = _impl_.features_;
+  _impl_.features_ = nullptr;
+  return temp;
+}
+inline ::tensorflow::Features* Example::_internal_mutable_features() {
+  
+  if (_impl_.features_ == nullptr) {
+    auto* p = CreateMaybeMessage<::tensorflow::Features>(GetArenaForAllocation());
+    _impl_.features_ = p;
+  }
+  return _impl_.features_;
+}
+inline ::tensorflow::Features* Example::mutable_features() {
+  ::tensorflow::Features* _msg = _internal_mutable_features();
+  // @@protoc_insertion_point(field_mutable:tensorflow.Example.features)
+  return _msg;
+}
+inline void Example::set_allocated_features(::tensorflow::Features* features) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.features_);
+  }
+  if (features) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(features));
+    if (message_arena != submessage_arena) {
+      features = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, features, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.features_ = features;
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.Example.features)
+}
+
+// -------------------------------------------------------------------
+
+// SequenceExample
+
+// .tensorflow.Features context = 1;
+inline bool SequenceExample::_internal_has_context() const {
+  return this != internal_default_instance() && _impl_.context_ != nullptr;
+}
+inline bool SequenceExample::has_context() const {
+  return _internal_has_context();
+}
+inline const ::tensorflow::Features& SequenceExample::_internal_context() const {
+  const ::tensorflow::Features* p = _impl_.context_;
+  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::Features&>(
+      ::tensorflow::_Features_default_instance_);
+}
+inline const ::tensorflow::Features& SequenceExample::context() const {
+  // @@protoc_insertion_point(field_get:tensorflow.SequenceExample.context)
+  return _internal_context();
+}
+inline void SequenceExample::unsafe_arena_set_allocated_context(
+    ::tensorflow::Features* context) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.context_);
+  }
+  _impl_.context_ = context;
+  if (context) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.SequenceExample.context)
+}
+inline ::tensorflow::Features* SequenceExample::release_context() {
+  
+  ::tensorflow::Features* temp = _impl_.context_;
+  _impl_.context_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::tensorflow::Features* SequenceExample::unsafe_arena_release_context() {
+  // @@protoc_insertion_point(field_release:tensorflow.SequenceExample.context)
+  
+  ::tensorflow::Features* temp = _impl_.context_;
+  _impl_.context_ = nullptr;
+  return temp;
+}
+inline ::tensorflow::Features* SequenceExample::_internal_mutable_context() {
+  
+  if (_impl_.context_ == nullptr) {
+    auto* p = CreateMaybeMessage<::tensorflow::Features>(GetArenaForAllocation());
+    _impl_.context_ = p;
+  }
+  return _impl_.context_;
+}
+inline ::tensorflow::Features* SequenceExample::mutable_context() {
+  ::tensorflow::Features* _msg = _internal_mutable_context();
+  // @@protoc_insertion_point(field_mutable:tensorflow.SequenceExample.context)
+  return _msg;
+}
+inline void SequenceExample::set_allocated_context(::tensorflow::Features* context) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.context_);
+  }
+  if (context) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(context));
+    if (message_arena != submessage_arena) {
+      context = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, context, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.context_ = context;
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.SequenceExample.context)
+}
+
+// .tensorflow.FeatureLists feature_lists = 2;
+inline bool SequenceExample::_internal_has_feature_lists() const {
+  return this != internal_default_instance() && _impl_.feature_lists_ != nullptr;
+}
+inline bool SequenceExample::has_feature_lists() const {
+  return _internal_has_feature_lists();
+}
+inline const ::tensorflow::FeatureLists& SequenceExample::_internal_feature_lists() const {
+  const ::tensorflow::FeatureLists* p = _impl_.feature_lists_;
+  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::FeatureLists&>(
+      ::tensorflow::_FeatureLists_default_instance_);
+}
+inline const ::tensorflow::FeatureLists& SequenceExample::feature_lists() const {
+  // @@protoc_insertion_point(field_get:tensorflow.SequenceExample.feature_lists)
+  return _internal_feature_lists();
+}
+inline void SequenceExample::unsafe_arena_set_allocated_feature_lists(
+    ::tensorflow::FeatureLists* feature_lists) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.feature_lists_);
+  }
+  _impl_.feature_lists_ = feature_lists;
+  if (feature_lists) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.SequenceExample.feature_lists)
+}
+inline ::tensorflow::FeatureLists* SequenceExample::release_feature_lists() {
+  
+  ::tensorflow::FeatureLists* temp = _impl_.feature_lists_;
+  _impl_.feature_lists_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::tensorflow::FeatureLists* SequenceExample::unsafe_arena_release_feature_lists() {
+  // @@protoc_insertion_point(field_release:tensorflow.SequenceExample.feature_lists)
+  
+  ::tensorflow::FeatureLists* temp = _impl_.feature_lists_;
+  _impl_.feature_lists_ = nullptr;
+  return temp;
+}
+inline ::tensorflow::FeatureLists* SequenceExample::_internal_mutable_feature_lists() {
+  
+  if (_impl_.feature_lists_ == nullptr) {
+    auto* p = CreateMaybeMessage<::tensorflow::FeatureLists>(GetArenaForAllocation());
+    _impl_.feature_lists_ = p;
+  }
+  return _impl_.feature_lists_;
+}
+inline ::tensorflow::FeatureLists* SequenceExample::mutable_feature_lists() {
+  ::tensorflow::FeatureLists* _msg = _internal_mutable_feature_lists();
+  // @@protoc_insertion_point(field_mutable:tensorflow.SequenceExample.feature_lists)
+  return _msg;
+}
+inline void SequenceExample::set_allocated_feature_lists(::tensorflow::FeatureLists* feature_lists) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.feature_lists_);
+  }
+  if (feature_lists) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(feature_lists));
+    if (message_arena != submessage_arena) {
+      feature_lists = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, feature_lists, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.feature_lists_ = feature_lists;
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.SequenceExample.feature_lists)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace tensorflow
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fexample_2fexample_2eproto
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/example/example.proto b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/example/example.proto
new file mode 100644
index 0000000000000000000000000000000000000000..9f762fb51136992a73a95de1fa08cd4b5676a624
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/example/example.proto
@@ -0,0 +1,301 @@
+// Protocol messages for describing input data Examples for machine learning
+// model training or inference.
+syntax = "proto3";
+
+package tensorflow;
+
+import "tensorflow/core/example/feature.proto";
+
+option cc_enable_arenas = true;
+option java_outer_classname = "ExampleProtos";
+option java_multiple_files = true;
+option java_package = "org.tensorflow.example";
+option go_package = "github.com/tensorflow/tensorflow/tensorflow/go/core/example/example_protos_go_proto";
+
+// An Example is a mostly-normalized data format for storing data for
+// training and inference.  It contains a key-value store (features); where
+// each key (string) maps to a Feature message (which is oneof packed BytesList,
+// FloatList, or Int64List).  This flexible and compact format allows the
+// storage of large amounts of typed data, but requires that the data shape
+// and use be determined by the configuration files and parsers that are used to
+// read and write this format.  That is, the Example is mostly *not* a
+// self-describing format.  In TensorFlow, Examples are read in row-major
+// format, so any configuration that describes data with rank-2 or above
+// should keep this in mind. If you flatten a matrix into a FloatList it should
+// be stored as [ row 0 ... row 1 ... row M-1 ]
+//
+// An Example for a movie recommendation application:
+//   features {
+//     feature {
+//       key: "age"
+//       value { float_list {
+//         value: 29.0
+//       }}
+//     }
+//     feature {
+//       key: "movie"
+//       value { bytes_list {
+//         value: "The Shawshank Redemption"
+//         value: "Fight Club"
+//       }}
+//     }
+//     feature {
+//       key: "movie_ratings"
+//       value { float_list {
+//         value: 9.0
+//         value: 9.7
+//       }}
+//     }
+//     feature {
+//       key: "suggestion"
+//       value { bytes_list {
+//         value: "Inception"
+//       }}
+//     }
+//     # Note that this feature exists to be used as a label in training.
+//     # E.g., if training a logistic regression model to predict purchase
+//     # probability in our learning tool we would set the label feature to
+//     # "suggestion_purchased".
+//     feature {
+//       key: "suggestion_purchased"
+//       value { float_list {
+//         value: 1.0
+//       }}
+//     }
+//     # Similar to "suggestion_purchased" above this feature exists to be used
+//     # as a label in training.
+//     # E.g., if training a linear regression model to predict purchase
+//     # price in our learning tool we would set the label feature to
+//     # "purchase_price".
+//     feature {
+//       key: "purchase_price"
+//       value { float_list {
+//         value: 9.99
+//       }}
+//     }
+//  }
+//
+// A conformant Example data set obeys the following conventions:
+//   - If a Feature K exists in one example with data type T, it must be of
+//       type T in all other examples when present. It may be omitted.
+//   - The number of instances of Feature K list data may vary across examples,
+//       depending on the requirements of the model.
+//   - If a Feature K doesn't exist in an example, a K-specific default will be
+//       used, if configured.
+//   - If a Feature K exists in an example but contains no items, the intent
+//       is considered to be an empty tensor and no default will be used.
+
+message Example {
+  Features features = 1;
+}
+
+// A SequenceExample is an Example representing one or more sequences, and
+// some context.  The context contains features which apply to the entire
+// example. The feature_lists contain a key, value map where each key is
+// associated with a repeated set of Features (a FeatureList).
+// A FeatureList thus represents the values of a feature identified by its key
+// over time / frames.
+//
+// Below is a SequenceExample for a movie recommendation application recording a
+// sequence of ratings by a user. The time-independent features ("locale",
+// "age", "favorites") describing the user are part of the context. The sequence
+// of movies the user rated are part of the feature_lists. For each movie in the
+// sequence we have information on its name and actors and the user's rating.
+// This information is recorded in three separate feature_list(s).
+// In the example below there are only two movies. All three feature_list(s),
+// namely "movie_ratings", "movie_names", and "actors" have a feature value for
+// both movies. Note, that "actors" is itself a bytes_list with multiple
+// strings per movie.
+//
+// context: {
+//   feature: {
+//     key  : "locale"
+//     value: {
+//       bytes_list: {
+//         value: [ "pt_BR" ]
+//       }
+//     }
+//   }
+//   feature: {
+//     key  : "age"
+//     value: {
+//       float_list: {
+//         value: [ 19.0 ]
+//       }
+//     }
+//   }
+//   feature: {
+//     key  : "favorites"
+//     value: {
+//       bytes_list: {
+//         value: [ "Majesty Rose", "Savannah Outen", "One Direction" ]
+//       }
+//     }
+//   }
+// }
+// feature_lists: {
+//   feature_list: {
+//     key  : "movie_ratings"
+//     value: {
+//       feature: {
+//         float_list: {
+//           value: [ 4.5 ]
+//         }
+//       }
+//       feature: {
+//         float_list: {
+//           value: [ 5.0 ]
+//         }
+//       }
+//     }
+//   }
+//   feature_list: {
+//     key  : "movie_names"
+//     value: {
+//       feature: {
+//         bytes_list: {
+//           value: [ "The Shawshank Redemption" ]
+//         }
+//       }
+//       feature: {
+//         bytes_list: {
+//           value: [ "Fight Club" ]
+//         }
+//       }
+//     }
+//   }
+//   feature_list: {
+//     key  : "actors"
+//     value: {
+//       feature: {
+//         bytes_list: {
+//           value: [ "Tim Robbins", "Morgan Freeman" ]
+//         }
+//       }
+//       feature: {
+//         bytes_list: {
+//           value: [ "Brad Pitt", "Edward Norton", "Helena Bonham Carter" ]
+//         }
+//       }
+//     }
+//   }
+// }
+//
+// A conformant SequenceExample data set obeys the following conventions:
+//
+// Context:
+//   - All conformant context features K must obey the same conventions as
+//     a conformant Example's features (see above).
+// Feature lists:
+//   - A FeatureList L may be missing in an example; it is up to the
+//     parser configuration to determine if this is allowed or considered
+//     an empty list (zero length).
+//   - If a FeatureList L exists, it may be empty (zero length).
+//   - If a FeatureList L is non-empty, all features within the FeatureList
+//     must have the same data type T. Even across SequenceExamples, the type T
+//     of the FeatureList identified by the same key must be the same. An entry
+//     without any values may serve as an empty feature.
+//   - If a FeatureList L is non-empty, it is up to the parser configuration
+//     to determine if all features within the FeatureList must
+//     have the same size.  The same holds for this FeatureList across multiple
+//     examples.
+//   - For sequence modeling, e.g.:
+//        http://colah.github.io/posts/2015-08-Understanding-LSTMs/
+//        https://github.com/tensorflow/nmt
+//     the feature lists represent a sequence of frames.
+//     In this scenario, all FeatureLists in a SequenceExample have the same
+//     number of Feature messages, so that the ith element in each FeatureList
+//     is part of the ith frame (or time step).
+// Examples of conformant and non-conformant examples' FeatureLists:
+//
+// Conformant FeatureLists:
+//    feature_lists: { feature_list: {
+//      key: "movie_ratings"
+//      value: { feature: { float_list: { value: [ 4.5 ] } }
+//               feature: { float_list: { value: [ 5.0 ] } } }
+//    } }
+//
+// Non-conformant FeatureLists (mismatched types):
+//    feature_lists: { feature_list: {
+//      key: "movie_ratings"
+//      value: { feature: { float_list: { value: [ 4.5 ] } }
+//               feature: { int64_list: { value: [ 5 ] } } }
+//    } }
+//
+// Conditionally conformant FeatureLists, the parser configuration determines
+// if the feature sizes must match:
+//    feature_lists: { feature_list: {
+//      key: "movie_ratings"
+//      value: { feature: { float_list: { value: [ 4.5 ] } }
+//               feature: { float_list: { value: [ 5.0, 6.0 ] } } }
+//    } }
+//
+// Conformant pair of SequenceExample
+//    feature_lists: { feature_list: {
+//      key: "movie_ratings"
+//      value: { feature: { float_list: { value: [ 4.5 ] } }
+//               feature: { float_list: { value: [ 5.0 ] } } }
+//    } }
+// and:
+//    feature_lists: { feature_list: {
+//      key: "movie_ratings"
+//      value: { feature: { float_list: { value: [ 4.5 ] } }
+//               feature: { float_list: { value: [ 5.0 ] } }
+//               feature: { float_list: { value: [ 2.0 ] } } }
+//    } }
+//
+// Conformant pair of SequenceExample
+//    feature_lists: { feature_list: {
+//      key: "movie_ratings"
+//      value: { feature: { float_list: { value: [ 4.5 ] } }
+//               feature: { float_list: { value: [ 5.0 ] } } }
+//    } }
+// and:
+//    feature_lists: { feature_list: {
+//      key: "movie_ratings"
+//      value: { }
+//    } }
+//
+// Conditionally conformant pair of SequenceExample, the parser configuration
+// determines if the second feature_lists is consistent (zero-length) or
+// invalid (missing "movie_ratings"):
+//    feature_lists: { feature_list: {
+//      key: "movie_ratings"
+//      value: { feature: { float_list: { value: [ 4.5 ] } }
+//               feature: { float_list: { value: [ 5.0 ] } } }
+//    } }
+// and:
+//    feature_lists: { }
+//
+// Non-conformant pair of SequenceExample (mismatched types)
+//    feature_lists: { feature_list: {
+//      key: "movie_ratings"
+//      value: { feature: { float_list: { value: [ 4.5 ] } }
+//               feature: { float_list: { value: [ 5.0 ] } } }
+//    } }
+// and:
+//    feature_lists: { feature_list: {
+//      key: "movie_ratings"
+//      value: { feature: { int64_list: { value: [ 4 ] } }
+//               feature: { int64_list: { value: [ 5 ] } }
+//               feature: { int64_list: { value: [ 2 ] } } }
+//    } }
+//
+// Conditionally conformant pair of SequenceExample; the parser configuration
+// determines if the feature sizes must match:
+//    feature_lists: { feature_list: {
+//      key: "movie_ratings"
+//      value: { feature: { float_list: { value: [ 4.5 ] } }
+//               feature: { float_list: { value: [ 5.0 ] } } }
+//    } }
+// and:
+//    feature_lists: { feature_list: {
+//      key: "movie_ratings"
+//      value: { feature: { float_list: { value: [ 4.0 ] } }
+//               feature: { float_list: { value: [ 5.0, 3.0 ] } }
+//    } }
+
+message SequenceExample {
+  Features context = 1;
+  FeatureLists feature_lists = 2;
+}
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/example/example_parser_configuration.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/example/example_parser_configuration.h
new file mode 100644
index 0000000000000000000000000000000000000000..8bbed28471d5a7123a7a5840a99665bd9cb530f3
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/example/example_parser_configuration.h
@@ -0,0 +1,56 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_EXAMPLE_EXAMPLE_PARSER_CONFIGURATION_H_
+#define TENSORFLOW_CORE_EXAMPLE_EXAMPLE_PARSER_CONFIGURATION_H_
+
+#include <string>
+#include <vector>
+
+#include "tensorflow/core/example/example.pb.h"
+#include "tensorflow/core/example/example_parser_configuration.pb.h"
+#include "tensorflow/core/framework/allocator.h"
+#include "tensorflow/core/framework/graph.pb.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/platform/types.h"
+#include "tensorflow/core/public/session.h"
+#include "tensorflow/core/util/example_proto_helper.h"
+#include "tensorflow/core/util/sparse/sparse_tensor.h"
+
+// This is a set of helper methods that will make it possible to share
+// tensorflow::Example proto Tensor conversion code inside the ExampleParserOp
+// OpKernel as well as in external code.
+namespace tensorflow {
+
+// Given a graph and the node_name of a ParseExample op,
+// extract the FixedLenFeature/VarLenFeature configurations.
+Status ExtractExampleParserConfiguration(
+    const tensorflow::GraphDef& graph, const string& node_name,
+    tensorflow::Session* session,
+    std::vector<FixedLenFeature>* fixed_len_features,
+    std::vector<VarLenFeature>* var_len_features);
+
+// Given a config proto, ostensibly extracted via python,
+// fill a vector of C++ structs suitable for calling
+// the tensorflow.Example -> Tensor conversion code.
+Status ExampleParserConfigurationProtoToFeatureVectors(
+    const ExampleParserConfiguration& config_proto,
+    std::vector<FixedLenFeature>* fixed_len_features,
+    std::vector<VarLenFeature>* var_len_features);
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_EXAMPLE_EXAMPLE_PARSER_CONFIGURATION_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/example/example_parser_configuration.pb.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/example/example_parser_configuration.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..f321972e5684e6c05c7ceb561b8930c1a584f59a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/example/example_parser_configuration.pb.h
@@ -0,0 +1,1504 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: tensorflow/core/example/example_parser_configuration.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fexample_2fexample_5fparser_5fconfiguration_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fexample_2fexample_5fparser_5fconfiguration_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3021000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3021009 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/map.h>  // IWYU pragma: export
+#include <google/protobuf/map_entry.h>
+#include <google/protobuf/map_field_inl.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "tensorflow/core/framework/tensor.pb.h"
+#include "tensorflow/core/framework/tensor_shape.pb.h"
+#include "tensorflow/core/framework/types.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_tensorflow_2fcore_2fexample_2fexample_5fparser_5fconfiguration_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_tensorflow_2fcore_2fexample_2fexample_5fparser_5fconfiguration_2eproto {
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_tensorflow_2fcore_2fexample_2fexample_5fparser_5fconfiguration_2eproto;
+namespace tensorflow {
+class ExampleParserConfiguration;
+struct ExampleParserConfigurationDefaultTypeInternal;
+extern ExampleParserConfigurationDefaultTypeInternal _ExampleParserConfiguration_default_instance_;
+class ExampleParserConfiguration_FeatureMapEntry_DoNotUse;
+struct ExampleParserConfiguration_FeatureMapEntry_DoNotUseDefaultTypeInternal;
+extern ExampleParserConfiguration_FeatureMapEntry_DoNotUseDefaultTypeInternal _ExampleParserConfiguration_FeatureMapEntry_DoNotUse_default_instance_;
+class FeatureConfiguration;
+struct FeatureConfigurationDefaultTypeInternal;
+extern FeatureConfigurationDefaultTypeInternal _FeatureConfiguration_default_instance_;
+class FixedLenFeatureProto;
+struct FixedLenFeatureProtoDefaultTypeInternal;
+extern FixedLenFeatureProtoDefaultTypeInternal _FixedLenFeatureProto_default_instance_;
+class VarLenFeatureProto;
+struct VarLenFeatureProtoDefaultTypeInternal;
+extern VarLenFeatureProtoDefaultTypeInternal _VarLenFeatureProto_default_instance_;
+}  // namespace tensorflow
+PROTOBUF_NAMESPACE_OPEN
+template<> ::tensorflow::ExampleParserConfiguration* Arena::CreateMaybeMessage<::tensorflow::ExampleParserConfiguration>(Arena*);
+template<> ::tensorflow::ExampleParserConfiguration_FeatureMapEntry_DoNotUse* Arena::CreateMaybeMessage<::tensorflow::ExampleParserConfiguration_FeatureMapEntry_DoNotUse>(Arena*);
+template<> ::tensorflow::FeatureConfiguration* Arena::CreateMaybeMessage<::tensorflow::FeatureConfiguration>(Arena*);
+template<> ::tensorflow::FixedLenFeatureProto* Arena::CreateMaybeMessage<::tensorflow::FixedLenFeatureProto>(Arena*);
+template<> ::tensorflow::VarLenFeatureProto* Arena::CreateMaybeMessage<::tensorflow::VarLenFeatureProto>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace tensorflow {
+
+// ===================================================================
+
+class VarLenFeatureProto final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.VarLenFeatureProto) */ {
+ public:
+  inline VarLenFeatureProto() : VarLenFeatureProto(nullptr) {}
+  ~VarLenFeatureProto() override;
+  explicit PROTOBUF_CONSTEXPR VarLenFeatureProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  VarLenFeatureProto(const VarLenFeatureProto& from);
+  VarLenFeatureProto(VarLenFeatureProto&& from) noexcept
+    : VarLenFeatureProto() {
+    *this = ::std::move(from);
+  }
+
+  inline VarLenFeatureProto& operator=(const VarLenFeatureProto& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline VarLenFeatureProto& operator=(VarLenFeatureProto&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const VarLenFeatureProto& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const VarLenFeatureProto* internal_default_instance() {
+    return reinterpret_cast<const VarLenFeatureProto*>(
+               &_VarLenFeatureProto_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(VarLenFeatureProto& a, VarLenFeatureProto& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(VarLenFeatureProto* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(VarLenFeatureProto* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  VarLenFeatureProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<VarLenFeatureProto>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const VarLenFeatureProto& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const VarLenFeatureProto& from) {
+    VarLenFeatureProto::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(VarLenFeatureProto* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.VarLenFeatureProto";
+  }
+  protected:
+  explicit VarLenFeatureProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kValuesOutputTensorNameFieldNumber = 2,
+    kIndicesOutputTensorNameFieldNumber = 3,
+    kShapesOutputTensorNameFieldNumber = 4,
+    kDtypeFieldNumber = 1,
+  };
+  // string values_output_tensor_name = 2;
+  void clear_values_output_tensor_name();
+  const std::string& values_output_tensor_name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_values_output_tensor_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_values_output_tensor_name();
+  PROTOBUF_NODISCARD std::string* release_values_output_tensor_name();
+  void set_allocated_values_output_tensor_name(std::string* values_output_tensor_name);
+  private:
+  const std::string& _internal_values_output_tensor_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_values_output_tensor_name(const std::string& value);
+  std::string* _internal_mutable_values_output_tensor_name();
+  public:
+
+  // string indices_output_tensor_name = 3;
+  void clear_indices_output_tensor_name();
+  const std::string& indices_output_tensor_name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_indices_output_tensor_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_indices_output_tensor_name();
+  PROTOBUF_NODISCARD std::string* release_indices_output_tensor_name();
+  void set_allocated_indices_output_tensor_name(std::string* indices_output_tensor_name);
+  private:
+  const std::string& _internal_indices_output_tensor_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_indices_output_tensor_name(const std::string& value);
+  std::string* _internal_mutable_indices_output_tensor_name();
+  public:
+
+  // string shapes_output_tensor_name = 4;
+  void clear_shapes_output_tensor_name();
+  const std::string& shapes_output_tensor_name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_shapes_output_tensor_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_shapes_output_tensor_name();
+  PROTOBUF_NODISCARD std::string* release_shapes_output_tensor_name();
+  void set_allocated_shapes_output_tensor_name(std::string* shapes_output_tensor_name);
+  private:
+  const std::string& _internal_shapes_output_tensor_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_shapes_output_tensor_name(const std::string& value);
+  std::string* _internal_mutable_shapes_output_tensor_name();
+  public:
+
+  // .tensorflow.DataType dtype = 1;
+  void clear_dtype();
+  ::tensorflow::DataType dtype() const;
+  void set_dtype(::tensorflow::DataType value);
+  private:
+  ::tensorflow::DataType _internal_dtype() const;
+  void _internal_set_dtype(::tensorflow::DataType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.VarLenFeatureProto)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr values_output_tensor_name_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr indices_output_tensor_name_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr shapes_output_tensor_name_;
+    int dtype_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fexample_2fexample_5fparser_5fconfiguration_2eproto;
+};
+// -------------------------------------------------------------------
+
+class FixedLenFeatureProto final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.FixedLenFeatureProto) */ {
+ public:
+  inline FixedLenFeatureProto() : FixedLenFeatureProto(nullptr) {}
+  ~FixedLenFeatureProto() override;
+  explicit PROTOBUF_CONSTEXPR FixedLenFeatureProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  FixedLenFeatureProto(const FixedLenFeatureProto& from);
+  FixedLenFeatureProto(FixedLenFeatureProto&& from) noexcept
+    : FixedLenFeatureProto() {
+    *this = ::std::move(from);
+  }
+
+  inline FixedLenFeatureProto& operator=(const FixedLenFeatureProto& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline FixedLenFeatureProto& operator=(FixedLenFeatureProto&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const FixedLenFeatureProto& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const FixedLenFeatureProto* internal_default_instance() {
+    return reinterpret_cast<const FixedLenFeatureProto*>(
+               &_FixedLenFeatureProto_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(FixedLenFeatureProto& a, FixedLenFeatureProto& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(FixedLenFeatureProto* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(FixedLenFeatureProto* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  FixedLenFeatureProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<FixedLenFeatureProto>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const FixedLenFeatureProto& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const FixedLenFeatureProto& from) {
+    FixedLenFeatureProto::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(FixedLenFeatureProto* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.FixedLenFeatureProto";
+  }
+  protected:
+  explicit FixedLenFeatureProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kValuesOutputTensorNameFieldNumber = 4,
+    kShapeFieldNumber = 2,
+    kDefaultValueFieldNumber = 3,
+    kDtypeFieldNumber = 1,
+  };
+  // string values_output_tensor_name = 4;
+  void clear_values_output_tensor_name();
+  const std::string& values_output_tensor_name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_values_output_tensor_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_values_output_tensor_name();
+  PROTOBUF_NODISCARD std::string* release_values_output_tensor_name();
+  void set_allocated_values_output_tensor_name(std::string* values_output_tensor_name);
+  private:
+  const std::string& _internal_values_output_tensor_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_values_output_tensor_name(const std::string& value);
+  std::string* _internal_mutable_values_output_tensor_name();
+  public:
+
+  // .tensorflow.TensorShapeProto shape = 2;
+  bool has_shape() const;
+  private:
+  bool _internal_has_shape() const;
+  public:
+  void clear_shape();
+  const ::tensorflow::TensorShapeProto& shape() const;
+  PROTOBUF_NODISCARD ::tensorflow::TensorShapeProto* release_shape();
+  ::tensorflow::TensorShapeProto* mutable_shape();
+  void set_allocated_shape(::tensorflow::TensorShapeProto* shape);
+  private:
+  const ::tensorflow::TensorShapeProto& _internal_shape() const;
+  ::tensorflow::TensorShapeProto* _internal_mutable_shape();
+  public:
+  void unsafe_arena_set_allocated_shape(
+      ::tensorflow::TensorShapeProto* shape);
+  ::tensorflow::TensorShapeProto* unsafe_arena_release_shape();
+
+  // .tensorflow.TensorProto default_value = 3;
+  bool has_default_value() const;
+  private:
+  bool _internal_has_default_value() const;
+  public:
+  void clear_default_value();
+  const ::tensorflow::TensorProto& default_value() const;
+  PROTOBUF_NODISCARD ::tensorflow::TensorProto* release_default_value();
+  ::tensorflow::TensorProto* mutable_default_value();
+  void set_allocated_default_value(::tensorflow::TensorProto* default_value);
+  private:
+  const ::tensorflow::TensorProto& _internal_default_value() const;
+  ::tensorflow::TensorProto* _internal_mutable_default_value();
+  public:
+  void unsafe_arena_set_allocated_default_value(
+      ::tensorflow::TensorProto* default_value);
+  ::tensorflow::TensorProto* unsafe_arena_release_default_value();
+
+  // .tensorflow.DataType dtype = 1;
+  void clear_dtype();
+  ::tensorflow::DataType dtype() const;
+  void set_dtype(::tensorflow::DataType value);
+  private:
+  ::tensorflow::DataType _internal_dtype() const;
+  void _internal_set_dtype(::tensorflow::DataType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.FixedLenFeatureProto)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr values_output_tensor_name_;
+    ::tensorflow::TensorShapeProto* shape_;
+    ::tensorflow::TensorProto* default_value_;
+    int dtype_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fexample_2fexample_5fparser_5fconfiguration_2eproto;
+};
+// -------------------------------------------------------------------
+
+class FeatureConfiguration final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.FeatureConfiguration) */ {
+ public:
+  inline FeatureConfiguration() : FeatureConfiguration(nullptr) {}
+  ~FeatureConfiguration() override;
+  explicit PROTOBUF_CONSTEXPR FeatureConfiguration(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  FeatureConfiguration(const FeatureConfiguration& from);
+  FeatureConfiguration(FeatureConfiguration&& from) noexcept
+    : FeatureConfiguration() {
+    *this = ::std::move(from);
+  }
+
+  inline FeatureConfiguration& operator=(const FeatureConfiguration& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline FeatureConfiguration& operator=(FeatureConfiguration&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const FeatureConfiguration& default_instance() {
+    return *internal_default_instance();
+  }
+  enum ConfigCase {
+    kFixedLenFeature = 1,
+    kVarLenFeature = 2,
+    CONFIG_NOT_SET = 0,
+  };
+
+  static inline const FeatureConfiguration* internal_default_instance() {
+    return reinterpret_cast<const FeatureConfiguration*>(
+               &_FeatureConfiguration_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(FeatureConfiguration& a, FeatureConfiguration& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(FeatureConfiguration* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(FeatureConfiguration* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  FeatureConfiguration* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<FeatureConfiguration>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const FeatureConfiguration& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const FeatureConfiguration& from) {
+    FeatureConfiguration::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(FeatureConfiguration* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.FeatureConfiguration";
+  }
+  protected:
+  explicit FeatureConfiguration(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kFixedLenFeatureFieldNumber = 1,
+    kVarLenFeatureFieldNumber = 2,
+  };
+  // .tensorflow.FixedLenFeatureProto fixed_len_feature = 1;
+  bool has_fixed_len_feature() const;
+  private:
+  bool _internal_has_fixed_len_feature() const;
+  public:
+  void clear_fixed_len_feature();
+  const ::tensorflow::FixedLenFeatureProto& fixed_len_feature() const;
+  PROTOBUF_NODISCARD ::tensorflow::FixedLenFeatureProto* release_fixed_len_feature();
+  ::tensorflow::FixedLenFeatureProto* mutable_fixed_len_feature();
+  void set_allocated_fixed_len_feature(::tensorflow::FixedLenFeatureProto* fixed_len_feature);
+  private:
+  const ::tensorflow::FixedLenFeatureProto& _internal_fixed_len_feature() const;
+  ::tensorflow::FixedLenFeatureProto* _internal_mutable_fixed_len_feature();
+  public:
+  void unsafe_arena_set_allocated_fixed_len_feature(
+      ::tensorflow::FixedLenFeatureProto* fixed_len_feature);
+  ::tensorflow::FixedLenFeatureProto* unsafe_arena_release_fixed_len_feature();
+
+  // .tensorflow.VarLenFeatureProto var_len_feature = 2;
+  bool has_var_len_feature() const;
+  private:
+  bool _internal_has_var_len_feature() const;
+  public:
+  void clear_var_len_feature();
+  const ::tensorflow::VarLenFeatureProto& var_len_feature() const;
+  PROTOBUF_NODISCARD ::tensorflow::VarLenFeatureProto* release_var_len_feature();
+  ::tensorflow::VarLenFeatureProto* mutable_var_len_feature();
+  void set_allocated_var_len_feature(::tensorflow::VarLenFeatureProto* var_len_feature);
+  private:
+  const ::tensorflow::VarLenFeatureProto& _internal_var_len_feature() const;
+  ::tensorflow::VarLenFeatureProto* _internal_mutable_var_len_feature();
+  public:
+  void unsafe_arena_set_allocated_var_len_feature(
+      ::tensorflow::VarLenFeatureProto* var_len_feature);
+  ::tensorflow::VarLenFeatureProto* unsafe_arena_release_var_len_feature();
+
+  void clear_config();
+  ConfigCase config_case() const;
+  // @@protoc_insertion_point(class_scope:tensorflow.FeatureConfiguration)
+ private:
+  class _Internal;
+  void set_has_fixed_len_feature();
+  void set_has_var_len_feature();
+
+  inline bool has_config() const;
+  inline void clear_has_config();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    union ConfigUnion {
+      constexpr ConfigUnion() : _constinit_{} {}
+        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+      ::tensorflow::FixedLenFeatureProto* fixed_len_feature_;
+      ::tensorflow::VarLenFeatureProto* var_len_feature_;
+    } config_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    uint32_t _oneof_case_[1];
+
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fexample_2fexample_5fparser_5fconfiguration_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ExampleParserConfiguration_FeatureMapEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<ExampleParserConfiguration_FeatureMapEntry_DoNotUse, 
+    std::string, ::tensorflow::FeatureConfiguration,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> {
+public:
+  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<ExampleParserConfiguration_FeatureMapEntry_DoNotUse, 
+    std::string, ::tensorflow::FeatureConfiguration,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
+  ExampleParserConfiguration_FeatureMapEntry_DoNotUse();
+  explicit PROTOBUF_CONSTEXPR ExampleParserConfiguration_FeatureMapEntry_DoNotUse(
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+  explicit ExampleParserConfiguration_FeatureMapEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  void MergeFrom(const ExampleParserConfiguration_FeatureMapEntry_DoNotUse& other);
+  static const ExampleParserConfiguration_FeatureMapEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const ExampleParserConfiguration_FeatureMapEntry_DoNotUse*>(&_ExampleParserConfiguration_FeatureMapEntry_DoNotUse_default_instance_); }
+  static bool ValidateKey(std::string* s) {
+    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "tensorflow.ExampleParserConfiguration.FeatureMapEntry.key");
+ }
+  static bool ValidateValue(void*) { return true; }
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+  friend struct ::TableStruct_tensorflow_2fcore_2fexample_2fexample_5fparser_5fconfiguration_2eproto;
+};
+
+// -------------------------------------------------------------------
+
+class ExampleParserConfiguration final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.ExampleParserConfiguration) */ {
+ public:
+  inline ExampleParserConfiguration() : ExampleParserConfiguration(nullptr) {}
+  ~ExampleParserConfiguration() override;
+  explicit PROTOBUF_CONSTEXPR ExampleParserConfiguration(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ExampleParserConfiguration(const ExampleParserConfiguration& from);
+  ExampleParserConfiguration(ExampleParserConfiguration&& from) noexcept
+    : ExampleParserConfiguration() {
+    *this = ::std::move(from);
+  }
+
+  inline ExampleParserConfiguration& operator=(const ExampleParserConfiguration& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ExampleParserConfiguration& operator=(ExampleParserConfiguration&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ExampleParserConfiguration& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ExampleParserConfiguration* internal_default_instance() {
+    return reinterpret_cast<const ExampleParserConfiguration*>(
+               &_ExampleParserConfiguration_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    4;
+
+  friend void swap(ExampleParserConfiguration& a, ExampleParserConfiguration& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ExampleParserConfiguration* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ExampleParserConfiguration* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ExampleParserConfiguration* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ExampleParserConfiguration>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ExampleParserConfiguration& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const ExampleParserConfiguration& from) {
+    ExampleParserConfiguration::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ExampleParserConfiguration* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.ExampleParserConfiguration";
+  }
+  protected:
+  explicit ExampleParserConfiguration(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kFeatureMapFieldNumber = 1,
+  };
+  // map<string, .tensorflow.FeatureConfiguration> feature_map = 1;
+  int feature_map_size() const;
+  private:
+  int _internal_feature_map_size() const;
+  public:
+  void clear_feature_map();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::FeatureConfiguration >&
+      _internal_feature_map() const;
+  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::FeatureConfiguration >*
+      _internal_mutable_feature_map();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::FeatureConfiguration >&
+      feature_map() const;
+  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::FeatureConfiguration >*
+      mutable_feature_map();
+
+  // @@protoc_insertion_point(class_scope:tensorflow.ExampleParserConfiguration)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::MapField<
+        ExampleParserConfiguration_FeatureMapEntry_DoNotUse,
+        std::string, ::tensorflow::FeatureConfiguration,
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> feature_map_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fexample_2fexample_5fparser_5fconfiguration_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// VarLenFeatureProto
+
+// .tensorflow.DataType dtype = 1;
+inline void VarLenFeatureProto::clear_dtype() {
+  _impl_.dtype_ = 0;
+}
+inline ::tensorflow::DataType VarLenFeatureProto::_internal_dtype() const {
+  return static_cast< ::tensorflow::DataType >(_impl_.dtype_);
+}
+inline ::tensorflow::DataType VarLenFeatureProto::dtype() const {
+  // @@protoc_insertion_point(field_get:tensorflow.VarLenFeatureProto.dtype)
+  return _internal_dtype();
+}
+inline void VarLenFeatureProto::_internal_set_dtype(::tensorflow::DataType value) {
+  
+  _impl_.dtype_ = value;
+}
+inline void VarLenFeatureProto::set_dtype(::tensorflow::DataType value) {
+  _internal_set_dtype(value);
+  // @@protoc_insertion_point(field_set:tensorflow.VarLenFeatureProto.dtype)
+}
+
+// string values_output_tensor_name = 2;
+inline void VarLenFeatureProto::clear_values_output_tensor_name() {
+  _impl_.values_output_tensor_name_.ClearToEmpty();
+}
+inline const std::string& VarLenFeatureProto::values_output_tensor_name() const {
+  // @@protoc_insertion_point(field_get:tensorflow.VarLenFeatureProto.values_output_tensor_name)
+  return _internal_values_output_tensor_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void VarLenFeatureProto::set_values_output_tensor_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.values_output_tensor_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.VarLenFeatureProto.values_output_tensor_name)
+}
+inline std::string* VarLenFeatureProto::mutable_values_output_tensor_name() {
+  std::string* _s = _internal_mutable_values_output_tensor_name();
+  // @@protoc_insertion_point(field_mutable:tensorflow.VarLenFeatureProto.values_output_tensor_name)
+  return _s;
+}
+inline const std::string& VarLenFeatureProto::_internal_values_output_tensor_name() const {
+  return _impl_.values_output_tensor_name_.Get();
+}
+inline void VarLenFeatureProto::_internal_set_values_output_tensor_name(const std::string& value) {
+  
+  _impl_.values_output_tensor_name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* VarLenFeatureProto::_internal_mutable_values_output_tensor_name() {
+  
+  return _impl_.values_output_tensor_name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* VarLenFeatureProto::release_values_output_tensor_name() {
+  // @@protoc_insertion_point(field_release:tensorflow.VarLenFeatureProto.values_output_tensor_name)
+  return _impl_.values_output_tensor_name_.Release();
+}
+inline void VarLenFeatureProto::set_allocated_values_output_tensor_name(std::string* values_output_tensor_name) {
+  if (values_output_tensor_name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.values_output_tensor_name_.SetAllocated(values_output_tensor_name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.values_output_tensor_name_.IsDefault()) {
+    _impl_.values_output_tensor_name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.VarLenFeatureProto.values_output_tensor_name)
+}
+
+// string indices_output_tensor_name = 3;
+inline void VarLenFeatureProto::clear_indices_output_tensor_name() {
+  _impl_.indices_output_tensor_name_.ClearToEmpty();
+}
+inline const std::string& VarLenFeatureProto::indices_output_tensor_name() const {
+  // @@protoc_insertion_point(field_get:tensorflow.VarLenFeatureProto.indices_output_tensor_name)
+  return _internal_indices_output_tensor_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void VarLenFeatureProto::set_indices_output_tensor_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.indices_output_tensor_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.VarLenFeatureProto.indices_output_tensor_name)
+}
+inline std::string* VarLenFeatureProto::mutable_indices_output_tensor_name() {
+  std::string* _s = _internal_mutable_indices_output_tensor_name();
+  // @@protoc_insertion_point(field_mutable:tensorflow.VarLenFeatureProto.indices_output_tensor_name)
+  return _s;
+}
+inline const std::string& VarLenFeatureProto::_internal_indices_output_tensor_name() const {
+  return _impl_.indices_output_tensor_name_.Get();
+}
+inline void VarLenFeatureProto::_internal_set_indices_output_tensor_name(const std::string& value) {
+  
+  _impl_.indices_output_tensor_name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* VarLenFeatureProto::_internal_mutable_indices_output_tensor_name() {
+  
+  return _impl_.indices_output_tensor_name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* VarLenFeatureProto::release_indices_output_tensor_name() {
+  // @@protoc_insertion_point(field_release:tensorflow.VarLenFeatureProto.indices_output_tensor_name)
+  return _impl_.indices_output_tensor_name_.Release();
+}
+inline void VarLenFeatureProto::set_allocated_indices_output_tensor_name(std::string* indices_output_tensor_name) {
+  if (indices_output_tensor_name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.indices_output_tensor_name_.SetAllocated(indices_output_tensor_name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.indices_output_tensor_name_.IsDefault()) {
+    _impl_.indices_output_tensor_name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.VarLenFeatureProto.indices_output_tensor_name)
+}
+
+// string shapes_output_tensor_name = 4;
+inline void VarLenFeatureProto::clear_shapes_output_tensor_name() {
+  _impl_.shapes_output_tensor_name_.ClearToEmpty();
+}
+inline const std::string& VarLenFeatureProto::shapes_output_tensor_name() const {
+  // @@protoc_insertion_point(field_get:tensorflow.VarLenFeatureProto.shapes_output_tensor_name)
+  return _internal_shapes_output_tensor_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void VarLenFeatureProto::set_shapes_output_tensor_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.shapes_output_tensor_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.VarLenFeatureProto.shapes_output_tensor_name)
+}
+inline std::string* VarLenFeatureProto::mutable_shapes_output_tensor_name() {
+  std::string* _s = _internal_mutable_shapes_output_tensor_name();
+  // @@protoc_insertion_point(field_mutable:tensorflow.VarLenFeatureProto.shapes_output_tensor_name)
+  return _s;
+}
+inline const std::string& VarLenFeatureProto::_internal_shapes_output_tensor_name() const {
+  return _impl_.shapes_output_tensor_name_.Get();
+}
+inline void VarLenFeatureProto::_internal_set_shapes_output_tensor_name(const std::string& value) {
+  
+  _impl_.shapes_output_tensor_name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* VarLenFeatureProto::_internal_mutable_shapes_output_tensor_name() {
+  
+  return _impl_.shapes_output_tensor_name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* VarLenFeatureProto::release_shapes_output_tensor_name() {
+  // @@protoc_insertion_point(field_release:tensorflow.VarLenFeatureProto.shapes_output_tensor_name)
+  return _impl_.shapes_output_tensor_name_.Release();
+}
+inline void VarLenFeatureProto::set_allocated_shapes_output_tensor_name(std::string* shapes_output_tensor_name) {
+  if (shapes_output_tensor_name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.shapes_output_tensor_name_.SetAllocated(shapes_output_tensor_name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.shapes_output_tensor_name_.IsDefault()) {
+    _impl_.shapes_output_tensor_name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.VarLenFeatureProto.shapes_output_tensor_name)
+}
+
+// -------------------------------------------------------------------
+
+// FixedLenFeatureProto
+
+// .tensorflow.DataType dtype = 1;
+inline void FixedLenFeatureProto::clear_dtype() {
+  _impl_.dtype_ = 0;
+}
+inline ::tensorflow::DataType FixedLenFeatureProto::_internal_dtype() const {
+  return static_cast< ::tensorflow::DataType >(_impl_.dtype_);
+}
+inline ::tensorflow::DataType FixedLenFeatureProto::dtype() const {
+  // @@protoc_insertion_point(field_get:tensorflow.FixedLenFeatureProto.dtype)
+  return _internal_dtype();
+}
+inline void FixedLenFeatureProto::_internal_set_dtype(::tensorflow::DataType value) {
+  
+  _impl_.dtype_ = value;
+}
+inline void FixedLenFeatureProto::set_dtype(::tensorflow::DataType value) {
+  _internal_set_dtype(value);
+  // @@protoc_insertion_point(field_set:tensorflow.FixedLenFeatureProto.dtype)
+}
+
+// .tensorflow.TensorShapeProto shape = 2;
+inline bool FixedLenFeatureProto::_internal_has_shape() const {
+  return this != internal_default_instance() && _impl_.shape_ != nullptr;
+}
+inline bool FixedLenFeatureProto::has_shape() const {
+  return _internal_has_shape();
+}
+inline const ::tensorflow::TensorShapeProto& FixedLenFeatureProto::_internal_shape() const {
+  const ::tensorflow::TensorShapeProto* p = _impl_.shape_;
+  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::TensorShapeProto&>(
+      ::tensorflow::_TensorShapeProto_default_instance_);
+}
+inline const ::tensorflow::TensorShapeProto& FixedLenFeatureProto::shape() const {
+  // @@protoc_insertion_point(field_get:tensorflow.FixedLenFeatureProto.shape)
+  return _internal_shape();
+}
+inline void FixedLenFeatureProto::unsafe_arena_set_allocated_shape(
+    ::tensorflow::TensorShapeProto* shape) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.shape_);
+  }
+  _impl_.shape_ = shape;
+  if (shape) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.FixedLenFeatureProto.shape)
+}
+inline ::tensorflow::TensorShapeProto* FixedLenFeatureProto::release_shape() {
+  
+  ::tensorflow::TensorShapeProto* temp = _impl_.shape_;
+  _impl_.shape_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::tensorflow::TensorShapeProto* FixedLenFeatureProto::unsafe_arena_release_shape() {
+  // @@protoc_insertion_point(field_release:tensorflow.FixedLenFeatureProto.shape)
+  
+  ::tensorflow::TensorShapeProto* temp = _impl_.shape_;
+  _impl_.shape_ = nullptr;
+  return temp;
+}
+inline ::tensorflow::TensorShapeProto* FixedLenFeatureProto::_internal_mutable_shape() {
+  
+  if (_impl_.shape_ == nullptr) {
+    auto* p = CreateMaybeMessage<::tensorflow::TensorShapeProto>(GetArenaForAllocation());
+    _impl_.shape_ = p;
+  }
+  return _impl_.shape_;
+}
+inline ::tensorflow::TensorShapeProto* FixedLenFeatureProto::mutable_shape() {
+  ::tensorflow::TensorShapeProto* _msg = _internal_mutable_shape();
+  // @@protoc_insertion_point(field_mutable:tensorflow.FixedLenFeatureProto.shape)
+  return _msg;
+}
+inline void FixedLenFeatureProto::set_allocated_shape(::tensorflow::TensorShapeProto* shape) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.shape_);
+  }
+  if (shape) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(shape));
+    if (message_arena != submessage_arena) {
+      shape = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, shape, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.shape_ = shape;
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.FixedLenFeatureProto.shape)
+}
+
+// .tensorflow.TensorProto default_value = 3;
+inline bool FixedLenFeatureProto::_internal_has_default_value() const {
+  return this != internal_default_instance() && _impl_.default_value_ != nullptr;
+}
+inline bool FixedLenFeatureProto::has_default_value() const {
+  return _internal_has_default_value();
+}
+inline const ::tensorflow::TensorProto& FixedLenFeatureProto::_internal_default_value() const {
+  const ::tensorflow::TensorProto* p = _impl_.default_value_;
+  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::TensorProto&>(
+      ::tensorflow::_TensorProto_default_instance_);
+}
+inline const ::tensorflow::TensorProto& FixedLenFeatureProto::default_value() const {
+  // @@protoc_insertion_point(field_get:tensorflow.FixedLenFeatureProto.default_value)
+  return _internal_default_value();
+}
+inline void FixedLenFeatureProto::unsafe_arena_set_allocated_default_value(
+    ::tensorflow::TensorProto* default_value) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.default_value_);
+  }
+  _impl_.default_value_ = default_value;
+  if (default_value) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.FixedLenFeatureProto.default_value)
+}
+inline ::tensorflow::TensorProto* FixedLenFeatureProto::release_default_value() {
+  
+  ::tensorflow::TensorProto* temp = _impl_.default_value_;
+  _impl_.default_value_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::tensorflow::TensorProto* FixedLenFeatureProto::unsafe_arena_release_default_value() {
+  // @@protoc_insertion_point(field_release:tensorflow.FixedLenFeatureProto.default_value)
+  
+  ::tensorflow::TensorProto* temp = _impl_.default_value_;
+  _impl_.default_value_ = nullptr;
+  return temp;
+}
+inline ::tensorflow::TensorProto* FixedLenFeatureProto::_internal_mutable_default_value() {
+  
+  if (_impl_.default_value_ == nullptr) {
+    auto* p = CreateMaybeMessage<::tensorflow::TensorProto>(GetArenaForAllocation());
+    _impl_.default_value_ = p;
+  }
+  return _impl_.default_value_;
+}
+inline ::tensorflow::TensorProto* FixedLenFeatureProto::mutable_default_value() {
+  ::tensorflow::TensorProto* _msg = _internal_mutable_default_value();
+  // @@protoc_insertion_point(field_mutable:tensorflow.FixedLenFeatureProto.default_value)
+  return _msg;
+}
+inline void FixedLenFeatureProto::set_allocated_default_value(::tensorflow::TensorProto* default_value) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.default_value_);
+  }
+  if (default_value) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(default_value));
+    if (message_arena != submessage_arena) {
+      default_value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, default_value, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.default_value_ = default_value;
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.FixedLenFeatureProto.default_value)
+}
+
+// string values_output_tensor_name = 4;
+inline void FixedLenFeatureProto::clear_values_output_tensor_name() {
+  _impl_.values_output_tensor_name_.ClearToEmpty();
+}
+inline const std::string& FixedLenFeatureProto::values_output_tensor_name() const {
+  // @@protoc_insertion_point(field_get:tensorflow.FixedLenFeatureProto.values_output_tensor_name)
+  return _internal_values_output_tensor_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void FixedLenFeatureProto::set_values_output_tensor_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.values_output_tensor_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.FixedLenFeatureProto.values_output_tensor_name)
+}
+inline std::string* FixedLenFeatureProto::mutable_values_output_tensor_name() {
+  std::string* _s = _internal_mutable_values_output_tensor_name();
+  // @@protoc_insertion_point(field_mutable:tensorflow.FixedLenFeatureProto.values_output_tensor_name)
+  return _s;
+}
+inline const std::string& FixedLenFeatureProto::_internal_values_output_tensor_name() const {
+  return _impl_.values_output_tensor_name_.Get();
+}
+inline void FixedLenFeatureProto::_internal_set_values_output_tensor_name(const std::string& value) {
+  
+  _impl_.values_output_tensor_name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* FixedLenFeatureProto::_internal_mutable_values_output_tensor_name() {
+  
+  return _impl_.values_output_tensor_name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* FixedLenFeatureProto::release_values_output_tensor_name() {
+  // @@protoc_insertion_point(field_release:tensorflow.FixedLenFeatureProto.values_output_tensor_name)
+  return _impl_.values_output_tensor_name_.Release();
+}
+inline void FixedLenFeatureProto::set_allocated_values_output_tensor_name(std::string* values_output_tensor_name) {
+  if (values_output_tensor_name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.values_output_tensor_name_.SetAllocated(values_output_tensor_name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.values_output_tensor_name_.IsDefault()) {
+    _impl_.values_output_tensor_name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.FixedLenFeatureProto.values_output_tensor_name)
+}
+
+// -------------------------------------------------------------------
+
+// FeatureConfiguration
+
+// .tensorflow.FixedLenFeatureProto fixed_len_feature = 1;
+inline bool FeatureConfiguration::_internal_has_fixed_len_feature() const {
+  return config_case() == kFixedLenFeature;
+}
+inline bool FeatureConfiguration::has_fixed_len_feature() const {
+  return _internal_has_fixed_len_feature();
+}
+inline void FeatureConfiguration::set_has_fixed_len_feature() {
+  _impl_._oneof_case_[0] = kFixedLenFeature;
+}
+inline void FeatureConfiguration::clear_fixed_len_feature() {
+  if (_internal_has_fixed_len_feature()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete _impl_.config_.fixed_len_feature_;
+    }
+    clear_has_config();
+  }
+}
+inline ::tensorflow::FixedLenFeatureProto* FeatureConfiguration::release_fixed_len_feature() {
+  // @@protoc_insertion_point(field_release:tensorflow.FeatureConfiguration.fixed_len_feature)
+  if (_internal_has_fixed_len_feature()) {
+    clear_has_config();
+    ::tensorflow::FixedLenFeatureProto* temp = _impl_.config_.fixed_len_feature_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    _impl_.config_.fixed_len_feature_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::tensorflow::FixedLenFeatureProto& FeatureConfiguration::_internal_fixed_len_feature() const {
+  return _internal_has_fixed_len_feature()
+      ? *_impl_.config_.fixed_len_feature_
+      : reinterpret_cast< ::tensorflow::FixedLenFeatureProto&>(::tensorflow::_FixedLenFeatureProto_default_instance_);
+}
+inline const ::tensorflow::FixedLenFeatureProto& FeatureConfiguration::fixed_len_feature() const {
+  // @@protoc_insertion_point(field_get:tensorflow.FeatureConfiguration.fixed_len_feature)
+  return _internal_fixed_len_feature();
+}
+inline ::tensorflow::FixedLenFeatureProto* FeatureConfiguration::unsafe_arena_release_fixed_len_feature() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.FeatureConfiguration.fixed_len_feature)
+  if (_internal_has_fixed_len_feature()) {
+    clear_has_config();
+    ::tensorflow::FixedLenFeatureProto* temp = _impl_.config_.fixed_len_feature_;
+    _impl_.config_.fixed_len_feature_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void FeatureConfiguration::unsafe_arena_set_allocated_fixed_len_feature(::tensorflow::FixedLenFeatureProto* fixed_len_feature) {
+  clear_config();
+  if (fixed_len_feature) {
+    set_has_fixed_len_feature();
+    _impl_.config_.fixed_len_feature_ = fixed_len_feature;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.FeatureConfiguration.fixed_len_feature)
+}
+inline ::tensorflow::FixedLenFeatureProto* FeatureConfiguration::_internal_mutable_fixed_len_feature() {
+  if (!_internal_has_fixed_len_feature()) {
+    clear_config();
+    set_has_fixed_len_feature();
+    _impl_.config_.fixed_len_feature_ = CreateMaybeMessage< ::tensorflow::FixedLenFeatureProto >(GetArenaForAllocation());
+  }
+  return _impl_.config_.fixed_len_feature_;
+}
+inline ::tensorflow::FixedLenFeatureProto* FeatureConfiguration::mutable_fixed_len_feature() {
+  ::tensorflow::FixedLenFeatureProto* _msg = _internal_mutable_fixed_len_feature();
+  // @@protoc_insertion_point(field_mutable:tensorflow.FeatureConfiguration.fixed_len_feature)
+  return _msg;
+}
+
+// .tensorflow.VarLenFeatureProto var_len_feature = 2;
+inline bool FeatureConfiguration::_internal_has_var_len_feature() const {
+  return config_case() == kVarLenFeature;
+}
+inline bool FeatureConfiguration::has_var_len_feature() const {
+  return _internal_has_var_len_feature();
+}
+inline void FeatureConfiguration::set_has_var_len_feature() {
+  _impl_._oneof_case_[0] = kVarLenFeature;
+}
+inline void FeatureConfiguration::clear_var_len_feature() {
+  if (_internal_has_var_len_feature()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete _impl_.config_.var_len_feature_;
+    }
+    clear_has_config();
+  }
+}
+inline ::tensorflow::VarLenFeatureProto* FeatureConfiguration::release_var_len_feature() {
+  // @@protoc_insertion_point(field_release:tensorflow.FeatureConfiguration.var_len_feature)
+  if (_internal_has_var_len_feature()) {
+    clear_has_config();
+    ::tensorflow::VarLenFeatureProto* temp = _impl_.config_.var_len_feature_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    _impl_.config_.var_len_feature_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::tensorflow::VarLenFeatureProto& FeatureConfiguration::_internal_var_len_feature() const {
+  return _internal_has_var_len_feature()
+      ? *_impl_.config_.var_len_feature_
+      : reinterpret_cast< ::tensorflow::VarLenFeatureProto&>(::tensorflow::_VarLenFeatureProto_default_instance_);
+}
+inline const ::tensorflow::VarLenFeatureProto& FeatureConfiguration::var_len_feature() const {
+  // @@protoc_insertion_point(field_get:tensorflow.FeatureConfiguration.var_len_feature)
+  return _internal_var_len_feature();
+}
+inline ::tensorflow::VarLenFeatureProto* FeatureConfiguration::unsafe_arena_release_var_len_feature() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.FeatureConfiguration.var_len_feature)
+  if (_internal_has_var_len_feature()) {
+    clear_has_config();
+    ::tensorflow::VarLenFeatureProto* temp = _impl_.config_.var_len_feature_;
+    _impl_.config_.var_len_feature_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void FeatureConfiguration::unsafe_arena_set_allocated_var_len_feature(::tensorflow::VarLenFeatureProto* var_len_feature) {
+  clear_config();
+  if (var_len_feature) {
+    set_has_var_len_feature();
+    _impl_.config_.var_len_feature_ = var_len_feature;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.FeatureConfiguration.var_len_feature)
+}
+inline ::tensorflow::VarLenFeatureProto* FeatureConfiguration::_internal_mutable_var_len_feature() {
+  if (!_internal_has_var_len_feature()) {
+    clear_config();
+    set_has_var_len_feature();
+    _impl_.config_.var_len_feature_ = CreateMaybeMessage< ::tensorflow::VarLenFeatureProto >(GetArenaForAllocation());
+  }
+  return _impl_.config_.var_len_feature_;
+}
+inline ::tensorflow::VarLenFeatureProto* FeatureConfiguration::mutable_var_len_feature() {
+  ::tensorflow::VarLenFeatureProto* _msg = _internal_mutable_var_len_feature();
+  // @@protoc_insertion_point(field_mutable:tensorflow.FeatureConfiguration.var_len_feature)
+  return _msg;
+}
+
+inline bool FeatureConfiguration::has_config() const {
+  return config_case() != CONFIG_NOT_SET;
+}
+inline void FeatureConfiguration::clear_has_config() {
+  _impl_._oneof_case_[0] = CONFIG_NOT_SET;
+}
+inline FeatureConfiguration::ConfigCase FeatureConfiguration::config_case() const {
+  return FeatureConfiguration::ConfigCase(_impl_._oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// ExampleParserConfiguration
+
+// map<string, .tensorflow.FeatureConfiguration> feature_map = 1;
+inline int ExampleParserConfiguration::_internal_feature_map_size() const {
+  return _impl_.feature_map_.size();
+}
+inline int ExampleParserConfiguration::feature_map_size() const {
+  return _internal_feature_map_size();
+}
+inline void ExampleParserConfiguration::clear_feature_map() {
+  _impl_.feature_map_.Clear();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::FeatureConfiguration >&
+ExampleParserConfiguration::_internal_feature_map() const {
+  return _impl_.feature_map_.GetMap();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::FeatureConfiguration >&
+ExampleParserConfiguration::feature_map() const {
+  // @@protoc_insertion_point(field_map:tensorflow.ExampleParserConfiguration.feature_map)
+  return _internal_feature_map();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::FeatureConfiguration >*
+ExampleParserConfiguration::_internal_mutable_feature_map() {
+  return _impl_.feature_map_.MutableMap();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::FeatureConfiguration >*
+ExampleParserConfiguration::mutable_feature_map() {
+  // @@protoc_insertion_point(field_mutable_map:tensorflow.ExampleParserConfiguration.feature_map)
+  return _internal_mutable_feature_map();
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace tensorflow
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fexample_2fexample_5fparser_5fconfiguration_2eproto
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/example/example_parser_configuration.proto b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/example/example_parser_configuration.proto
new file mode 100644
index 0000000000000000000000000000000000000000..0af0f4b44ca968dca5f82e62abfc95e69f0eac84
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/example/example_parser_configuration.proto
@@ -0,0 +1,40 @@
+// Protocol messages for describing the configuration of the ExampleParserOp.
+
+syntax = "proto3";
+
+package tensorflow;
+
+import "tensorflow/core/framework/tensor.proto";
+import "tensorflow/core/framework/tensor_shape.proto";
+import "tensorflow/core/framework/types.proto";
+
+option cc_enable_arenas = true;
+option java_outer_classname = "ExampleParserConfigurationProtos";
+option java_multiple_files = true;
+option java_package = "org.tensorflow.example";
+option go_package = "github.com/tensorflow/tensorflow/tensorflow/go/core/example/example_parser_configuration_go_proto";
+
+message VarLenFeatureProto {
+  tensorflow.DataType dtype = 1;
+  string values_output_tensor_name = 2;
+  string indices_output_tensor_name = 3;
+  string shapes_output_tensor_name = 4;
+}
+
+message FixedLenFeatureProto {
+  tensorflow.DataType dtype = 1;
+  tensorflow.TensorShapeProto shape = 2;
+  tensorflow.TensorProto default_value = 3;
+  string values_output_tensor_name = 4;
+}
+
+message FeatureConfiguration {
+  oneof config {
+    FixedLenFeatureProto fixed_len_feature = 1;
+    VarLenFeatureProto var_len_feature = 2;
+  }
+}
+
+message ExampleParserConfiguration {
+  map<string, FeatureConfiguration> feature_map = 1;
+}
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/example/feature.pb.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/example/feature.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..55ac3a4c3e3b0f68085ae4745c926b668462b7f2
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/example/feature.pb.h
@@ -0,0 +1,1895 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: tensorflow/core/example/feature.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fexample_2ffeature_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fexample_2ffeature_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3021000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3021009 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/map.h>  // IWYU pragma: export
+#include <google/protobuf/map_entry.h>
+#include <google/protobuf/map_field_inl.h>
+#include <google/protobuf/unknown_field_set.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_tensorflow_2fcore_2fexample_2ffeature_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_tensorflow_2fcore_2fexample_2ffeature_2eproto {
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_tensorflow_2fcore_2fexample_2ffeature_2eproto;
+namespace tensorflow {
+class BytesList;
+struct BytesListDefaultTypeInternal;
+extern BytesListDefaultTypeInternal _BytesList_default_instance_;
+class Feature;
+struct FeatureDefaultTypeInternal;
+extern FeatureDefaultTypeInternal _Feature_default_instance_;
+class FeatureList;
+struct FeatureListDefaultTypeInternal;
+extern FeatureListDefaultTypeInternal _FeatureList_default_instance_;
+class FeatureLists;
+struct FeatureListsDefaultTypeInternal;
+extern FeatureListsDefaultTypeInternal _FeatureLists_default_instance_;
+class FeatureLists_FeatureListEntry_DoNotUse;
+struct FeatureLists_FeatureListEntry_DoNotUseDefaultTypeInternal;
+extern FeatureLists_FeatureListEntry_DoNotUseDefaultTypeInternal _FeatureLists_FeatureListEntry_DoNotUse_default_instance_;
+class Features;
+struct FeaturesDefaultTypeInternal;
+extern FeaturesDefaultTypeInternal _Features_default_instance_;
+class Features_FeatureEntry_DoNotUse;
+struct Features_FeatureEntry_DoNotUseDefaultTypeInternal;
+extern Features_FeatureEntry_DoNotUseDefaultTypeInternal _Features_FeatureEntry_DoNotUse_default_instance_;
+class FloatList;
+struct FloatListDefaultTypeInternal;
+extern FloatListDefaultTypeInternal _FloatList_default_instance_;
+class Int64List;
+struct Int64ListDefaultTypeInternal;
+extern Int64ListDefaultTypeInternal _Int64List_default_instance_;
+}  // namespace tensorflow
+PROTOBUF_NAMESPACE_OPEN
+template<> ::tensorflow::BytesList* Arena::CreateMaybeMessage<::tensorflow::BytesList>(Arena*);
+template<> ::tensorflow::Feature* Arena::CreateMaybeMessage<::tensorflow::Feature>(Arena*);
+template<> ::tensorflow::FeatureList* Arena::CreateMaybeMessage<::tensorflow::FeatureList>(Arena*);
+template<> ::tensorflow::FeatureLists* Arena::CreateMaybeMessage<::tensorflow::FeatureLists>(Arena*);
+template<> ::tensorflow::FeatureLists_FeatureListEntry_DoNotUse* Arena::CreateMaybeMessage<::tensorflow::FeatureLists_FeatureListEntry_DoNotUse>(Arena*);
+template<> ::tensorflow::Features* Arena::CreateMaybeMessage<::tensorflow::Features>(Arena*);
+template<> ::tensorflow::Features_FeatureEntry_DoNotUse* Arena::CreateMaybeMessage<::tensorflow::Features_FeatureEntry_DoNotUse>(Arena*);
+template<> ::tensorflow::FloatList* Arena::CreateMaybeMessage<::tensorflow::FloatList>(Arena*);
+template<> ::tensorflow::Int64List* Arena::CreateMaybeMessage<::tensorflow::Int64List>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace tensorflow {
+
+// ===================================================================
+
+class BytesList final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.BytesList) */ {
+ public:
+  inline BytesList() : BytesList(nullptr) {}
+  ~BytesList() override;
+  explicit PROTOBUF_CONSTEXPR BytesList(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  BytesList(const BytesList& from);
+  BytesList(BytesList&& from) noexcept
+    : BytesList() {
+    *this = ::std::move(from);
+  }
+
+  inline BytesList& operator=(const BytesList& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline BytesList& operator=(BytesList&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const BytesList& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const BytesList* internal_default_instance() {
+    return reinterpret_cast<const BytesList*>(
+               &_BytesList_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(BytesList& a, BytesList& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(BytesList* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(BytesList* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  BytesList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<BytesList>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const BytesList& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const BytesList& from) {
+    BytesList::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(BytesList* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.BytesList";
+  }
+  protected:
+  explicit BytesList(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kValueFieldNumber = 1,
+  };
+  // repeated bytes value = 1;
+  int value_size() const;
+  private:
+  int _internal_value_size() const;
+  public:
+  void clear_value();
+  const std::string& value(int index) const;
+  std::string* mutable_value(int index);
+  void set_value(int index, const std::string& value);
+  void set_value(int index, std::string&& value);
+  void set_value(int index, const char* value);
+  void set_value(int index, const void* value, size_t size);
+  std::string* add_value();
+  void add_value(const std::string& value);
+  void add_value(std::string&& value);
+  void add_value(const char* value);
+  void add_value(const void* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& value() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_value();
+  private:
+  const std::string& _internal_value(int index) const;
+  std::string* _internal_add_value();
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.BytesList)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> value_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fexample_2ffeature_2eproto;
+};
+// -------------------------------------------------------------------
+
+class FloatList final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.FloatList) */ {
+ public:
+  inline FloatList() : FloatList(nullptr) {}
+  ~FloatList() override;
+  explicit PROTOBUF_CONSTEXPR FloatList(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  FloatList(const FloatList& from);
+  FloatList(FloatList&& from) noexcept
+    : FloatList() {
+    *this = ::std::move(from);
+  }
+
+  inline FloatList& operator=(const FloatList& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline FloatList& operator=(FloatList&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const FloatList& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const FloatList* internal_default_instance() {
+    return reinterpret_cast<const FloatList*>(
+               &_FloatList_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(FloatList& a, FloatList& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(FloatList* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(FloatList* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  FloatList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<FloatList>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const FloatList& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const FloatList& from) {
+    FloatList::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(FloatList* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.FloatList";
+  }
+  protected:
+  explicit FloatList(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kValueFieldNumber = 1,
+  };
+  // repeated float value = 1 [packed = true];
+  int value_size() const;
+  private:
+  int _internal_value_size() const;
+  public:
+  void clear_value();
+  private:
+  float _internal_value(int index) const;
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
+      _internal_value() const;
+  void _internal_add_value(float value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
+      _internal_mutable_value();
+  public:
+  float value(int index) const;
+  void set_value(int index, float value);
+  void add_value(float value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
+      value() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
+      mutable_value();
+
+  // @@protoc_insertion_point(class_scope:tensorflow.FloatList)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > value_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fexample_2ffeature_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Int64List final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.Int64List) */ {
+ public:
+  inline Int64List() : Int64List(nullptr) {}
+  ~Int64List() override;
+  explicit PROTOBUF_CONSTEXPR Int64List(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Int64List(const Int64List& from);
+  Int64List(Int64List&& from) noexcept
+    : Int64List() {
+    *this = ::std::move(from);
+  }
+
+  inline Int64List& operator=(const Int64List& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Int64List& operator=(Int64List&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Int64List& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Int64List* internal_default_instance() {
+    return reinterpret_cast<const Int64List*>(
+               &_Int64List_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(Int64List& a, Int64List& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Int64List* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Int64List* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Int64List* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Int64List>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Int64List& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Int64List& from) {
+    Int64List::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Int64List* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.Int64List";
+  }
+  protected:
+  explicit Int64List(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kValueFieldNumber = 1,
+  };
+  // repeated int64 value = 1 [packed = true];
+  int value_size() const;
+  private:
+  int _internal_value_size() const;
+  public:
+  void clear_value();
+  private:
+  int64_t _internal_value(int index) const;
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
+      _internal_value() const;
+  void _internal_add_value(int64_t value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
+      _internal_mutable_value();
+  public:
+  int64_t value(int index) const;
+  void set_value(int index, int64_t value);
+  void add_value(int64_t value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
+      value() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
+      mutable_value();
+
+  // @@protoc_insertion_point(class_scope:tensorflow.Int64List)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > value_;
+    mutable std::atomic<int> _value_cached_byte_size_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fexample_2ffeature_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Feature final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.Feature) */ {
+ public:
+  inline Feature() : Feature(nullptr) {}
+  ~Feature() override;
+  explicit PROTOBUF_CONSTEXPR Feature(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Feature(const Feature& from);
+  Feature(Feature&& from) noexcept
+    : Feature() {
+    *this = ::std::move(from);
+  }
+
+  inline Feature& operator=(const Feature& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Feature& operator=(Feature&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Feature& default_instance() {
+    return *internal_default_instance();
+  }
+  enum KindCase {
+    kBytesList = 1,
+    kFloatList = 2,
+    kInt64List = 3,
+    KIND_NOT_SET = 0,
+  };
+
+  static inline const Feature* internal_default_instance() {
+    return reinterpret_cast<const Feature*>(
+               &_Feature_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  friend void swap(Feature& a, Feature& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Feature* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Feature* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Feature* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Feature>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Feature& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Feature& from) {
+    Feature::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Feature* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.Feature";
+  }
+  protected:
+  explicit Feature(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kBytesListFieldNumber = 1,
+    kFloatListFieldNumber = 2,
+    kInt64ListFieldNumber = 3,
+  };
+  // .tensorflow.BytesList bytes_list = 1;
+  bool has_bytes_list() const;
+  private:
+  bool _internal_has_bytes_list() const;
+  public:
+  void clear_bytes_list();
+  const ::tensorflow::BytesList& bytes_list() const;
+  PROTOBUF_NODISCARD ::tensorflow::BytesList* release_bytes_list();
+  ::tensorflow::BytesList* mutable_bytes_list();
+  void set_allocated_bytes_list(::tensorflow::BytesList* bytes_list);
+  private:
+  const ::tensorflow::BytesList& _internal_bytes_list() const;
+  ::tensorflow::BytesList* _internal_mutable_bytes_list();
+  public:
+  void unsafe_arena_set_allocated_bytes_list(
+      ::tensorflow::BytesList* bytes_list);
+  ::tensorflow::BytesList* unsafe_arena_release_bytes_list();
+
+  // .tensorflow.FloatList float_list = 2;
+  bool has_float_list() const;
+  private:
+  bool _internal_has_float_list() const;
+  public:
+  void clear_float_list();
+  const ::tensorflow::FloatList& float_list() const;
+  PROTOBUF_NODISCARD ::tensorflow::FloatList* release_float_list();
+  ::tensorflow::FloatList* mutable_float_list();
+  void set_allocated_float_list(::tensorflow::FloatList* float_list);
+  private:
+  const ::tensorflow::FloatList& _internal_float_list() const;
+  ::tensorflow::FloatList* _internal_mutable_float_list();
+  public:
+  void unsafe_arena_set_allocated_float_list(
+      ::tensorflow::FloatList* float_list);
+  ::tensorflow::FloatList* unsafe_arena_release_float_list();
+
+  // .tensorflow.Int64List int64_list = 3;
+  bool has_int64_list() const;
+  private:
+  bool _internal_has_int64_list() const;
+  public:
+  void clear_int64_list();
+  const ::tensorflow::Int64List& int64_list() const;
+  PROTOBUF_NODISCARD ::tensorflow::Int64List* release_int64_list();
+  ::tensorflow::Int64List* mutable_int64_list();
+  void set_allocated_int64_list(::tensorflow::Int64List* int64_list);
+  private:
+  const ::tensorflow::Int64List& _internal_int64_list() const;
+  ::tensorflow::Int64List* _internal_mutable_int64_list();
+  public:
+  void unsafe_arena_set_allocated_int64_list(
+      ::tensorflow::Int64List* int64_list);
+  ::tensorflow::Int64List* unsafe_arena_release_int64_list();
+
+  void clear_kind();
+  KindCase kind_case() const;
+  // @@protoc_insertion_point(class_scope:tensorflow.Feature)
+ private:
+  class _Internal;
+  void set_has_bytes_list();
+  void set_has_float_list();
+  void set_has_int64_list();
+
+  inline bool has_kind() const;
+  inline void clear_has_kind();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    union KindUnion {
+      constexpr KindUnion() : _constinit_{} {}
+        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+      ::tensorflow::BytesList* bytes_list_;
+      ::tensorflow::FloatList* float_list_;
+      ::tensorflow::Int64List* int64_list_;
+    } kind_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    uint32_t _oneof_case_[1];
+
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fexample_2ffeature_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Features_FeatureEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<Features_FeatureEntry_DoNotUse, 
+    std::string, ::tensorflow::Feature,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> {
+public:
+  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<Features_FeatureEntry_DoNotUse, 
+    std::string, ::tensorflow::Feature,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
+  Features_FeatureEntry_DoNotUse();
+  explicit PROTOBUF_CONSTEXPR Features_FeatureEntry_DoNotUse(
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+  explicit Features_FeatureEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  void MergeFrom(const Features_FeatureEntry_DoNotUse& other);
+  static const Features_FeatureEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const Features_FeatureEntry_DoNotUse*>(&_Features_FeatureEntry_DoNotUse_default_instance_); }
+  static bool ValidateKey(std::string* s) {
+    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "tensorflow.Features.FeatureEntry.key");
+ }
+  static bool ValidateValue(void*) { return true; }
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+  friend struct ::TableStruct_tensorflow_2fcore_2fexample_2ffeature_2eproto;
+};
+
+// -------------------------------------------------------------------
+
+class Features final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.Features) */ {
+ public:
+  inline Features() : Features(nullptr) {}
+  ~Features() override;
+  explicit PROTOBUF_CONSTEXPR Features(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Features(const Features& from);
+  Features(Features&& from) noexcept
+    : Features() {
+    *this = ::std::move(from);
+  }
+
+  inline Features& operator=(const Features& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Features& operator=(Features&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Features& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Features* internal_default_instance() {
+    return reinterpret_cast<const Features*>(
+               &_Features_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    5;
+
+  friend void swap(Features& a, Features& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Features* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Features* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Features* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Features>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Features& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Features& from) {
+    Features::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Features* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.Features";
+  }
+  protected:
+  explicit Features(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kFeatureFieldNumber = 1,
+  };
+  // map<string, .tensorflow.Feature> feature = 1;
+  int feature_size() const;
+  private:
+  int _internal_feature_size() const;
+  public:
+  void clear_feature();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::Feature >&
+      _internal_feature() const;
+  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::Feature >*
+      _internal_mutable_feature();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::Feature >&
+      feature() const;
+  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::Feature >*
+      mutable_feature();
+
+  // @@protoc_insertion_point(class_scope:tensorflow.Features)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::MapField<
+        Features_FeatureEntry_DoNotUse,
+        std::string, ::tensorflow::Feature,
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> feature_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fexample_2ffeature_2eproto;
+};
+// -------------------------------------------------------------------
+
+class FeatureList final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.FeatureList) */ {
+ public:
+  inline FeatureList() : FeatureList(nullptr) {}
+  ~FeatureList() override;
+  explicit PROTOBUF_CONSTEXPR FeatureList(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  FeatureList(const FeatureList& from);
+  FeatureList(FeatureList&& from) noexcept
+    : FeatureList() {
+    *this = ::std::move(from);
+  }
+
+  inline FeatureList& operator=(const FeatureList& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline FeatureList& operator=(FeatureList&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const FeatureList& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const FeatureList* internal_default_instance() {
+    return reinterpret_cast<const FeatureList*>(
+               &_FeatureList_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    6;
+
+  friend void swap(FeatureList& a, FeatureList& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(FeatureList* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(FeatureList* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  FeatureList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<FeatureList>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const FeatureList& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const FeatureList& from) {
+    FeatureList::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(FeatureList* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.FeatureList";
+  }
+  protected:
+  explicit FeatureList(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kFeatureFieldNumber = 1,
+  };
+  // repeated .tensorflow.Feature feature = 1;
+  int feature_size() const;
+  private:
+  int _internal_feature_size() const;
+  public:
+  void clear_feature();
+  ::tensorflow::Feature* mutable_feature(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::Feature >*
+      mutable_feature();
+  private:
+  const ::tensorflow::Feature& _internal_feature(int index) const;
+  ::tensorflow::Feature* _internal_add_feature();
+  public:
+  const ::tensorflow::Feature& feature(int index) const;
+  ::tensorflow::Feature* add_feature();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::Feature >&
+      feature() const;
+
+  // @@protoc_insertion_point(class_scope:tensorflow.FeatureList)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::Feature > feature_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fexample_2ffeature_2eproto;
+};
+// -------------------------------------------------------------------
+
+class FeatureLists_FeatureListEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<FeatureLists_FeatureListEntry_DoNotUse, 
+    std::string, ::tensorflow::FeatureList,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> {
+public:
+  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<FeatureLists_FeatureListEntry_DoNotUse, 
+    std::string, ::tensorflow::FeatureList,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
+  FeatureLists_FeatureListEntry_DoNotUse();
+  explicit PROTOBUF_CONSTEXPR FeatureLists_FeatureListEntry_DoNotUse(
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+  explicit FeatureLists_FeatureListEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  void MergeFrom(const FeatureLists_FeatureListEntry_DoNotUse& other);
+  static const FeatureLists_FeatureListEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const FeatureLists_FeatureListEntry_DoNotUse*>(&_FeatureLists_FeatureListEntry_DoNotUse_default_instance_); }
+  static bool ValidateKey(std::string* s) {
+    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "tensorflow.FeatureLists.FeatureListEntry.key");
+ }
+  static bool ValidateValue(void*) { return true; }
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+  friend struct ::TableStruct_tensorflow_2fcore_2fexample_2ffeature_2eproto;
+};
+
+// -------------------------------------------------------------------
+
+class FeatureLists final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.FeatureLists) */ {
+ public:
+  inline FeatureLists() : FeatureLists(nullptr) {}
+  ~FeatureLists() override;
+  explicit PROTOBUF_CONSTEXPR FeatureLists(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  FeatureLists(const FeatureLists& from);
+  FeatureLists(FeatureLists&& from) noexcept
+    : FeatureLists() {
+    *this = ::std::move(from);
+  }
+
+  inline FeatureLists& operator=(const FeatureLists& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline FeatureLists& operator=(FeatureLists&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const FeatureLists& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const FeatureLists* internal_default_instance() {
+    return reinterpret_cast<const FeatureLists*>(
+               &_FeatureLists_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    8;
+
+  friend void swap(FeatureLists& a, FeatureLists& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(FeatureLists* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(FeatureLists* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  FeatureLists* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<FeatureLists>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const FeatureLists& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const FeatureLists& from) {
+    FeatureLists::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(FeatureLists* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.FeatureLists";
+  }
+  protected:
+  explicit FeatureLists(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kFeatureListFieldNumber = 1,
+  };
+  // map<string, .tensorflow.FeatureList> feature_list = 1;
+  int feature_list_size() const;
+  private:
+  int _internal_feature_list_size() const;
+  public:
+  void clear_feature_list();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::FeatureList >&
+      _internal_feature_list() const;
+  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::FeatureList >*
+      _internal_mutable_feature_list();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::FeatureList >&
+      feature_list() const;
+  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::FeatureList >*
+      mutable_feature_list();
+
+  // @@protoc_insertion_point(class_scope:tensorflow.FeatureLists)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::MapField<
+        FeatureLists_FeatureListEntry_DoNotUse,
+        std::string, ::tensorflow::FeatureList,
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> feature_list_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fexample_2ffeature_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// BytesList
+
+// repeated bytes value = 1;
+inline int BytesList::_internal_value_size() const {
+  return _impl_.value_.size();
+}
+inline int BytesList::value_size() const {
+  return _internal_value_size();
+}
+inline void BytesList::clear_value() {
+  _impl_.value_.Clear();
+}
+inline std::string* BytesList::add_value() {
+  std::string* _s = _internal_add_value();
+  // @@protoc_insertion_point(field_add_mutable:tensorflow.BytesList.value)
+  return _s;
+}
+inline const std::string& BytesList::_internal_value(int index) const {
+  return _impl_.value_.Get(index);
+}
+inline const std::string& BytesList::value(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.BytesList.value)
+  return _internal_value(index);
+}
+inline std::string* BytesList::mutable_value(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.BytesList.value)
+  return _impl_.value_.Mutable(index);
+}
+inline void BytesList::set_value(int index, const std::string& value) {
+  _impl_.value_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:tensorflow.BytesList.value)
+}
+inline void BytesList::set_value(int index, std::string&& value) {
+  _impl_.value_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:tensorflow.BytesList.value)
+}
+inline void BytesList::set_value(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.value_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:tensorflow.BytesList.value)
+}
+inline void BytesList::set_value(int index, const void* value, size_t size) {
+  _impl_.value_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:tensorflow.BytesList.value)
+}
+inline std::string* BytesList::_internal_add_value() {
+  return _impl_.value_.Add();
+}
+inline void BytesList::add_value(const std::string& value) {
+  _impl_.value_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:tensorflow.BytesList.value)
+}
+inline void BytesList::add_value(std::string&& value) {
+  _impl_.value_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:tensorflow.BytesList.value)
+}
+inline void BytesList::add_value(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.value_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:tensorflow.BytesList.value)
+}
+inline void BytesList::add_value(const void* value, size_t size) {
+  _impl_.value_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:tensorflow.BytesList.value)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+BytesList::value() const {
+  // @@protoc_insertion_point(field_list:tensorflow.BytesList.value)
+  return _impl_.value_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+BytesList::mutable_value() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.BytesList.value)
+  return &_impl_.value_;
+}
+
+// -------------------------------------------------------------------
+
+// FloatList
+
+// repeated float value = 1 [packed = true];
+inline int FloatList::_internal_value_size() const {
+  return _impl_.value_.size();
+}
+inline int FloatList::value_size() const {
+  return _internal_value_size();
+}
+inline void FloatList::clear_value() {
+  _impl_.value_.Clear();
+}
+inline float FloatList::_internal_value(int index) const {
+  return _impl_.value_.Get(index);
+}
+inline float FloatList::value(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.FloatList.value)
+  return _internal_value(index);
+}
+inline void FloatList::set_value(int index, float value) {
+  _impl_.value_.Set(index, value);
+  // @@protoc_insertion_point(field_set:tensorflow.FloatList.value)
+}
+inline void FloatList::_internal_add_value(float value) {
+  _impl_.value_.Add(value);
+}
+inline void FloatList::add_value(float value) {
+  _internal_add_value(value);
+  // @@protoc_insertion_point(field_add:tensorflow.FloatList.value)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
+FloatList::_internal_value() const {
+  return _impl_.value_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
+FloatList::value() const {
+  // @@protoc_insertion_point(field_list:tensorflow.FloatList.value)
+  return _internal_value();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
+FloatList::_internal_mutable_value() {
+  return &_impl_.value_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
+FloatList::mutable_value() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.FloatList.value)
+  return _internal_mutable_value();
+}
+
+// -------------------------------------------------------------------
+
+// Int64List
+
+// repeated int64 value = 1 [packed = true];
+inline int Int64List::_internal_value_size() const {
+  return _impl_.value_.size();
+}
+inline int Int64List::value_size() const {
+  return _internal_value_size();
+}
+inline void Int64List::clear_value() {
+  _impl_.value_.Clear();
+}
+inline int64_t Int64List::_internal_value(int index) const {
+  return _impl_.value_.Get(index);
+}
+inline int64_t Int64List::value(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.Int64List.value)
+  return _internal_value(index);
+}
+inline void Int64List::set_value(int index, int64_t value) {
+  _impl_.value_.Set(index, value);
+  // @@protoc_insertion_point(field_set:tensorflow.Int64List.value)
+}
+inline void Int64List::_internal_add_value(int64_t value) {
+  _impl_.value_.Add(value);
+}
+inline void Int64List::add_value(int64_t value) {
+  _internal_add_value(value);
+  // @@protoc_insertion_point(field_add:tensorflow.Int64List.value)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
+Int64List::_internal_value() const {
+  return _impl_.value_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
+Int64List::value() const {
+  // @@protoc_insertion_point(field_list:tensorflow.Int64List.value)
+  return _internal_value();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
+Int64List::_internal_mutable_value() {
+  return &_impl_.value_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
+Int64List::mutable_value() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.Int64List.value)
+  return _internal_mutable_value();
+}
+
+// -------------------------------------------------------------------
+
+// Feature
+
+// .tensorflow.BytesList bytes_list = 1;
+inline bool Feature::_internal_has_bytes_list() const {
+  return kind_case() == kBytesList;
+}
+inline bool Feature::has_bytes_list() const {
+  return _internal_has_bytes_list();
+}
+inline void Feature::set_has_bytes_list() {
+  _impl_._oneof_case_[0] = kBytesList;
+}
+inline void Feature::clear_bytes_list() {
+  if (_internal_has_bytes_list()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete _impl_.kind_.bytes_list_;
+    }
+    clear_has_kind();
+  }
+}
+inline ::tensorflow::BytesList* Feature::release_bytes_list() {
+  // @@protoc_insertion_point(field_release:tensorflow.Feature.bytes_list)
+  if (_internal_has_bytes_list()) {
+    clear_has_kind();
+    ::tensorflow::BytesList* temp = _impl_.kind_.bytes_list_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    _impl_.kind_.bytes_list_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::tensorflow::BytesList& Feature::_internal_bytes_list() const {
+  return _internal_has_bytes_list()
+      ? *_impl_.kind_.bytes_list_
+      : reinterpret_cast< ::tensorflow::BytesList&>(::tensorflow::_BytesList_default_instance_);
+}
+inline const ::tensorflow::BytesList& Feature::bytes_list() const {
+  // @@protoc_insertion_point(field_get:tensorflow.Feature.bytes_list)
+  return _internal_bytes_list();
+}
+inline ::tensorflow::BytesList* Feature::unsafe_arena_release_bytes_list() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.Feature.bytes_list)
+  if (_internal_has_bytes_list()) {
+    clear_has_kind();
+    ::tensorflow::BytesList* temp = _impl_.kind_.bytes_list_;
+    _impl_.kind_.bytes_list_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Feature::unsafe_arena_set_allocated_bytes_list(::tensorflow::BytesList* bytes_list) {
+  clear_kind();
+  if (bytes_list) {
+    set_has_bytes_list();
+    _impl_.kind_.bytes_list_ = bytes_list;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.Feature.bytes_list)
+}
+inline ::tensorflow::BytesList* Feature::_internal_mutable_bytes_list() {
+  if (!_internal_has_bytes_list()) {
+    clear_kind();
+    set_has_bytes_list();
+    _impl_.kind_.bytes_list_ = CreateMaybeMessage< ::tensorflow::BytesList >(GetArenaForAllocation());
+  }
+  return _impl_.kind_.bytes_list_;
+}
+inline ::tensorflow::BytesList* Feature::mutable_bytes_list() {
+  ::tensorflow::BytesList* _msg = _internal_mutable_bytes_list();
+  // @@protoc_insertion_point(field_mutable:tensorflow.Feature.bytes_list)
+  return _msg;
+}
+
+// .tensorflow.FloatList float_list = 2;
+inline bool Feature::_internal_has_float_list() const {
+  return kind_case() == kFloatList;
+}
+inline bool Feature::has_float_list() const {
+  return _internal_has_float_list();
+}
+inline void Feature::set_has_float_list() {
+  _impl_._oneof_case_[0] = kFloatList;
+}
+inline void Feature::clear_float_list() {
+  if (_internal_has_float_list()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete _impl_.kind_.float_list_;
+    }
+    clear_has_kind();
+  }
+}
+inline ::tensorflow::FloatList* Feature::release_float_list() {
+  // @@protoc_insertion_point(field_release:tensorflow.Feature.float_list)
+  if (_internal_has_float_list()) {
+    clear_has_kind();
+    ::tensorflow::FloatList* temp = _impl_.kind_.float_list_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    _impl_.kind_.float_list_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::tensorflow::FloatList& Feature::_internal_float_list() const {
+  return _internal_has_float_list()
+      ? *_impl_.kind_.float_list_
+      : reinterpret_cast< ::tensorflow::FloatList&>(::tensorflow::_FloatList_default_instance_);
+}
+inline const ::tensorflow::FloatList& Feature::float_list() const {
+  // @@protoc_insertion_point(field_get:tensorflow.Feature.float_list)
+  return _internal_float_list();
+}
+inline ::tensorflow::FloatList* Feature::unsafe_arena_release_float_list() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.Feature.float_list)
+  if (_internal_has_float_list()) {
+    clear_has_kind();
+    ::tensorflow::FloatList* temp = _impl_.kind_.float_list_;
+    _impl_.kind_.float_list_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Feature::unsafe_arena_set_allocated_float_list(::tensorflow::FloatList* float_list) {
+  clear_kind();
+  if (float_list) {
+    set_has_float_list();
+    _impl_.kind_.float_list_ = float_list;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.Feature.float_list)
+}
+inline ::tensorflow::FloatList* Feature::_internal_mutable_float_list() {
+  if (!_internal_has_float_list()) {
+    clear_kind();
+    set_has_float_list();
+    _impl_.kind_.float_list_ = CreateMaybeMessage< ::tensorflow::FloatList >(GetArenaForAllocation());
+  }
+  return _impl_.kind_.float_list_;
+}
+inline ::tensorflow::FloatList* Feature::mutable_float_list() {
+  ::tensorflow::FloatList* _msg = _internal_mutable_float_list();
+  // @@protoc_insertion_point(field_mutable:tensorflow.Feature.float_list)
+  return _msg;
+}
+
+// .tensorflow.Int64List int64_list = 3;
+inline bool Feature::_internal_has_int64_list() const {
+  return kind_case() == kInt64List;
+}
+inline bool Feature::has_int64_list() const {
+  return _internal_has_int64_list();
+}
+inline void Feature::set_has_int64_list() {
+  _impl_._oneof_case_[0] = kInt64List;
+}
+inline void Feature::clear_int64_list() {
+  if (_internal_has_int64_list()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete _impl_.kind_.int64_list_;
+    }
+    clear_has_kind();
+  }
+}
+inline ::tensorflow::Int64List* Feature::release_int64_list() {
+  // @@protoc_insertion_point(field_release:tensorflow.Feature.int64_list)
+  if (_internal_has_int64_list()) {
+    clear_has_kind();
+    ::tensorflow::Int64List* temp = _impl_.kind_.int64_list_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    _impl_.kind_.int64_list_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::tensorflow::Int64List& Feature::_internal_int64_list() const {
+  return _internal_has_int64_list()
+      ? *_impl_.kind_.int64_list_
+      : reinterpret_cast< ::tensorflow::Int64List&>(::tensorflow::_Int64List_default_instance_);
+}
+inline const ::tensorflow::Int64List& Feature::int64_list() const {
+  // @@protoc_insertion_point(field_get:tensorflow.Feature.int64_list)
+  return _internal_int64_list();
+}
+inline ::tensorflow::Int64List* Feature::unsafe_arena_release_int64_list() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.Feature.int64_list)
+  if (_internal_has_int64_list()) {
+    clear_has_kind();
+    ::tensorflow::Int64List* temp = _impl_.kind_.int64_list_;
+    _impl_.kind_.int64_list_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Feature::unsafe_arena_set_allocated_int64_list(::tensorflow::Int64List* int64_list) {
+  clear_kind();
+  if (int64_list) {
+    set_has_int64_list();
+    _impl_.kind_.int64_list_ = int64_list;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.Feature.int64_list)
+}
+inline ::tensorflow::Int64List* Feature::_internal_mutable_int64_list() {
+  if (!_internal_has_int64_list()) {
+    clear_kind();
+    set_has_int64_list();
+    _impl_.kind_.int64_list_ = CreateMaybeMessage< ::tensorflow::Int64List >(GetArenaForAllocation());
+  }
+  return _impl_.kind_.int64_list_;
+}
+inline ::tensorflow::Int64List* Feature::mutable_int64_list() {
+  ::tensorflow::Int64List* _msg = _internal_mutable_int64_list();
+  // @@protoc_insertion_point(field_mutable:tensorflow.Feature.int64_list)
+  return _msg;
+}
+
+inline bool Feature::has_kind() const {
+  return kind_case() != KIND_NOT_SET;
+}
+inline void Feature::clear_has_kind() {
+  _impl_._oneof_case_[0] = KIND_NOT_SET;
+}
+inline Feature::KindCase Feature::kind_case() const {
+  return Feature::KindCase(_impl_._oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// Features
+
+// map<string, .tensorflow.Feature> feature = 1;
+inline int Features::_internal_feature_size() const {
+  return _impl_.feature_.size();
+}
+inline int Features::feature_size() const {
+  return _internal_feature_size();
+}
+inline void Features::clear_feature() {
+  _impl_.feature_.Clear();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::Feature >&
+Features::_internal_feature() const {
+  return _impl_.feature_.GetMap();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::Feature >&
+Features::feature() const {
+  // @@protoc_insertion_point(field_map:tensorflow.Features.feature)
+  return _internal_feature();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::Feature >*
+Features::_internal_mutable_feature() {
+  return _impl_.feature_.MutableMap();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::Feature >*
+Features::mutable_feature() {
+  // @@protoc_insertion_point(field_mutable_map:tensorflow.Features.feature)
+  return _internal_mutable_feature();
+}
+
+// -------------------------------------------------------------------
+
+// FeatureList
+
+// repeated .tensorflow.Feature feature = 1;
+inline int FeatureList::_internal_feature_size() const {
+  return _impl_.feature_.size();
+}
+inline int FeatureList::feature_size() const {
+  return _internal_feature_size();
+}
+inline void FeatureList::clear_feature() {
+  _impl_.feature_.Clear();
+}
+inline ::tensorflow::Feature* FeatureList::mutable_feature(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.FeatureList.feature)
+  return _impl_.feature_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::Feature >*
+FeatureList::mutable_feature() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.FeatureList.feature)
+  return &_impl_.feature_;
+}
+inline const ::tensorflow::Feature& FeatureList::_internal_feature(int index) const {
+  return _impl_.feature_.Get(index);
+}
+inline const ::tensorflow::Feature& FeatureList::feature(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.FeatureList.feature)
+  return _internal_feature(index);
+}
+inline ::tensorflow::Feature* FeatureList::_internal_add_feature() {
+  return _impl_.feature_.Add();
+}
+inline ::tensorflow::Feature* FeatureList::add_feature() {
+  ::tensorflow::Feature* _add = _internal_add_feature();
+  // @@protoc_insertion_point(field_add:tensorflow.FeatureList.feature)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::Feature >&
+FeatureList::feature() const {
+  // @@protoc_insertion_point(field_list:tensorflow.FeatureList.feature)
+  return _impl_.feature_;
+}
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// FeatureLists
+
+// map<string, .tensorflow.FeatureList> feature_list = 1;
+inline int FeatureLists::_internal_feature_list_size() const {
+  return _impl_.feature_list_.size();
+}
+inline int FeatureLists::feature_list_size() const {
+  return _internal_feature_list_size();
+}
+inline void FeatureLists::clear_feature_list() {
+  _impl_.feature_list_.Clear();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::FeatureList >&
+FeatureLists::_internal_feature_list() const {
+  return _impl_.feature_list_.GetMap();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::FeatureList >&
+FeatureLists::feature_list() const {
+  // @@protoc_insertion_point(field_map:tensorflow.FeatureLists.feature_list)
+  return _internal_feature_list();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::FeatureList >*
+FeatureLists::_internal_mutable_feature_list() {
+  return _impl_.feature_list_.MutableMap();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::FeatureList >*
+FeatureLists::mutable_feature_list() {
+  // @@protoc_insertion_point(field_mutable_map:tensorflow.FeatureLists.feature_list)
+  return _internal_mutable_feature_list();
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace tensorflow
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fexample_2ffeature_2eproto
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/example/feature.proto b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/example/feature.proto
new file mode 100644
index 0000000000000000000000000000000000000000..7f9fad982348d238ac2ac8fd12ae19bba147de52
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/example/feature.proto
@@ -0,0 +1,110 @@
+// Protocol messages for describing features for machine learning model
+// training or inference.
+//
+// There are three base Feature types:
+//   - bytes
+//   - float
+//   - int64
+//
+// A Feature contains Lists which may hold zero or more values.  These
+// lists are the base values BytesList, FloatList, Int64List.
+//
+// Features are organized into categories by name.  The Features message
+// contains the mapping from name to Feature.
+//
+// Example Features for a movie recommendation application:
+//   feature {
+//     key: "age"
+//     value { float_list {
+//       value: 29.0
+//     }}
+//   }
+//   feature {
+//     key: "movie"
+//     value { bytes_list {
+//       value: "The Shawshank Redemption"
+//       value: "Fight Club"
+//     }}
+//   }
+//   feature {
+//     key: "movie_ratings"
+//     value { float_list {
+//       value: 9.0
+//       value: 9.7
+//     }}
+//   }
+//   feature {
+//     key: "suggestion"
+//     value { bytes_list {
+//       value: "Inception"
+//     }}
+//   }
+//   feature {
+//     key: "suggestion_purchased"
+//     value { int64_list {
+//       value: 1
+//     }}
+//   }
+//   feature {
+//     key: "purchase_price"
+//     value { float_list {
+//       value: 9.99
+//     }}
+//   }
+//
+
+syntax = "proto3";
+
+package tensorflow;
+
+option cc_enable_arenas = true;
+option java_outer_classname = "FeatureProtos";
+option java_multiple_files = true;
+option java_package = "org.tensorflow.example";
+option go_package = "github.com/tensorflow/tensorflow/tensorflow/go/core/example/example_protos_go_proto";
+
+// LINT.IfChange
+// Containers to hold repeated fundamental values.
+message BytesList {
+  repeated bytes value = 1;
+}
+message FloatList {
+  repeated float value = 1 [packed = true];
+}
+message Int64List {
+  repeated int64 value = 1 [packed = true];
+}
+
+// Containers for non-sequential data.
+message Feature {
+  // Each feature can be exactly one kind.
+  oneof kind {
+    BytesList bytes_list = 1;
+    FloatList float_list = 2;
+    Int64List int64_list = 3;
+  }
+}
+
+message Features {
+  // Map from feature name to feature.
+  map<string, Feature> feature = 1;
+}
+
+// Containers for sequential data.
+//
+// A FeatureList contains lists of Features.  These may hold zero or more
+// Feature values.
+//
+// FeatureLists are organized into categories by name.  The FeatureLists message
+// contains the mapping from name to FeatureList.
+//
+message FeatureList {
+  repeated Feature feature = 1;
+}
+
+message FeatureLists {
+  // Map from feature name to feature list.
+  map<string, FeatureList> feature_list = 1;
+}
+// LINT.ThenChange(
+//     https://www.tensorflow.org/code/tensorflow/python/training/training.py)
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/example/feature_util.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/example/feature_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..5f55138a94f4b055c14bd7b8cfe842bb45df6459
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/example/feature_util.h
@@ -0,0 +1,638 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// A set of lightweight wrappers which simplify access to Feature protos.
+//
+// TensorFlow Example proto uses associative maps on top of oneof fields.
+// SequenceExample proto uses associative map of FeatureList.
+// So accessing feature values is not very convenient.
+//
+// For example, to read a first value of integer feature "tag":
+//   int id = example.features().feature().at("tag").int64_list().value(0);
+//
+// to add a value:
+//   auto features = example->mutable_features();
+//   (*features->mutable_feature())["tag"].mutable_int64_list()->add_value(id);
+//
+// For float features you have to use float_list, for string - bytes_list.
+//
+// To do the same with this library:
+//   int id = GetFeatureValues<int64_t>("tag", example).Get(0);
+//   GetFeatureValues<int64_t>("tag", &example)->Add(id);
+//
+// Modification of bytes features is slightly different:
+//   auto tag = GetFeatureValues<std::string>("tag", &example);
+//   *tag->Add() = "lorem ipsum";
+//
+// To copy multiple values into a feature:
+//   AppendFeatureValues({1,2,3}, "tag", &example);
+//
+// GetFeatureValues gives you access to underlying data - RepeatedField object
+// (RepeatedPtrField for byte list). So refer to its documentation of
+// RepeatedField for full list of supported methods.
+//
+// NOTE: Due to the nature of oneof proto fields setting a feature of one type
+// automatically clears all values stored as another type with the same feature
+// key.
+//
+// This library also has tools to work with SequenceExample protos.
+//
+// To get a value from SequenceExample.context:
+//   int id = GetFeatureValues<protobuf_int64>("tag", se.context()).Get(0);
+// To add a value to the context:
+//   GetFeatureValues<protobuf_int64>("tag", se.mutable_context())->Add(42);
+//
+// To add values to feature_lists:
+//   AppendFeatureValues({4.0},
+//                       GetFeatureList("images", &se)->Add());
+//   AppendFeatureValues({5.0, 3.0},
+//                       GetFeatureList("images", &se)->Add());
+// This will create a feature list keyed as "images" with two features:
+//   feature_lists {
+//     feature_list {
+//       key: "images"
+//       value {
+//         feature { float_list { value: [4.0] } }
+//         feature { float_list { value: [5.0, 3.0] } }
+//       }
+//     }
+//   }
+// For string-valued features, note that the Append... and Set... functions
+// support absl::string_view containers. This allows you to copy existing
+// buffers into a Feature with only one copy:
+//   std::vector<absl::string_view> image;
+//   image.push_back(image_buffer);               // No copy.
+//   SetFeatureValues(image, "image", &example);  // Copy.
+//
+// Functions exposed by this library:
+//   HasFeature<[FeatureType]>(key, proto) -> bool
+//     Returns true if a feature with the specified key, and optionally
+//     FeatureType, belongs to the Features or Example proto.
+//   HasFeatureList(key, sequence_example) -> bool
+//     Returns true if SequenceExample has a feature_list with the key.
+//
+//   GetFeatureValues<FeatureType>(key, proto) -> RepeatedField<FeatureType>
+//     Returns values for the specified key and the FeatureType.
+//     Supported types for the proto: Example, Features.
+//   GetFeatureList(key, sequence_example) -> RepeatedPtrField<Feature>
+//     Returns Feature protos associated with a key.
+//
+//   AppendFeatureValues(begin, end, feature)
+//   AppendFeatureValues(container or initializer_list, feature)
+//     Copies values into a Feature.
+//   AppendFeatureValues(begin, end, key, proto)
+//   AppendFeatureValues(container or initializer_list, key, proto)
+//     Copies values into Features and Example protos with the specified key.
+//
+//   ClearFeatureValues<FeatureType>(feature)
+//     Clears the feature's repeated field of the given type.
+//
+//   SetFeatureValues(begin, end, feature)
+//   SetFeatureValues(container or initializer_list, feature)
+//     Clears a Feature, then copies values into it.
+//   SetFeatureValues(begin, end, key, proto)
+//   SetFeatureValues(container or initializer_list, key, proto)
+//     Clears Features or Example protos with the specified key,
+//     then copies values into them.
+//
+// Auxiliary functions, it is unlikely you'll need to use them directly:
+//   GetFeatures(proto) -> Features
+//     A convenience function to get Features proto.
+//     Supported types for the proto: Example, Features.
+//   GetFeature(key, proto) -> Feature
+//     Returns a Feature proto for the specified key.
+//     Supported types for the proto: Example, Features.
+//   GetFeatureValues<FeatureType>(feature) -> RepeatedField<FeatureType>
+//     Returns values of the feature for the FeatureType.
+
+#ifndef TENSORFLOW_CORE_EXAMPLE_FEATURE_UTIL_H_
+#define TENSORFLOW_CORE_EXAMPLE_FEATURE_UTIL_H_
+
+#include <algorithm>
+#include <iterator>
+#include <string>
+#include <type_traits>
+#include <utility>
+
+#include "absl/strings/string_view.h"
+#include "tensorflow/core/example/example.pb.h"
+#include "tensorflow/core/example/feature.pb.h"
+#include "tensorflow/core/platform/protobuf.h"
+#include "tensorflow/core/platform/stringpiece.h"
+
+// Must come after the import for absl::string_view.
+#ifdef ABSL_HAVE_STD_STRING_VIEW
+#include <string_view>
+#endif
+
+namespace tensorflow {
+namespace internal {
+
+// TODO(gorban): Update all clients in a followup CL.
+// Returns a reference to a feature corresponding to the name.
+// Note: it will create a new Feature if it is missing in the example.
+ABSL_DEPRECATED("Use GetFeature instead.")
+Feature& ExampleFeature(absl::string_view name, Example* example);
+
+// Specializations of RepeatedFieldTrait define a type of RepeatedField
+// corresponding to a selected feature type.
+template <typename FeatureType>
+struct RepeatedFieldTrait;
+
+template <>
+struct RepeatedFieldTrait<protobuf_int64> {
+  using Type = protobuf::RepeatedField<protobuf_int64>;
+};
+
+template <>
+struct RepeatedFieldTrait<float> {
+  using Type = protobuf::RepeatedField<float>;
+};
+
+template <>
+struct RepeatedFieldTrait<tstring> {
+  using Type = protobuf::RepeatedPtrField<std::string>;
+};
+
+template <>
+struct RepeatedFieldTrait<std::string> {
+  using Type = protobuf::RepeatedPtrField<std::string>;
+};
+
+// Specializations of FeatureTrait define a type of feature corresponding to a
+// selected value type.
+template <typename ValueType, class Enable = void>
+struct FeatureTrait;
+
+template <typename ValueType>
+struct FeatureTrait<ValueType, typename std::enable_if<
+                                   std::is_integral<ValueType>::value>::type> {
+  using Type = protobuf_int64;
+};
+
+template <typename ValueType>
+struct FeatureTrait<
+    ValueType,
+    typename std::enable_if<std::is_floating_point<ValueType>::value>::type> {
+  using Type = float;
+};
+
+template <typename T>
+struct is_string
+    : public std::integral_constant<
+          bool,
+          std::is_same<char*, typename std::decay<T>::type>::value ||
+              std::is_same<const char*, typename std::decay<T>::type>::value> {
+};
+
+template <>
+struct is_string<std::string> : std::true_type {};
+
+template <>
+struct is_string<::tensorflow::StringPiece> : std::true_type {};
+
+template <>
+struct is_string<tstring> : std::true_type {};
+
+template <typename ValueType>
+struct FeatureTrait<
+    ValueType, typename std::enable_if<is_string<ValueType>::value>::type> {
+  using Type = std::string;
+};
+
+// Port of the C++20 `requires` expressions.
+template <typename... T, typename F>
+constexpr bool Requires(F) {
+  return std::is_invocable<F, T...>::value;
+}
+
+struct NoneSuch {};
+
+// True if the Feature map in a tf.Example supports heterogenous lookup.
+// See https://abseil.io/tips/144.
+inline constexpr bool kFeatureMapHasHeterogeneousLookup =
+    Requires<decltype(Features::default_instance().feature())>(
+        [](auto&& c) -> decltype(c.find(NoneSuch{})) {});
+
+// Converts an `absl::string_view` into a string-type compatible for use in the
+// protobuf library (e.g. as lookup keys in `proto2::Map` or as elements addable
+// to a `proto2::RepeatedPtrField`) depending on the BUILD mode.
+//
+// NOTE: While the newest versions of `proto2::Map` support heterogenous lookup,
+// it does so through `std::string_view`. If the type is just an alias (as noted
+// by `ABSL_USES_STD_STRING_VIEW`) then nothing more needs to be done; however,
+// when the type is not an alias an explicit conversion to is necessary.
+//
+// NOTE: This conversion is only necessary until the migration for protobuf to
+// take a dependency on ABSL is complete.
+inline auto ProtoMapKey(absl::string_view str) {
+  if constexpr (kFeatureMapHasHeterogeneousLookup) {
+#ifdef ABSL_USES_STD_STRING_VIEW
+    return str;
+#else
+#ifdef ABSL_HAVE_STD_STRING_VIEW
+    return std::string_view(str.data(), str.size());
+#else
+    return std::string(str);
+#endif
+#endif
+  } else {
+    return std::string(str);
+  }
+}
+
+}  //  namespace internal
+
+// Returns true if sequence_example has a feature_list with the specified key.
+bool HasFeatureList(absl::string_view key,
+                    const SequenceExample& sequence_example);
+
+template <typename T>
+struct TypeHasFeatures : std::false_type {};
+
+template <>
+struct TypeHasFeatures<SequenceExample> : std::true_type {};
+
+template <>
+struct TypeHasFeatures<Example> : std::true_type {};
+
+template <>
+struct TypeHasFeatures<Features> : std::true_type {};
+
+// A family of template functions to return mutable Features proto from a
+// container proto. Supported ProtoTypes: SequenceExample, Example, Features.
+template <typename ProtoType>
+typename std::enable_if<TypeHasFeatures<ProtoType>::value, Features*>::type
+GetFeatures(ProtoType* proto);
+
+template <>
+Features* GetFeatures<Features>(Features* proto);
+template <>
+Features* GetFeatures<Example>(Example* proto);
+template <>
+Features* GetFeatures<SequenceExample>(SequenceExample* proto);
+
+template <typename ProtoType>
+typename std::enable_if<TypeHasFeatures<ProtoType>::value,
+                        const Features&>::type
+GetFeatures(const ProtoType& proto);
+
+template <>
+const Features& GetFeatures<Features>(const Features& proto);
+template <>
+const Features& GetFeatures<Example>(const Example& proto);
+template <>
+const Features& GetFeatures<SequenceExample>(const SequenceExample& proto);
+
+// Base declaration of a family of template functions to return a read only
+// repeated field of feature values.
+template <typename FeatureType>
+const typename internal::RepeatedFieldTrait<FeatureType>::Type&
+GetFeatureValues(const Feature& feature);
+
+template <>
+const protobuf::RepeatedField<protobuf_int64>& GetFeatureValues<protobuf_int64>(
+    const Feature& feature);
+template <>
+const protobuf::RepeatedField<float>& GetFeatureValues<float>(
+    const Feature& feature);
+template <>
+const protobuf::RepeatedPtrField<std::string>& GetFeatureValues<tstring>(
+    const Feature& feature);
+template <>
+const protobuf::RepeatedPtrField<std::string>& GetFeatureValues<std::string>(
+    const Feature& feature);
+
+// Returns a read only repeated field corresponding to a feature with the
+// specified name and FeatureType. Supported ProtoTypes: SequenceExample,
+// Example, Features.
+template <typename FeatureType, typename ProtoType>
+const typename internal::RepeatedFieldTrait<FeatureType>::Type&
+GetFeatureValues(absl::string_view key, const ProtoType& proto) {
+  return GetFeatureValues<FeatureType>(
+      GetFeatures(proto).feature().at(internal::ProtoMapKey(key)));
+}
+
+// Returns a mutable repeated field of a feature values.
+template <typename FeatureType>
+typename internal::RepeatedFieldTrait<FeatureType>::Type* GetFeatureValues(
+    Feature* feature);
+
+template <>
+protobuf::RepeatedField<protobuf_int64>* GetFeatureValues<protobuf_int64>(
+    Feature* feature);
+template <>
+protobuf::RepeatedField<float>* GetFeatureValues<float>(Feature* feature);
+template <>
+protobuf::RepeatedPtrField<std::string>* GetFeatureValues<tstring>(
+    Feature* feature);
+template <>
+protobuf::RepeatedPtrField<std::string>* GetFeatureValues<std::string>(
+    Feature* feature);
+
+// Returns a mutable repeated field corresponding to a feature with the
+// specified name and FeatureType. Supported ProtoTypes: SequenceExample,
+// Example, Features.
+template <typename FeatureType, typename ProtoType>
+typename internal::RepeatedFieldTrait<FeatureType>::Type* GetFeatureValues(
+    absl::string_view key, ProtoType* proto) {
+  ::tensorflow::Feature& feature =
+      (*GetFeatures(proto)->mutable_feature())[internal::ProtoMapKey(key)];
+  return GetFeatureValues<FeatureType>(&feature);
+}
+
+// Returns a read-only Feature proto for the specified key, throws
+// std::out_of_range if the key is not found. Supported types for the proto:
+// SequenceExample, Example, Features.
+template <typename ProtoType>
+const Feature& GetFeature(absl::string_view key, const ProtoType& proto) {
+  return GetFeatures(proto).feature().at(internal::ProtoMapKey(key));
+}
+
+// Returns a read-only Feature proto for the specified key, returns nullptr
+// if the key is not found. Supported types for the proto: SequenceExample,
+// Example, Features.
+template <typename ProtoType>
+const Feature* MaybeGetFeature(absl::string_view key, const ProtoType& proto) {
+  const protobuf::Map<std::string, Feature>& feature_map =
+      GetFeatures(proto).feature();
+  auto it = feature_map.find(internal::ProtoMapKey(key));
+
+  if (it == feature_map.end()) {
+    return nullptr;
+  }
+
+  return &it->second;
+}
+
+// Base declaration of a family of template functions to return a read only
+// repeated field of feature values or nullptr.
+template <typename FeatureType>
+const typename internal::RepeatedFieldTrait<FeatureType>::Type*
+MaybeGetFeatureValues(const Feature& feature);
+
+template <>
+const protobuf::RepeatedField<protobuf_int64>*
+MaybeGetFeatureValues<protobuf_int64>(const Feature& feature);
+template <>
+const protobuf::RepeatedField<float>* MaybeGetFeatureValues<float>(
+    const Feature& feature);
+template <>
+const protobuf::RepeatedPtrField<std::string>* MaybeGetFeatureValues<tstring>(
+    const Feature& feature);
+template <>
+const protobuf::RepeatedPtrField<std::string>*
+MaybeGetFeatureValues<std::string>(const Feature& feature);
+
+// Returns a read only repeated field corresponding to a feature with the
+// specified name and FeatureType. Supported ProtoTypes: SequenceExample,
+// Example, Features.
+template <typename FeatureType, typename ProtoType>
+const typename internal::RepeatedFieldTrait<FeatureType>::Type*
+MaybeGetFeatureValues(absl::string_view key, const ProtoType& proto) {
+  const Feature* feature = MaybeGetFeature(key, proto);
+  if (feature == nullptr) {
+    return nullptr;
+  }
+  return &GetFeatureValues<FeatureType>(*feature);
+}
+
+// Returns a mutable Feature proto for the specified key, creates a new if
+// necessary. Supported types for the proto: SequenceExample, Example, Features.
+template <typename ProtoType>
+Feature* GetFeature(absl::string_view key, ProtoType* proto) {
+  return &(*GetFeatures(proto)->mutable_feature())[internal::ProtoMapKey(key)];
+}
+
+// Returns a repeated field with features corresponding to a feature_list key.
+const protobuf::RepeatedPtrField<Feature>& GetFeatureList(
+    absl::string_view key, const SequenceExample& sequence_example);
+
+// Returns a mutable repeated field with features corresponding to a
+// feature_list key. It will create a new FeatureList if necessary.
+protobuf::RepeatedPtrField<Feature>* GetFeatureList(
+    absl::string_view feature_list_key, SequenceExample* sequence_example);
+
+template <typename IteratorType>
+void AppendFeatureValues(IteratorType first, IteratorType last,
+                         Feature* feature) {
+  using FeatureType = typename internal::FeatureTrait<
+      typename std::iterator_traits<IteratorType>::value_type>::Type;
+  auto& values = *GetFeatureValues<FeatureType>(feature);
+  values.Reserve(std::distance(first, last));
+  for (auto it = first; it != last; ++it) {
+    *values.Add() = *it;
+  }
+}
+
+template <typename ValueType>
+void AppendFeatureValues(std::initializer_list<ValueType> container,
+                         Feature* feature) {
+  using FeatureType = typename internal::FeatureTrait<ValueType>::Type;
+  auto& values = *GetFeatureValues<FeatureType>(feature);
+  values.Reserve(container.size());
+  for (auto& elt : container) {
+    *values.Add() = std::move(elt);
+  }
+}
+
+namespace internal {
+
+// HasSize<T>::value is true_type if T has a size() member.
+template <typename T, typename = void>
+struct HasSize : std::false_type {};
+
+template <typename T>
+struct HasSize<T, absl::void_t<decltype(std::declval<T>().size())>>
+    : std::true_type {};
+
+// Reserves the container's size, if a container.size() method exists.
+template <typename ContainerType, typename RepeatedFieldType>
+auto ReserveIfSizeAvailable(const ContainerType& container,
+                            RepeatedFieldType& values) ->
+    typename std::enable_if_t<HasSize<ContainerType>::value, void> {
+  values.Reserve(container.size());
+}
+
+template <typename ContainerType, typename RepeatedFieldType>
+auto ReserveIfSizeAvailable(const ContainerType& container,
+                            RepeatedFieldType& values) ->
+    typename std::enable_if_t<!HasSize<ContainerType>::value, void> {}
+
+}  // namespace internal
+
+template <typename ContainerType>
+void AppendFeatureValues(const ContainerType& container, Feature* feature) {
+  using IteratorType = typename ContainerType::const_iterator;
+  using FeatureType = typename internal::FeatureTrait<
+      typename std::iterator_traits<IteratorType>::value_type>::Type;
+  auto* values = GetFeatureValues<FeatureType>(feature);
+  internal::ReserveIfSizeAvailable(container, *values);
+  // This is equivalent to std::copy into `values` with a
+  // RepeatedFieldBackInserter, the difference is RFBI isn't compatible with
+  // types that we want to convert (e.g. absl::string_view -> std::string).
+  for (const auto& elt : container) {
+    if constexpr (internal::is_string<FeatureType>::value) {
+      *values->Add() = std::string(elt);
+    } else {
+      *values->Add() = elt;
+    }
+  }
+}
+
+// Copies elements from the range, defined by [first, last) into the feature
+// obtainable from the (proto, key) combination.
+template <typename IteratorType, typename ProtoType>
+void AppendFeatureValues(IteratorType first, IteratorType last,
+                         absl::string_view key, ProtoType* proto) {
+  AppendFeatureValues(first, last, GetFeature(key, GetFeatures(proto)));
+}
+
+// Copies all elements from the container into a feature.
+template <typename ContainerType, typename ProtoType>
+void AppendFeatureValues(const ContainerType& container, absl::string_view key,
+                         ProtoType* proto) {
+  AppendFeatureValues<ContainerType>(container,
+                                     GetFeature(key, GetFeatures(proto)));
+}
+
+// Copies all elements from the initializer list into a Feature contained by
+// Features or Example proto.
+template <typename ValueType, typename ProtoType>
+void AppendFeatureValues(std::initializer_list<ValueType> container,
+                         absl::string_view key, ProtoType* proto) {
+  AppendFeatureValues<ValueType>(container,
+                                 GetFeature(key, GetFeatures(proto)));
+}
+
+// Clears the feature's repeated field (int64, float, or string).
+template <typename... FeatureType>
+void ClearFeatureValues(Feature* feature);
+
+template <>
+void ClearFeatureValues<protobuf_int64>(Feature* feature);
+template <>
+void ClearFeatureValues<float>(Feature* feature);
+template <>
+void ClearFeatureValues<std::string>(Feature* feature);
+template <>
+void ClearFeatureValues<tstring>(Feature* feature);
+
+// Clears the feature's repeated field (int64, float, or string). Copies
+// elements from the range, defined by [first, last) into the feature's repeated
+// field.
+template <typename IteratorType>
+void SetFeatureValues(IteratorType first, IteratorType last, Feature* feature) {
+  using FeatureType = typename internal::FeatureTrait<
+      typename std::iterator_traits<IteratorType>::value_type>::Type;
+  ClearFeatureValues<FeatureType>(feature);
+  AppendFeatureValues(first, last, feature);
+}
+
+// Clears the feature's repeated field (int64, float, or string). Copies all
+// elements from the initializer list into the feature's repeated field.
+template <typename ValueType>
+void SetFeatureValues(std::initializer_list<ValueType> container,
+                      Feature* feature) {
+  using FeatureType = typename internal::FeatureTrait<ValueType>::Type;
+  ClearFeatureValues<FeatureType>(feature);
+  AppendFeatureValues(container, feature);
+}
+
+// Clears the feature's repeated field (int64, float, or string). Copies all
+// elements from the container into the feature's repeated field.
+template <typename ContainerType>
+void SetFeatureValues(const ContainerType& container, Feature* feature) {
+  using IteratorType = typename ContainerType::const_iterator;
+  using FeatureType = typename internal::FeatureTrait<
+      typename std::iterator_traits<IteratorType>::value_type>::Type;
+  ClearFeatureValues<FeatureType>(feature);
+  AppendFeatureValues(container, feature);
+}
+
+// Clears the feature's repeated field (int64, float, or string). Copies
+// elements from the range, defined by [first, last) into the feature's repeated
+// field.
+template <typename IteratorType, typename ProtoType>
+void SetFeatureValues(IteratorType first, IteratorType last,
+                      absl::string_view key, ProtoType* proto) {
+  SetFeatureValues(first, last, GetFeature(key, GetFeatures(proto)));
+}
+
+// Clears the feature's repeated field (int64, float, or string). Copies all
+// elements from the container into the feature's repeated field.
+template <typename ContainerType, typename ProtoType>
+void SetFeatureValues(const ContainerType& container, absl::string_view key,
+                      ProtoType* proto) {
+  SetFeatureValues<ContainerType>(container,
+                                  GetFeature(key, GetFeatures(proto)));
+}
+
+// Clears the feature's repeated field (int64, float, or string). Copies all
+// elements from the initializer list into the feature's repeated field.
+template <typename ValueType, typename ProtoType>
+void SetFeatureValues(std::initializer_list<ValueType> container,
+                      absl::string_view key, ProtoType* proto) {
+  SetFeatureValues<ValueType>(container, GetFeature(key, GetFeatures(proto)));
+}
+
+// Returns true if a feature with the specified key belongs to the Features.
+// The template parameter pack accepts zero or one template argument - which
+// is FeatureType. If the FeatureType not specified (zero template arguments)
+// the function will not check the feature type. Otherwise it will return false
+// if the feature has a wrong type.
+template <typename... FeatureType>
+bool HasFeature(absl::string_view key, const Features& features);
+
+template <>
+bool HasFeature<>(absl::string_view key, const Features& features);
+template <>
+bool HasFeature<protobuf_int64>(absl::string_view key,
+                                const Features& features);
+template <>
+bool HasFeature<float>(absl::string_view key, const Features& features);
+template <>
+bool HasFeature<std::string>(absl::string_view key, const Features& features);
+template <>
+bool HasFeature<tstring>(absl::string_view key, const Features& features);
+
+// Returns true if a feature with the specified key belongs to the Example.
+// Doesn't check feature type if used without FeatureType, otherwise the
+// specialized versions return false if the feature has a wrong type.
+template <typename... FeatureType>
+bool HasFeature(absl::string_view key, const Example& example) {
+  return HasFeature<FeatureType...>(key, GetFeatures(example));
+}
+
+// Returns true if a feature with the specified key belongs to the
+// SequenceExample. Doesn't check feature type if used without FeatureType,
+// otherwise the specialized versions return false if the feature has a wrong
+// type.
+template <typename... FeatureType>
+bool HasFeature(absl::string_view key,
+                const SequenceExample& sequence_example) {
+  return HasFeature<FeatureType...>(key, GetFeatures(sequence_example));
+}
+
+// TODO(gorban): update all clients in a followup CL.
+template <typename... FeatureType>
+ABSL_DEPRECATED("Use HasFeature instead.")
+bool ExampleHasFeature(absl::string_view key, const Example& example) {
+  return HasFeature<FeatureType...>(key, example);
+}
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_EXAMPLE_FEATURE_UTIL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/allocation_description.pb.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/allocation_description.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..e645c180df12d0b0e38c91de6048a0db91b3914e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/allocation_description.pb.h
@@ -0,0 +1,437 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: tensorflow/core/framework/allocation_description.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fallocation_5fdescription_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fallocation_5fdescription_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3021000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3021009 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_tensorflow_2fcore_2fframework_2fallocation_5fdescription_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_tensorflow_2fcore_2fframework_2fallocation_5fdescription_2eproto {
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_tensorflow_2fcore_2fframework_2fallocation_5fdescription_2eproto;
+namespace tensorflow {
+class AllocationDescription;
+struct AllocationDescriptionDefaultTypeInternal;
+extern AllocationDescriptionDefaultTypeInternal _AllocationDescription_default_instance_;
+}  // namespace tensorflow
+PROTOBUF_NAMESPACE_OPEN
+template<> ::tensorflow::AllocationDescription* Arena::CreateMaybeMessage<::tensorflow::AllocationDescription>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace tensorflow {
+
+// ===================================================================
+
+class AllocationDescription final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.AllocationDescription) */ {
+ public:
+  inline AllocationDescription() : AllocationDescription(nullptr) {}
+  ~AllocationDescription() override;
+  explicit PROTOBUF_CONSTEXPR AllocationDescription(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  AllocationDescription(const AllocationDescription& from);
+  AllocationDescription(AllocationDescription&& from) noexcept
+    : AllocationDescription() {
+    *this = ::std::move(from);
+  }
+
+  inline AllocationDescription& operator=(const AllocationDescription& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline AllocationDescription& operator=(AllocationDescription&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const AllocationDescription& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const AllocationDescription* internal_default_instance() {
+    return reinterpret_cast<const AllocationDescription*>(
+               &_AllocationDescription_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(AllocationDescription& a, AllocationDescription& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(AllocationDescription* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(AllocationDescription* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  AllocationDescription* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<AllocationDescription>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const AllocationDescription& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const AllocationDescription& from) {
+    AllocationDescription::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(AllocationDescription* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.AllocationDescription";
+  }
+  protected:
+  explicit AllocationDescription(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kAllocatorNameFieldNumber = 3,
+    kRequestedBytesFieldNumber = 1,
+    kAllocatedBytesFieldNumber = 2,
+    kAllocationIdFieldNumber = 4,
+    kPtrFieldNumber = 6,
+    kHasSingleReferenceFieldNumber = 5,
+  };
+  // string allocator_name = 3;
+  void clear_allocator_name();
+  const std::string& allocator_name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_allocator_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_allocator_name();
+  PROTOBUF_NODISCARD std::string* release_allocator_name();
+  void set_allocated_allocator_name(std::string* allocator_name);
+  private:
+  const std::string& _internal_allocator_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_allocator_name(const std::string& value);
+  std::string* _internal_mutable_allocator_name();
+  public:
+
+  // int64 requested_bytes = 1;
+  void clear_requested_bytes();
+  int64_t requested_bytes() const;
+  void set_requested_bytes(int64_t value);
+  private:
+  int64_t _internal_requested_bytes() const;
+  void _internal_set_requested_bytes(int64_t value);
+  public:
+
+  // int64 allocated_bytes = 2;
+  void clear_allocated_bytes();
+  int64_t allocated_bytes() const;
+  void set_allocated_bytes(int64_t value);
+  private:
+  int64_t _internal_allocated_bytes() const;
+  void _internal_set_allocated_bytes(int64_t value);
+  public:
+
+  // int64 allocation_id = 4;
+  void clear_allocation_id();
+  int64_t allocation_id() const;
+  void set_allocation_id(int64_t value);
+  private:
+  int64_t _internal_allocation_id() const;
+  void _internal_set_allocation_id(int64_t value);
+  public:
+
+  // uint64 ptr = 6;
+  void clear_ptr();
+  uint64_t ptr() const;
+  void set_ptr(uint64_t value);
+  private:
+  uint64_t _internal_ptr() const;
+  void _internal_set_ptr(uint64_t value);
+  public:
+
+  // bool has_single_reference = 5;
+  void clear_has_single_reference();
+  bool has_single_reference() const;
+  void set_has_single_reference(bool value);
+  private:
+  bool _internal_has_single_reference() const;
+  void _internal_set_has_single_reference(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.AllocationDescription)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr allocator_name_;
+    int64_t requested_bytes_;
+    int64_t allocated_bytes_;
+    int64_t allocation_id_;
+    uint64_t ptr_;
+    bool has_single_reference_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fallocation_5fdescription_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// AllocationDescription
+
+// int64 requested_bytes = 1;
+inline void AllocationDescription::clear_requested_bytes() {
+  _impl_.requested_bytes_ = int64_t{0};
+}
+inline int64_t AllocationDescription::_internal_requested_bytes() const {
+  return _impl_.requested_bytes_;
+}
+inline int64_t AllocationDescription::requested_bytes() const {
+  // @@protoc_insertion_point(field_get:tensorflow.AllocationDescription.requested_bytes)
+  return _internal_requested_bytes();
+}
+inline void AllocationDescription::_internal_set_requested_bytes(int64_t value) {
+  
+  _impl_.requested_bytes_ = value;
+}
+inline void AllocationDescription::set_requested_bytes(int64_t value) {
+  _internal_set_requested_bytes(value);
+  // @@protoc_insertion_point(field_set:tensorflow.AllocationDescription.requested_bytes)
+}
+
+// int64 allocated_bytes = 2;
+inline void AllocationDescription::clear_allocated_bytes() {
+  _impl_.allocated_bytes_ = int64_t{0};
+}
+inline int64_t AllocationDescription::_internal_allocated_bytes() const {
+  return _impl_.allocated_bytes_;
+}
+inline int64_t AllocationDescription::allocated_bytes() const {
+  // @@protoc_insertion_point(field_get:tensorflow.AllocationDescription.allocated_bytes)
+  return _internal_allocated_bytes();
+}
+inline void AllocationDescription::_internal_set_allocated_bytes(int64_t value) {
+  
+  _impl_.allocated_bytes_ = value;
+}
+inline void AllocationDescription::set_allocated_bytes(int64_t value) {
+  _internal_set_allocated_bytes(value);
+  // @@protoc_insertion_point(field_set:tensorflow.AllocationDescription.allocated_bytes)
+}
+
+// string allocator_name = 3;
+inline void AllocationDescription::clear_allocator_name() {
+  _impl_.allocator_name_.ClearToEmpty();
+}
+inline const std::string& AllocationDescription::allocator_name() const {
+  // @@protoc_insertion_point(field_get:tensorflow.AllocationDescription.allocator_name)
+  return _internal_allocator_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void AllocationDescription::set_allocator_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.allocator_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.AllocationDescription.allocator_name)
+}
+inline std::string* AllocationDescription::mutable_allocator_name() {
+  std::string* _s = _internal_mutable_allocator_name();
+  // @@protoc_insertion_point(field_mutable:tensorflow.AllocationDescription.allocator_name)
+  return _s;
+}
+inline const std::string& AllocationDescription::_internal_allocator_name() const {
+  return _impl_.allocator_name_.Get();
+}
+inline void AllocationDescription::_internal_set_allocator_name(const std::string& value) {
+  
+  _impl_.allocator_name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* AllocationDescription::_internal_mutable_allocator_name() {
+  
+  return _impl_.allocator_name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* AllocationDescription::release_allocator_name() {
+  // @@protoc_insertion_point(field_release:tensorflow.AllocationDescription.allocator_name)
+  return _impl_.allocator_name_.Release();
+}
+inline void AllocationDescription::set_allocated_allocator_name(std::string* allocator_name) {
+  if (allocator_name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.allocator_name_.SetAllocated(allocator_name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.allocator_name_.IsDefault()) {
+    _impl_.allocator_name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.AllocationDescription.allocator_name)
+}
+
+// int64 allocation_id = 4;
+inline void AllocationDescription::clear_allocation_id() {
+  _impl_.allocation_id_ = int64_t{0};
+}
+inline int64_t AllocationDescription::_internal_allocation_id() const {
+  return _impl_.allocation_id_;
+}
+inline int64_t AllocationDescription::allocation_id() const {
+  // @@protoc_insertion_point(field_get:tensorflow.AllocationDescription.allocation_id)
+  return _internal_allocation_id();
+}
+inline void AllocationDescription::_internal_set_allocation_id(int64_t value) {
+  
+  _impl_.allocation_id_ = value;
+}
+inline void AllocationDescription::set_allocation_id(int64_t value) {
+  _internal_set_allocation_id(value);
+  // @@protoc_insertion_point(field_set:tensorflow.AllocationDescription.allocation_id)
+}
+
+// bool has_single_reference = 5;
+inline void AllocationDescription::clear_has_single_reference() {
+  _impl_.has_single_reference_ = false;
+}
+inline bool AllocationDescription::_internal_has_single_reference() const {
+  return _impl_.has_single_reference_;
+}
+inline bool AllocationDescription::has_single_reference() const {
+  // @@protoc_insertion_point(field_get:tensorflow.AllocationDescription.has_single_reference)
+  return _internal_has_single_reference();
+}
+inline void AllocationDescription::_internal_set_has_single_reference(bool value) {
+  
+  _impl_.has_single_reference_ = value;
+}
+inline void AllocationDescription::set_has_single_reference(bool value) {
+  _internal_set_has_single_reference(value);
+  // @@protoc_insertion_point(field_set:tensorflow.AllocationDescription.has_single_reference)
+}
+
+// uint64 ptr = 6;
+inline void AllocationDescription::clear_ptr() {
+  _impl_.ptr_ = uint64_t{0u};
+}
+inline uint64_t AllocationDescription::_internal_ptr() const {
+  return _impl_.ptr_;
+}
+inline uint64_t AllocationDescription::ptr() const {
+  // @@protoc_insertion_point(field_get:tensorflow.AllocationDescription.ptr)
+  return _internal_ptr();
+}
+inline void AllocationDescription::_internal_set_ptr(uint64_t value) {
+  
+  _impl_.ptr_ = value;
+}
+inline void AllocationDescription::set_ptr(uint64_t value) {
+  _internal_set_ptr(value);
+  // @@protoc_insertion_point(field_set:tensorflow.AllocationDescription.ptr)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace tensorflow
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fallocation_5fdescription_2eproto
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/allocation_description.proto b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/allocation_description.proto
new file mode 100644
index 0000000000000000000000000000000000000000..f18caa40b2bde7cbb3a51b676cfdbfad18caa740
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/allocation_description.proto
@@ -0,0 +1,29 @@
+syntax = "proto3";
+
+package tensorflow;
+
+option cc_enable_arenas = true;
+option java_outer_classname = "AllocationDescriptionProtos";
+option java_multiple_files = true;
+option java_package = "org.tensorflow.framework";
+option go_package = "github.com/tensorflow/tensorflow/tensorflow/go/core/framework/allocation_description_go_proto";
+
+message AllocationDescription {
+  // Total number of bytes requested
+  int64 requested_bytes = 1;
+
+  // Total number of bytes allocated if known
+  int64 allocated_bytes = 2;
+
+  // Name of the allocator used
+  string allocator_name = 3;
+
+  // Identifier of the allocated buffer if known
+  int64 allocation_id = 4;
+
+  // Set if this tensor only has one remaining reference
+  bool has_single_reference = 5;
+
+  // Address of the allocation.
+  uint64 ptr = 6;
+}
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/allocator.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/allocator.h
new file mode 100644
index 0000000000000000000000000000000000000000..9e6fdc8f0c9369479815153f9b76c670b325026f
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/allocator.h
@@ -0,0 +1,55 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_ALLOCATOR_H_
+#define TENSORFLOW_CORE_FRAMEWORK_ALLOCATOR_H_
+
+#include <stdlib.h>
+
+#include <functional>
+#include <limits>
+
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+#include "tensorflow/core/framework/numeric_types.h"
+#include "tensorflow/core/framework/type_traits.h"
+#include "tensorflow/core/platform/logging.h"
+#include "tensorflow/core/platform/macros.h"
+#include "tensorflow/core/platform/numa.h"
+#include "tensorflow/core/platform/types.h"
+#include "tsl/framework/allocator.h"
+
+namespace tensorflow {
+
+// NOLINTBEGIN(misc-unused-using-decls)
+using tsl::AllocationAttributes;
+using tsl::Allocator;
+using tsl::AllocatorAttributes;
+using tsl::AllocatorMemoryType;
+using tsl::AllocatorStats;
+using tsl::AllocatorWrapper;
+using tsl::cpu_allocator;
+using tsl::cpu_allocator_base;
+using tsl::CPUAllocatorFullStatsEnabled;
+using tsl::CPUAllocatorStatsEnabled;
+using tsl::DisableCPUAllocatorStats;
+using tsl::EnableCPUAllocatorFullStats;
+using tsl::EnableCPUAllocatorStats;
+using tsl::SubAllocator;
+// NOLINTEND(misc-unused-using-decls)
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_ALLOCATOR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/allocator_registry.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/allocator_registry.h
new file mode 100644
index 0000000000000000000000000000000000000000..1bc537554c76c117b3449fa2d2e84a672281f8f2
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/allocator_registry.h
@@ -0,0 +1,40 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// Classes to maintain a static registry of memory allocator factories.
+#ifndef TENSORFLOW_CORE_FRAMEWORK_ALLOCATOR_REGISTRY_H_
+#define TENSORFLOW_CORE_FRAMEWORK_ALLOCATOR_REGISTRY_H_
+
+#include <string>
+#include <vector>
+
+#include "tensorflow/core/framework/allocator.h"
+#include "tensorflow/core/platform/macros.h"
+#include "tensorflow/core/platform/mutex.h"
+#include "tensorflow/core/platform/numa.h"
+#include "tsl/framework/allocator_registry.h"
+
+namespace tensorflow {
+
+// NOLINTBEGIN(misc-unused-using-decls)
+using tsl::AllocatorFactory;
+using tsl::AllocatorFactoryRegistration;
+using tsl::AllocatorFactoryRegistry;
+using tsl::ProcessStateInterface;
+// NOLINTEND(misc-unused-using-decls)
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_ALLOCATOR_REGISTRY_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/api_def.pb.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/api_def.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..f61281b12652f0c6f7b0e417853b1c3454309b03
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/api_def.pb.h
@@ -0,0 +1,2369 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: tensorflow/core/framework/api_def.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fapi_5fdef_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fapi_5fdef_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3021000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3021009 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "tensorflow/core/framework/attr_value.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_tensorflow_2fcore_2fframework_2fapi_5fdef_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_tensorflow_2fcore_2fframework_2fapi_5fdef_2eproto {
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_tensorflow_2fcore_2fframework_2fapi_5fdef_2eproto;
+namespace tensorflow {
+class ApiDef;
+struct ApiDefDefaultTypeInternal;
+extern ApiDefDefaultTypeInternal _ApiDef_default_instance_;
+class ApiDef_Arg;
+struct ApiDef_ArgDefaultTypeInternal;
+extern ApiDef_ArgDefaultTypeInternal _ApiDef_Arg_default_instance_;
+class ApiDef_Attr;
+struct ApiDef_AttrDefaultTypeInternal;
+extern ApiDef_AttrDefaultTypeInternal _ApiDef_Attr_default_instance_;
+class ApiDef_Endpoint;
+struct ApiDef_EndpointDefaultTypeInternal;
+extern ApiDef_EndpointDefaultTypeInternal _ApiDef_Endpoint_default_instance_;
+class ApiDefs;
+struct ApiDefsDefaultTypeInternal;
+extern ApiDefsDefaultTypeInternal _ApiDefs_default_instance_;
+}  // namespace tensorflow
+PROTOBUF_NAMESPACE_OPEN
+template<> ::tensorflow::ApiDef* Arena::CreateMaybeMessage<::tensorflow::ApiDef>(Arena*);
+template<> ::tensorflow::ApiDef_Arg* Arena::CreateMaybeMessage<::tensorflow::ApiDef_Arg>(Arena*);
+template<> ::tensorflow::ApiDef_Attr* Arena::CreateMaybeMessage<::tensorflow::ApiDef_Attr>(Arena*);
+template<> ::tensorflow::ApiDef_Endpoint* Arena::CreateMaybeMessage<::tensorflow::ApiDef_Endpoint>(Arena*);
+template<> ::tensorflow::ApiDefs* Arena::CreateMaybeMessage<::tensorflow::ApiDefs>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace tensorflow {
+
+enum ApiDef_Visibility : int {
+  ApiDef_Visibility_DEFAULT_VISIBILITY = 0,
+  ApiDef_Visibility_VISIBLE = 1,
+  ApiDef_Visibility_SKIP = 2,
+  ApiDef_Visibility_HIDDEN = 3,
+  ApiDef_Visibility_ApiDef_Visibility_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
+  ApiDef_Visibility_ApiDef_Visibility_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
+};
+bool ApiDef_Visibility_IsValid(int value);
+constexpr ApiDef_Visibility ApiDef_Visibility_Visibility_MIN = ApiDef_Visibility_DEFAULT_VISIBILITY;
+constexpr ApiDef_Visibility ApiDef_Visibility_Visibility_MAX = ApiDef_Visibility_HIDDEN;
+constexpr int ApiDef_Visibility_Visibility_ARRAYSIZE = ApiDef_Visibility_Visibility_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ApiDef_Visibility_descriptor();
+template<typename T>
+inline const std::string& ApiDef_Visibility_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ApiDef_Visibility>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ApiDef_Visibility_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    ApiDef_Visibility_descriptor(), enum_t_value);
+}
+inline bool ApiDef_Visibility_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ApiDef_Visibility* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ApiDef_Visibility>(
+    ApiDef_Visibility_descriptor(), name, value);
+}
+// ===================================================================
+
+class ApiDef_Endpoint final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.ApiDef.Endpoint) */ {
+ public:
+  inline ApiDef_Endpoint() : ApiDef_Endpoint(nullptr) {}
+  ~ApiDef_Endpoint() override;
+  explicit PROTOBUF_CONSTEXPR ApiDef_Endpoint(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ApiDef_Endpoint(const ApiDef_Endpoint& from);
+  ApiDef_Endpoint(ApiDef_Endpoint&& from) noexcept
+    : ApiDef_Endpoint() {
+    *this = ::std::move(from);
+  }
+
+  inline ApiDef_Endpoint& operator=(const ApiDef_Endpoint& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ApiDef_Endpoint& operator=(ApiDef_Endpoint&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ApiDef_Endpoint& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ApiDef_Endpoint* internal_default_instance() {
+    return reinterpret_cast<const ApiDef_Endpoint*>(
+               &_ApiDef_Endpoint_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(ApiDef_Endpoint& a, ApiDef_Endpoint& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ApiDef_Endpoint* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ApiDef_Endpoint* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ApiDef_Endpoint* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ApiDef_Endpoint>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ApiDef_Endpoint& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const ApiDef_Endpoint& from) {
+    ApiDef_Endpoint::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ApiDef_Endpoint* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.ApiDef.Endpoint";
+  }
+  protected:
+  explicit ApiDef_Endpoint(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNameFieldNumber = 1,
+    kDeprecatedFieldNumber = 3,
+    kDeprecationVersionFieldNumber = 4,
+  };
+  // string name = 1;
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // bool deprecated = 3;
+  void clear_deprecated();
+  bool deprecated() const;
+  void set_deprecated(bool value);
+  private:
+  bool _internal_deprecated() const;
+  void _internal_set_deprecated(bool value);
+  public:
+
+  // int32 deprecation_version = 4;
+  void clear_deprecation_version();
+  int32_t deprecation_version() const;
+  void set_deprecation_version(int32_t value);
+  private:
+  int32_t _internal_deprecation_version() const;
+  void _internal_set_deprecation_version(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.ApiDef.Endpoint)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+    bool deprecated_;
+    int32_t deprecation_version_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fapi_5fdef_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ApiDef_Arg final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.ApiDef.Arg) */ {
+ public:
+  inline ApiDef_Arg() : ApiDef_Arg(nullptr) {}
+  ~ApiDef_Arg() override;
+  explicit PROTOBUF_CONSTEXPR ApiDef_Arg(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ApiDef_Arg(const ApiDef_Arg& from);
+  ApiDef_Arg(ApiDef_Arg&& from) noexcept
+    : ApiDef_Arg() {
+    *this = ::std::move(from);
+  }
+
+  inline ApiDef_Arg& operator=(const ApiDef_Arg& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ApiDef_Arg& operator=(ApiDef_Arg&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ApiDef_Arg& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ApiDef_Arg* internal_default_instance() {
+    return reinterpret_cast<const ApiDef_Arg*>(
+               &_ApiDef_Arg_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(ApiDef_Arg& a, ApiDef_Arg& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ApiDef_Arg* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ApiDef_Arg* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ApiDef_Arg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ApiDef_Arg>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ApiDef_Arg& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const ApiDef_Arg& from) {
+    ApiDef_Arg::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ApiDef_Arg* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.ApiDef.Arg";
+  }
+  protected:
+  explicit ApiDef_Arg(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNameFieldNumber = 1,
+    kRenameToFieldNumber = 2,
+    kDescriptionFieldNumber = 3,
+  };
+  // string name = 1;
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // string rename_to = 2;
+  void clear_rename_to();
+  const std::string& rename_to() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_rename_to(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_rename_to();
+  PROTOBUF_NODISCARD std::string* release_rename_to();
+  void set_allocated_rename_to(std::string* rename_to);
+  private:
+  const std::string& _internal_rename_to() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_rename_to(const std::string& value);
+  std::string* _internal_mutable_rename_to();
+  public:
+
+  // string description = 3;
+  void clear_description();
+  const std::string& description() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_description(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_description();
+  PROTOBUF_NODISCARD std::string* release_description();
+  void set_allocated_description(std::string* description);
+  private:
+  const std::string& _internal_description() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_description(const std::string& value);
+  std::string* _internal_mutable_description();
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.ApiDef.Arg)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr rename_to_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fapi_5fdef_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ApiDef_Attr final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.ApiDef.Attr) */ {
+ public:
+  inline ApiDef_Attr() : ApiDef_Attr(nullptr) {}
+  ~ApiDef_Attr() override;
+  explicit PROTOBUF_CONSTEXPR ApiDef_Attr(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ApiDef_Attr(const ApiDef_Attr& from);
+  ApiDef_Attr(ApiDef_Attr&& from) noexcept
+    : ApiDef_Attr() {
+    *this = ::std::move(from);
+  }
+
+  inline ApiDef_Attr& operator=(const ApiDef_Attr& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ApiDef_Attr& operator=(ApiDef_Attr&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ApiDef_Attr& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ApiDef_Attr* internal_default_instance() {
+    return reinterpret_cast<const ApiDef_Attr*>(
+               &_ApiDef_Attr_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(ApiDef_Attr& a, ApiDef_Attr& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ApiDef_Attr* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ApiDef_Attr* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ApiDef_Attr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ApiDef_Attr>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ApiDef_Attr& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const ApiDef_Attr& from) {
+    ApiDef_Attr::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ApiDef_Attr* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.ApiDef.Attr";
+  }
+  protected:
+  explicit ApiDef_Attr(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNameFieldNumber = 1,
+    kRenameToFieldNumber = 2,
+    kDescriptionFieldNumber = 4,
+    kDefaultValueFieldNumber = 3,
+  };
+  // string name = 1;
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // string rename_to = 2;
+  void clear_rename_to();
+  const std::string& rename_to() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_rename_to(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_rename_to();
+  PROTOBUF_NODISCARD std::string* release_rename_to();
+  void set_allocated_rename_to(std::string* rename_to);
+  private:
+  const std::string& _internal_rename_to() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_rename_to(const std::string& value);
+  std::string* _internal_mutable_rename_to();
+  public:
+
+  // string description = 4;
+  void clear_description();
+  const std::string& description() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_description(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_description();
+  PROTOBUF_NODISCARD std::string* release_description();
+  void set_allocated_description(std::string* description);
+  private:
+  const std::string& _internal_description() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_description(const std::string& value);
+  std::string* _internal_mutable_description();
+  public:
+
+  // .tensorflow.AttrValue default_value = 3;
+  bool has_default_value() const;
+  private:
+  bool _internal_has_default_value() const;
+  public:
+  void clear_default_value();
+  const ::tensorflow::AttrValue& default_value() const;
+  PROTOBUF_NODISCARD ::tensorflow::AttrValue* release_default_value();
+  ::tensorflow::AttrValue* mutable_default_value();
+  void set_allocated_default_value(::tensorflow::AttrValue* default_value);
+  private:
+  const ::tensorflow::AttrValue& _internal_default_value() const;
+  ::tensorflow::AttrValue* _internal_mutable_default_value();
+  public:
+  void unsafe_arena_set_allocated_default_value(
+      ::tensorflow::AttrValue* default_value);
+  ::tensorflow::AttrValue* unsafe_arena_release_default_value();
+
+  // @@protoc_insertion_point(class_scope:tensorflow.ApiDef.Attr)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr rename_to_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_;
+    ::tensorflow::AttrValue* default_value_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fapi_5fdef_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ApiDef final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.ApiDef) */ {
+ public:
+  inline ApiDef() : ApiDef(nullptr) {}
+  ~ApiDef() override;
+  explicit PROTOBUF_CONSTEXPR ApiDef(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ApiDef(const ApiDef& from);
+  ApiDef(ApiDef&& from) noexcept
+    : ApiDef() {
+    *this = ::std::move(from);
+  }
+
+  inline ApiDef& operator=(const ApiDef& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ApiDef& operator=(ApiDef&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ApiDef& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ApiDef* internal_default_instance() {
+    return reinterpret_cast<const ApiDef*>(
+               &_ApiDef_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  friend void swap(ApiDef& a, ApiDef& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ApiDef* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ApiDef* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ApiDef* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ApiDef>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ApiDef& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const ApiDef& from) {
+    ApiDef::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ApiDef* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.ApiDef";
+  }
+  protected:
+  explicit ApiDef(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ApiDef_Endpoint Endpoint;
+  typedef ApiDef_Arg Arg;
+  typedef ApiDef_Attr Attr;
+
+  typedef ApiDef_Visibility Visibility;
+  static constexpr Visibility DEFAULT_VISIBILITY =
+    ApiDef_Visibility_DEFAULT_VISIBILITY;
+  static constexpr Visibility VISIBLE =
+    ApiDef_Visibility_VISIBLE;
+  static constexpr Visibility SKIP =
+    ApiDef_Visibility_SKIP;
+  static constexpr Visibility HIDDEN =
+    ApiDef_Visibility_HIDDEN;
+  static inline bool Visibility_IsValid(int value) {
+    return ApiDef_Visibility_IsValid(value);
+  }
+  static constexpr Visibility Visibility_MIN =
+    ApiDef_Visibility_Visibility_MIN;
+  static constexpr Visibility Visibility_MAX =
+    ApiDef_Visibility_Visibility_MAX;
+  static constexpr int Visibility_ARRAYSIZE =
+    ApiDef_Visibility_Visibility_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  Visibility_descriptor() {
+    return ApiDef_Visibility_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& Visibility_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, Visibility>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function Visibility_Name.");
+    return ApiDef_Visibility_Name(enum_t_value);
+  }
+  static inline bool Visibility_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      Visibility* value) {
+    return ApiDef_Visibility_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kEndpointFieldNumber = 3,
+    kInArgFieldNumber = 4,
+    kOutArgFieldNumber = 5,
+    kAttrFieldNumber = 6,
+    kArgOrderFieldNumber = 11,
+    kGraphOpNameFieldNumber = 1,
+    kSummaryFieldNumber = 7,
+    kDescriptionFieldNumber = 8,
+    kDescriptionPrefixFieldNumber = 9,
+    kDescriptionSuffixFieldNumber = 10,
+    kDeprecationMessageFieldNumber = 12,
+    kVisibilityFieldNumber = 2,
+    kDeprecationVersionFieldNumber = 13,
+  };
+  // repeated .tensorflow.ApiDef.Endpoint endpoint = 3;
+  int endpoint_size() const;
+  private:
+  int _internal_endpoint_size() const;
+  public:
+  void clear_endpoint();
+  ::tensorflow::ApiDef_Endpoint* mutable_endpoint(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::ApiDef_Endpoint >*
+      mutable_endpoint();
+  private:
+  const ::tensorflow::ApiDef_Endpoint& _internal_endpoint(int index) const;
+  ::tensorflow::ApiDef_Endpoint* _internal_add_endpoint();
+  public:
+  const ::tensorflow::ApiDef_Endpoint& endpoint(int index) const;
+  ::tensorflow::ApiDef_Endpoint* add_endpoint();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::ApiDef_Endpoint >&
+      endpoint() const;
+
+  // repeated .tensorflow.ApiDef.Arg in_arg = 4;
+  int in_arg_size() const;
+  private:
+  int _internal_in_arg_size() const;
+  public:
+  void clear_in_arg();
+  ::tensorflow::ApiDef_Arg* mutable_in_arg(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::ApiDef_Arg >*
+      mutable_in_arg();
+  private:
+  const ::tensorflow::ApiDef_Arg& _internal_in_arg(int index) const;
+  ::tensorflow::ApiDef_Arg* _internal_add_in_arg();
+  public:
+  const ::tensorflow::ApiDef_Arg& in_arg(int index) const;
+  ::tensorflow::ApiDef_Arg* add_in_arg();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::ApiDef_Arg >&
+      in_arg() const;
+
+  // repeated .tensorflow.ApiDef.Arg out_arg = 5;
+  int out_arg_size() const;
+  private:
+  int _internal_out_arg_size() const;
+  public:
+  void clear_out_arg();
+  ::tensorflow::ApiDef_Arg* mutable_out_arg(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::ApiDef_Arg >*
+      mutable_out_arg();
+  private:
+  const ::tensorflow::ApiDef_Arg& _internal_out_arg(int index) const;
+  ::tensorflow::ApiDef_Arg* _internal_add_out_arg();
+  public:
+  const ::tensorflow::ApiDef_Arg& out_arg(int index) const;
+  ::tensorflow::ApiDef_Arg* add_out_arg();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::ApiDef_Arg >&
+      out_arg() const;
+
+  // repeated .tensorflow.ApiDef.Attr attr = 6;
+  int attr_size() const;
+  private:
+  int _internal_attr_size() const;
+  public:
+  void clear_attr();
+  ::tensorflow::ApiDef_Attr* mutable_attr(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::ApiDef_Attr >*
+      mutable_attr();
+  private:
+  const ::tensorflow::ApiDef_Attr& _internal_attr(int index) const;
+  ::tensorflow::ApiDef_Attr* _internal_add_attr();
+  public:
+  const ::tensorflow::ApiDef_Attr& attr(int index) const;
+  ::tensorflow::ApiDef_Attr* add_attr();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::ApiDef_Attr >&
+      attr() const;
+
+  // repeated string arg_order = 11;
+  int arg_order_size() const;
+  private:
+  int _internal_arg_order_size() const;
+  public:
+  void clear_arg_order();
+  const std::string& arg_order(int index) const;
+  std::string* mutable_arg_order(int index);
+  void set_arg_order(int index, const std::string& value);
+  void set_arg_order(int index, std::string&& value);
+  void set_arg_order(int index, const char* value);
+  void set_arg_order(int index, const char* value, size_t size);
+  std::string* add_arg_order();
+  void add_arg_order(const std::string& value);
+  void add_arg_order(std::string&& value);
+  void add_arg_order(const char* value);
+  void add_arg_order(const char* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& arg_order() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_arg_order();
+  private:
+  const std::string& _internal_arg_order(int index) const;
+  std::string* _internal_add_arg_order();
+  public:
+
+  // string graph_op_name = 1;
+  void clear_graph_op_name();
+  const std::string& graph_op_name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_graph_op_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_graph_op_name();
+  PROTOBUF_NODISCARD std::string* release_graph_op_name();
+  void set_allocated_graph_op_name(std::string* graph_op_name);
+  private:
+  const std::string& _internal_graph_op_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_graph_op_name(const std::string& value);
+  std::string* _internal_mutable_graph_op_name();
+  public:
+
+  // string summary = 7;
+  void clear_summary();
+  const std::string& summary() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_summary(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_summary();
+  PROTOBUF_NODISCARD std::string* release_summary();
+  void set_allocated_summary(std::string* summary);
+  private:
+  const std::string& _internal_summary() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_summary(const std::string& value);
+  std::string* _internal_mutable_summary();
+  public:
+
+  // string description = 8;
+  void clear_description();
+  const std::string& description() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_description(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_description();
+  PROTOBUF_NODISCARD std::string* release_description();
+  void set_allocated_description(std::string* description);
+  private:
+  const std::string& _internal_description() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_description(const std::string& value);
+  std::string* _internal_mutable_description();
+  public:
+
+  // string description_prefix = 9;
+  void clear_description_prefix();
+  const std::string& description_prefix() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_description_prefix(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_description_prefix();
+  PROTOBUF_NODISCARD std::string* release_description_prefix();
+  void set_allocated_description_prefix(std::string* description_prefix);
+  private:
+  const std::string& _internal_description_prefix() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_description_prefix(const std::string& value);
+  std::string* _internal_mutable_description_prefix();
+  public:
+
+  // string description_suffix = 10;
+  void clear_description_suffix();
+  const std::string& description_suffix() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_description_suffix(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_description_suffix();
+  PROTOBUF_NODISCARD std::string* release_description_suffix();
+  void set_allocated_description_suffix(std::string* description_suffix);
+  private:
+  const std::string& _internal_description_suffix() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_description_suffix(const std::string& value);
+  std::string* _internal_mutable_description_suffix();
+  public:
+
+  // string deprecation_message = 12;
+  void clear_deprecation_message();
+  const std::string& deprecation_message() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_deprecation_message(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_deprecation_message();
+  PROTOBUF_NODISCARD std::string* release_deprecation_message();
+  void set_allocated_deprecation_message(std::string* deprecation_message);
+  private:
+  const std::string& _internal_deprecation_message() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_deprecation_message(const std::string& value);
+  std::string* _internal_mutable_deprecation_message();
+  public:
+
+  // .tensorflow.ApiDef.Visibility visibility = 2;
+  void clear_visibility();
+  ::tensorflow::ApiDef_Visibility visibility() const;
+  void set_visibility(::tensorflow::ApiDef_Visibility value);
+  private:
+  ::tensorflow::ApiDef_Visibility _internal_visibility() const;
+  void _internal_set_visibility(::tensorflow::ApiDef_Visibility value);
+  public:
+
+  // int32 deprecation_version = 13;
+  void clear_deprecation_version();
+  int32_t deprecation_version() const;
+  void set_deprecation_version(int32_t value);
+  private:
+  int32_t _internal_deprecation_version() const;
+  void _internal_set_deprecation_version(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.ApiDef)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::ApiDef_Endpoint > endpoint_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::ApiDef_Arg > in_arg_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::ApiDef_Arg > out_arg_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::ApiDef_Attr > attr_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> arg_order_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr graph_op_name_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr summary_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_prefix_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_suffix_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr deprecation_message_;
+    int visibility_;
+    int32_t deprecation_version_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fapi_5fdef_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ApiDefs final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.ApiDefs) */ {
+ public:
+  inline ApiDefs() : ApiDefs(nullptr) {}
+  ~ApiDefs() override;
+  explicit PROTOBUF_CONSTEXPR ApiDefs(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ApiDefs(const ApiDefs& from);
+  ApiDefs(ApiDefs&& from) noexcept
+    : ApiDefs() {
+    *this = ::std::move(from);
+  }
+
+  inline ApiDefs& operator=(const ApiDefs& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ApiDefs& operator=(ApiDefs&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ApiDefs& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ApiDefs* internal_default_instance() {
+    return reinterpret_cast<const ApiDefs*>(
+               &_ApiDefs_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    4;
+
+  friend void swap(ApiDefs& a, ApiDefs& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ApiDefs* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ApiDefs* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ApiDefs* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ApiDefs>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ApiDefs& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const ApiDefs& from) {
+    ApiDefs::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ApiDefs* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.ApiDefs";
+  }
+  protected:
+  explicit ApiDefs(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kOpFieldNumber = 1,
+  };
+  // repeated .tensorflow.ApiDef op = 1;
+  int op_size() const;
+  private:
+  int _internal_op_size() const;
+  public:
+  void clear_op();
+  ::tensorflow::ApiDef* mutable_op(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::ApiDef >*
+      mutable_op();
+  private:
+  const ::tensorflow::ApiDef& _internal_op(int index) const;
+  ::tensorflow::ApiDef* _internal_add_op();
+  public:
+  const ::tensorflow::ApiDef& op(int index) const;
+  ::tensorflow::ApiDef* add_op();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::ApiDef >&
+      op() const;
+
+  // @@protoc_insertion_point(class_scope:tensorflow.ApiDefs)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::ApiDef > op_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fapi_5fdef_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// ApiDef_Endpoint
+
+// string name = 1;
+inline void ApiDef_Endpoint::clear_name() {
+  _impl_.name_.ClearToEmpty();
+}
+inline const std::string& ApiDef_Endpoint::name() const {
+  // @@protoc_insertion_point(field_get:tensorflow.ApiDef.Endpoint.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ApiDef_Endpoint::set_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.ApiDef.Endpoint.name)
+}
+inline std::string* ApiDef_Endpoint::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:tensorflow.ApiDef.Endpoint.name)
+  return _s;
+}
+inline const std::string& ApiDef_Endpoint::_internal_name() const {
+  return _impl_.name_.Get();
+}
+inline void ApiDef_Endpoint::_internal_set_name(const std::string& value) {
+  
+  _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ApiDef_Endpoint::_internal_mutable_name() {
+  
+  return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ApiDef_Endpoint::release_name() {
+  // @@protoc_insertion_point(field_release:tensorflow.ApiDef.Endpoint.name)
+  return _impl_.name_.Release();
+}
+inline void ApiDef_Endpoint::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.ApiDef.Endpoint.name)
+}
+
+// bool deprecated = 3;
+inline void ApiDef_Endpoint::clear_deprecated() {
+  _impl_.deprecated_ = false;
+}
+inline bool ApiDef_Endpoint::_internal_deprecated() const {
+  return _impl_.deprecated_;
+}
+inline bool ApiDef_Endpoint::deprecated() const {
+  // @@protoc_insertion_point(field_get:tensorflow.ApiDef.Endpoint.deprecated)
+  return _internal_deprecated();
+}
+inline void ApiDef_Endpoint::_internal_set_deprecated(bool value) {
+  
+  _impl_.deprecated_ = value;
+}
+inline void ApiDef_Endpoint::set_deprecated(bool value) {
+  _internal_set_deprecated(value);
+  // @@protoc_insertion_point(field_set:tensorflow.ApiDef.Endpoint.deprecated)
+}
+
+// int32 deprecation_version = 4;
+inline void ApiDef_Endpoint::clear_deprecation_version() {
+  _impl_.deprecation_version_ = 0;
+}
+inline int32_t ApiDef_Endpoint::_internal_deprecation_version() const {
+  return _impl_.deprecation_version_;
+}
+inline int32_t ApiDef_Endpoint::deprecation_version() const {
+  // @@protoc_insertion_point(field_get:tensorflow.ApiDef.Endpoint.deprecation_version)
+  return _internal_deprecation_version();
+}
+inline void ApiDef_Endpoint::_internal_set_deprecation_version(int32_t value) {
+  
+  _impl_.deprecation_version_ = value;
+}
+inline void ApiDef_Endpoint::set_deprecation_version(int32_t value) {
+  _internal_set_deprecation_version(value);
+  // @@protoc_insertion_point(field_set:tensorflow.ApiDef.Endpoint.deprecation_version)
+}
+
+// -------------------------------------------------------------------
+
+// ApiDef_Arg
+
+// string name = 1;
+inline void ApiDef_Arg::clear_name() {
+  _impl_.name_.ClearToEmpty();
+}
+inline const std::string& ApiDef_Arg::name() const {
+  // @@protoc_insertion_point(field_get:tensorflow.ApiDef.Arg.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ApiDef_Arg::set_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.ApiDef.Arg.name)
+}
+inline std::string* ApiDef_Arg::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:tensorflow.ApiDef.Arg.name)
+  return _s;
+}
+inline const std::string& ApiDef_Arg::_internal_name() const {
+  return _impl_.name_.Get();
+}
+inline void ApiDef_Arg::_internal_set_name(const std::string& value) {
+  
+  _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ApiDef_Arg::_internal_mutable_name() {
+  
+  return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ApiDef_Arg::release_name() {
+  // @@protoc_insertion_point(field_release:tensorflow.ApiDef.Arg.name)
+  return _impl_.name_.Release();
+}
+inline void ApiDef_Arg::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.ApiDef.Arg.name)
+}
+
+// string rename_to = 2;
+inline void ApiDef_Arg::clear_rename_to() {
+  _impl_.rename_to_.ClearToEmpty();
+}
+inline const std::string& ApiDef_Arg::rename_to() const {
+  // @@protoc_insertion_point(field_get:tensorflow.ApiDef.Arg.rename_to)
+  return _internal_rename_to();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ApiDef_Arg::set_rename_to(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.rename_to_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.ApiDef.Arg.rename_to)
+}
+inline std::string* ApiDef_Arg::mutable_rename_to() {
+  std::string* _s = _internal_mutable_rename_to();
+  // @@protoc_insertion_point(field_mutable:tensorflow.ApiDef.Arg.rename_to)
+  return _s;
+}
+inline const std::string& ApiDef_Arg::_internal_rename_to() const {
+  return _impl_.rename_to_.Get();
+}
+inline void ApiDef_Arg::_internal_set_rename_to(const std::string& value) {
+  
+  _impl_.rename_to_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ApiDef_Arg::_internal_mutable_rename_to() {
+  
+  return _impl_.rename_to_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ApiDef_Arg::release_rename_to() {
+  // @@protoc_insertion_point(field_release:tensorflow.ApiDef.Arg.rename_to)
+  return _impl_.rename_to_.Release();
+}
+inline void ApiDef_Arg::set_allocated_rename_to(std::string* rename_to) {
+  if (rename_to != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.rename_to_.SetAllocated(rename_to, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.rename_to_.IsDefault()) {
+    _impl_.rename_to_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.ApiDef.Arg.rename_to)
+}
+
+// string description = 3;
+inline void ApiDef_Arg::clear_description() {
+  _impl_.description_.ClearToEmpty();
+}
+inline const std::string& ApiDef_Arg::description() const {
+  // @@protoc_insertion_point(field_get:tensorflow.ApiDef.Arg.description)
+  return _internal_description();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ApiDef_Arg::set_description(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.description_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.ApiDef.Arg.description)
+}
+inline std::string* ApiDef_Arg::mutable_description() {
+  std::string* _s = _internal_mutable_description();
+  // @@protoc_insertion_point(field_mutable:tensorflow.ApiDef.Arg.description)
+  return _s;
+}
+inline const std::string& ApiDef_Arg::_internal_description() const {
+  return _impl_.description_.Get();
+}
+inline void ApiDef_Arg::_internal_set_description(const std::string& value) {
+  
+  _impl_.description_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ApiDef_Arg::_internal_mutable_description() {
+  
+  return _impl_.description_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ApiDef_Arg::release_description() {
+  // @@protoc_insertion_point(field_release:tensorflow.ApiDef.Arg.description)
+  return _impl_.description_.Release();
+}
+inline void ApiDef_Arg::set_allocated_description(std::string* description) {
+  if (description != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.description_.SetAllocated(description, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.description_.IsDefault()) {
+    _impl_.description_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.ApiDef.Arg.description)
+}
+
+// -------------------------------------------------------------------
+
+// ApiDef_Attr
+
+// string name = 1;
+inline void ApiDef_Attr::clear_name() {
+  _impl_.name_.ClearToEmpty();
+}
+inline const std::string& ApiDef_Attr::name() const {
+  // @@protoc_insertion_point(field_get:tensorflow.ApiDef.Attr.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ApiDef_Attr::set_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.ApiDef.Attr.name)
+}
+inline std::string* ApiDef_Attr::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:tensorflow.ApiDef.Attr.name)
+  return _s;
+}
+inline const std::string& ApiDef_Attr::_internal_name() const {
+  return _impl_.name_.Get();
+}
+inline void ApiDef_Attr::_internal_set_name(const std::string& value) {
+  
+  _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ApiDef_Attr::_internal_mutable_name() {
+  
+  return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ApiDef_Attr::release_name() {
+  // @@protoc_insertion_point(field_release:tensorflow.ApiDef.Attr.name)
+  return _impl_.name_.Release();
+}
+inline void ApiDef_Attr::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.ApiDef.Attr.name)
+}
+
+// string rename_to = 2;
+inline void ApiDef_Attr::clear_rename_to() {
+  _impl_.rename_to_.ClearToEmpty();
+}
+inline const std::string& ApiDef_Attr::rename_to() const {
+  // @@protoc_insertion_point(field_get:tensorflow.ApiDef.Attr.rename_to)
+  return _internal_rename_to();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ApiDef_Attr::set_rename_to(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.rename_to_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.ApiDef.Attr.rename_to)
+}
+inline std::string* ApiDef_Attr::mutable_rename_to() {
+  std::string* _s = _internal_mutable_rename_to();
+  // @@protoc_insertion_point(field_mutable:tensorflow.ApiDef.Attr.rename_to)
+  return _s;
+}
+inline const std::string& ApiDef_Attr::_internal_rename_to() const {
+  return _impl_.rename_to_.Get();
+}
+inline void ApiDef_Attr::_internal_set_rename_to(const std::string& value) {
+  
+  _impl_.rename_to_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ApiDef_Attr::_internal_mutable_rename_to() {
+  
+  return _impl_.rename_to_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ApiDef_Attr::release_rename_to() {
+  // @@protoc_insertion_point(field_release:tensorflow.ApiDef.Attr.rename_to)
+  return _impl_.rename_to_.Release();
+}
+inline void ApiDef_Attr::set_allocated_rename_to(std::string* rename_to) {
+  if (rename_to != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.rename_to_.SetAllocated(rename_to, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.rename_to_.IsDefault()) {
+    _impl_.rename_to_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.ApiDef.Attr.rename_to)
+}
+
+// .tensorflow.AttrValue default_value = 3;
+inline bool ApiDef_Attr::_internal_has_default_value() const {
+  return this != internal_default_instance() && _impl_.default_value_ != nullptr;
+}
+inline bool ApiDef_Attr::has_default_value() const {
+  return _internal_has_default_value();
+}
+inline const ::tensorflow::AttrValue& ApiDef_Attr::_internal_default_value() const {
+  const ::tensorflow::AttrValue* p = _impl_.default_value_;
+  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::AttrValue&>(
+      ::tensorflow::_AttrValue_default_instance_);
+}
+inline const ::tensorflow::AttrValue& ApiDef_Attr::default_value() const {
+  // @@protoc_insertion_point(field_get:tensorflow.ApiDef.Attr.default_value)
+  return _internal_default_value();
+}
+inline void ApiDef_Attr::unsafe_arena_set_allocated_default_value(
+    ::tensorflow::AttrValue* default_value) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.default_value_);
+  }
+  _impl_.default_value_ = default_value;
+  if (default_value) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.ApiDef.Attr.default_value)
+}
+inline ::tensorflow::AttrValue* ApiDef_Attr::release_default_value() {
+  
+  ::tensorflow::AttrValue* temp = _impl_.default_value_;
+  _impl_.default_value_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::tensorflow::AttrValue* ApiDef_Attr::unsafe_arena_release_default_value() {
+  // @@protoc_insertion_point(field_release:tensorflow.ApiDef.Attr.default_value)
+  
+  ::tensorflow::AttrValue* temp = _impl_.default_value_;
+  _impl_.default_value_ = nullptr;
+  return temp;
+}
+inline ::tensorflow::AttrValue* ApiDef_Attr::_internal_mutable_default_value() {
+  
+  if (_impl_.default_value_ == nullptr) {
+    auto* p = CreateMaybeMessage<::tensorflow::AttrValue>(GetArenaForAllocation());
+    _impl_.default_value_ = p;
+  }
+  return _impl_.default_value_;
+}
+inline ::tensorflow::AttrValue* ApiDef_Attr::mutable_default_value() {
+  ::tensorflow::AttrValue* _msg = _internal_mutable_default_value();
+  // @@protoc_insertion_point(field_mutable:tensorflow.ApiDef.Attr.default_value)
+  return _msg;
+}
+inline void ApiDef_Attr::set_allocated_default_value(::tensorflow::AttrValue* default_value) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.default_value_);
+  }
+  if (default_value) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(default_value));
+    if (message_arena != submessage_arena) {
+      default_value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, default_value, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.default_value_ = default_value;
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.ApiDef.Attr.default_value)
+}
+
+// string description = 4;
+inline void ApiDef_Attr::clear_description() {
+  _impl_.description_.ClearToEmpty();
+}
+inline const std::string& ApiDef_Attr::description() const {
+  // @@protoc_insertion_point(field_get:tensorflow.ApiDef.Attr.description)
+  return _internal_description();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ApiDef_Attr::set_description(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.description_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.ApiDef.Attr.description)
+}
+inline std::string* ApiDef_Attr::mutable_description() {
+  std::string* _s = _internal_mutable_description();
+  // @@protoc_insertion_point(field_mutable:tensorflow.ApiDef.Attr.description)
+  return _s;
+}
+inline const std::string& ApiDef_Attr::_internal_description() const {
+  return _impl_.description_.Get();
+}
+inline void ApiDef_Attr::_internal_set_description(const std::string& value) {
+  
+  _impl_.description_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ApiDef_Attr::_internal_mutable_description() {
+  
+  return _impl_.description_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ApiDef_Attr::release_description() {
+  // @@protoc_insertion_point(field_release:tensorflow.ApiDef.Attr.description)
+  return _impl_.description_.Release();
+}
+inline void ApiDef_Attr::set_allocated_description(std::string* description) {
+  if (description != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.description_.SetAllocated(description, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.description_.IsDefault()) {
+    _impl_.description_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.ApiDef.Attr.description)
+}
+
+// -------------------------------------------------------------------
+
+// ApiDef
+
+// string graph_op_name = 1;
+inline void ApiDef::clear_graph_op_name() {
+  _impl_.graph_op_name_.ClearToEmpty();
+}
+inline const std::string& ApiDef::graph_op_name() const {
+  // @@protoc_insertion_point(field_get:tensorflow.ApiDef.graph_op_name)
+  return _internal_graph_op_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ApiDef::set_graph_op_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.graph_op_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.ApiDef.graph_op_name)
+}
+inline std::string* ApiDef::mutable_graph_op_name() {
+  std::string* _s = _internal_mutable_graph_op_name();
+  // @@protoc_insertion_point(field_mutable:tensorflow.ApiDef.graph_op_name)
+  return _s;
+}
+inline const std::string& ApiDef::_internal_graph_op_name() const {
+  return _impl_.graph_op_name_.Get();
+}
+inline void ApiDef::_internal_set_graph_op_name(const std::string& value) {
+  
+  _impl_.graph_op_name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ApiDef::_internal_mutable_graph_op_name() {
+  
+  return _impl_.graph_op_name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ApiDef::release_graph_op_name() {
+  // @@protoc_insertion_point(field_release:tensorflow.ApiDef.graph_op_name)
+  return _impl_.graph_op_name_.Release();
+}
+inline void ApiDef::set_allocated_graph_op_name(std::string* graph_op_name) {
+  if (graph_op_name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.graph_op_name_.SetAllocated(graph_op_name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.graph_op_name_.IsDefault()) {
+    _impl_.graph_op_name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.ApiDef.graph_op_name)
+}
+
+// string deprecation_message = 12;
+inline void ApiDef::clear_deprecation_message() {
+  _impl_.deprecation_message_.ClearToEmpty();
+}
+inline const std::string& ApiDef::deprecation_message() const {
+  // @@protoc_insertion_point(field_get:tensorflow.ApiDef.deprecation_message)
+  return _internal_deprecation_message();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ApiDef::set_deprecation_message(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.deprecation_message_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.ApiDef.deprecation_message)
+}
+inline std::string* ApiDef::mutable_deprecation_message() {
+  std::string* _s = _internal_mutable_deprecation_message();
+  // @@protoc_insertion_point(field_mutable:tensorflow.ApiDef.deprecation_message)
+  return _s;
+}
+inline const std::string& ApiDef::_internal_deprecation_message() const {
+  return _impl_.deprecation_message_.Get();
+}
+inline void ApiDef::_internal_set_deprecation_message(const std::string& value) {
+  
+  _impl_.deprecation_message_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ApiDef::_internal_mutable_deprecation_message() {
+  
+  return _impl_.deprecation_message_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ApiDef::release_deprecation_message() {
+  // @@protoc_insertion_point(field_release:tensorflow.ApiDef.deprecation_message)
+  return _impl_.deprecation_message_.Release();
+}
+inline void ApiDef::set_allocated_deprecation_message(std::string* deprecation_message) {
+  if (deprecation_message != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.deprecation_message_.SetAllocated(deprecation_message, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.deprecation_message_.IsDefault()) {
+    _impl_.deprecation_message_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.ApiDef.deprecation_message)
+}
+
+// int32 deprecation_version = 13;
+inline void ApiDef::clear_deprecation_version() {
+  _impl_.deprecation_version_ = 0;
+}
+inline int32_t ApiDef::_internal_deprecation_version() const {
+  return _impl_.deprecation_version_;
+}
+inline int32_t ApiDef::deprecation_version() const {
+  // @@protoc_insertion_point(field_get:tensorflow.ApiDef.deprecation_version)
+  return _internal_deprecation_version();
+}
+inline void ApiDef::_internal_set_deprecation_version(int32_t value) {
+  
+  _impl_.deprecation_version_ = value;
+}
+inline void ApiDef::set_deprecation_version(int32_t value) {
+  _internal_set_deprecation_version(value);
+  // @@protoc_insertion_point(field_set:tensorflow.ApiDef.deprecation_version)
+}
+
+// .tensorflow.ApiDef.Visibility visibility = 2;
+inline void ApiDef::clear_visibility() {
+  _impl_.visibility_ = 0;
+}
+inline ::tensorflow::ApiDef_Visibility ApiDef::_internal_visibility() const {
+  return static_cast< ::tensorflow::ApiDef_Visibility >(_impl_.visibility_);
+}
+inline ::tensorflow::ApiDef_Visibility ApiDef::visibility() const {
+  // @@protoc_insertion_point(field_get:tensorflow.ApiDef.visibility)
+  return _internal_visibility();
+}
+inline void ApiDef::_internal_set_visibility(::tensorflow::ApiDef_Visibility value) {
+  
+  _impl_.visibility_ = value;
+}
+inline void ApiDef::set_visibility(::tensorflow::ApiDef_Visibility value) {
+  _internal_set_visibility(value);
+  // @@protoc_insertion_point(field_set:tensorflow.ApiDef.visibility)
+}
+
+// repeated .tensorflow.ApiDef.Endpoint endpoint = 3;
+inline int ApiDef::_internal_endpoint_size() const {
+  return _impl_.endpoint_.size();
+}
+inline int ApiDef::endpoint_size() const {
+  return _internal_endpoint_size();
+}
+inline void ApiDef::clear_endpoint() {
+  _impl_.endpoint_.Clear();
+}
+inline ::tensorflow::ApiDef_Endpoint* ApiDef::mutable_endpoint(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.ApiDef.endpoint)
+  return _impl_.endpoint_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::ApiDef_Endpoint >*
+ApiDef::mutable_endpoint() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.ApiDef.endpoint)
+  return &_impl_.endpoint_;
+}
+inline const ::tensorflow::ApiDef_Endpoint& ApiDef::_internal_endpoint(int index) const {
+  return _impl_.endpoint_.Get(index);
+}
+inline const ::tensorflow::ApiDef_Endpoint& ApiDef::endpoint(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.ApiDef.endpoint)
+  return _internal_endpoint(index);
+}
+inline ::tensorflow::ApiDef_Endpoint* ApiDef::_internal_add_endpoint() {
+  return _impl_.endpoint_.Add();
+}
+inline ::tensorflow::ApiDef_Endpoint* ApiDef::add_endpoint() {
+  ::tensorflow::ApiDef_Endpoint* _add = _internal_add_endpoint();
+  // @@protoc_insertion_point(field_add:tensorflow.ApiDef.endpoint)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::ApiDef_Endpoint >&
+ApiDef::endpoint() const {
+  // @@protoc_insertion_point(field_list:tensorflow.ApiDef.endpoint)
+  return _impl_.endpoint_;
+}
+
+// repeated .tensorflow.ApiDef.Arg in_arg = 4;
+inline int ApiDef::_internal_in_arg_size() const {
+  return _impl_.in_arg_.size();
+}
+inline int ApiDef::in_arg_size() const {
+  return _internal_in_arg_size();
+}
+inline void ApiDef::clear_in_arg() {
+  _impl_.in_arg_.Clear();
+}
+inline ::tensorflow::ApiDef_Arg* ApiDef::mutable_in_arg(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.ApiDef.in_arg)
+  return _impl_.in_arg_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::ApiDef_Arg >*
+ApiDef::mutable_in_arg() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.ApiDef.in_arg)
+  return &_impl_.in_arg_;
+}
+inline const ::tensorflow::ApiDef_Arg& ApiDef::_internal_in_arg(int index) const {
+  return _impl_.in_arg_.Get(index);
+}
+inline const ::tensorflow::ApiDef_Arg& ApiDef::in_arg(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.ApiDef.in_arg)
+  return _internal_in_arg(index);
+}
+inline ::tensorflow::ApiDef_Arg* ApiDef::_internal_add_in_arg() {
+  return _impl_.in_arg_.Add();
+}
+inline ::tensorflow::ApiDef_Arg* ApiDef::add_in_arg() {
+  ::tensorflow::ApiDef_Arg* _add = _internal_add_in_arg();
+  // @@protoc_insertion_point(field_add:tensorflow.ApiDef.in_arg)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::ApiDef_Arg >&
+ApiDef::in_arg() const {
+  // @@protoc_insertion_point(field_list:tensorflow.ApiDef.in_arg)
+  return _impl_.in_arg_;
+}
+
+// repeated .tensorflow.ApiDef.Arg out_arg = 5;
+inline int ApiDef::_internal_out_arg_size() const {
+  return _impl_.out_arg_.size();
+}
+inline int ApiDef::out_arg_size() const {
+  return _internal_out_arg_size();
+}
+inline void ApiDef::clear_out_arg() {
+  _impl_.out_arg_.Clear();
+}
+inline ::tensorflow::ApiDef_Arg* ApiDef::mutable_out_arg(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.ApiDef.out_arg)
+  return _impl_.out_arg_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::ApiDef_Arg >*
+ApiDef::mutable_out_arg() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.ApiDef.out_arg)
+  return &_impl_.out_arg_;
+}
+inline const ::tensorflow::ApiDef_Arg& ApiDef::_internal_out_arg(int index) const {
+  return _impl_.out_arg_.Get(index);
+}
+inline const ::tensorflow::ApiDef_Arg& ApiDef::out_arg(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.ApiDef.out_arg)
+  return _internal_out_arg(index);
+}
+inline ::tensorflow::ApiDef_Arg* ApiDef::_internal_add_out_arg() {
+  return _impl_.out_arg_.Add();
+}
+inline ::tensorflow::ApiDef_Arg* ApiDef::add_out_arg() {
+  ::tensorflow::ApiDef_Arg* _add = _internal_add_out_arg();
+  // @@protoc_insertion_point(field_add:tensorflow.ApiDef.out_arg)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::ApiDef_Arg >&
+ApiDef::out_arg() const {
+  // @@protoc_insertion_point(field_list:tensorflow.ApiDef.out_arg)
+  return _impl_.out_arg_;
+}
+
+// repeated string arg_order = 11;
+inline int ApiDef::_internal_arg_order_size() const {
+  return _impl_.arg_order_.size();
+}
+inline int ApiDef::arg_order_size() const {
+  return _internal_arg_order_size();
+}
+inline void ApiDef::clear_arg_order() {
+  _impl_.arg_order_.Clear();
+}
+inline std::string* ApiDef::add_arg_order() {
+  std::string* _s = _internal_add_arg_order();
+  // @@protoc_insertion_point(field_add_mutable:tensorflow.ApiDef.arg_order)
+  return _s;
+}
+inline const std::string& ApiDef::_internal_arg_order(int index) const {
+  return _impl_.arg_order_.Get(index);
+}
+inline const std::string& ApiDef::arg_order(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.ApiDef.arg_order)
+  return _internal_arg_order(index);
+}
+inline std::string* ApiDef::mutable_arg_order(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.ApiDef.arg_order)
+  return _impl_.arg_order_.Mutable(index);
+}
+inline void ApiDef::set_arg_order(int index, const std::string& value) {
+  _impl_.arg_order_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:tensorflow.ApiDef.arg_order)
+}
+inline void ApiDef::set_arg_order(int index, std::string&& value) {
+  _impl_.arg_order_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:tensorflow.ApiDef.arg_order)
+}
+inline void ApiDef::set_arg_order(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.arg_order_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:tensorflow.ApiDef.arg_order)
+}
+inline void ApiDef::set_arg_order(int index, const char* value, size_t size) {
+  _impl_.arg_order_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:tensorflow.ApiDef.arg_order)
+}
+inline std::string* ApiDef::_internal_add_arg_order() {
+  return _impl_.arg_order_.Add();
+}
+inline void ApiDef::add_arg_order(const std::string& value) {
+  _impl_.arg_order_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:tensorflow.ApiDef.arg_order)
+}
+inline void ApiDef::add_arg_order(std::string&& value) {
+  _impl_.arg_order_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:tensorflow.ApiDef.arg_order)
+}
+inline void ApiDef::add_arg_order(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.arg_order_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:tensorflow.ApiDef.arg_order)
+}
+inline void ApiDef::add_arg_order(const char* value, size_t size) {
+  _impl_.arg_order_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:tensorflow.ApiDef.arg_order)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+ApiDef::arg_order() const {
+  // @@protoc_insertion_point(field_list:tensorflow.ApiDef.arg_order)
+  return _impl_.arg_order_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+ApiDef::mutable_arg_order() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.ApiDef.arg_order)
+  return &_impl_.arg_order_;
+}
+
+// repeated .tensorflow.ApiDef.Attr attr = 6;
+inline int ApiDef::_internal_attr_size() const {
+  return _impl_.attr_.size();
+}
+inline int ApiDef::attr_size() const {
+  return _internal_attr_size();
+}
+inline void ApiDef::clear_attr() {
+  _impl_.attr_.Clear();
+}
+inline ::tensorflow::ApiDef_Attr* ApiDef::mutable_attr(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.ApiDef.attr)
+  return _impl_.attr_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::ApiDef_Attr >*
+ApiDef::mutable_attr() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.ApiDef.attr)
+  return &_impl_.attr_;
+}
+inline const ::tensorflow::ApiDef_Attr& ApiDef::_internal_attr(int index) const {
+  return _impl_.attr_.Get(index);
+}
+inline const ::tensorflow::ApiDef_Attr& ApiDef::attr(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.ApiDef.attr)
+  return _internal_attr(index);
+}
+inline ::tensorflow::ApiDef_Attr* ApiDef::_internal_add_attr() {
+  return _impl_.attr_.Add();
+}
+inline ::tensorflow::ApiDef_Attr* ApiDef::add_attr() {
+  ::tensorflow::ApiDef_Attr* _add = _internal_add_attr();
+  // @@protoc_insertion_point(field_add:tensorflow.ApiDef.attr)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::ApiDef_Attr >&
+ApiDef::attr() const {
+  // @@protoc_insertion_point(field_list:tensorflow.ApiDef.attr)
+  return _impl_.attr_;
+}
+
+// string summary = 7;
+inline void ApiDef::clear_summary() {
+  _impl_.summary_.ClearToEmpty();
+}
+inline const std::string& ApiDef::summary() const {
+  // @@protoc_insertion_point(field_get:tensorflow.ApiDef.summary)
+  return _internal_summary();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ApiDef::set_summary(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.summary_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.ApiDef.summary)
+}
+inline std::string* ApiDef::mutable_summary() {
+  std::string* _s = _internal_mutable_summary();
+  // @@protoc_insertion_point(field_mutable:tensorflow.ApiDef.summary)
+  return _s;
+}
+inline const std::string& ApiDef::_internal_summary() const {
+  return _impl_.summary_.Get();
+}
+inline void ApiDef::_internal_set_summary(const std::string& value) {
+  
+  _impl_.summary_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ApiDef::_internal_mutable_summary() {
+  
+  return _impl_.summary_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ApiDef::release_summary() {
+  // @@protoc_insertion_point(field_release:tensorflow.ApiDef.summary)
+  return _impl_.summary_.Release();
+}
+inline void ApiDef::set_allocated_summary(std::string* summary) {
+  if (summary != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.summary_.SetAllocated(summary, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.summary_.IsDefault()) {
+    _impl_.summary_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.ApiDef.summary)
+}
+
+// string description = 8;
+inline void ApiDef::clear_description() {
+  _impl_.description_.ClearToEmpty();
+}
+inline const std::string& ApiDef::description() const {
+  // @@protoc_insertion_point(field_get:tensorflow.ApiDef.description)
+  return _internal_description();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ApiDef::set_description(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.description_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.ApiDef.description)
+}
+inline std::string* ApiDef::mutable_description() {
+  std::string* _s = _internal_mutable_description();
+  // @@protoc_insertion_point(field_mutable:tensorflow.ApiDef.description)
+  return _s;
+}
+inline const std::string& ApiDef::_internal_description() const {
+  return _impl_.description_.Get();
+}
+inline void ApiDef::_internal_set_description(const std::string& value) {
+  
+  _impl_.description_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ApiDef::_internal_mutable_description() {
+  
+  return _impl_.description_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ApiDef::release_description() {
+  // @@protoc_insertion_point(field_release:tensorflow.ApiDef.description)
+  return _impl_.description_.Release();
+}
+inline void ApiDef::set_allocated_description(std::string* description) {
+  if (description != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.description_.SetAllocated(description, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.description_.IsDefault()) {
+    _impl_.description_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.ApiDef.description)
+}
+
+// string description_prefix = 9;
+inline void ApiDef::clear_description_prefix() {
+  _impl_.description_prefix_.ClearToEmpty();
+}
+inline const std::string& ApiDef::description_prefix() const {
+  // @@protoc_insertion_point(field_get:tensorflow.ApiDef.description_prefix)
+  return _internal_description_prefix();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ApiDef::set_description_prefix(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.description_prefix_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.ApiDef.description_prefix)
+}
+inline std::string* ApiDef::mutable_description_prefix() {
+  std::string* _s = _internal_mutable_description_prefix();
+  // @@protoc_insertion_point(field_mutable:tensorflow.ApiDef.description_prefix)
+  return _s;
+}
+inline const std::string& ApiDef::_internal_description_prefix() const {
+  return _impl_.description_prefix_.Get();
+}
+inline void ApiDef::_internal_set_description_prefix(const std::string& value) {
+  
+  _impl_.description_prefix_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ApiDef::_internal_mutable_description_prefix() {
+  
+  return _impl_.description_prefix_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ApiDef::release_description_prefix() {
+  // @@protoc_insertion_point(field_release:tensorflow.ApiDef.description_prefix)
+  return _impl_.description_prefix_.Release();
+}
+inline void ApiDef::set_allocated_description_prefix(std::string* description_prefix) {
+  if (description_prefix != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.description_prefix_.SetAllocated(description_prefix, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.description_prefix_.IsDefault()) {
+    _impl_.description_prefix_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.ApiDef.description_prefix)
+}
+
+// string description_suffix = 10;
+inline void ApiDef::clear_description_suffix() {
+  _impl_.description_suffix_.ClearToEmpty();
+}
+inline const std::string& ApiDef::description_suffix() const {
+  // @@protoc_insertion_point(field_get:tensorflow.ApiDef.description_suffix)
+  return _internal_description_suffix();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ApiDef::set_description_suffix(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.description_suffix_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.ApiDef.description_suffix)
+}
+inline std::string* ApiDef::mutable_description_suffix() {
+  std::string* _s = _internal_mutable_description_suffix();
+  // @@protoc_insertion_point(field_mutable:tensorflow.ApiDef.description_suffix)
+  return _s;
+}
+inline const std::string& ApiDef::_internal_description_suffix() const {
+  return _impl_.description_suffix_.Get();
+}
+inline void ApiDef::_internal_set_description_suffix(const std::string& value) {
+  
+  _impl_.description_suffix_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ApiDef::_internal_mutable_description_suffix() {
+  
+  return _impl_.description_suffix_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ApiDef::release_description_suffix() {
+  // @@protoc_insertion_point(field_release:tensorflow.ApiDef.description_suffix)
+  return _impl_.description_suffix_.Release();
+}
+inline void ApiDef::set_allocated_description_suffix(std::string* description_suffix) {
+  if (description_suffix != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.description_suffix_.SetAllocated(description_suffix, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.description_suffix_.IsDefault()) {
+    _impl_.description_suffix_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.ApiDef.description_suffix)
+}
+
+// -------------------------------------------------------------------
+
+// ApiDefs
+
+// repeated .tensorflow.ApiDef op = 1;
+inline int ApiDefs::_internal_op_size() const {
+  return _impl_.op_.size();
+}
+inline int ApiDefs::op_size() const {
+  return _internal_op_size();
+}
+inline void ApiDefs::clear_op() {
+  _impl_.op_.Clear();
+}
+inline ::tensorflow::ApiDef* ApiDefs::mutable_op(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.ApiDefs.op)
+  return _impl_.op_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::ApiDef >*
+ApiDefs::mutable_op() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.ApiDefs.op)
+  return &_impl_.op_;
+}
+inline const ::tensorflow::ApiDef& ApiDefs::_internal_op(int index) const {
+  return _impl_.op_.Get(index);
+}
+inline const ::tensorflow::ApiDef& ApiDefs::op(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.ApiDefs.op)
+  return _internal_op(index);
+}
+inline ::tensorflow::ApiDef* ApiDefs::_internal_add_op() {
+  return _impl_.op_.Add();
+}
+inline ::tensorflow::ApiDef* ApiDefs::add_op() {
+  ::tensorflow::ApiDef* _add = _internal_add_op();
+  // @@protoc_insertion_point(field_add:tensorflow.ApiDefs.op)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::ApiDef >&
+ApiDefs::op() const {
+  // @@protoc_insertion_point(field_list:tensorflow.ApiDefs.op)
+  return _impl_.op_;
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace tensorflow
+
+PROTOBUF_NAMESPACE_OPEN
+
+template <> struct is_proto_enum< ::tensorflow::ApiDef_Visibility> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::tensorflow::ApiDef_Visibility>() {
+  return ::tensorflow::ApiDef_Visibility_descriptor();
+}
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fapi_5fdef_2eproto
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/api_def.proto b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/api_def.proto
new file mode 100644
index 0000000000000000000000000000000000000000..1823ce64f2f64bd9987d510c35b4e7ac933ec0bd
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/api_def.proto
@@ -0,0 +1,138 @@
+// Defines the text format for including per-op API definition and
+// overrides for client language op code generators.
+
+syntax = "proto3";
+
+package tensorflow;
+
+import "tensorflow/core/framework/attr_value.proto";
+
+option cc_enable_arenas = true;
+option java_outer_classname = "ApiDefProtos";
+option java_multiple_files = true;
+option java_package = "org.tensorflow.framework";
+option go_package = "github.com/tensorflow/tensorflow/tensorflow/go/core/framework/api_def_go_proto";
+
+// Used to specify and override the default API & behavior in the
+// generated code for client languages, from what you would get from
+// the OpDef alone. There will be a set of ApiDefs that are common
+// to all client languages, and another set per client language.
+// The per-client-language ApiDefs will inherit values from the
+// common ApiDefs which it can either replace or modify.
+//
+// We separate the API definition from the OpDef so we can evolve the
+// API while remaining backwards compatible when interpreting old
+// graphs.  Overrides go in an "api_def.pbtxt" file with a text-format
+// ApiDefs message.
+//
+// WARNING: Be *very* careful changing the API for any existing op --
+// you can change the semantics of existing code.  These changes may
+// need to wait until a major release of TensorFlow to avoid breaking
+// our compatibility promises.
+message ApiDef {
+  // Name of the op (in the OpDef) to specify the API for.
+  string graph_op_name = 1;
+  // If this op is deprecated, set deprecation message to the message
+  // that should be logged when this op is used.
+  // The message should indicate alternative op to use, if any.
+  string deprecation_message = 12;
+  // Major version when the op will be deleted. For e.g. set this
+  // value to 2 if op API should be removed in TensorFlow 2.0 and
+  // deprecated in versions before that.
+  int32 deprecation_version = 13;
+
+  enum Visibility {
+    // Normally this is "VISIBLE" unless you are inheriting a
+    // different value from another ApiDef.
+    DEFAULT_VISIBILITY = 0;
+    // Publicly visible in the API.
+    VISIBLE = 1;
+    // Do not include this op in the generated API. If visibility is
+    // set to 'SKIP', other fields are ignored for this op.
+    SKIP = 2;
+    // Hide this op by putting it into an internal namespace (or whatever
+    // is appropriate in the target language).
+    HIDDEN = 3;
+  }
+  Visibility visibility = 2;
+
+  // If you specify any endpoint, this will replace all of the
+  // inherited endpoints.  The first endpoint should be the
+  // "canonical" endpoint, and should not be deprecated (unless all
+  // endpoints are deprecated).
+  message Endpoint {
+    // Name should be either like "CamelCaseName" or
+    // "Package.CamelCaseName". Client-language-specific ApiDefs may
+    // use a snake_case convention instead of CamelCase.
+    string name = 1;
+
+    // Set if this endpoint is deprecated. If set to true, a message suggesting
+    // to use a non-deprecated endpoint instead will be printed. If all
+    // endpoints are deprecated, set deprecation_message in ApiDef instead.
+    bool deprecated = 3;
+
+    // Major version when an endpoint will be deleted. For e.g. set this
+    // value to 2 if endpoint should be removed in TensorFlow 2.0 and
+    // deprecated in versions before that.
+    int32 deprecation_version = 4;
+  }
+  repeated Endpoint endpoint = 3;
+
+  message Arg {
+    string name = 1;
+
+    // Change the name used to access this arg in the API from what
+    // is used in the GraphDef.  Note that these names in `backticks`
+    // will also be replaced in the summary & description fields.
+    string rename_to = 2;
+
+    // Note: this will replace any inherited arg doc. There is no
+    // current way of modifying arg descriptions (other than replacing
+    // them entirely) as can be done with op descriptions.
+    string description = 3;
+  }
+  repeated Arg in_arg = 4;
+  repeated Arg out_arg = 5;
+  // List of original in_arg names to specify new argument order.
+  // Length of arg_order should be either empty to keep current order
+  // or match size of in_arg.
+  repeated string arg_order = 11;
+
+  // Description of the graph-construction-time configuration of this
+  // Op.  That is to say, this describes the attr fields that will
+  // be specified in the NodeDef.
+  message Attr {
+    string name = 1;
+
+    // Change the name used to access this attr in the API from what
+    // is used in the GraphDef.  Note that these names in `backticks`
+    // will also be replaced in the summary & description fields.
+    string rename_to = 2;
+
+    // Specify a new default value to use for this attr.  This default
+    // will be used when creating new graphs, as opposed to the
+    // default in the OpDef, which will be used when interpreting old
+    // GraphDefs.
+    AttrValue default_value = 3;
+
+    // Note: this will replace any inherited attr doc, there is no current
+    // way of modifying attr descriptions as can be done with op descriptions.
+    string description = 4;
+  }
+  repeated Attr attr = 6;
+
+  // One-line human-readable description of what the Op does.
+  string summary = 7;
+
+  // Additional, longer human-readable description of what the Op does.
+  string description = 8;
+
+  // Modify an existing/inherited description by adding text to the beginning
+  // or end.
+  string description_prefix = 9;
+  string description_suffix = 10;
+}
+
+message ApiDefs {
+  repeated ApiDef op = 1;
+}
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/attr_value.pb.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/attr_value.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..39c52721826fec27e20d1d76454be34acaadcbb2
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/attr_value.pb.h
@@ -0,0 +1,2035 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: tensorflow/core/framework/attr_value.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fattr_5fvalue_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fattr_5fvalue_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3021000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3021009 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/map.h>  // IWYU pragma: export
+#include <google/protobuf/map_entry.h>
+#include <google/protobuf/map_field_inl.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "tensorflow/core/framework/tensor.pb.h"
+#include "tensorflow/core/framework/tensor_shape.pb.h"
+#include "tensorflow/core/framework/types.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_tensorflow_2fcore_2fframework_2fattr_5fvalue_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_tensorflow_2fcore_2fframework_2fattr_5fvalue_2eproto {
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_tensorflow_2fcore_2fframework_2fattr_5fvalue_2eproto;
+namespace tensorflow {
+class AttrValue;
+struct AttrValueDefaultTypeInternal;
+extern AttrValueDefaultTypeInternal _AttrValue_default_instance_;
+class AttrValue_ListValue;
+struct AttrValue_ListValueDefaultTypeInternal;
+extern AttrValue_ListValueDefaultTypeInternal _AttrValue_ListValue_default_instance_;
+class NameAttrList;
+struct NameAttrListDefaultTypeInternal;
+extern NameAttrListDefaultTypeInternal _NameAttrList_default_instance_;
+class NameAttrList_AttrEntry_DoNotUse;
+struct NameAttrList_AttrEntry_DoNotUseDefaultTypeInternal;
+extern NameAttrList_AttrEntry_DoNotUseDefaultTypeInternal _NameAttrList_AttrEntry_DoNotUse_default_instance_;
+}  // namespace tensorflow
+PROTOBUF_NAMESPACE_OPEN
+template<> ::tensorflow::AttrValue* Arena::CreateMaybeMessage<::tensorflow::AttrValue>(Arena*);
+template<> ::tensorflow::AttrValue_ListValue* Arena::CreateMaybeMessage<::tensorflow::AttrValue_ListValue>(Arena*);
+template<> ::tensorflow::NameAttrList* Arena::CreateMaybeMessage<::tensorflow::NameAttrList>(Arena*);
+template<> ::tensorflow::NameAttrList_AttrEntry_DoNotUse* Arena::CreateMaybeMessage<::tensorflow::NameAttrList_AttrEntry_DoNotUse>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace tensorflow {
+
+// ===================================================================
+
+class AttrValue_ListValue final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.AttrValue.ListValue) */ {
+ public:
+  inline AttrValue_ListValue() : AttrValue_ListValue(nullptr) {}
+  ~AttrValue_ListValue() override;
+  explicit PROTOBUF_CONSTEXPR AttrValue_ListValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  AttrValue_ListValue(const AttrValue_ListValue& from);
+  AttrValue_ListValue(AttrValue_ListValue&& from) noexcept
+    : AttrValue_ListValue() {
+    *this = ::std::move(from);
+  }
+
+  inline AttrValue_ListValue& operator=(const AttrValue_ListValue& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline AttrValue_ListValue& operator=(AttrValue_ListValue&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const AttrValue_ListValue& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const AttrValue_ListValue* internal_default_instance() {
+    return reinterpret_cast<const AttrValue_ListValue*>(
+               &_AttrValue_ListValue_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(AttrValue_ListValue& a, AttrValue_ListValue& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(AttrValue_ListValue* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(AttrValue_ListValue* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  AttrValue_ListValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<AttrValue_ListValue>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const AttrValue_ListValue& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const AttrValue_ListValue& from) {
+    AttrValue_ListValue::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(AttrValue_ListValue* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.AttrValue.ListValue";
+  }
+  protected:
+  explicit AttrValue_ListValue(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kSFieldNumber = 2,
+    kIFieldNumber = 3,
+    kFFieldNumber = 4,
+    kBFieldNumber = 5,
+    kTypeFieldNumber = 6,
+    kShapeFieldNumber = 7,
+    kTensorFieldNumber = 8,
+    kFuncFieldNumber = 9,
+  };
+  // repeated bytes s = 2;
+  int s_size() const;
+  private:
+  int _internal_s_size() const;
+  public:
+  void clear_s();
+  const std::string& s(int index) const;
+  std::string* mutable_s(int index);
+  void set_s(int index, const std::string& value);
+  void set_s(int index, std::string&& value);
+  void set_s(int index, const char* value);
+  void set_s(int index, const void* value, size_t size);
+  std::string* add_s();
+  void add_s(const std::string& value);
+  void add_s(std::string&& value);
+  void add_s(const char* value);
+  void add_s(const void* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& s() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_s();
+  private:
+  const std::string& _internal_s(int index) const;
+  std::string* _internal_add_s();
+  public:
+
+  // repeated int64 i = 3 [packed = true];
+  int i_size() const;
+  private:
+  int _internal_i_size() const;
+  public:
+  void clear_i();
+  private:
+  int64_t _internal_i(int index) const;
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
+      _internal_i() const;
+  void _internal_add_i(int64_t value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
+      _internal_mutable_i();
+  public:
+  int64_t i(int index) const;
+  void set_i(int index, int64_t value);
+  void add_i(int64_t value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
+      i() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
+      mutable_i();
+
+  // repeated float f = 4 [packed = true];
+  int f_size() const;
+  private:
+  int _internal_f_size() const;
+  public:
+  void clear_f();
+  private:
+  float _internal_f(int index) const;
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
+      _internal_f() const;
+  void _internal_add_f(float value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
+      _internal_mutable_f();
+  public:
+  float f(int index) const;
+  void set_f(int index, float value);
+  void add_f(float value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
+      f() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
+      mutable_f();
+
+  // repeated bool b = 5 [packed = true];
+  int b_size() const;
+  private:
+  int _internal_b_size() const;
+  public:
+  void clear_b();
+  private:
+  bool _internal_b(int index) const;
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >&
+      _internal_b() const;
+  void _internal_add_b(bool value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >*
+      _internal_mutable_b();
+  public:
+  bool b(int index) const;
+  void set_b(int index, bool value);
+  void add_b(bool value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >&
+      b() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >*
+      mutable_b();
+
+  // repeated .tensorflow.DataType type = 6 [packed = true];
+  int type_size() const;
+  private:
+  int _internal_type_size() const;
+  public:
+  void clear_type();
+  private:
+  ::tensorflow::DataType _internal_type(int index) const;
+  void _internal_add_type(::tensorflow::DataType value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_type();
+  public:
+  ::tensorflow::DataType type(int index) const;
+  void set_type(int index, ::tensorflow::DataType value);
+  void add_type(::tensorflow::DataType value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& type() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_type();
+
+  // repeated .tensorflow.TensorShapeProto shape = 7;
+  int shape_size() const;
+  private:
+  int _internal_shape_size() const;
+  public:
+  void clear_shape();
+  ::tensorflow::TensorShapeProto* mutable_shape(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TensorShapeProto >*
+      mutable_shape();
+  private:
+  const ::tensorflow::TensorShapeProto& _internal_shape(int index) const;
+  ::tensorflow::TensorShapeProto* _internal_add_shape();
+  public:
+  const ::tensorflow::TensorShapeProto& shape(int index) const;
+  ::tensorflow::TensorShapeProto* add_shape();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TensorShapeProto >&
+      shape() const;
+
+  // repeated .tensorflow.TensorProto tensor = 8;
+  int tensor_size() const;
+  private:
+  int _internal_tensor_size() const;
+  public:
+  void clear_tensor();
+  ::tensorflow::TensorProto* mutable_tensor(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TensorProto >*
+      mutable_tensor();
+  private:
+  const ::tensorflow::TensorProto& _internal_tensor(int index) const;
+  ::tensorflow::TensorProto* _internal_add_tensor();
+  public:
+  const ::tensorflow::TensorProto& tensor(int index) const;
+  ::tensorflow::TensorProto* add_tensor();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TensorProto >&
+      tensor() const;
+
+  // repeated .tensorflow.NameAttrList func = 9;
+  int func_size() const;
+  private:
+  int _internal_func_size() const;
+  public:
+  void clear_func();
+  ::tensorflow::NameAttrList* mutable_func(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::NameAttrList >*
+      mutable_func();
+  private:
+  const ::tensorflow::NameAttrList& _internal_func(int index) const;
+  ::tensorflow::NameAttrList* _internal_add_func();
+  public:
+  const ::tensorflow::NameAttrList& func(int index) const;
+  ::tensorflow::NameAttrList* add_func();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::NameAttrList >&
+      func() const;
+
+  // @@protoc_insertion_point(class_scope:tensorflow.AttrValue.ListValue)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> s_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > i_;
+    mutable std::atomic<int> _i_cached_byte_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > f_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool > b_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField<int> type_;
+    mutable std::atomic<int> _type_cached_byte_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TensorShapeProto > shape_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TensorProto > tensor_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::NameAttrList > func_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fattr_5fvalue_2eproto;
+};
+// -------------------------------------------------------------------
+
+class AttrValue final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.AttrValue) */ {
+ public:
+  inline AttrValue() : AttrValue(nullptr) {}
+  ~AttrValue() override;
+  explicit PROTOBUF_CONSTEXPR AttrValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  AttrValue(const AttrValue& from);
+  AttrValue(AttrValue&& from) noexcept
+    : AttrValue() {
+    *this = ::std::move(from);
+  }
+
+  inline AttrValue& operator=(const AttrValue& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline AttrValue& operator=(AttrValue&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const AttrValue& default_instance() {
+    return *internal_default_instance();
+  }
+  enum ValueCase {
+    kS = 2,
+    kI = 3,
+    kF = 4,
+    kB = 5,
+    kType = 6,
+    kShape = 7,
+    kTensor = 8,
+    kList = 1,
+    kFunc = 10,
+    kPlaceholder = 9,
+    VALUE_NOT_SET = 0,
+  };
+
+  static inline const AttrValue* internal_default_instance() {
+    return reinterpret_cast<const AttrValue*>(
+               &_AttrValue_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(AttrValue& a, AttrValue& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(AttrValue* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(AttrValue* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  AttrValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<AttrValue>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const AttrValue& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const AttrValue& from) {
+    AttrValue::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(AttrValue* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.AttrValue";
+  }
+  protected:
+  explicit AttrValue(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef AttrValue_ListValue ListValue;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kSFieldNumber = 2,
+    kIFieldNumber = 3,
+    kFFieldNumber = 4,
+    kBFieldNumber = 5,
+    kTypeFieldNumber = 6,
+    kShapeFieldNumber = 7,
+    kTensorFieldNumber = 8,
+    kListFieldNumber = 1,
+    kFuncFieldNumber = 10,
+    kPlaceholderFieldNumber = 9,
+  };
+  // bytes s = 2;
+  bool has_s() const;
+  private:
+  bool _internal_has_s() const;
+  public:
+  void clear_s();
+  const std::string& s() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_s(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_s();
+  PROTOBUF_NODISCARD std::string* release_s();
+  void set_allocated_s(std::string* s);
+  private:
+  const std::string& _internal_s() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_s(const std::string& value);
+  std::string* _internal_mutable_s();
+  public:
+
+  // int64 i = 3;
+  bool has_i() const;
+  private:
+  bool _internal_has_i() const;
+  public:
+  void clear_i();
+  int64_t i() const;
+  void set_i(int64_t value);
+  private:
+  int64_t _internal_i() const;
+  void _internal_set_i(int64_t value);
+  public:
+
+  // float f = 4;
+  bool has_f() const;
+  private:
+  bool _internal_has_f() const;
+  public:
+  void clear_f();
+  float f() const;
+  void set_f(float value);
+  private:
+  float _internal_f() const;
+  void _internal_set_f(float value);
+  public:
+
+  // bool b = 5;
+  bool has_b() const;
+  private:
+  bool _internal_has_b() const;
+  public:
+  void clear_b();
+  bool b() const;
+  void set_b(bool value);
+  private:
+  bool _internal_b() const;
+  void _internal_set_b(bool value);
+  public:
+
+  // .tensorflow.DataType type = 6;
+  bool has_type() const;
+  private:
+  bool _internal_has_type() const;
+  public:
+  void clear_type();
+  ::tensorflow::DataType type() const;
+  void set_type(::tensorflow::DataType value);
+  private:
+  ::tensorflow::DataType _internal_type() const;
+  void _internal_set_type(::tensorflow::DataType value);
+  public:
+
+  // .tensorflow.TensorShapeProto shape = 7;
+  bool has_shape() const;
+  private:
+  bool _internal_has_shape() const;
+  public:
+  void clear_shape();
+  const ::tensorflow::TensorShapeProto& shape() const;
+  PROTOBUF_NODISCARD ::tensorflow::TensorShapeProto* release_shape();
+  ::tensorflow::TensorShapeProto* mutable_shape();
+  void set_allocated_shape(::tensorflow::TensorShapeProto* shape);
+  private:
+  const ::tensorflow::TensorShapeProto& _internal_shape() const;
+  ::tensorflow::TensorShapeProto* _internal_mutable_shape();
+  public:
+  void unsafe_arena_set_allocated_shape(
+      ::tensorflow::TensorShapeProto* shape);
+  ::tensorflow::TensorShapeProto* unsafe_arena_release_shape();
+
+  // .tensorflow.TensorProto tensor = 8;
+  bool has_tensor() const;
+  private:
+  bool _internal_has_tensor() const;
+  public:
+  void clear_tensor();
+  const ::tensorflow::TensorProto& tensor() const;
+  PROTOBUF_NODISCARD ::tensorflow::TensorProto* release_tensor();
+  ::tensorflow::TensorProto* mutable_tensor();
+  void set_allocated_tensor(::tensorflow::TensorProto* tensor);
+  private:
+  const ::tensorflow::TensorProto& _internal_tensor() const;
+  ::tensorflow::TensorProto* _internal_mutable_tensor();
+  public:
+  void unsafe_arena_set_allocated_tensor(
+      ::tensorflow::TensorProto* tensor);
+  ::tensorflow::TensorProto* unsafe_arena_release_tensor();
+
+  // .tensorflow.AttrValue.ListValue list = 1;
+  bool has_list() const;
+  private:
+  bool _internal_has_list() const;
+  public:
+  void clear_list();
+  const ::tensorflow::AttrValue_ListValue& list() const;
+  PROTOBUF_NODISCARD ::tensorflow::AttrValue_ListValue* release_list();
+  ::tensorflow::AttrValue_ListValue* mutable_list();
+  void set_allocated_list(::tensorflow::AttrValue_ListValue* list);
+  private:
+  const ::tensorflow::AttrValue_ListValue& _internal_list() const;
+  ::tensorflow::AttrValue_ListValue* _internal_mutable_list();
+  public:
+  void unsafe_arena_set_allocated_list(
+      ::tensorflow::AttrValue_ListValue* list);
+  ::tensorflow::AttrValue_ListValue* unsafe_arena_release_list();
+
+  // .tensorflow.NameAttrList func = 10;
+  bool has_func() const;
+  private:
+  bool _internal_has_func() const;
+  public:
+  void clear_func();
+  const ::tensorflow::NameAttrList& func() const;
+  PROTOBUF_NODISCARD ::tensorflow::NameAttrList* release_func();
+  ::tensorflow::NameAttrList* mutable_func();
+  void set_allocated_func(::tensorflow::NameAttrList* func);
+  private:
+  const ::tensorflow::NameAttrList& _internal_func() const;
+  ::tensorflow::NameAttrList* _internal_mutable_func();
+  public:
+  void unsafe_arena_set_allocated_func(
+      ::tensorflow::NameAttrList* func);
+  ::tensorflow::NameAttrList* unsafe_arena_release_func();
+
+  // string placeholder = 9;
+  bool has_placeholder() const;
+  private:
+  bool _internal_has_placeholder() const;
+  public:
+  void clear_placeholder();
+  const std::string& placeholder() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_placeholder(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_placeholder();
+  PROTOBUF_NODISCARD std::string* release_placeholder();
+  void set_allocated_placeholder(std::string* placeholder);
+  private:
+  const std::string& _internal_placeholder() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_placeholder(const std::string& value);
+  std::string* _internal_mutable_placeholder();
+  public:
+
+  void clear_value();
+  ValueCase value_case() const;
+  // @@protoc_insertion_point(class_scope:tensorflow.AttrValue)
+ private:
+  class _Internal;
+  void set_has_s();
+  void set_has_i();
+  void set_has_f();
+  void set_has_b();
+  void set_has_type();
+  void set_has_shape();
+  void set_has_tensor();
+  void set_has_list();
+  void set_has_func();
+  void set_has_placeholder();
+
+  inline bool has_value() const;
+  inline void clear_has_value();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    union ValueUnion {
+      constexpr ValueUnion() : _constinit_{} {}
+        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr s_;
+      int64_t i_;
+      float f_;
+      bool b_;
+      int type_;
+      ::tensorflow::TensorShapeProto* shape_;
+      ::tensorflow::TensorProto* tensor_;
+      ::tensorflow::AttrValue_ListValue* list_;
+      ::tensorflow::NameAttrList* func_;
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr placeholder_;
+    } value_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    uint32_t _oneof_case_[1];
+
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fattr_5fvalue_2eproto;
+};
+// -------------------------------------------------------------------
+
+class NameAttrList_AttrEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<NameAttrList_AttrEntry_DoNotUse, 
+    std::string, ::tensorflow::AttrValue,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> {
+public:
+  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<NameAttrList_AttrEntry_DoNotUse, 
+    std::string, ::tensorflow::AttrValue,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
+  NameAttrList_AttrEntry_DoNotUse();
+  explicit PROTOBUF_CONSTEXPR NameAttrList_AttrEntry_DoNotUse(
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+  explicit NameAttrList_AttrEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  void MergeFrom(const NameAttrList_AttrEntry_DoNotUse& other);
+  static const NameAttrList_AttrEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const NameAttrList_AttrEntry_DoNotUse*>(&_NameAttrList_AttrEntry_DoNotUse_default_instance_); }
+  static bool ValidateKey(std::string* s) {
+    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "tensorflow.NameAttrList.AttrEntry.key");
+ }
+  static bool ValidateValue(void*) { return true; }
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fattr_5fvalue_2eproto;
+};
+
+// -------------------------------------------------------------------
+
+class NameAttrList final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.NameAttrList) */ {
+ public:
+  inline NameAttrList() : NameAttrList(nullptr) {}
+  ~NameAttrList() override;
+  explicit PROTOBUF_CONSTEXPR NameAttrList(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  NameAttrList(const NameAttrList& from);
+  NameAttrList(NameAttrList&& from) noexcept
+    : NameAttrList() {
+    *this = ::std::move(from);
+  }
+
+  inline NameAttrList& operator=(const NameAttrList& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline NameAttrList& operator=(NameAttrList&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const NameAttrList& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const NameAttrList* internal_default_instance() {
+    return reinterpret_cast<const NameAttrList*>(
+               &_NameAttrList_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  friend void swap(NameAttrList& a, NameAttrList& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(NameAttrList* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(NameAttrList* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  NameAttrList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<NameAttrList>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const NameAttrList& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const NameAttrList& from) {
+    NameAttrList::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(NameAttrList* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.NameAttrList";
+  }
+  protected:
+  explicit NameAttrList(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kAttrFieldNumber = 2,
+    kNameFieldNumber = 1,
+  };
+  // map<string, .tensorflow.AttrValue> attr = 2;
+  int attr_size() const;
+  private:
+  int _internal_attr_size() const;
+  public:
+  void clear_attr();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::AttrValue >&
+      _internal_attr() const;
+  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::AttrValue >*
+      _internal_mutable_attr();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::AttrValue >&
+      attr() const;
+  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::AttrValue >*
+      mutable_attr();
+
+  // string name = 1;
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.NameAttrList)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::MapField<
+        NameAttrList_AttrEntry_DoNotUse,
+        std::string, ::tensorflow::AttrValue,
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> attr_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fattr_5fvalue_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// AttrValue_ListValue
+
+// repeated bytes s = 2;
+inline int AttrValue_ListValue::_internal_s_size() const {
+  return _impl_.s_.size();
+}
+inline int AttrValue_ListValue::s_size() const {
+  return _internal_s_size();
+}
+inline void AttrValue_ListValue::clear_s() {
+  _impl_.s_.Clear();
+}
+inline std::string* AttrValue_ListValue::add_s() {
+  std::string* _s = _internal_add_s();
+  // @@protoc_insertion_point(field_add_mutable:tensorflow.AttrValue.ListValue.s)
+  return _s;
+}
+inline const std::string& AttrValue_ListValue::_internal_s(int index) const {
+  return _impl_.s_.Get(index);
+}
+inline const std::string& AttrValue_ListValue::s(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.AttrValue.ListValue.s)
+  return _internal_s(index);
+}
+inline std::string* AttrValue_ListValue::mutable_s(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.AttrValue.ListValue.s)
+  return _impl_.s_.Mutable(index);
+}
+inline void AttrValue_ListValue::set_s(int index, const std::string& value) {
+  _impl_.s_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:tensorflow.AttrValue.ListValue.s)
+}
+inline void AttrValue_ListValue::set_s(int index, std::string&& value) {
+  _impl_.s_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:tensorflow.AttrValue.ListValue.s)
+}
+inline void AttrValue_ListValue::set_s(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.s_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:tensorflow.AttrValue.ListValue.s)
+}
+inline void AttrValue_ListValue::set_s(int index, const void* value, size_t size) {
+  _impl_.s_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:tensorflow.AttrValue.ListValue.s)
+}
+inline std::string* AttrValue_ListValue::_internal_add_s() {
+  return _impl_.s_.Add();
+}
+inline void AttrValue_ListValue::add_s(const std::string& value) {
+  _impl_.s_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:tensorflow.AttrValue.ListValue.s)
+}
+inline void AttrValue_ListValue::add_s(std::string&& value) {
+  _impl_.s_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:tensorflow.AttrValue.ListValue.s)
+}
+inline void AttrValue_ListValue::add_s(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.s_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:tensorflow.AttrValue.ListValue.s)
+}
+inline void AttrValue_ListValue::add_s(const void* value, size_t size) {
+  _impl_.s_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:tensorflow.AttrValue.ListValue.s)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+AttrValue_ListValue::s() const {
+  // @@protoc_insertion_point(field_list:tensorflow.AttrValue.ListValue.s)
+  return _impl_.s_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+AttrValue_ListValue::mutable_s() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.AttrValue.ListValue.s)
+  return &_impl_.s_;
+}
+
+// repeated int64 i = 3 [packed = true];
+inline int AttrValue_ListValue::_internal_i_size() const {
+  return _impl_.i_.size();
+}
+inline int AttrValue_ListValue::i_size() const {
+  return _internal_i_size();
+}
+inline void AttrValue_ListValue::clear_i() {
+  _impl_.i_.Clear();
+}
+inline int64_t AttrValue_ListValue::_internal_i(int index) const {
+  return _impl_.i_.Get(index);
+}
+inline int64_t AttrValue_ListValue::i(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.AttrValue.ListValue.i)
+  return _internal_i(index);
+}
+inline void AttrValue_ListValue::set_i(int index, int64_t value) {
+  _impl_.i_.Set(index, value);
+  // @@protoc_insertion_point(field_set:tensorflow.AttrValue.ListValue.i)
+}
+inline void AttrValue_ListValue::_internal_add_i(int64_t value) {
+  _impl_.i_.Add(value);
+}
+inline void AttrValue_ListValue::add_i(int64_t value) {
+  _internal_add_i(value);
+  // @@protoc_insertion_point(field_add:tensorflow.AttrValue.ListValue.i)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
+AttrValue_ListValue::_internal_i() const {
+  return _impl_.i_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
+AttrValue_ListValue::i() const {
+  // @@protoc_insertion_point(field_list:tensorflow.AttrValue.ListValue.i)
+  return _internal_i();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
+AttrValue_ListValue::_internal_mutable_i() {
+  return &_impl_.i_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
+AttrValue_ListValue::mutable_i() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.AttrValue.ListValue.i)
+  return _internal_mutable_i();
+}
+
+// repeated float f = 4 [packed = true];
+inline int AttrValue_ListValue::_internal_f_size() const {
+  return _impl_.f_.size();
+}
+inline int AttrValue_ListValue::f_size() const {
+  return _internal_f_size();
+}
+inline void AttrValue_ListValue::clear_f() {
+  _impl_.f_.Clear();
+}
+inline float AttrValue_ListValue::_internal_f(int index) const {
+  return _impl_.f_.Get(index);
+}
+inline float AttrValue_ListValue::f(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.AttrValue.ListValue.f)
+  return _internal_f(index);
+}
+inline void AttrValue_ListValue::set_f(int index, float value) {
+  _impl_.f_.Set(index, value);
+  // @@protoc_insertion_point(field_set:tensorflow.AttrValue.ListValue.f)
+}
+inline void AttrValue_ListValue::_internal_add_f(float value) {
+  _impl_.f_.Add(value);
+}
+inline void AttrValue_ListValue::add_f(float value) {
+  _internal_add_f(value);
+  // @@protoc_insertion_point(field_add:tensorflow.AttrValue.ListValue.f)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
+AttrValue_ListValue::_internal_f() const {
+  return _impl_.f_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
+AttrValue_ListValue::f() const {
+  // @@protoc_insertion_point(field_list:tensorflow.AttrValue.ListValue.f)
+  return _internal_f();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
+AttrValue_ListValue::_internal_mutable_f() {
+  return &_impl_.f_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
+AttrValue_ListValue::mutable_f() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.AttrValue.ListValue.f)
+  return _internal_mutable_f();
+}
+
+// repeated bool b = 5 [packed = true];
+inline int AttrValue_ListValue::_internal_b_size() const {
+  return _impl_.b_.size();
+}
+inline int AttrValue_ListValue::b_size() const {
+  return _internal_b_size();
+}
+inline void AttrValue_ListValue::clear_b() {
+  _impl_.b_.Clear();
+}
+inline bool AttrValue_ListValue::_internal_b(int index) const {
+  return _impl_.b_.Get(index);
+}
+inline bool AttrValue_ListValue::b(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.AttrValue.ListValue.b)
+  return _internal_b(index);
+}
+inline void AttrValue_ListValue::set_b(int index, bool value) {
+  _impl_.b_.Set(index, value);
+  // @@protoc_insertion_point(field_set:tensorflow.AttrValue.ListValue.b)
+}
+inline void AttrValue_ListValue::_internal_add_b(bool value) {
+  _impl_.b_.Add(value);
+}
+inline void AttrValue_ListValue::add_b(bool value) {
+  _internal_add_b(value);
+  // @@protoc_insertion_point(field_add:tensorflow.AttrValue.ListValue.b)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >&
+AttrValue_ListValue::_internal_b() const {
+  return _impl_.b_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >&
+AttrValue_ListValue::b() const {
+  // @@protoc_insertion_point(field_list:tensorflow.AttrValue.ListValue.b)
+  return _internal_b();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >*
+AttrValue_ListValue::_internal_mutable_b() {
+  return &_impl_.b_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >*
+AttrValue_ListValue::mutable_b() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.AttrValue.ListValue.b)
+  return _internal_mutable_b();
+}
+
+// repeated .tensorflow.DataType type = 6 [packed = true];
+inline int AttrValue_ListValue::_internal_type_size() const {
+  return _impl_.type_.size();
+}
+inline int AttrValue_ListValue::type_size() const {
+  return _internal_type_size();
+}
+inline void AttrValue_ListValue::clear_type() {
+  _impl_.type_.Clear();
+}
+inline ::tensorflow::DataType AttrValue_ListValue::_internal_type(int index) const {
+  return static_cast< ::tensorflow::DataType >(_impl_.type_.Get(index));
+}
+inline ::tensorflow::DataType AttrValue_ListValue::type(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.AttrValue.ListValue.type)
+  return _internal_type(index);
+}
+inline void AttrValue_ListValue::set_type(int index, ::tensorflow::DataType value) {
+  _impl_.type_.Set(index, value);
+  // @@protoc_insertion_point(field_set:tensorflow.AttrValue.ListValue.type)
+}
+inline void AttrValue_ListValue::_internal_add_type(::tensorflow::DataType value) {
+  _impl_.type_.Add(value);
+}
+inline void AttrValue_ListValue::add_type(::tensorflow::DataType value) {
+  _internal_add_type(value);
+  // @@protoc_insertion_point(field_add:tensorflow.AttrValue.ListValue.type)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
+AttrValue_ListValue::type() const {
+  // @@protoc_insertion_point(field_list:tensorflow.AttrValue.ListValue.type)
+  return _impl_.type_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
+AttrValue_ListValue::_internal_mutable_type() {
+  return &_impl_.type_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
+AttrValue_ListValue::mutable_type() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.AttrValue.ListValue.type)
+  return _internal_mutable_type();
+}
+
+// repeated .tensorflow.TensorShapeProto shape = 7;
+inline int AttrValue_ListValue::_internal_shape_size() const {
+  return _impl_.shape_.size();
+}
+inline int AttrValue_ListValue::shape_size() const {
+  return _internal_shape_size();
+}
+inline ::tensorflow::TensorShapeProto* AttrValue_ListValue::mutable_shape(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.AttrValue.ListValue.shape)
+  return _impl_.shape_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TensorShapeProto >*
+AttrValue_ListValue::mutable_shape() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.AttrValue.ListValue.shape)
+  return &_impl_.shape_;
+}
+inline const ::tensorflow::TensorShapeProto& AttrValue_ListValue::_internal_shape(int index) const {
+  return _impl_.shape_.Get(index);
+}
+inline const ::tensorflow::TensorShapeProto& AttrValue_ListValue::shape(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.AttrValue.ListValue.shape)
+  return _internal_shape(index);
+}
+inline ::tensorflow::TensorShapeProto* AttrValue_ListValue::_internal_add_shape() {
+  return _impl_.shape_.Add();
+}
+inline ::tensorflow::TensorShapeProto* AttrValue_ListValue::add_shape() {
+  ::tensorflow::TensorShapeProto* _add = _internal_add_shape();
+  // @@protoc_insertion_point(field_add:tensorflow.AttrValue.ListValue.shape)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TensorShapeProto >&
+AttrValue_ListValue::shape() const {
+  // @@protoc_insertion_point(field_list:tensorflow.AttrValue.ListValue.shape)
+  return _impl_.shape_;
+}
+
+// repeated .tensorflow.TensorProto tensor = 8;
+inline int AttrValue_ListValue::_internal_tensor_size() const {
+  return _impl_.tensor_.size();
+}
+inline int AttrValue_ListValue::tensor_size() const {
+  return _internal_tensor_size();
+}
+inline ::tensorflow::TensorProto* AttrValue_ListValue::mutable_tensor(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.AttrValue.ListValue.tensor)
+  return _impl_.tensor_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TensorProto >*
+AttrValue_ListValue::mutable_tensor() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.AttrValue.ListValue.tensor)
+  return &_impl_.tensor_;
+}
+inline const ::tensorflow::TensorProto& AttrValue_ListValue::_internal_tensor(int index) const {
+  return _impl_.tensor_.Get(index);
+}
+inline const ::tensorflow::TensorProto& AttrValue_ListValue::tensor(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.AttrValue.ListValue.tensor)
+  return _internal_tensor(index);
+}
+inline ::tensorflow::TensorProto* AttrValue_ListValue::_internal_add_tensor() {
+  return _impl_.tensor_.Add();
+}
+inline ::tensorflow::TensorProto* AttrValue_ListValue::add_tensor() {
+  ::tensorflow::TensorProto* _add = _internal_add_tensor();
+  // @@protoc_insertion_point(field_add:tensorflow.AttrValue.ListValue.tensor)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TensorProto >&
+AttrValue_ListValue::tensor() const {
+  // @@protoc_insertion_point(field_list:tensorflow.AttrValue.ListValue.tensor)
+  return _impl_.tensor_;
+}
+
+// repeated .tensorflow.NameAttrList func = 9;
+inline int AttrValue_ListValue::_internal_func_size() const {
+  return _impl_.func_.size();
+}
+inline int AttrValue_ListValue::func_size() const {
+  return _internal_func_size();
+}
+inline void AttrValue_ListValue::clear_func() {
+  _impl_.func_.Clear();
+}
+inline ::tensorflow::NameAttrList* AttrValue_ListValue::mutable_func(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.AttrValue.ListValue.func)
+  return _impl_.func_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::NameAttrList >*
+AttrValue_ListValue::mutable_func() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.AttrValue.ListValue.func)
+  return &_impl_.func_;
+}
+inline const ::tensorflow::NameAttrList& AttrValue_ListValue::_internal_func(int index) const {
+  return _impl_.func_.Get(index);
+}
+inline const ::tensorflow::NameAttrList& AttrValue_ListValue::func(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.AttrValue.ListValue.func)
+  return _internal_func(index);
+}
+inline ::tensorflow::NameAttrList* AttrValue_ListValue::_internal_add_func() {
+  return _impl_.func_.Add();
+}
+inline ::tensorflow::NameAttrList* AttrValue_ListValue::add_func() {
+  ::tensorflow::NameAttrList* _add = _internal_add_func();
+  // @@protoc_insertion_point(field_add:tensorflow.AttrValue.ListValue.func)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::NameAttrList >&
+AttrValue_ListValue::func() const {
+  // @@protoc_insertion_point(field_list:tensorflow.AttrValue.ListValue.func)
+  return _impl_.func_;
+}
+
+// -------------------------------------------------------------------
+
+// AttrValue
+
+// bytes s = 2;
+inline bool AttrValue::_internal_has_s() const {
+  return value_case() == kS;
+}
+inline bool AttrValue::has_s() const {
+  return _internal_has_s();
+}
+inline void AttrValue::set_has_s() {
+  _impl_._oneof_case_[0] = kS;
+}
+inline void AttrValue::clear_s() {
+  if (_internal_has_s()) {
+    _impl_.value_.s_.Destroy();
+    clear_has_value();
+  }
+}
+inline const std::string& AttrValue::s() const {
+  // @@protoc_insertion_point(field_get:tensorflow.AttrValue.s)
+  return _internal_s();
+}
+template <typename ArgT0, typename... ArgT>
+inline void AttrValue::set_s(ArgT0&& arg0, ArgT... args) {
+  if (!_internal_has_s()) {
+    clear_value();
+    set_has_s();
+    _impl_.value_.s_.InitDefault();
+  }
+  _impl_.value_.s_.SetBytes( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.AttrValue.s)
+}
+inline std::string* AttrValue::mutable_s() {
+  std::string* _s = _internal_mutable_s();
+  // @@protoc_insertion_point(field_mutable:tensorflow.AttrValue.s)
+  return _s;
+}
+inline const std::string& AttrValue::_internal_s() const {
+  if (_internal_has_s()) {
+    return _impl_.value_.s_.Get();
+  }
+  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void AttrValue::_internal_set_s(const std::string& value) {
+  if (!_internal_has_s()) {
+    clear_value();
+    set_has_s();
+    _impl_.value_.s_.InitDefault();
+  }
+  _impl_.value_.s_.Set(value, GetArenaForAllocation());
+}
+inline std::string* AttrValue::_internal_mutable_s() {
+  if (!_internal_has_s()) {
+    clear_value();
+    set_has_s();
+    _impl_.value_.s_.InitDefault();
+  }
+  return _impl_.value_.s_.Mutable(      GetArenaForAllocation());
+}
+inline std::string* AttrValue::release_s() {
+  // @@protoc_insertion_point(field_release:tensorflow.AttrValue.s)
+  if (_internal_has_s()) {
+    clear_has_value();
+    return _impl_.value_.s_.Release();
+  } else {
+    return nullptr;
+  }
+}
+inline void AttrValue::set_allocated_s(std::string* s) {
+  if (has_value()) {
+    clear_value();
+  }
+  if (s != nullptr) {
+    set_has_s();
+    _impl_.value_.s_.InitAllocated(s, GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.AttrValue.s)
+}
+
+// int64 i = 3;
+inline bool AttrValue::_internal_has_i() const {
+  return value_case() == kI;
+}
+inline bool AttrValue::has_i() const {
+  return _internal_has_i();
+}
+inline void AttrValue::set_has_i() {
+  _impl_._oneof_case_[0] = kI;
+}
+inline void AttrValue::clear_i() {
+  if (_internal_has_i()) {
+    _impl_.value_.i_ = int64_t{0};
+    clear_has_value();
+  }
+}
+inline int64_t AttrValue::_internal_i() const {
+  if (_internal_has_i()) {
+    return _impl_.value_.i_;
+  }
+  return int64_t{0};
+}
+inline void AttrValue::_internal_set_i(int64_t value) {
+  if (!_internal_has_i()) {
+    clear_value();
+    set_has_i();
+  }
+  _impl_.value_.i_ = value;
+}
+inline int64_t AttrValue::i() const {
+  // @@protoc_insertion_point(field_get:tensorflow.AttrValue.i)
+  return _internal_i();
+}
+inline void AttrValue::set_i(int64_t value) {
+  _internal_set_i(value);
+  // @@protoc_insertion_point(field_set:tensorflow.AttrValue.i)
+}
+
+// float f = 4;
+inline bool AttrValue::_internal_has_f() const {
+  return value_case() == kF;
+}
+inline bool AttrValue::has_f() const {
+  return _internal_has_f();
+}
+inline void AttrValue::set_has_f() {
+  _impl_._oneof_case_[0] = kF;
+}
+inline void AttrValue::clear_f() {
+  if (_internal_has_f()) {
+    _impl_.value_.f_ = 0;
+    clear_has_value();
+  }
+}
+inline float AttrValue::_internal_f() const {
+  if (_internal_has_f()) {
+    return _impl_.value_.f_;
+  }
+  return 0;
+}
+inline void AttrValue::_internal_set_f(float value) {
+  if (!_internal_has_f()) {
+    clear_value();
+    set_has_f();
+  }
+  _impl_.value_.f_ = value;
+}
+inline float AttrValue::f() const {
+  // @@protoc_insertion_point(field_get:tensorflow.AttrValue.f)
+  return _internal_f();
+}
+inline void AttrValue::set_f(float value) {
+  _internal_set_f(value);
+  // @@protoc_insertion_point(field_set:tensorflow.AttrValue.f)
+}
+
+// bool b = 5;
+inline bool AttrValue::_internal_has_b() const {
+  return value_case() == kB;
+}
+inline bool AttrValue::has_b() const {
+  return _internal_has_b();
+}
+inline void AttrValue::set_has_b() {
+  _impl_._oneof_case_[0] = kB;
+}
+inline void AttrValue::clear_b() {
+  if (_internal_has_b()) {
+    _impl_.value_.b_ = false;
+    clear_has_value();
+  }
+}
+inline bool AttrValue::_internal_b() const {
+  if (_internal_has_b()) {
+    return _impl_.value_.b_;
+  }
+  return false;
+}
+inline void AttrValue::_internal_set_b(bool value) {
+  if (!_internal_has_b()) {
+    clear_value();
+    set_has_b();
+  }
+  _impl_.value_.b_ = value;
+}
+inline bool AttrValue::b() const {
+  // @@protoc_insertion_point(field_get:tensorflow.AttrValue.b)
+  return _internal_b();
+}
+inline void AttrValue::set_b(bool value) {
+  _internal_set_b(value);
+  // @@protoc_insertion_point(field_set:tensorflow.AttrValue.b)
+}
+
+// .tensorflow.DataType type = 6;
+inline bool AttrValue::_internal_has_type() const {
+  return value_case() == kType;
+}
+inline bool AttrValue::has_type() const {
+  return _internal_has_type();
+}
+inline void AttrValue::set_has_type() {
+  _impl_._oneof_case_[0] = kType;
+}
+inline void AttrValue::clear_type() {
+  if (_internal_has_type()) {
+    _impl_.value_.type_ = 0;
+    clear_has_value();
+  }
+}
+inline ::tensorflow::DataType AttrValue::_internal_type() const {
+  if (_internal_has_type()) {
+    return static_cast< ::tensorflow::DataType >(_impl_.value_.type_);
+  }
+  return static_cast< ::tensorflow::DataType >(0);
+}
+inline ::tensorflow::DataType AttrValue::type() const {
+  // @@protoc_insertion_point(field_get:tensorflow.AttrValue.type)
+  return _internal_type();
+}
+inline void AttrValue::_internal_set_type(::tensorflow::DataType value) {
+  if (!_internal_has_type()) {
+    clear_value();
+    set_has_type();
+  }
+  _impl_.value_.type_ = value;
+}
+inline void AttrValue::set_type(::tensorflow::DataType value) {
+  _internal_set_type(value);
+  // @@protoc_insertion_point(field_set:tensorflow.AttrValue.type)
+}
+
+// .tensorflow.TensorShapeProto shape = 7;
+inline bool AttrValue::_internal_has_shape() const {
+  return value_case() == kShape;
+}
+inline bool AttrValue::has_shape() const {
+  return _internal_has_shape();
+}
+inline void AttrValue::set_has_shape() {
+  _impl_._oneof_case_[0] = kShape;
+}
+inline ::tensorflow::TensorShapeProto* AttrValue::release_shape() {
+  // @@protoc_insertion_point(field_release:tensorflow.AttrValue.shape)
+  if (_internal_has_shape()) {
+    clear_has_value();
+    ::tensorflow::TensorShapeProto* temp = _impl_.value_.shape_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    _impl_.value_.shape_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::tensorflow::TensorShapeProto& AttrValue::_internal_shape() const {
+  return _internal_has_shape()
+      ? *_impl_.value_.shape_
+      : reinterpret_cast< ::tensorflow::TensorShapeProto&>(::tensorflow::_TensorShapeProto_default_instance_);
+}
+inline const ::tensorflow::TensorShapeProto& AttrValue::shape() const {
+  // @@protoc_insertion_point(field_get:tensorflow.AttrValue.shape)
+  return _internal_shape();
+}
+inline ::tensorflow::TensorShapeProto* AttrValue::unsafe_arena_release_shape() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.AttrValue.shape)
+  if (_internal_has_shape()) {
+    clear_has_value();
+    ::tensorflow::TensorShapeProto* temp = _impl_.value_.shape_;
+    _impl_.value_.shape_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void AttrValue::unsafe_arena_set_allocated_shape(::tensorflow::TensorShapeProto* shape) {
+  clear_value();
+  if (shape) {
+    set_has_shape();
+    _impl_.value_.shape_ = shape;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.AttrValue.shape)
+}
+inline ::tensorflow::TensorShapeProto* AttrValue::_internal_mutable_shape() {
+  if (!_internal_has_shape()) {
+    clear_value();
+    set_has_shape();
+    _impl_.value_.shape_ = CreateMaybeMessage< ::tensorflow::TensorShapeProto >(GetArenaForAllocation());
+  }
+  return _impl_.value_.shape_;
+}
+inline ::tensorflow::TensorShapeProto* AttrValue::mutable_shape() {
+  ::tensorflow::TensorShapeProto* _msg = _internal_mutable_shape();
+  // @@protoc_insertion_point(field_mutable:tensorflow.AttrValue.shape)
+  return _msg;
+}
+
+// .tensorflow.TensorProto tensor = 8;
+inline bool AttrValue::_internal_has_tensor() const {
+  return value_case() == kTensor;
+}
+inline bool AttrValue::has_tensor() const {
+  return _internal_has_tensor();
+}
+inline void AttrValue::set_has_tensor() {
+  _impl_._oneof_case_[0] = kTensor;
+}
+inline ::tensorflow::TensorProto* AttrValue::release_tensor() {
+  // @@protoc_insertion_point(field_release:tensorflow.AttrValue.tensor)
+  if (_internal_has_tensor()) {
+    clear_has_value();
+    ::tensorflow::TensorProto* temp = _impl_.value_.tensor_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    _impl_.value_.tensor_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::tensorflow::TensorProto& AttrValue::_internal_tensor() const {
+  return _internal_has_tensor()
+      ? *_impl_.value_.tensor_
+      : reinterpret_cast< ::tensorflow::TensorProto&>(::tensorflow::_TensorProto_default_instance_);
+}
+inline const ::tensorflow::TensorProto& AttrValue::tensor() const {
+  // @@protoc_insertion_point(field_get:tensorflow.AttrValue.tensor)
+  return _internal_tensor();
+}
+inline ::tensorflow::TensorProto* AttrValue::unsafe_arena_release_tensor() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.AttrValue.tensor)
+  if (_internal_has_tensor()) {
+    clear_has_value();
+    ::tensorflow::TensorProto* temp = _impl_.value_.tensor_;
+    _impl_.value_.tensor_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void AttrValue::unsafe_arena_set_allocated_tensor(::tensorflow::TensorProto* tensor) {
+  clear_value();
+  if (tensor) {
+    set_has_tensor();
+    _impl_.value_.tensor_ = tensor;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.AttrValue.tensor)
+}
+inline ::tensorflow::TensorProto* AttrValue::_internal_mutable_tensor() {
+  if (!_internal_has_tensor()) {
+    clear_value();
+    set_has_tensor();
+    _impl_.value_.tensor_ = CreateMaybeMessage< ::tensorflow::TensorProto >(GetArenaForAllocation());
+  }
+  return _impl_.value_.tensor_;
+}
+inline ::tensorflow::TensorProto* AttrValue::mutable_tensor() {
+  ::tensorflow::TensorProto* _msg = _internal_mutable_tensor();
+  // @@protoc_insertion_point(field_mutable:tensorflow.AttrValue.tensor)
+  return _msg;
+}
+
+// .tensorflow.AttrValue.ListValue list = 1;
+inline bool AttrValue::_internal_has_list() const {
+  return value_case() == kList;
+}
+inline bool AttrValue::has_list() const {
+  return _internal_has_list();
+}
+inline void AttrValue::set_has_list() {
+  _impl_._oneof_case_[0] = kList;
+}
+inline void AttrValue::clear_list() {
+  if (_internal_has_list()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete _impl_.value_.list_;
+    }
+    clear_has_value();
+  }
+}
+inline ::tensorflow::AttrValue_ListValue* AttrValue::release_list() {
+  // @@protoc_insertion_point(field_release:tensorflow.AttrValue.list)
+  if (_internal_has_list()) {
+    clear_has_value();
+    ::tensorflow::AttrValue_ListValue* temp = _impl_.value_.list_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    _impl_.value_.list_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::tensorflow::AttrValue_ListValue& AttrValue::_internal_list() const {
+  return _internal_has_list()
+      ? *_impl_.value_.list_
+      : reinterpret_cast< ::tensorflow::AttrValue_ListValue&>(::tensorflow::_AttrValue_ListValue_default_instance_);
+}
+inline const ::tensorflow::AttrValue_ListValue& AttrValue::list() const {
+  // @@protoc_insertion_point(field_get:tensorflow.AttrValue.list)
+  return _internal_list();
+}
+inline ::tensorflow::AttrValue_ListValue* AttrValue::unsafe_arena_release_list() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.AttrValue.list)
+  if (_internal_has_list()) {
+    clear_has_value();
+    ::tensorflow::AttrValue_ListValue* temp = _impl_.value_.list_;
+    _impl_.value_.list_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void AttrValue::unsafe_arena_set_allocated_list(::tensorflow::AttrValue_ListValue* list) {
+  clear_value();
+  if (list) {
+    set_has_list();
+    _impl_.value_.list_ = list;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.AttrValue.list)
+}
+inline ::tensorflow::AttrValue_ListValue* AttrValue::_internal_mutable_list() {
+  if (!_internal_has_list()) {
+    clear_value();
+    set_has_list();
+    _impl_.value_.list_ = CreateMaybeMessage< ::tensorflow::AttrValue_ListValue >(GetArenaForAllocation());
+  }
+  return _impl_.value_.list_;
+}
+inline ::tensorflow::AttrValue_ListValue* AttrValue::mutable_list() {
+  ::tensorflow::AttrValue_ListValue* _msg = _internal_mutable_list();
+  // @@protoc_insertion_point(field_mutable:tensorflow.AttrValue.list)
+  return _msg;
+}
+
+// .tensorflow.NameAttrList func = 10;
+inline bool AttrValue::_internal_has_func() const {
+  return value_case() == kFunc;
+}
+inline bool AttrValue::has_func() const {
+  return _internal_has_func();
+}
+inline void AttrValue::set_has_func() {
+  _impl_._oneof_case_[0] = kFunc;
+}
+inline void AttrValue::clear_func() {
+  if (_internal_has_func()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete _impl_.value_.func_;
+    }
+    clear_has_value();
+  }
+}
+inline ::tensorflow::NameAttrList* AttrValue::release_func() {
+  // @@protoc_insertion_point(field_release:tensorflow.AttrValue.func)
+  if (_internal_has_func()) {
+    clear_has_value();
+    ::tensorflow::NameAttrList* temp = _impl_.value_.func_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    _impl_.value_.func_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::tensorflow::NameAttrList& AttrValue::_internal_func() const {
+  return _internal_has_func()
+      ? *_impl_.value_.func_
+      : reinterpret_cast< ::tensorflow::NameAttrList&>(::tensorflow::_NameAttrList_default_instance_);
+}
+inline const ::tensorflow::NameAttrList& AttrValue::func() const {
+  // @@protoc_insertion_point(field_get:tensorflow.AttrValue.func)
+  return _internal_func();
+}
+inline ::tensorflow::NameAttrList* AttrValue::unsafe_arena_release_func() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.AttrValue.func)
+  if (_internal_has_func()) {
+    clear_has_value();
+    ::tensorflow::NameAttrList* temp = _impl_.value_.func_;
+    _impl_.value_.func_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void AttrValue::unsafe_arena_set_allocated_func(::tensorflow::NameAttrList* func) {
+  clear_value();
+  if (func) {
+    set_has_func();
+    _impl_.value_.func_ = func;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.AttrValue.func)
+}
+inline ::tensorflow::NameAttrList* AttrValue::_internal_mutable_func() {
+  if (!_internal_has_func()) {
+    clear_value();
+    set_has_func();
+    _impl_.value_.func_ = CreateMaybeMessage< ::tensorflow::NameAttrList >(GetArenaForAllocation());
+  }
+  return _impl_.value_.func_;
+}
+inline ::tensorflow::NameAttrList* AttrValue::mutable_func() {
+  ::tensorflow::NameAttrList* _msg = _internal_mutable_func();
+  // @@protoc_insertion_point(field_mutable:tensorflow.AttrValue.func)
+  return _msg;
+}
+
+// string placeholder = 9;
+inline bool AttrValue::_internal_has_placeholder() const {
+  return value_case() == kPlaceholder;
+}
+inline bool AttrValue::has_placeholder() const {
+  return _internal_has_placeholder();
+}
+inline void AttrValue::set_has_placeholder() {
+  _impl_._oneof_case_[0] = kPlaceholder;
+}
+inline void AttrValue::clear_placeholder() {
+  if (_internal_has_placeholder()) {
+    _impl_.value_.placeholder_.Destroy();
+    clear_has_value();
+  }
+}
+inline const std::string& AttrValue::placeholder() const {
+  // @@protoc_insertion_point(field_get:tensorflow.AttrValue.placeholder)
+  return _internal_placeholder();
+}
+template <typename ArgT0, typename... ArgT>
+inline void AttrValue::set_placeholder(ArgT0&& arg0, ArgT... args) {
+  if (!_internal_has_placeholder()) {
+    clear_value();
+    set_has_placeholder();
+    _impl_.value_.placeholder_.InitDefault();
+  }
+  _impl_.value_.placeholder_.Set( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.AttrValue.placeholder)
+}
+inline std::string* AttrValue::mutable_placeholder() {
+  std::string* _s = _internal_mutable_placeholder();
+  // @@protoc_insertion_point(field_mutable:tensorflow.AttrValue.placeholder)
+  return _s;
+}
+inline const std::string& AttrValue::_internal_placeholder() const {
+  if (_internal_has_placeholder()) {
+    return _impl_.value_.placeholder_.Get();
+  }
+  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void AttrValue::_internal_set_placeholder(const std::string& value) {
+  if (!_internal_has_placeholder()) {
+    clear_value();
+    set_has_placeholder();
+    _impl_.value_.placeholder_.InitDefault();
+  }
+  _impl_.value_.placeholder_.Set(value, GetArenaForAllocation());
+}
+inline std::string* AttrValue::_internal_mutable_placeholder() {
+  if (!_internal_has_placeholder()) {
+    clear_value();
+    set_has_placeholder();
+    _impl_.value_.placeholder_.InitDefault();
+  }
+  return _impl_.value_.placeholder_.Mutable(      GetArenaForAllocation());
+}
+inline std::string* AttrValue::release_placeholder() {
+  // @@protoc_insertion_point(field_release:tensorflow.AttrValue.placeholder)
+  if (_internal_has_placeholder()) {
+    clear_has_value();
+    return _impl_.value_.placeholder_.Release();
+  } else {
+    return nullptr;
+  }
+}
+inline void AttrValue::set_allocated_placeholder(std::string* placeholder) {
+  if (has_value()) {
+    clear_value();
+  }
+  if (placeholder != nullptr) {
+    set_has_placeholder();
+    _impl_.value_.placeholder_.InitAllocated(placeholder, GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.AttrValue.placeholder)
+}
+
+inline bool AttrValue::has_value() const {
+  return value_case() != VALUE_NOT_SET;
+}
+inline void AttrValue::clear_has_value() {
+  _impl_._oneof_case_[0] = VALUE_NOT_SET;
+}
+inline AttrValue::ValueCase AttrValue::value_case() const {
+  return AttrValue::ValueCase(_impl_._oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// NameAttrList
+
+// string name = 1;
+inline void NameAttrList::clear_name() {
+  _impl_.name_.ClearToEmpty();
+}
+inline const std::string& NameAttrList::name() const {
+  // @@protoc_insertion_point(field_get:tensorflow.NameAttrList.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void NameAttrList::set_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.NameAttrList.name)
+}
+inline std::string* NameAttrList::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:tensorflow.NameAttrList.name)
+  return _s;
+}
+inline const std::string& NameAttrList::_internal_name() const {
+  return _impl_.name_.Get();
+}
+inline void NameAttrList::_internal_set_name(const std::string& value) {
+  
+  _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* NameAttrList::_internal_mutable_name() {
+  
+  return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* NameAttrList::release_name() {
+  // @@protoc_insertion_point(field_release:tensorflow.NameAttrList.name)
+  return _impl_.name_.Release();
+}
+inline void NameAttrList::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.NameAttrList.name)
+}
+
+// map<string, .tensorflow.AttrValue> attr = 2;
+inline int NameAttrList::_internal_attr_size() const {
+  return _impl_.attr_.size();
+}
+inline int NameAttrList::attr_size() const {
+  return _internal_attr_size();
+}
+inline void NameAttrList::clear_attr() {
+  _impl_.attr_.Clear();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::AttrValue >&
+NameAttrList::_internal_attr() const {
+  return _impl_.attr_.GetMap();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::AttrValue >&
+NameAttrList::attr() const {
+  // @@protoc_insertion_point(field_map:tensorflow.NameAttrList.attr)
+  return _internal_attr();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::AttrValue >*
+NameAttrList::_internal_mutable_attr() {
+  return _impl_.attr_.MutableMap();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::AttrValue >*
+NameAttrList::mutable_attr() {
+  // @@protoc_insertion_point(field_mutable_map:tensorflow.NameAttrList.attr)
+  return _internal_mutable_attr();
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace tensorflow
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fattr_5fvalue_2eproto
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/attr_value.proto b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/attr_value.proto
new file mode 100644
index 0000000000000000000000000000000000000000..2bd5b552a3614ae0cc8cb316dfc4ae8482c5e3e1
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/attr_value.proto
@@ -0,0 +1,64 @@
+syntax = "proto3";
+
+package tensorflow;
+
+import "tensorflow/core/framework/tensor.proto";
+import "tensorflow/core/framework/tensor_shape.proto";
+import "tensorflow/core/framework/types.proto";
+
+option cc_enable_arenas = true;
+option java_outer_classname = "AttrValueProtos";
+option java_multiple_files = true;
+option java_package = "org.tensorflow.framework";
+option go_package = "github.com/tensorflow/tensorflow/tensorflow/go/core/framework/attr_value_go_proto";
+
+// Protocol buffer representing the value for an attr used to configure an Op.
+// Comment indicates the corresponding attr type.  Only the field matching the
+// attr type may be filled.
+message AttrValue {
+  // LINT.IfChange
+  message ListValue {
+    repeated bytes s = 2;                        // "list(string)"
+    repeated int64 i = 3 [packed = true];        // "list(int)"
+    repeated float f = 4 [packed = true];        // "list(float)"
+    repeated bool b = 5 [packed = true];         // "list(bool)"
+    repeated DataType type = 6 [packed = true];  // "list(type)"
+    repeated TensorShapeProto shape = 7;         // "list(shape)"
+    repeated TensorProto tensor = 8;             // "list(tensor)"
+    repeated NameAttrList func = 9;              // "list(attr)"
+  }
+  // LINT.ThenChange(//tensorflow/c/c_api.cc)
+
+  oneof value {
+    bytes s = 2;                 // "string"
+    int64 i = 3;                 // "int"
+    float f = 4;                 // "float"
+    bool b = 5;                  // "bool"
+    DataType type = 6;           // "type"
+    TensorShapeProto shape = 7;  // "shape"
+    TensorProto tensor = 8;      // "tensor"
+    ListValue list = 1;          // any "list(...)"
+
+    // "func" represents a function. func.name is a function's name or
+    // a primitive op's name. func.attr.first is the name of an attr
+    // defined for that function. func.attr.second is the value for
+    // that attr in the instantiation.
+    NameAttrList func = 10;
+
+    // This is a placeholder only used in nodes defined inside a
+    // function.  It indicates the attr value will be supplied when
+    // the function is instantiated.  For example, let us suppose a
+    // node "N" in function "FN". "N" has an attr "A" with value
+    // placeholder = "foo". When FN is instantiated with attr "foo"
+    // set to "bar", the instantiated node N's attr A will have been
+    // given the value "bar".
+    string placeholder = 9;
+  }
+}
+
+// A list of attr names and their values. The whole list is attached
+// with a string name.  E.g., MatMul[T=float].
+message NameAttrList {
+  string name = 1;
+  map<string, AttrValue> attr = 2;
+}
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/attr_value_util.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/attr_value_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..0717e2cc3307c80e8e4b55c208c6314e5c491b3a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/attr_value_util.h
@@ -0,0 +1,140 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_ATTR_VALUE_UTIL_H_
+#define TENSORFLOW_CORE_FRAMEWORK_ATTR_VALUE_UTIL_H_
+
+#include <functional>
+#include <string>
+#include <vector>
+
+#include "tensorflow/core/framework/partial_tensor_shape.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/tensor_shape.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/lib/core/stringpiece.h"
+#include "tensorflow/core/lib/gtl/array_slice.h"
+
+namespace tensorflow {
+
+namespace attr_value_util_internal {
+// Return the size of the tensor represented by this TensorProto. If shape is
+// not fully defined return -1.
+int64_t TensorByteSize(const TensorProto& t);
+}  // namespace attr_value_util_internal
+
+// Forward declare protos so their symbols can be removed from .so exports
+class AttrValue;
+class NameAttrList;
+
+// A human-readable rendering of attr_value, that is more concise than a
+// text-format proto.
+std::string SummarizeAttrValue(const AttrValue& attr_value);
+
+// Generates an error if attr_value doesn't have the indicated attr type.
+Status AttrValueHasType(const AttrValue& attr_value, StringPiece type);
+
+// Converts a text proto value from "text" into the field of *out
+// indicated by "type" (e.g. from the type field of an AttrDef).
+// Examples:
+// * If type:"int" and text:"-14", then *out is set to "i: -14"
+// * If type:"list(string)" and text:"['foo', 'bar']",
+//   then *out is set to "list { s: ['foo', 'bar'] }"
+// Returns true on success.
+bool ParseAttrValue(StringPiece type, StringPiece text, AttrValue* out);
+
+// Sets *out based on the type of value.
+void SetAttrValue(const std::string& value, AttrValue* out);
+void SetAttrValue(const tstring& value, AttrValue* out);
+void SetAttrValue(const char* value, AttrValue* out);
+void SetAttrValue(StringPiece value, AttrValue* out);
+void SetAttrValue(int64_t value, AttrValue* out);
+void SetAttrValue(int32_t value, AttrValue* out);
+void SetAttrValue(float value, AttrValue* out);
+void SetAttrValue(double value, AttrValue* out);
+void SetAttrValue(bool value, AttrValue* out);
+void SetAttrValue(DataType value, AttrValue* out);
+void SetAttrValue(const TensorShape& value, AttrValue* out);
+void SetAttrValue(const TensorShapeProto& value, AttrValue* out);
+void SetAttrValue(const PartialTensorShape& value, AttrValue* out);
+void SetAttrValue(const Tensor& value, AttrValue* out);
+void SetAttrValue(const TensorProto& value, AttrValue* out);
+void SetAttrValue(const NameAttrList& value, AttrValue* out);
+
+void SetAttrValue(gtl::ArraySlice<string> value, AttrValue* out);
+void SetAttrValue(gtl::ArraySlice<tstring> value, AttrValue* out);
+void SetAttrValue(gtl::ArraySlice<const char*> value, AttrValue* out);
+void SetAttrValue(gtl::ArraySlice<StringPiece> value, AttrValue* out);
+void SetAttrValue(gtl::ArraySlice<int64_t> value, AttrValue* out);
+void SetAttrValue(gtl::ArraySlice<int32> value, AttrValue* out);
+void SetAttrValue(gtl::ArraySlice<float> value, AttrValue* out);
+void SetAttrValue(gtl::ArraySlice<double> value, AttrValue* out);
+void SetAttrValue(gtl::ArraySlice<bool> value, AttrValue* out);
+void SetAttrValue(const std::vector<bool>& value, AttrValue* out);
+void SetAttrValue(std::initializer_list<bool> value, AttrValue* out);
+void SetAttrValue(DataTypeSlice value, AttrValue* out);
+void SetAttrValue(gtl::ArraySlice<TensorShape> value, AttrValue* out);
+void SetAttrValue(gtl::ArraySlice<TensorShapeProto> value, AttrValue* out);
+void SetAttrValue(gtl::ArraySlice<PartialTensorShape> value, AttrValue* out);
+void SetAttrValue(gtl::ArraySlice<Tensor> value, AttrValue* out);
+void SetAttrValue(gtl::ArraySlice<TensorProto> value, AttrValue* out);
+void SetAttrValue(gtl::ArraySlice<NameAttrList> value, AttrValue* out);
+
+void SetAttrValue(const AttrValue& value, AttrValue* out);
+
+void MoveAttrValue(std::vector<string>&& value, AttrValue* out);
+
+// Returns a hash of `a` that is consistent with AreAttrValuesEqual. In other
+// words, if two AttrValues compare equal according to AreAttrValuesEqual,
+// they will have the same hash value.
+// Similarly to protobuf deterministic serialization, hash value is
+// guaranteed to be stable only for a given binary. In particular, one should
+// probably not persist the returned value.
+uint64 AttrValueHash(const AttrValue& a);
+
+// WARNING: Equality check might return false-negative for large (> 32mb)
+// tensors defined with different TensorProto representations.
+//
+// A pair of consistent hash and equals functions that are guaranteed to be fast
+// with AttrValues that potentially can have very large Tensors (larger than
+// 32mb) defined by TensorProto. If large identical Tensors are defined using
+// different representations (e.g. one with tensor content, and second with
+// bool_val), they will have different hash code and equals will return false.
+// Small (less than 32mb) tensors with different TensorProto representations
+// hashed/compared by their tensor content.
+uint64 FastAttrValueHash(const AttrValue& a);
+// Returns true if a and b have the same value. If false negatives are allowed,
+// then compares proto representation to avoid construction of large (> 32mb)
+// tensors.
+bool AreAttrValuesEqual(const AttrValue& a, const AttrValue& b,
+                        bool allow_false_negatives = false);
+
+// Returns true if "val" has a placeholder.
+bool HasPlaceHolder(const AttrValue& val);
+
+// SubstitutePlaceholders recursively replaces placeholders in 'value'
+// with an attr value by calling SubstituteFunc. Returns true iff all
+// placeholders in "value" are replaced with a value.
+//
+// SubstituteFunc is given a placeholder string. If the placeholder is
+// unknown, SubstituteFunc returns false. Otherwise, overwrites the
+// attr value and returns true.
+using SubstituteFunc = std::function<bool(const string&, AttrValue*)>;
+bool SubstitutePlaceholders(const SubstituteFunc& substitute, AttrValue* value);
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_ATTR_VALUE_UTIL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/bfloat16.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/bfloat16.h
new file mode 100644
index 0000000000000000000000000000000000000000..4f13039daa39426a05657ae039734ddfa727cfec
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/bfloat16.h
@@ -0,0 +1,61 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_BFLOAT16_H_
+#define TENSORFLOW_CORE_FRAMEWORK_BFLOAT16_H_
+
+#include "tensorflow/core/framework/numeric_types.h"
+#include "tensorflow/core/platform/types.h"
+
+// Compact 16-bit encoding of floating point numbers. This representation uses
+// 1 bit for the sign, 8 bits for the exponent and 7 bits for the mantissa.  It
+// is assumed that floats are in IEEE 754 format so the representation is just
+// bits 16-31 of a single precision float.
+//
+// NOTE: The IEEE floating point standard defines a float16 format that
+// is different than this format (it has fewer bits of exponent and more
+// bits of mantissa).  We don't use that format here because conversion
+// to/from 32-bit floats is more complex for that format, and the
+// conversion for this format is very simple.
+//
+// Because of the existing IEEE float16 type, we do not name our representation
+// "float16" but just use "uint16".
+//
+// <-----our 16bits float------->
+// s e e e e e e e e f f f f f f f f f f f f f f f f f f f f f f f
+// <------------------------------float-------------------------->
+// 3 3             2 2             1 1                           0
+// 1 0             3 2             5 4                           0
+//
+//
+// This type only supports conversion back and forth with float.
+//
+// This file must be compilable by nvcc.
+//
+// The type is defined in framework/numeric_types.h.
+
+namespace tensorflow {
+
+// Convert from float to bfloat16 with rounding-to-nearest-even.
+void RoundFloatToBFloat16(const float* src, bfloat16* dst, int64_t size);
+// Convert from float to bfloat16 with truncation. Notice this conversion is
+// lossy since it truncates the float to 7 mantissa bits without rounding.
+void FloatToBFloat16(const float* src, bfloat16* dst, int64_t size);
+// Convert from bfloat16 to float. This conversion is lossless.
+void BFloat16ToFloat(const bfloat16* src, float* dst, int64_t size);
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_BFLOAT16_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/bounds_check.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/bounds_check.h
new file mode 100644
index 0000000000000000000000000000000000000000..76e6e6dd05877708cc8c3c600c60115979047259
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/bounds_check.h
@@ -0,0 +1,54 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_BOUNDS_CHECK_H_
+#define TENSORFLOW_CORE_FRAMEWORK_BOUNDS_CHECK_H_
+
+#include <type_traits>
+
+#include "Eigen/Core"  // from @eigen_archive
+#include "tensorflow/core/platform/macros.h"
+
+namespace tensorflow {
+
+// Check that 0 <= index < limit using a single comparison, assuming
+// that 0 <= limit if Index is signed.  Intended for use in performance
+// critical contexts where 0 <= index < limit is almost always true.
+template <typename Ta, typename Tb>
+EIGEN_ALWAYS_INLINE EIGEN_DEVICE_FUNC bool FastBoundsCheck(const Ta index,
+                                                           const Tb limit) {
+  static_assert(std::is_integral<Ta>::value && std::is_integral<Tb>::value,
+                "FastBoundsCheck can only be used on integer types.");
+  typedef typename std::make_unsigned<decltype(index + limit)>::type UIndex;
+  return TF_PREDICT_TRUE(static_cast<UIndex>(index) <
+                         static_cast<UIndex>(limit));
+}
+
+namespace internal {
+// Ensure that the compiler cannot elide a copy into a local, for
+// bounds checking on source tensors that might be updated asynchronously.
+// This function may only be used on primitive integral types (int32, int64,
+// etc).  It does not guarantee any atomicity or barriers.
+template <typename T>
+EIGEN_ALWAYS_INLINE EIGEN_DEVICE_FUNC const T SubtleMustCopy(const T &x) {
+  static_assert(std::is_integral<T>::value,
+                "SubtleMustCopy can only be used on integer types.");
+  auto *to_x = reinterpret_cast<const volatile T *>(&x);
+  return *to_x;
+}
+}  // namespace internal
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_BOUNDS_CHECK_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/cancellation.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/cancellation.h
new file mode 100644
index 0000000000000000000000000000000000000000..7961787e87ebbbd0a18e4d64c80458e53e74037c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/cancellation.h
@@ -0,0 +1,39 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_CANCELLATION_H_
+#define TENSORFLOW_CORE_FRAMEWORK_CANCELLATION_H_
+
+#include "tensorflow/core/lib/core/notification.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/lib/gtl/flatmap.h"
+#include "tensorflow/core/lib/hash/hash.h"
+#include "tensorflow/core/platform/mutex.h"
+#include "tensorflow/core/platform/status.h"
+#include "tensorflow/core/platform/stringpiece.h"
+#include "tensorflow/core/platform/thread_annotations.h"
+#include "tensorflow/core/platform/types.h"
+#include "tsl/framework/cancellation.h"
+
+namespace tensorflow {
+// NOLINTBEGIN(misc-unused-using-decls)
+using tsl::CancelCallback;
+using tsl::CancellationManager;
+using tsl::CancellationToken;
+using tsl::RegisterCancellationCallback;
+// NOLINTEND(misc-unused-using-decls)
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_CANCELLATION_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/collective.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/collective.h
new file mode 100644
index 0000000000000000000000000000000000000000..4b43fb226af248c615caf34d07fc61b6085c0c9a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/collective.h
@@ -0,0 +1,516 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_FRAMEWORK_COLLECTIVE_H_
+#define TENSORFLOW_CORE_FRAMEWORK_COLLECTIVE_H_
+
+#include <string>
+#include <vector>
+
+#include "absl/container/flat_hash_set.h"
+#include "tensorflow/core/framework/cancellation.h"
+#include "tensorflow/core/framework/device_attributes.pb.h"
+#include "tensorflow/core/framework/device_base.h"
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/lib/core/refcount.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/platform/intrusive_ptr.h"
+
+namespace tensorflow {
+
+class BufRendezvous;
+class CompleteGroupRequest;
+class CompleteGroupResponse;
+class CompleteInstanceRequest;
+class CompleteInstanceResponse;
+class Device;
+class DeviceMgr;
+class GetStepSequenceRequest;
+class GetStepSequenceResponse;
+class NcclManager;
+class Tensor;
+
+// Types of supported collective operations.
+enum CollectiveType {
+  REDUCTION_COLLECTIVE = 0,
+  BROADCAST_COLLECTIVE,
+  GATHER_COLLECTIVE,
+  PERMUTE_COLLECTIVE,
+  ALL_TO_ALL_COLLECTIVE,
+  REDUCE_SCATTER_COLLECTIVE,
+  UNDEFINED_COLLECTIVE,
+};
+
+// Some collective op implementations require runtime group configuration from
+// the OpKernel.  Currently, this struct is used to set communicator key for
+// NCCL-based collective implementation.
+struct CollGroupRuntimeDetails {
+  string communicator_key;  // for communicator-based techniques e.g. NCCL
+  string ToString() const;
+};
+
+struct CollGroupMember {
+  DeviceAttributes device;
+  string task;
+  bool is_local;
+  // User provided rank
+  int32 rank = -1;
+};
+
+// Data common to all members of a device group.
+// All members share the same device set but its order is
+// particular to an instance so it is stored there.
+struct CollGroupParams {
+  // Inputs from Collective ops:
+  int32 group_key;
+  int32 group_size;
+  DeviceType device_type;
+  int user_specified_rank = -1;  // rank provided by the user.
+  // Generated from Collective Group Resolver:
+  // Members in this group, in default rank order.
+  std::vector<CollGroupMember> members;
+  // True if every task has the same number of devices.
+  bool same_num_devices_per_task = false;
+  // Task -> number of devices on that task.
+  std::unordered_map<string, int32> num_devices_per_task;
+  int32 num_tasks;  // number of distinct tasks in group
+  CollGroupRuntimeDetails runtime_details;
+  string ToString() const;
+  CollGroupParams()
+      : group_key(0), group_size(0), device_type(DEVICE_CPU), num_tasks(0) {}
+};
+
+// The best implementation of a collective op depends on many factors
+// including the number of devices involved, the topology of
+// interconnects between them and the sizes of inputs.  This structure
+// is used in generating and representing data movement choreography
+// for each specific algorithm, hence it does not have a single, fixed
+// interpretation.  On first execution the runtime will update this
+// structure with decisions that will guide all subsequent executions.
+struct CollImplDetails {
+  string collective_name;
+  std::vector<std::vector<int>> subdiv_permutations;
+  // subdiv_offsets and max_subdivs_per_device are used together as follows:
+  // When subdiv_offsets is provided (non-empty) it is used as is. When
+  // subdiv_offsets is not provided subdivisons are generated dynamically
+  // constrained by max_subdivs_per_device. When subdiv_offsets is empty AND
+  // max_subdivs_per_device = 0 an internal default kMaxSubdivsPerDeviceDefault
+  // is used. When max_subdivs_per_device = -1, no subivision is done.
+  int max_subdivs_per_device = -1;  // Upper bound on subdivisions per device.
+  std::vector<int> subdiv_offsets;
+  std::vector<int> subdiv_source_rank;  // rank of source in each subdiv
+  std::vector<int32>
+      dependencies;           // collective instances on which this node depends
+  string communication_hint;  // user-supplied hint for implementation choice,
+                              // e.g. ring or nccl
+  float timeout_seconds;      // If non zero, set a completion timeout for the
+                              // collective op to detect staleness.
+};
+
+// Data common to all members of a collective instance.
+// TODO(b/163171014) Refactor this struct to not be a union of all fields.
+struct CollInstanceParams {
+  // Identifies all participating graph nodes.
+  int32 instance_key = -1;
+  // The full identifier includes both instance_key and step_id.
+  int64_t step_id = 0;
+  CollectiveType type = UNDEFINED_COLLECTIVE;
+  DataType data_type = DT_FLOAT;
+  TensorShape shape = {0};
+  CollImplDetails impl_details;
+  string ToString() const;
+  CollInstanceParams& operator=(const struct CollInstanceParams& other);
+  std::vector<string> devices;  // permuter only
+
+  // For permuter only
+  // Each rank in the permutation is a receiver.
+  // Indices of each rank means a sender to that rank.
+  // Example: permutation = {2,0,1} means
+  //   rank 0 sends to rank 2
+  //   rank 1 sends to rank 0
+  //   rank 2 sends to rank 1
+  std::vector<int> permutation;
+};
+
+// Unique to a single CollectiveOp node.
+struct CollectiveParams : public core::RefCounted {
+  CollGroupParams group;
+  CollInstanceParams instance;
+
+  string name = "";        // node name used only for log or error messages
+  int default_rank = -1;   // index of this op within device_names
+  bool is_source = false;  // broadcast only
+  int source_rank = -1;    // broadcast only
+  // Rank of this device in each subdivision permutation.
+  std::vector<int> subdiv_rank;
+  OpKernel* merge_op = nullptr;  // reduction only
+  OpKernel* final_op = nullptr;  // reduction only
+  string ToString() const;
+  bool run_group_initialization = true;
+  bool is_stateless = false;
+};
+
+class CollectiveExecutor;
+
+// Interface that provides resolution of device localities.
+class DeviceResolverInterface {
+ public:
+  virtual ~DeviceResolverInterface() {}
+
+  // Populates *attributes with the DeviceAttributes of the specified device.
+  virtual Status GetDeviceAttributes(const string& device,
+                                     DeviceAttributes* attributes) = 0;
+
+  // Returns all device attributes of a task.
+  virtual Status GetAllDeviceAttributes(
+      const string& task, std::vector<DeviceAttributes>* attributes) = 0;
+
+  // Updates device attributes. It returns error if any device already
+  // exists in the DeviceResolver and has a different incarnation.
+  virtual Status UpdateDeviceAttributes(
+      const std::vector<DeviceAttributes>& attributes) = 0;
+};
+
+// Interface that provides resolution of shared CollectiveParams fields.
+class ParamResolverInterface {
+ public:
+  virtual ~ParamResolverInterface() {}
+
+  // Called by each collective op at first execution in order to fill out
+  // the CollectiveParams structure with data gathered from the full
+  // (maybe distributed) collection of peer nodes.
+  virtual void CompleteParamsAsync(const DeviceAttributes& device,
+                                   CollectiveParams* cp,
+                                   CancellationManager* cancel_mgr,
+                                   const StatusCallback& done) = 0;
+
+  // Completes group_params with data gathered from all devices in the group.
+  // This blocks until all devices are there.
+  virtual void CompleteGroupAsync(const DeviceAttributes& device,
+                                  CollGroupParams* group_params,
+                                  CancellationManager* cancel_mgr,
+                                  const StatusCallback& done) = 0;
+
+  // Used within a distributed implementation to discover/verify data
+  // shared across an instance group.
+  // Note: this works differently from CompleteGroupAsync as a refactor is in
+  // progress.
+  virtual void CompleteInstanceAsync(const CompleteInstanceRequest* request,
+                                     CompleteInstanceResponse* response,
+                                     CancellationManager* cancel_mgr,
+                                     const StatusCallback& done) = 0;
+
+  // Looks up a group. It returns an error if the group is not ready or not
+  // found.
+  virtual Status LookupGroup(int32_t group_key, CollGroupParams* group) = 0;
+
+  // Aborts the resolver. After abortion the resolver can no longer be used.
+  virtual void StartAbort(const Status& s) = 0;
+};
+
+// Graphs which utilize Collective Ops in a common instance must
+// execute with identical step_ids even if they are disjoint graphs
+// run by otherwise independent tasks.  This interface supplies
+// coordinated step_ids to use in such cases.
+class StepSequenceInterface {
+ public:
+  virtual ~StepSequenceInterface() {}
+
+  // Used with a distributed implementation to coordinate step_id
+  // sequences across tasks.
+  virtual void GetStepSequenceAsync(const GetStepSequenceRequest* request,
+                                    GetStepSequenceResponse* response,
+                                    const StatusCallback& done) = 0;
+
+  // Refresh the local per-graph_key step_id sequence from collective
+  // group leader, if applicable.
+  virtual void RefreshStepIdSequenceAsync(int64_t graph_key,
+                                          const StatusCallback& done) = 0;
+
+  // Returns the step_id that should be used for initiating a new execution
+  // on the specified graph. May return the same step_id multiple times if
+  // RetireStepId or RefreshStepIdReservation is not called.
+  virtual int64_t NextStepId(int64_t graph_key) = 0;
+
+  // Reports that execution of the given step has completed successfully.
+  // Should be called immediately after a step completes with OK status,
+  // prior to calling NextStepId().  If the step fails, don't call.
+  virtual void RetireStepId(int64_t graph_key, int64_t step_id) = 0;
+};
+
+class NcclCommunicatorInterface;
+
+// Interface that provides access to per-step CollectiveExecutor
+// instances and various distributed resolution capabilities.
+class CollectiveExecutorMgrInterface : public StepSequenceInterface {
+ public:
+  virtual ~CollectiveExecutorMgrInterface() {}
+
+  // Returns the step-specific CollectiveExecutor, creating if one does not
+  // already exist.  The caller assumes ownership of one Ref on the object.
+  virtual CollectiveExecutor* FindOrCreate(int64_t step_id) = 0;
+
+  // If there is a CollectiveExecutor for step_id, remove it from the
+  // table.
+  virtual void Cleanup(int64_t step_id) = 0;
+
+  virtual ParamResolverInterface* GetParamResolver() const = 0;
+
+  virtual DeviceResolverInterface* GetDeviceResolver() const = 0;
+
+  virtual NcclCommunicatorInterface* GetNcclCommunicator() const = 0;
+};
+
+// Interface that a Collective Op implementation uses to exchange data
+// with peers.  Note that data exchange is currently limited to types
+// for which DMAHelper::CanUseDMA() returns true, i.e.  dense numeric
+// types.
+class CollectiveRemoteAccess {
+ public:
+  virtual ~CollectiveRemoteAccess() {}
+
+  virtual void RecvFromPeer(const string& peer_device, const string& peer_task,
+                            bool peer_is_local, const string& key,
+                            Device* to_device, DeviceContext* to_device_ctx,
+                            const AllocatorAttributes& to_alloc_attr,
+                            Tensor* to_tensor,
+                            const DeviceLocality& client_locality,
+                            int dev_to_dev_stream_index,
+                            CancellationManager* cancellation_manager,
+                            const StatusCallback& done) = 0;
+
+  virtual void PostToPeer(const string& peer_device, const string& peer_task,
+                          const string& key, Device* from_device,
+                          DeviceContext* from_device_ctx,
+                          const AllocatorAttributes& from_alloc_attr,
+                          const Tensor* from_tensor,
+                          const DeviceLocality& client_locality,
+                          CancellationManager* cancellation_manager,
+                          const StatusCallback& done) = 0;
+
+  // Checks the health of a collective peer. It probes the peer to see if it is
+  // alive. Note that if a peer has restarted, it's considered a different one,
+  // so CheckPeerHealth fails.
+  virtual void CheckPeerHealth(const string& peer_task, int64_t timeout_in_ms,
+                               const StatusCallback& done) = 0;
+
+  virtual BufRendezvous* buf_rendezvous() = 0;
+
+  virtual void StartAbort(const Status& s) = 0;
+};
+
+// A step-specific object that can execute a collective operation completely
+// described by a CollectiveParams object.
+class CollectiveExecutor : public core::RefCounted {
+ public:
+  virtual void StartAbort(const Status& s) {}
+
+  virtual void ExecuteAsync(OpKernelContext* ctx,
+                            const CollectiveParams* col_params,
+                            const string& exec_key, StatusCallback done) {
+    done(errors::Internal(
+        "A collective Op has been called in a context in which "
+        "a CollectiveExecutor has not been provided."));
+  }
+
+  virtual void CompleteParamsAsync(const DeviceAttributes& device,
+                                   CollectiveParams* cp,
+                                   CancellationManager* cancel_mgr,
+                                   StatusCallback done) {
+    done(errors::Internal(
+        "A collective Op has been called in a context in which "
+        "a CollectiveExecutor has not been provided."));
+  }
+
+  virtual void CompleteGroupAsync(const DeviceAttributes& device,
+                                  CollGroupParams* group_params,
+                                  CancellationManager* cancel_mgr,
+                                  StatusCallback done) {
+    return cem_->GetParamResolver()->CompleteGroupAsync(device, group_params,
+                                                        cancel_mgr, done);
+  }
+
+  virtual Status LookupGroup(int32_t group_key, CollGroupParams* group) {
+    return cem_->GetParamResolver()->LookupGroup(group_key, group);
+  }
+
+  // Runs the potentially-blocking closure/expensive callback.
+  virtual void RunClosure(std::function<void()> closure) = 0;
+
+  virtual CollectiveRemoteAccess* remote_access() { return nullptr; }
+
+  // `WaitForDependencies` and `Launched` are used for fine-grained control of
+  // execution order between collective instances.  These functions are intended
+  // to be called in `Run` function of collective implementations, and may be
+  // used to make part, or whole, of the collective execution ordered with
+  // respect to other collective instances.
+  //
+  // `WaitForDependencies` will block until it is safe to continue the callee's
+  // execution, where safety is defined as: ordered with respect to the
+  // collective instances defined in the callee's `wait_for` attribute.
+  virtual void WaitForDependencies(const CollectiveParams& col_params) {}
+  // `UnblockDependencies` unblocks the dependent collective instances by
+  // recording that this caller's device has completed the critical portion of
+  // the collective execution.
+  virtual void UnblockDependencies(const CollectiveParams& col_params) {}
+
+  // Used to designate an invalid group or instance key.
+  static int64_t kInvalidId;
+
+  // Lexically scoped handle for Ref.
+  class Handle {
+   public:
+    explicit Handle(CollectiveExecutor* ce, bool inherit_ref) : ce_(ce) {
+      if (!inherit_ref) ce->Ref();
+    }
+    ~Handle() { ce_->Unref(); }
+    CollectiveExecutor* get() const { return ce_; }
+
+   private:
+    CollectiveExecutor* ce_;
+  };
+
+ protected:
+  explicit CollectiveExecutor(CollectiveExecutorMgrInterface* cem)
+      : cem_(cem) {}
+
+  // For use only by derived classes
+  static OpKernelContext::Params* CtxParams(OpKernelContext* ctx);
+  CollectiveExecutorMgrInterface* cem_;
+
+  CollectiveExecutor(const CollectiveExecutor&) = delete;
+  void operator=(const CollectiveExecutor&) = delete;
+};
+
+struct CollectiveContext {
+  CollectiveExecutor* col_exec;                  // Not owned
+  NcclCommunicatorInterface* nccl_communicator;  // Not owned
+  const DeviceMgr* dev_mgr;                      // Not owned
+  OpKernelContext* op_ctx;                       // Not owned
+  OpKernelContext::Params* op_params;            // Not owned
+  core::IntrusivePtr<const CollectiveParams> col_params;
+  const string exec_key;
+  const int64_t step_id;
+  const Tensor* input;  // Not owned
+  Tensor* output;       // Not owned
+  Device* device;       // The device for which this instance labors
+  const string device_name;
+  DeviceLocality device_locality;
+
+  CollectiveContext(CollectiveExecutor* col_exec,
+                    NcclCommunicatorInterface* nccl_communicator,
+                    const DeviceMgr* dev_mgr, OpKernelContext* ctx,
+                    OpKernelContext::Params* op_params,
+                    const CollectiveParams* col_params, const string& exec_key,
+                    int64_t step_id, const Tensor* input, Tensor* output);
+};
+
+class NcclCommunicatorInterface {
+ public:
+  virtual ~NcclCommunicatorInterface() = default;
+
+  virtual string GenerateCommunicatorKey() = 0;
+
+  virtual void Enqueue(std::shared_ptr<CollectiveContext> col_ctx,
+                       StatusCallback done) = 0;
+
+  virtual void StartAbort(const Status& s) = 0;
+};
+
+// Interface of a Collective Op implementation.  Each specific CollectiveOp will
+// implement this interface and register the implementation via the
+// CollectiveRegistry detailed below.  See common_runtime/ring_reducer and
+// common_runtime/hierarchical_tree_broadcaster for examples.
+class CollectiveImplementationInterface : public core::RefCounted {
+ public:
+  virtual ~CollectiveImplementationInterface() = default;
+
+  // Initializes the portions of `col_params` specific to this
+  // implementation.  Called exactly once for every Collective instance during
+  // the CollectiveParams resolution process when the graph is first executed,
+  // at the end of `CompleteInstanceLocal()`.
+  // NOTE(ayushd): This is effectively a static function because it modifies the
+  // `col_params` passed in and should not manipulate any data members.  However
+  // because it is virtual and needs to be implemented by every derived class we
+  // do not mark it as static.
+  virtual Status InitializeCollectiveParams(CollectiveParams* col_params) = 0;
+
+  // Prepares the CollectiveContext for executing this CollectiveImplementation.
+  // Called from CollectiveExecutor right before calling Run().  The
+  // CollectiveContext passed in must outlive the CollectiveImplementation
+  // object.
+  virtual Status InitializeCollectiveContext(
+      std::shared_ptr<CollectiveContext> col_ctx) = 0;
+
+  // Processes and moves data according to the logic of this Collective
+  // implementation.  Relies on appropriate initialization of op-specific
+  // CollectiveParams in InitializeCollectiveParams(), as well as appropriate
+  // context initialization in InitializeCollectiveContext().
+  virtual void Run(StatusCallback done) = 0;
+};
+
+// Static-methods only class for registering and looking up collective
+// implementations.
+class CollectiveRegistry {
+ public:
+  using Factory = std::function<CollectiveImplementationInterface*()>;
+  // Looks up a previously registered CollectiveImplementation under
+  // `collective_name`.  If found, creates an instance of the implementation and
+  // assign to `implementation`.
+  static Status Lookup(const string& collective_name,
+                       CollectiveImplementationInterface** implementation);
+
+  // Looks up a previously registered CollectiveImplementation under
+  // `collective_name`.  If found, returns the static instance of this
+  // implementation via `implementation`.  This instance should only be used to
+  // call InitializateCollectiveParams.
+  static Status LookupParamResolverInstance(
+      const string& collective_name,
+      CollectiveImplementationInterface** implementation);
+
+  // Returns all registered collective implementations.
+  static void GetAll(
+      std::vector<CollectiveImplementationInterface*>* implementations);
+
+ private:
+  friend class CollectiveRegistration;
+  // Registers a CollectiveImplementation with name `collective_name` and
+  // factory `factory`.  The latter is a function used to create instances of
+  // the CollectiveImplementation.  Also creates a static instance of the
+  // implementation - this instance is used during param resolution and should
+  // only be used to call InitializeCollectiveParams.
+  static Status Register(const string& collective_name, Factory factory);
+
+  static Status LookupHelper(const string& collective_name,
+                             CollectiveImplementationInterface** implementation,
+                             bool param_resolver);
+};
+
+// Class used to call CollectiveRegistry::Register.  This should only be used to
+// create a global static object.
+class CollectiveRegistration {
+ public:
+  CollectiveRegistration(const string& collective_name,
+                         CollectiveRegistry::Factory factory) {
+    TF_CHECK_OK(CollectiveRegistry::Register(collective_name, factory));
+  }
+};
+
+#define REGISTER_COLLECTIVE(name, implementation)             \
+  static CollectiveRegistration register_##name##_collective( \
+      #name, []() { return new implementation; });
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_COLLECTIVE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/common_shape_fns.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/common_shape_fns.h
new file mode 100644
index 0000000000000000000000000000000000000000..ce65aa99d13706323c923fe8beedc89c055ef002
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/common_shape_fns.h
@@ -0,0 +1,304 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_FRAMEWORK_COMMON_SHAPE_FNS_H_
+#define TENSORFLOW_CORE_FRAMEWORK_COMMON_SHAPE_FNS_H_
+
+#include <array>
+
+#include "tensorflow/core/framework/shape_inference.h"
+#include "tensorflow/core/util/padding.h"
+#include "tensorflow/core/util/tensor_format.h"
+
+namespace tensorflow {
+
+namespace shape_inference {
+
+// Like GetWindowedOutputSize, but deals with DimensionHandles. Does not support
+// EXPLICIT padding.
+Status GetWindowedOutputSizeFromDims(InferenceContext* c,
+                                     DimensionHandle input_size,
+                                     DimensionOrConstant filter_size,
+                                     int64_t stride, Padding padding_type,
+                                     DimensionHandle* output_size);
+
+// The V2 version computes the same outputs with arbitrary dilation_rate, and
+// supports EXPLICIT padding. For detailed equations, refer to the comments
+// for GetWindowedOutputSize(). The 'padding_before' and 'padding_after'
+// parameters are only used if padding_type == EXPLICIT.
+Status GetWindowedOutputSizeFromDimsV2(
+    InferenceContext* c, DimensionHandle input_size,
+    DimensionOrConstant filter_size, int64_t dilation_rate, int64_t stride,
+    Padding padding_type, int64_t padding_before, int64_t padding_after,
+    DimensionHandle* output_size);
+
+// Transfers shape of input(0) to output(0).
+Status UnchangedShape(shape_inference::InferenceContext* c);
+
+// Transfers shape of input(0) to output(0), after asserting its rank is <rank>.
+inline Status UnchangedShapeWithRank(shape_inference::InferenceContext* c,
+                                     int32_t rank) {
+  ShapeHandle out;
+  TF_RETURN_IF_ERROR(c->WithRank(c->input(0), rank, &out));
+  c->set_output(0, out);
+  return OkStatus();
+}
+
+// Transfers shape of input(0) to output(0), after asserting its rank >= <rank>.
+inline Status UnchangedShapeWithRankAtLeast(
+    shape_inference::InferenceContext* c, int32_t rank) {
+  ShapeHandle out;
+  TF_RETURN_IF_ERROR(c->WithRankAtLeast(c->input(0), rank, &out));
+  c->set_output(0, out);
+  return OkStatus();
+}
+
+// Transfers shape of input(0) to output(0), after asserting its rank <= <rank>.
+inline Status UnchangedShapeWithRankAtMost(shape_inference::InferenceContext* c,
+                                           int32_t rank) {
+  ShapeHandle out;
+  TF_RETURN_IF_ERROR(c->WithRankAtMost(c->input(0), rank, &out));
+  c->set_output(0, out);
+  return OkStatus();
+}
+
+// Shape function for use with ops no outputs.
+inline Status NoOutputs(shape_inference::InferenceContext* c) {
+  return OkStatus();
+}
+
+// Shape function for ops that output a single scalar value.
+inline Status ScalarShape(shape_inference::InferenceContext* c) {
+  c->set_output(0, c->Scalar());
+  return OkStatus();
+}
+
+// Shape function for binary ops where both inputs and the output match.
+inline Status MergeBothInputsShapeFn(InferenceContext* c) {
+  ShapeHandle out;
+  TF_RETURN_IF_ERROR(c->Merge(c->input(0), c->input(1), &out));
+  c->set_output(0, out);
+  return OkStatus();
+}
+
+// Shape function for dataset iterators.
+Status DatasetIteratorShape(shape_inference::InferenceContext* c);
+
+// Returns a new shape with the specified dims arranged in the specified
+// format. The returned value is owned by this context.
+// Note: if format = "FORMAT_NCHW_VECT_C" then C represents the outer_depth.
+Status MakeShapeFromFormat(TensorFormat format, DimensionOrConstant N,
+                           const std::vector<DimensionOrConstant>& spatial,
+                           DimensionOrConstant C, ShapeHandle* out,
+                           shape_inference::InferenceContext* context);
+
+// Shape function for MatMul-like operations.
+Status MatMulShape(shape_inference::InferenceContext* c);
+
+// Shape function for Batched MatMul-like operations with broadcasting across
+// batch dimensions.
+Status BatchMatMulV2Shape(shape_inference::InferenceContext* c);
+
+// Shape function for BatchMatMul-like operations
+Status BatchMatMulShape(shape_inference::InferenceContext* c);
+
+// Shape function for Einsum.
+Status EinsumShape(shape_inference::InferenceContext* c);
+
+// Shape function for BiasAdd-like operations.
+Status BiasAddShape(shape_inference::InferenceContext* c);
+
+// Shape function for BiasAddGrad-like operations.
+Status BiasAddGradShape(shape_inference::InferenceContext* c);
+
+// Shape function for general Convolution operation
+Status ConvShape(shape_inference::InferenceContext* c);
+
+// Shape function for Conv2D-like operations that support explicit padding.
+Status Conv2DShapeWithExplicitPadding(shape_inference::InferenceContext* c);
+
+// Shape function for Conv2D-like operations that do not support explicit
+// padding.
+Status Conv2DShape(shape_inference::InferenceContext* c);
+
+// Shape function for Conv3D-like operations.
+Status Conv3DShape(shape_inference::InferenceContext* c);
+
+// Shape function for DepthwiseConv2D-like operations that support explicit
+// padding.
+Status DepthwiseConv2DNativeShapeWithExplicitPadding(
+    shape_inference::InferenceContext* c);
+
+// Shape function for DepthwiseConv2D-like operations that do not support
+// explicit padding.
+Status DepthwiseConv2DNativeShape(shape_inference::InferenceContext* c);
+
+// Shape function for Conv2DBackpropInput.
+Status Conv2DBackpropInputShape(shape_inference::InferenceContext* c);
+
+// Shape function for Conv2DBackpropFilterWithBias.
+Status Conv2DBackpropFilterWithBiasShape(shape_inference::InferenceContext* c);
+
+// Shape function for AvgPool-like operations.
+Status AvgPoolShape(shape_inference::InferenceContext* c);
+
+// Shape function for AvgPoolGrad-like operations.
+Status AvgPoolGradShape(shape_inference::InferenceContext* c);
+
+// Shape function for FusedBatchNorm and FusedBatchNormV2 operations.
+Status FusedBatchNormShape(shape_inference::InferenceContext* c);
+
+// Shape function for FusedBatchNormV3 operations.
+Status FusedBatchNormV3Shape(shape_inference::InferenceContext* c);
+
+// Shape function for _FusedBatchNormEx operations.
+Status FusedBatchNormExShape(shape_inference::InferenceContext* c);
+
+// Shape function for FusedBatchNormGrad and FusedBatchNormGradV2 operations.
+Status FusedBatchNormGradShape(shape_inference::InferenceContext* c);
+
+// Shape function for _FusedBatchNormGradEx operations.
+Status FusedBatchNormGradExShape(shape_inference::InferenceContext* c);
+
+// Shape function for MatrixDiagPartV2 and MatrixDiagPartV3 operations.
+Status MatrixDiagPartV2Shape(shape_inference::InferenceContext* c);
+
+// Shape function for MatrixDiagV2 and MatrixDiagV3 operations.
+Status MatrixDiagV2Shape(shape_inference::InferenceContext* c);
+
+// Shape function for MatrixSetDiagV2 and MatrixSetDiagV3 operations.
+Status MatrixSetDiagV2Shape(shape_inference::InferenceContext* c);
+
+// Shape function for MaxPool-like operations that support explicit padding.
+Status MaxPoolShapeWithExplicitPadding(shape_inference::InferenceContext* c);
+
+// Shape function for MaxPool-like operations that do not support explicit
+// padding.
+Status MaxPoolShape(shape_inference::InferenceContext* c);
+
+// Shape function for MaxPoolV2-like operations.
+Status MaxPoolV2Shape(shape_inference::InferenceContext* c, int num_inputs);
+
+// Shape function for MaxPoolGrad-like operations.
+Status MaxPoolGradShape(shape_inference::InferenceContext* c);
+
+// Shape function for 3D Pooling operations.
+Status Pool3DShape(shape_inference::InferenceContext* c);
+
+// Shape function for MaxPool3DGrad-like operations.
+Status MaxPool3DGradShape(shape_inference::InferenceContext* c);
+
+// Shape function for AvgPool3DGrad-like operations.
+Status AvgPool3DGradShape(shape_inference::InferenceContext* c);
+
+// Shape function for use with ops whose output shapes are unknown.
+Status UnknownShape(shape_inference::InferenceContext* c);
+
+// Shape function for reduction operations.
+Status ReductionShape(shape_inference::InferenceContext* c);
+
+// Shape function for unsorted segment operations.
+Status SegmentReductionWithNumSegmentsShapeFn(InferenceContext* c);
+
+// Shape function for concat operations.
+// <num_inputs_to_concat> is the number of inputs to concatenate and are taken
+// from inputs
+// [1,num_inputs_to_concat] of the op.  Input 0 is the concat_dim input.
+Status ConcatShape(shape_inference::InferenceContext* c,
+                   int num_inputs_to_concat);
+
+// Shape function for concat operations.
+Status ConcatV2Shape(shape_inference::InferenceContext* c);
+
+Status QuantizedConcatV2Shape(InferenceContext* c, int num_inputs_to_concat);
+
+// Shape function for binary operators that broadcast their inputs
+// and with output to output_index.
+// Note: out cannot be NULL.
+Status BroadcastBinaryOpOutputShapeFnHelper(InferenceContext* c,
+                                            ShapeHandle shape_x,
+                                            ShapeHandle shape_y,
+                                            bool incompatible_shape_error,
+                                            ShapeHandle* out);
+
+// Shape function for binary operators that broadcast their inputs
+// and with output to output_index.
+inline Status BroadcastBinaryOpOutputShapeFn(InferenceContext* c,
+                                             int output_index) {
+  ShapeHandle out;
+  TF_RETURN_IF_ERROR(BroadcastBinaryOpOutputShapeFnHelper(
+      c, c->input(0), c->input(1), true, &out));
+  c->set_output(output_index, out);
+  return OkStatus();
+}
+
+// Shape function for binary operators that broadcast their inputs.
+// Tested by ops/math_ops_test.cc.
+inline Status BroadcastBinaryOpShapeFn(InferenceContext* c) {
+  return BroadcastBinaryOpOutputShapeFn(c, 0);
+}
+
+// Shape function for random operations.
+Status RandomShape(shape_inference::InferenceContext* c);
+
+// Shape function for Slice operations.
+Status SliceShape(shape_inference::InferenceContext* c);
+
+// Validates the 3 component tensors of a sparse tensor have the proper
+// shapes. This mimics SparseTensor.__init__ in python/framework/ops.py.
+Status ValidateSparseTensor(InferenceContext* c, ShapeHandle indices_shape,
+                            ShapeHandle values_shape, ShapeHandle shape_shape);
+
+Status ValidateVariableResourceHandle(
+    InferenceContext* c, std::vector<ShapeAndType>* shape_and_type);
+
+// Shape function for GatherNd operations.
+Status GatherNdShape(InferenceContext* c);
+
+// Helper shape function for ScatterNd.../TensorScatter... operations.
+Status ScatterNdShapeHelper(InferenceContext* c, ShapeHandle indices_shape,
+                            ShapeHandle updates_shape, ShapeHandle input_shape);
+
+// Shape function for ops with an explicit "shape" attribute.
+Status ExplicitShape(InferenceContext* c);
+
+// Shape function for multiple-output ops with an explicit "shapes" attribute.
+Status ExplicitShapes(InferenceContext* c);
+
+// Shape function for SparseReduceMax and SparseReduceSum.
+Status SparseReduceShapeFn(InferenceContext* c);
+
+// Shape function for QuantizedConv2D op.
+Status QuantizedConv2DShape(InferenceContext* c);
+
+// Shape function for _QuantizedConv2D op/fusion.
+Status FusedQuantizedConv2DShape(InferenceContext* c);
+
+// Shape function for _QuantizedDepthwiseConv2D op/fusion.
+Status FusedQuantizedDepthwiseConv2D(InferenceContext* c);
+
+// Shape function for QuantizedAvgPool op
+Status QuantizedAvgPoolShape(InferenceContext* c);
+
+// Shape function for QuantizeV2 op
+Status QuantizeV2Shape(InferenceContext* c);
+
+// Shape function for ReduceScatter ops
+Status ReduceScatterShape(shape_inference::InferenceContext* c);
+
+}  // namespace shape_inference
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_COMMON_SHAPE_FNS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/control_flow.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/control_flow.h
new file mode 100644
index 0000000000000000000000000000000000000000..3cc270b323d92fc0ee01e3646db821e3cfff9429
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/control_flow.h
@@ -0,0 +1,58 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_CONTROL_FLOW_H_
+#define TENSORFLOW_CORE_FRAMEWORK_CONTROL_FLOW_H_
+
+#include "tensorflow/core/lib/hash/hash.h"
+#include "tensorflow/core/platform/logging.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+
+const uint64 kIllegalFrameId = ~0uLL;
+const int64_t kIllegalIterId = -1;
+
+// For the purpose of control flow, every tensor produced by TensorFlow is
+// conceptually tagged by a 'FrameAndIter'. FrameAndIter consists of a
+// 'frame_id' and an 'iter_id'. The tensor value it represents is produced
+// in the frame with frame_id at the iteration of iter_id.
+struct FrameAndIter {
+  uint64 frame_id = kIllegalFrameId;
+  int64_t iter_id = kIllegalIterId;
+
+  FrameAndIter() {}
+
+  FrameAndIter(uint64 frame, int64_t iter) {
+    frame_id = frame;
+    iter_id = iter;
+  }
+
+  bool operator==(const FrameAndIter& other) const {
+    return (frame_id == other.frame_id && iter_id == other.iter_id);
+  }
+};
+
+struct FrameAndIterHash {
+  size_t operator()(const FrameAndIter& key) const {
+    // Make sure there are no padding bytes that we don't want
+    CHECK_EQ(sizeof(uint64) + sizeof(int64_t), sizeof(FrameAndIter));
+    return Hash64(reinterpret_cast<const char*>(&key), sizeof(FrameAndIter));
+  }
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_CONTROL_FLOW_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/cost_graph.pb.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/cost_graph.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..d2d836b0a1d5373bc37126a43bdbed08a87d0a9f
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/cost_graph.pb.h
@@ -0,0 +1,1954 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: tensorflow/core/framework/cost_graph.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fcost_5fgraph_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fcost_5fgraph_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3021000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3021009 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+#include "tensorflow/core/framework/tensor_shape.pb.h"
+#include "tensorflow/core/framework/types.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_tensorflow_2fcore_2fframework_2fcost_5fgraph_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_tensorflow_2fcore_2fframework_2fcost_5fgraph_2eproto {
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_tensorflow_2fcore_2fframework_2fcost_5fgraph_2eproto;
+namespace tensorflow {
+class CostGraphDef;
+struct CostGraphDefDefaultTypeInternal;
+extern CostGraphDefDefaultTypeInternal _CostGraphDef_default_instance_;
+class CostGraphDef_AggregatedCost;
+struct CostGraphDef_AggregatedCostDefaultTypeInternal;
+extern CostGraphDef_AggregatedCostDefaultTypeInternal _CostGraphDef_AggregatedCost_default_instance_;
+class CostGraphDef_Node;
+struct CostGraphDef_NodeDefaultTypeInternal;
+extern CostGraphDef_NodeDefaultTypeInternal _CostGraphDef_Node_default_instance_;
+class CostGraphDef_Node_InputInfo;
+struct CostGraphDef_Node_InputInfoDefaultTypeInternal;
+extern CostGraphDef_Node_InputInfoDefaultTypeInternal _CostGraphDef_Node_InputInfo_default_instance_;
+class CostGraphDef_Node_OutputInfo;
+struct CostGraphDef_Node_OutputInfoDefaultTypeInternal;
+extern CostGraphDef_Node_OutputInfoDefaultTypeInternal _CostGraphDef_Node_OutputInfo_default_instance_;
+}  // namespace tensorflow
+PROTOBUF_NAMESPACE_OPEN
+template<> ::tensorflow::CostGraphDef* Arena::CreateMaybeMessage<::tensorflow::CostGraphDef>(Arena*);
+template<> ::tensorflow::CostGraphDef_AggregatedCost* Arena::CreateMaybeMessage<::tensorflow::CostGraphDef_AggregatedCost>(Arena*);
+template<> ::tensorflow::CostGraphDef_Node* Arena::CreateMaybeMessage<::tensorflow::CostGraphDef_Node>(Arena*);
+template<> ::tensorflow::CostGraphDef_Node_InputInfo* Arena::CreateMaybeMessage<::tensorflow::CostGraphDef_Node_InputInfo>(Arena*);
+template<> ::tensorflow::CostGraphDef_Node_OutputInfo* Arena::CreateMaybeMessage<::tensorflow::CostGraphDef_Node_OutputInfo>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace tensorflow {
+
+// ===================================================================
+
+class CostGraphDef_Node_InputInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.CostGraphDef.Node.InputInfo) */ {
+ public:
+  inline CostGraphDef_Node_InputInfo() : CostGraphDef_Node_InputInfo(nullptr) {}
+  ~CostGraphDef_Node_InputInfo() override;
+  explicit PROTOBUF_CONSTEXPR CostGraphDef_Node_InputInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  CostGraphDef_Node_InputInfo(const CostGraphDef_Node_InputInfo& from);
+  CostGraphDef_Node_InputInfo(CostGraphDef_Node_InputInfo&& from) noexcept
+    : CostGraphDef_Node_InputInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline CostGraphDef_Node_InputInfo& operator=(const CostGraphDef_Node_InputInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline CostGraphDef_Node_InputInfo& operator=(CostGraphDef_Node_InputInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const CostGraphDef_Node_InputInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const CostGraphDef_Node_InputInfo* internal_default_instance() {
+    return reinterpret_cast<const CostGraphDef_Node_InputInfo*>(
+               &_CostGraphDef_Node_InputInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(CostGraphDef_Node_InputInfo& a, CostGraphDef_Node_InputInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(CostGraphDef_Node_InputInfo* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(CostGraphDef_Node_InputInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  CostGraphDef_Node_InputInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<CostGraphDef_Node_InputInfo>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const CostGraphDef_Node_InputInfo& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const CostGraphDef_Node_InputInfo& from) {
+    CostGraphDef_Node_InputInfo::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(CostGraphDef_Node_InputInfo* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.CostGraphDef.Node.InputInfo";
+  }
+  protected:
+  explicit CostGraphDef_Node_InputInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kPrecedingNodeFieldNumber = 1,
+    kPrecedingPortFieldNumber = 2,
+  };
+  // int32 preceding_node = 1;
+  void clear_preceding_node();
+  int32_t preceding_node() const;
+  void set_preceding_node(int32_t value);
+  private:
+  int32_t _internal_preceding_node() const;
+  void _internal_set_preceding_node(int32_t value);
+  public:
+
+  // int32 preceding_port = 2;
+  void clear_preceding_port();
+  int32_t preceding_port() const;
+  void set_preceding_port(int32_t value);
+  private:
+  int32_t _internal_preceding_port() const;
+  void _internal_set_preceding_port(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.CostGraphDef.Node.InputInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    int32_t preceding_node_;
+    int32_t preceding_port_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fcost_5fgraph_2eproto;
+};
+// -------------------------------------------------------------------
+
+class CostGraphDef_Node_OutputInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.CostGraphDef.Node.OutputInfo) */ {
+ public:
+  inline CostGraphDef_Node_OutputInfo() : CostGraphDef_Node_OutputInfo(nullptr) {}
+  ~CostGraphDef_Node_OutputInfo() override;
+  explicit PROTOBUF_CONSTEXPR CostGraphDef_Node_OutputInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  CostGraphDef_Node_OutputInfo(const CostGraphDef_Node_OutputInfo& from);
+  CostGraphDef_Node_OutputInfo(CostGraphDef_Node_OutputInfo&& from) noexcept
+    : CostGraphDef_Node_OutputInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline CostGraphDef_Node_OutputInfo& operator=(const CostGraphDef_Node_OutputInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline CostGraphDef_Node_OutputInfo& operator=(CostGraphDef_Node_OutputInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const CostGraphDef_Node_OutputInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const CostGraphDef_Node_OutputInfo* internal_default_instance() {
+    return reinterpret_cast<const CostGraphDef_Node_OutputInfo*>(
+               &_CostGraphDef_Node_OutputInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(CostGraphDef_Node_OutputInfo& a, CostGraphDef_Node_OutputInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(CostGraphDef_Node_OutputInfo* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(CostGraphDef_Node_OutputInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  CostGraphDef_Node_OutputInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<CostGraphDef_Node_OutputInfo>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const CostGraphDef_Node_OutputInfo& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const CostGraphDef_Node_OutputInfo& from) {
+    CostGraphDef_Node_OutputInfo::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(CostGraphDef_Node_OutputInfo* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.CostGraphDef.Node.OutputInfo";
+  }
+  protected:
+  explicit CostGraphDef_Node_OutputInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kShapeFieldNumber = 3,
+    kSizeFieldNumber = 1,
+    kAliasInputPortFieldNumber = 2,
+    kDtypeFieldNumber = 4,
+  };
+  // .tensorflow.TensorShapeProto shape = 3;
+  bool has_shape() const;
+  private:
+  bool _internal_has_shape() const;
+  public:
+  void clear_shape();
+  const ::tensorflow::TensorShapeProto& shape() const;
+  PROTOBUF_NODISCARD ::tensorflow::TensorShapeProto* release_shape();
+  ::tensorflow::TensorShapeProto* mutable_shape();
+  void set_allocated_shape(::tensorflow::TensorShapeProto* shape);
+  private:
+  const ::tensorflow::TensorShapeProto& _internal_shape() const;
+  ::tensorflow::TensorShapeProto* _internal_mutable_shape();
+  public:
+  void unsafe_arena_set_allocated_shape(
+      ::tensorflow::TensorShapeProto* shape);
+  ::tensorflow::TensorShapeProto* unsafe_arena_release_shape();
+
+  // int64 size = 1;
+  void clear_size();
+  int64_t size() const;
+  void set_size(int64_t value);
+  private:
+  int64_t _internal_size() const;
+  void _internal_set_size(int64_t value);
+  public:
+
+  // int64 alias_input_port = 2;
+  void clear_alias_input_port();
+  int64_t alias_input_port() const;
+  void set_alias_input_port(int64_t value);
+  private:
+  int64_t _internal_alias_input_port() const;
+  void _internal_set_alias_input_port(int64_t value);
+  public:
+
+  // .tensorflow.DataType dtype = 4;
+  void clear_dtype();
+  ::tensorflow::DataType dtype() const;
+  void set_dtype(::tensorflow::DataType value);
+  private:
+  ::tensorflow::DataType _internal_dtype() const;
+  void _internal_set_dtype(::tensorflow::DataType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.CostGraphDef.Node.OutputInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::tensorflow::TensorShapeProto* shape_;
+    int64_t size_;
+    int64_t alias_input_port_;
+    int dtype_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fcost_5fgraph_2eproto;
+};
+// -------------------------------------------------------------------
+
+class CostGraphDef_Node final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.CostGraphDef.Node) */ {
+ public:
+  inline CostGraphDef_Node() : CostGraphDef_Node(nullptr) {}
+  ~CostGraphDef_Node() override;
+  explicit PROTOBUF_CONSTEXPR CostGraphDef_Node(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  CostGraphDef_Node(const CostGraphDef_Node& from);
+  CostGraphDef_Node(CostGraphDef_Node&& from) noexcept
+    : CostGraphDef_Node() {
+    *this = ::std::move(from);
+  }
+
+  inline CostGraphDef_Node& operator=(const CostGraphDef_Node& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline CostGraphDef_Node& operator=(CostGraphDef_Node&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const CostGraphDef_Node& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const CostGraphDef_Node* internal_default_instance() {
+    return reinterpret_cast<const CostGraphDef_Node*>(
+               &_CostGraphDef_Node_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(CostGraphDef_Node& a, CostGraphDef_Node& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(CostGraphDef_Node* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(CostGraphDef_Node* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  CostGraphDef_Node* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<CostGraphDef_Node>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const CostGraphDef_Node& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const CostGraphDef_Node& from) {
+    CostGraphDef_Node::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(CostGraphDef_Node* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.CostGraphDef.Node";
+  }
+  protected:
+  explicit CostGraphDef_Node(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef CostGraphDef_Node_InputInfo InputInfo;
+  typedef CostGraphDef_Node_OutputInfo OutputInfo;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kInputInfoFieldNumber = 4,
+    kOutputInfoFieldNumber = 5,
+    kControlInputFieldNumber = 8,
+    kNameFieldNumber = 1,
+    kDeviceFieldNumber = 2,
+    kTemporaryMemorySizeFieldNumber = 6,
+    kComputeCostFieldNumber = 9,
+    kIdFieldNumber = 3,
+    kIsFinalFieldNumber = 7,
+    kInaccurateFieldNumber = 17,
+    kHostTempMemorySizeFieldNumber = 10,
+    kDeviceTempMemorySizeFieldNumber = 11,
+    kPersistentMemorySizeFieldNumber = 12,
+    kComputeTimeFieldNumber = 14,
+    kMemoryTimeFieldNumber = 15,
+    kDevicePersistentMemorySizeFieldNumber = 16,
+  };
+  // repeated .tensorflow.CostGraphDef.Node.InputInfo input_info = 4;
+  int input_info_size() const;
+  private:
+  int _internal_input_info_size() const;
+  public:
+  void clear_input_info();
+  ::tensorflow::CostGraphDef_Node_InputInfo* mutable_input_info(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::CostGraphDef_Node_InputInfo >*
+      mutable_input_info();
+  private:
+  const ::tensorflow::CostGraphDef_Node_InputInfo& _internal_input_info(int index) const;
+  ::tensorflow::CostGraphDef_Node_InputInfo* _internal_add_input_info();
+  public:
+  const ::tensorflow::CostGraphDef_Node_InputInfo& input_info(int index) const;
+  ::tensorflow::CostGraphDef_Node_InputInfo* add_input_info();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::CostGraphDef_Node_InputInfo >&
+      input_info() const;
+
+  // repeated .tensorflow.CostGraphDef.Node.OutputInfo output_info = 5;
+  int output_info_size() const;
+  private:
+  int _internal_output_info_size() const;
+  public:
+  void clear_output_info();
+  ::tensorflow::CostGraphDef_Node_OutputInfo* mutable_output_info(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::CostGraphDef_Node_OutputInfo >*
+      mutable_output_info();
+  private:
+  const ::tensorflow::CostGraphDef_Node_OutputInfo& _internal_output_info(int index) const;
+  ::tensorflow::CostGraphDef_Node_OutputInfo* _internal_add_output_info();
+  public:
+  const ::tensorflow::CostGraphDef_Node_OutputInfo& output_info(int index) const;
+  ::tensorflow::CostGraphDef_Node_OutputInfo* add_output_info();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::CostGraphDef_Node_OutputInfo >&
+      output_info() const;
+
+  // repeated int32 control_input = 8;
+  int control_input_size() const;
+  private:
+  int _internal_control_input_size() const;
+  public:
+  void clear_control_input();
+  private:
+  int32_t _internal_control_input(int index) const;
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+      _internal_control_input() const;
+  void _internal_add_control_input(int32_t value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+      _internal_mutable_control_input();
+  public:
+  int32_t control_input(int index) const;
+  void set_control_input(int index, int32_t value);
+  void add_control_input(int32_t value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+      control_input() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+      mutable_control_input();
+
+  // string name = 1;
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // string device = 2;
+  void clear_device();
+  const std::string& device() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_device(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_device();
+  PROTOBUF_NODISCARD std::string* release_device();
+  void set_allocated_device(std::string* device);
+  private:
+  const std::string& _internal_device() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_device(const std::string& value);
+  std::string* _internal_mutable_device();
+  public:
+
+  // int64 temporary_memory_size = 6;
+  void clear_temporary_memory_size();
+  int64_t temporary_memory_size() const;
+  void set_temporary_memory_size(int64_t value);
+  private:
+  int64_t _internal_temporary_memory_size() const;
+  void _internal_set_temporary_memory_size(int64_t value);
+  public:
+
+  // int64 compute_cost = 9;
+  void clear_compute_cost();
+  int64_t compute_cost() const;
+  void set_compute_cost(int64_t value);
+  private:
+  int64_t _internal_compute_cost() const;
+  void _internal_set_compute_cost(int64_t value);
+  public:
+
+  // int32 id = 3;
+  void clear_id();
+  int32_t id() const;
+  void set_id(int32_t value);
+  private:
+  int32_t _internal_id() const;
+  void _internal_set_id(int32_t value);
+  public:
+
+  // bool is_final = 7;
+  void clear_is_final();
+  bool is_final() const;
+  void set_is_final(bool value);
+  private:
+  bool _internal_is_final() const;
+  void _internal_set_is_final(bool value);
+  public:
+
+  // bool inaccurate = 17;
+  void clear_inaccurate();
+  bool inaccurate() const;
+  void set_inaccurate(bool value);
+  private:
+  bool _internal_inaccurate() const;
+  void _internal_set_inaccurate(bool value);
+  public:
+
+  // int64 host_temp_memory_size = 10 [deprecated = true];
+  PROTOBUF_DEPRECATED void clear_host_temp_memory_size();
+  PROTOBUF_DEPRECATED int64_t host_temp_memory_size() const;
+  PROTOBUF_DEPRECATED void set_host_temp_memory_size(int64_t value);
+  private:
+  int64_t _internal_host_temp_memory_size() const;
+  void _internal_set_host_temp_memory_size(int64_t value);
+  public:
+
+  // int64 device_temp_memory_size = 11 [deprecated = true];
+  PROTOBUF_DEPRECATED void clear_device_temp_memory_size();
+  PROTOBUF_DEPRECATED int64_t device_temp_memory_size() const;
+  PROTOBUF_DEPRECATED void set_device_temp_memory_size(int64_t value);
+  private:
+  int64_t _internal_device_temp_memory_size() const;
+  void _internal_set_device_temp_memory_size(int64_t value);
+  public:
+
+  // int64 persistent_memory_size = 12;
+  void clear_persistent_memory_size();
+  int64_t persistent_memory_size() const;
+  void set_persistent_memory_size(int64_t value);
+  private:
+  int64_t _internal_persistent_memory_size() const;
+  void _internal_set_persistent_memory_size(int64_t value);
+  public:
+
+  // int64 compute_time = 14;
+  void clear_compute_time();
+  int64_t compute_time() const;
+  void set_compute_time(int64_t value);
+  private:
+  int64_t _internal_compute_time() const;
+  void _internal_set_compute_time(int64_t value);
+  public:
+
+  // int64 memory_time = 15;
+  void clear_memory_time();
+  int64_t memory_time() const;
+  void set_memory_time(int64_t value);
+  private:
+  int64_t _internal_memory_time() const;
+  void _internal_set_memory_time(int64_t value);
+  public:
+
+  // int64 device_persistent_memory_size = 16 [deprecated = true];
+  PROTOBUF_DEPRECATED void clear_device_persistent_memory_size();
+  PROTOBUF_DEPRECATED int64_t device_persistent_memory_size() const;
+  PROTOBUF_DEPRECATED void set_device_persistent_memory_size(int64_t value);
+  private:
+  int64_t _internal_device_persistent_memory_size() const;
+  void _internal_set_device_persistent_memory_size(int64_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.CostGraphDef.Node)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::CostGraphDef_Node_InputInfo > input_info_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::CostGraphDef_Node_OutputInfo > output_info_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > control_input_;
+    mutable std::atomic<int> _control_input_cached_byte_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_;
+    int64_t temporary_memory_size_;
+    int64_t compute_cost_;
+    int32_t id_;
+    bool is_final_;
+    bool inaccurate_;
+    int64_t host_temp_memory_size_;
+    int64_t device_temp_memory_size_;
+    int64_t persistent_memory_size_;
+    int64_t compute_time_;
+    int64_t memory_time_;
+    int64_t device_persistent_memory_size_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fcost_5fgraph_2eproto;
+};
+// -------------------------------------------------------------------
+
+class CostGraphDef_AggregatedCost final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.CostGraphDef.AggregatedCost) */ {
+ public:
+  inline CostGraphDef_AggregatedCost() : CostGraphDef_AggregatedCost(nullptr) {}
+  ~CostGraphDef_AggregatedCost() override;
+  explicit PROTOBUF_CONSTEXPR CostGraphDef_AggregatedCost(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  CostGraphDef_AggregatedCost(const CostGraphDef_AggregatedCost& from);
+  CostGraphDef_AggregatedCost(CostGraphDef_AggregatedCost&& from) noexcept
+    : CostGraphDef_AggregatedCost() {
+    *this = ::std::move(from);
+  }
+
+  inline CostGraphDef_AggregatedCost& operator=(const CostGraphDef_AggregatedCost& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline CostGraphDef_AggregatedCost& operator=(CostGraphDef_AggregatedCost&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const CostGraphDef_AggregatedCost& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const CostGraphDef_AggregatedCost* internal_default_instance() {
+    return reinterpret_cast<const CostGraphDef_AggregatedCost*>(
+               &_CostGraphDef_AggregatedCost_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  friend void swap(CostGraphDef_AggregatedCost& a, CostGraphDef_AggregatedCost& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(CostGraphDef_AggregatedCost* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(CostGraphDef_AggregatedCost* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  CostGraphDef_AggregatedCost* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<CostGraphDef_AggregatedCost>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const CostGraphDef_AggregatedCost& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const CostGraphDef_AggregatedCost& from) {
+    CostGraphDef_AggregatedCost::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(CostGraphDef_AggregatedCost* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.CostGraphDef.AggregatedCost";
+  }
+  protected:
+  explicit CostGraphDef_AggregatedCost(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDimensionFieldNumber = 2,
+    kCostFieldNumber = 1,
+  };
+  // string dimension = 2;
+  void clear_dimension();
+  const std::string& dimension() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_dimension(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_dimension();
+  PROTOBUF_NODISCARD std::string* release_dimension();
+  void set_allocated_dimension(std::string* dimension);
+  private:
+  const std::string& _internal_dimension() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_dimension(const std::string& value);
+  std::string* _internal_mutable_dimension();
+  public:
+
+  // float cost = 1;
+  void clear_cost();
+  float cost() const;
+  void set_cost(float value);
+  private:
+  float _internal_cost() const;
+  void _internal_set_cost(float value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.CostGraphDef.AggregatedCost)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr dimension_;
+    float cost_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fcost_5fgraph_2eproto;
+};
+// -------------------------------------------------------------------
+
+class CostGraphDef final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.CostGraphDef) */ {
+ public:
+  inline CostGraphDef() : CostGraphDef(nullptr) {}
+  ~CostGraphDef() override;
+  explicit PROTOBUF_CONSTEXPR CostGraphDef(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  CostGraphDef(const CostGraphDef& from);
+  CostGraphDef(CostGraphDef&& from) noexcept
+    : CostGraphDef() {
+    *this = ::std::move(from);
+  }
+
+  inline CostGraphDef& operator=(const CostGraphDef& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline CostGraphDef& operator=(CostGraphDef&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const CostGraphDef& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const CostGraphDef* internal_default_instance() {
+    return reinterpret_cast<const CostGraphDef*>(
+               &_CostGraphDef_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    4;
+
+  friend void swap(CostGraphDef& a, CostGraphDef& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(CostGraphDef* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(CostGraphDef* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  CostGraphDef* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<CostGraphDef>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const CostGraphDef& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const CostGraphDef& from) {
+    CostGraphDef::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(CostGraphDef* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.CostGraphDef";
+  }
+  protected:
+  explicit CostGraphDef(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef CostGraphDef_Node Node;
+  typedef CostGraphDef_AggregatedCost AggregatedCost;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNodeFieldNumber = 1,
+    kCostFieldNumber = 2,
+  };
+  // repeated .tensorflow.CostGraphDef.Node node = 1;
+  int node_size() const;
+  private:
+  int _internal_node_size() const;
+  public:
+  void clear_node();
+  ::tensorflow::CostGraphDef_Node* mutable_node(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::CostGraphDef_Node >*
+      mutable_node();
+  private:
+  const ::tensorflow::CostGraphDef_Node& _internal_node(int index) const;
+  ::tensorflow::CostGraphDef_Node* _internal_add_node();
+  public:
+  const ::tensorflow::CostGraphDef_Node& node(int index) const;
+  ::tensorflow::CostGraphDef_Node* add_node();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::CostGraphDef_Node >&
+      node() const;
+
+  // repeated .tensorflow.CostGraphDef.AggregatedCost cost = 2;
+  int cost_size() const;
+  private:
+  int _internal_cost_size() const;
+  public:
+  void clear_cost();
+  ::tensorflow::CostGraphDef_AggregatedCost* mutable_cost(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::CostGraphDef_AggregatedCost >*
+      mutable_cost();
+  private:
+  const ::tensorflow::CostGraphDef_AggregatedCost& _internal_cost(int index) const;
+  ::tensorflow::CostGraphDef_AggregatedCost* _internal_add_cost();
+  public:
+  const ::tensorflow::CostGraphDef_AggregatedCost& cost(int index) const;
+  ::tensorflow::CostGraphDef_AggregatedCost* add_cost();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::CostGraphDef_AggregatedCost >&
+      cost() const;
+
+  // @@protoc_insertion_point(class_scope:tensorflow.CostGraphDef)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::CostGraphDef_Node > node_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::CostGraphDef_AggregatedCost > cost_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fcost_5fgraph_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// CostGraphDef_Node_InputInfo
+
+// int32 preceding_node = 1;
+inline void CostGraphDef_Node_InputInfo::clear_preceding_node() {
+  _impl_.preceding_node_ = 0;
+}
+inline int32_t CostGraphDef_Node_InputInfo::_internal_preceding_node() const {
+  return _impl_.preceding_node_;
+}
+inline int32_t CostGraphDef_Node_InputInfo::preceding_node() const {
+  // @@protoc_insertion_point(field_get:tensorflow.CostGraphDef.Node.InputInfo.preceding_node)
+  return _internal_preceding_node();
+}
+inline void CostGraphDef_Node_InputInfo::_internal_set_preceding_node(int32_t value) {
+  
+  _impl_.preceding_node_ = value;
+}
+inline void CostGraphDef_Node_InputInfo::set_preceding_node(int32_t value) {
+  _internal_set_preceding_node(value);
+  // @@protoc_insertion_point(field_set:tensorflow.CostGraphDef.Node.InputInfo.preceding_node)
+}
+
+// int32 preceding_port = 2;
+inline void CostGraphDef_Node_InputInfo::clear_preceding_port() {
+  _impl_.preceding_port_ = 0;
+}
+inline int32_t CostGraphDef_Node_InputInfo::_internal_preceding_port() const {
+  return _impl_.preceding_port_;
+}
+inline int32_t CostGraphDef_Node_InputInfo::preceding_port() const {
+  // @@protoc_insertion_point(field_get:tensorflow.CostGraphDef.Node.InputInfo.preceding_port)
+  return _internal_preceding_port();
+}
+inline void CostGraphDef_Node_InputInfo::_internal_set_preceding_port(int32_t value) {
+  
+  _impl_.preceding_port_ = value;
+}
+inline void CostGraphDef_Node_InputInfo::set_preceding_port(int32_t value) {
+  _internal_set_preceding_port(value);
+  // @@protoc_insertion_point(field_set:tensorflow.CostGraphDef.Node.InputInfo.preceding_port)
+}
+
+// -------------------------------------------------------------------
+
+// CostGraphDef_Node_OutputInfo
+
+// int64 size = 1;
+inline void CostGraphDef_Node_OutputInfo::clear_size() {
+  _impl_.size_ = int64_t{0};
+}
+inline int64_t CostGraphDef_Node_OutputInfo::_internal_size() const {
+  return _impl_.size_;
+}
+inline int64_t CostGraphDef_Node_OutputInfo::size() const {
+  // @@protoc_insertion_point(field_get:tensorflow.CostGraphDef.Node.OutputInfo.size)
+  return _internal_size();
+}
+inline void CostGraphDef_Node_OutputInfo::_internal_set_size(int64_t value) {
+  
+  _impl_.size_ = value;
+}
+inline void CostGraphDef_Node_OutputInfo::set_size(int64_t value) {
+  _internal_set_size(value);
+  // @@protoc_insertion_point(field_set:tensorflow.CostGraphDef.Node.OutputInfo.size)
+}
+
+// int64 alias_input_port = 2;
+inline void CostGraphDef_Node_OutputInfo::clear_alias_input_port() {
+  _impl_.alias_input_port_ = int64_t{0};
+}
+inline int64_t CostGraphDef_Node_OutputInfo::_internal_alias_input_port() const {
+  return _impl_.alias_input_port_;
+}
+inline int64_t CostGraphDef_Node_OutputInfo::alias_input_port() const {
+  // @@protoc_insertion_point(field_get:tensorflow.CostGraphDef.Node.OutputInfo.alias_input_port)
+  return _internal_alias_input_port();
+}
+inline void CostGraphDef_Node_OutputInfo::_internal_set_alias_input_port(int64_t value) {
+  
+  _impl_.alias_input_port_ = value;
+}
+inline void CostGraphDef_Node_OutputInfo::set_alias_input_port(int64_t value) {
+  _internal_set_alias_input_port(value);
+  // @@protoc_insertion_point(field_set:tensorflow.CostGraphDef.Node.OutputInfo.alias_input_port)
+}
+
+// .tensorflow.TensorShapeProto shape = 3;
+inline bool CostGraphDef_Node_OutputInfo::_internal_has_shape() const {
+  return this != internal_default_instance() && _impl_.shape_ != nullptr;
+}
+inline bool CostGraphDef_Node_OutputInfo::has_shape() const {
+  return _internal_has_shape();
+}
+inline const ::tensorflow::TensorShapeProto& CostGraphDef_Node_OutputInfo::_internal_shape() const {
+  const ::tensorflow::TensorShapeProto* p = _impl_.shape_;
+  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::TensorShapeProto&>(
+      ::tensorflow::_TensorShapeProto_default_instance_);
+}
+inline const ::tensorflow::TensorShapeProto& CostGraphDef_Node_OutputInfo::shape() const {
+  // @@protoc_insertion_point(field_get:tensorflow.CostGraphDef.Node.OutputInfo.shape)
+  return _internal_shape();
+}
+inline void CostGraphDef_Node_OutputInfo::unsafe_arena_set_allocated_shape(
+    ::tensorflow::TensorShapeProto* shape) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.shape_);
+  }
+  _impl_.shape_ = shape;
+  if (shape) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.CostGraphDef.Node.OutputInfo.shape)
+}
+inline ::tensorflow::TensorShapeProto* CostGraphDef_Node_OutputInfo::release_shape() {
+  
+  ::tensorflow::TensorShapeProto* temp = _impl_.shape_;
+  _impl_.shape_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::tensorflow::TensorShapeProto* CostGraphDef_Node_OutputInfo::unsafe_arena_release_shape() {
+  // @@protoc_insertion_point(field_release:tensorflow.CostGraphDef.Node.OutputInfo.shape)
+  
+  ::tensorflow::TensorShapeProto* temp = _impl_.shape_;
+  _impl_.shape_ = nullptr;
+  return temp;
+}
+inline ::tensorflow::TensorShapeProto* CostGraphDef_Node_OutputInfo::_internal_mutable_shape() {
+  
+  if (_impl_.shape_ == nullptr) {
+    auto* p = CreateMaybeMessage<::tensorflow::TensorShapeProto>(GetArenaForAllocation());
+    _impl_.shape_ = p;
+  }
+  return _impl_.shape_;
+}
+inline ::tensorflow::TensorShapeProto* CostGraphDef_Node_OutputInfo::mutable_shape() {
+  ::tensorflow::TensorShapeProto* _msg = _internal_mutable_shape();
+  // @@protoc_insertion_point(field_mutable:tensorflow.CostGraphDef.Node.OutputInfo.shape)
+  return _msg;
+}
+inline void CostGraphDef_Node_OutputInfo::set_allocated_shape(::tensorflow::TensorShapeProto* shape) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.shape_);
+  }
+  if (shape) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(shape));
+    if (message_arena != submessage_arena) {
+      shape = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, shape, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.shape_ = shape;
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.CostGraphDef.Node.OutputInfo.shape)
+}
+
+// .tensorflow.DataType dtype = 4;
+inline void CostGraphDef_Node_OutputInfo::clear_dtype() {
+  _impl_.dtype_ = 0;
+}
+inline ::tensorflow::DataType CostGraphDef_Node_OutputInfo::_internal_dtype() const {
+  return static_cast< ::tensorflow::DataType >(_impl_.dtype_);
+}
+inline ::tensorflow::DataType CostGraphDef_Node_OutputInfo::dtype() const {
+  // @@protoc_insertion_point(field_get:tensorflow.CostGraphDef.Node.OutputInfo.dtype)
+  return _internal_dtype();
+}
+inline void CostGraphDef_Node_OutputInfo::_internal_set_dtype(::tensorflow::DataType value) {
+  
+  _impl_.dtype_ = value;
+}
+inline void CostGraphDef_Node_OutputInfo::set_dtype(::tensorflow::DataType value) {
+  _internal_set_dtype(value);
+  // @@protoc_insertion_point(field_set:tensorflow.CostGraphDef.Node.OutputInfo.dtype)
+}
+
+// -------------------------------------------------------------------
+
+// CostGraphDef_Node
+
+// string name = 1;
+inline void CostGraphDef_Node::clear_name() {
+  _impl_.name_.ClearToEmpty();
+}
+inline const std::string& CostGraphDef_Node::name() const {
+  // @@protoc_insertion_point(field_get:tensorflow.CostGraphDef.Node.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void CostGraphDef_Node::set_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.CostGraphDef.Node.name)
+}
+inline std::string* CostGraphDef_Node::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:tensorflow.CostGraphDef.Node.name)
+  return _s;
+}
+inline const std::string& CostGraphDef_Node::_internal_name() const {
+  return _impl_.name_.Get();
+}
+inline void CostGraphDef_Node::_internal_set_name(const std::string& value) {
+  
+  _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* CostGraphDef_Node::_internal_mutable_name() {
+  
+  return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* CostGraphDef_Node::release_name() {
+  // @@protoc_insertion_point(field_release:tensorflow.CostGraphDef.Node.name)
+  return _impl_.name_.Release();
+}
+inline void CostGraphDef_Node::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.CostGraphDef.Node.name)
+}
+
+// string device = 2;
+inline void CostGraphDef_Node::clear_device() {
+  _impl_.device_.ClearToEmpty();
+}
+inline const std::string& CostGraphDef_Node::device() const {
+  // @@protoc_insertion_point(field_get:tensorflow.CostGraphDef.Node.device)
+  return _internal_device();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void CostGraphDef_Node::set_device(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.device_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.CostGraphDef.Node.device)
+}
+inline std::string* CostGraphDef_Node::mutable_device() {
+  std::string* _s = _internal_mutable_device();
+  // @@protoc_insertion_point(field_mutable:tensorflow.CostGraphDef.Node.device)
+  return _s;
+}
+inline const std::string& CostGraphDef_Node::_internal_device() const {
+  return _impl_.device_.Get();
+}
+inline void CostGraphDef_Node::_internal_set_device(const std::string& value) {
+  
+  _impl_.device_.Set(value, GetArenaForAllocation());
+}
+inline std::string* CostGraphDef_Node::_internal_mutable_device() {
+  
+  return _impl_.device_.Mutable(GetArenaForAllocation());
+}
+inline std::string* CostGraphDef_Node::release_device() {
+  // @@protoc_insertion_point(field_release:tensorflow.CostGraphDef.Node.device)
+  return _impl_.device_.Release();
+}
+inline void CostGraphDef_Node::set_allocated_device(std::string* device) {
+  if (device != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.device_.SetAllocated(device, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.device_.IsDefault()) {
+    _impl_.device_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.CostGraphDef.Node.device)
+}
+
+// int32 id = 3;
+inline void CostGraphDef_Node::clear_id() {
+  _impl_.id_ = 0;
+}
+inline int32_t CostGraphDef_Node::_internal_id() const {
+  return _impl_.id_;
+}
+inline int32_t CostGraphDef_Node::id() const {
+  // @@protoc_insertion_point(field_get:tensorflow.CostGraphDef.Node.id)
+  return _internal_id();
+}
+inline void CostGraphDef_Node::_internal_set_id(int32_t value) {
+  
+  _impl_.id_ = value;
+}
+inline void CostGraphDef_Node::set_id(int32_t value) {
+  _internal_set_id(value);
+  // @@protoc_insertion_point(field_set:tensorflow.CostGraphDef.Node.id)
+}
+
+// repeated .tensorflow.CostGraphDef.Node.InputInfo input_info = 4;
+inline int CostGraphDef_Node::_internal_input_info_size() const {
+  return _impl_.input_info_.size();
+}
+inline int CostGraphDef_Node::input_info_size() const {
+  return _internal_input_info_size();
+}
+inline void CostGraphDef_Node::clear_input_info() {
+  _impl_.input_info_.Clear();
+}
+inline ::tensorflow::CostGraphDef_Node_InputInfo* CostGraphDef_Node::mutable_input_info(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.CostGraphDef.Node.input_info)
+  return _impl_.input_info_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::CostGraphDef_Node_InputInfo >*
+CostGraphDef_Node::mutable_input_info() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.CostGraphDef.Node.input_info)
+  return &_impl_.input_info_;
+}
+inline const ::tensorflow::CostGraphDef_Node_InputInfo& CostGraphDef_Node::_internal_input_info(int index) const {
+  return _impl_.input_info_.Get(index);
+}
+inline const ::tensorflow::CostGraphDef_Node_InputInfo& CostGraphDef_Node::input_info(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.CostGraphDef.Node.input_info)
+  return _internal_input_info(index);
+}
+inline ::tensorflow::CostGraphDef_Node_InputInfo* CostGraphDef_Node::_internal_add_input_info() {
+  return _impl_.input_info_.Add();
+}
+inline ::tensorflow::CostGraphDef_Node_InputInfo* CostGraphDef_Node::add_input_info() {
+  ::tensorflow::CostGraphDef_Node_InputInfo* _add = _internal_add_input_info();
+  // @@protoc_insertion_point(field_add:tensorflow.CostGraphDef.Node.input_info)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::CostGraphDef_Node_InputInfo >&
+CostGraphDef_Node::input_info() const {
+  // @@protoc_insertion_point(field_list:tensorflow.CostGraphDef.Node.input_info)
+  return _impl_.input_info_;
+}
+
+// repeated .tensorflow.CostGraphDef.Node.OutputInfo output_info = 5;
+inline int CostGraphDef_Node::_internal_output_info_size() const {
+  return _impl_.output_info_.size();
+}
+inline int CostGraphDef_Node::output_info_size() const {
+  return _internal_output_info_size();
+}
+inline void CostGraphDef_Node::clear_output_info() {
+  _impl_.output_info_.Clear();
+}
+inline ::tensorflow::CostGraphDef_Node_OutputInfo* CostGraphDef_Node::mutable_output_info(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.CostGraphDef.Node.output_info)
+  return _impl_.output_info_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::CostGraphDef_Node_OutputInfo >*
+CostGraphDef_Node::mutable_output_info() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.CostGraphDef.Node.output_info)
+  return &_impl_.output_info_;
+}
+inline const ::tensorflow::CostGraphDef_Node_OutputInfo& CostGraphDef_Node::_internal_output_info(int index) const {
+  return _impl_.output_info_.Get(index);
+}
+inline const ::tensorflow::CostGraphDef_Node_OutputInfo& CostGraphDef_Node::output_info(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.CostGraphDef.Node.output_info)
+  return _internal_output_info(index);
+}
+inline ::tensorflow::CostGraphDef_Node_OutputInfo* CostGraphDef_Node::_internal_add_output_info() {
+  return _impl_.output_info_.Add();
+}
+inline ::tensorflow::CostGraphDef_Node_OutputInfo* CostGraphDef_Node::add_output_info() {
+  ::tensorflow::CostGraphDef_Node_OutputInfo* _add = _internal_add_output_info();
+  // @@protoc_insertion_point(field_add:tensorflow.CostGraphDef.Node.output_info)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::CostGraphDef_Node_OutputInfo >&
+CostGraphDef_Node::output_info() const {
+  // @@protoc_insertion_point(field_list:tensorflow.CostGraphDef.Node.output_info)
+  return _impl_.output_info_;
+}
+
+// int64 temporary_memory_size = 6;
+inline void CostGraphDef_Node::clear_temporary_memory_size() {
+  _impl_.temporary_memory_size_ = int64_t{0};
+}
+inline int64_t CostGraphDef_Node::_internal_temporary_memory_size() const {
+  return _impl_.temporary_memory_size_;
+}
+inline int64_t CostGraphDef_Node::temporary_memory_size() const {
+  // @@protoc_insertion_point(field_get:tensorflow.CostGraphDef.Node.temporary_memory_size)
+  return _internal_temporary_memory_size();
+}
+inline void CostGraphDef_Node::_internal_set_temporary_memory_size(int64_t value) {
+  
+  _impl_.temporary_memory_size_ = value;
+}
+inline void CostGraphDef_Node::set_temporary_memory_size(int64_t value) {
+  _internal_set_temporary_memory_size(value);
+  // @@protoc_insertion_point(field_set:tensorflow.CostGraphDef.Node.temporary_memory_size)
+}
+
+// int64 persistent_memory_size = 12;
+inline void CostGraphDef_Node::clear_persistent_memory_size() {
+  _impl_.persistent_memory_size_ = int64_t{0};
+}
+inline int64_t CostGraphDef_Node::_internal_persistent_memory_size() const {
+  return _impl_.persistent_memory_size_;
+}
+inline int64_t CostGraphDef_Node::persistent_memory_size() const {
+  // @@protoc_insertion_point(field_get:tensorflow.CostGraphDef.Node.persistent_memory_size)
+  return _internal_persistent_memory_size();
+}
+inline void CostGraphDef_Node::_internal_set_persistent_memory_size(int64_t value) {
+  
+  _impl_.persistent_memory_size_ = value;
+}
+inline void CostGraphDef_Node::set_persistent_memory_size(int64_t value) {
+  _internal_set_persistent_memory_size(value);
+  // @@protoc_insertion_point(field_set:tensorflow.CostGraphDef.Node.persistent_memory_size)
+}
+
+// int64 host_temp_memory_size = 10 [deprecated = true];
+inline void CostGraphDef_Node::clear_host_temp_memory_size() {
+  _impl_.host_temp_memory_size_ = int64_t{0};
+}
+inline int64_t CostGraphDef_Node::_internal_host_temp_memory_size() const {
+  return _impl_.host_temp_memory_size_;
+}
+inline int64_t CostGraphDef_Node::host_temp_memory_size() const {
+  // @@protoc_insertion_point(field_get:tensorflow.CostGraphDef.Node.host_temp_memory_size)
+  return _internal_host_temp_memory_size();
+}
+inline void CostGraphDef_Node::_internal_set_host_temp_memory_size(int64_t value) {
+  
+  _impl_.host_temp_memory_size_ = value;
+}
+inline void CostGraphDef_Node::set_host_temp_memory_size(int64_t value) {
+  _internal_set_host_temp_memory_size(value);
+  // @@protoc_insertion_point(field_set:tensorflow.CostGraphDef.Node.host_temp_memory_size)
+}
+
+// int64 device_temp_memory_size = 11 [deprecated = true];
+inline void CostGraphDef_Node::clear_device_temp_memory_size() {
+  _impl_.device_temp_memory_size_ = int64_t{0};
+}
+inline int64_t CostGraphDef_Node::_internal_device_temp_memory_size() const {
+  return _impl_.device_temp_memory_size_;
+}
+inline int64_t CostGraphDef_Node::device_temp_memory_size() const {
+  // @@protoc_insertion_point(field_get:tensorflow.CostGraphDef.Node.device_temp_memory_size)
+  return _internal_device_temp_memory_size();
+}
+inline void CostGraphDef_Node::_internal_set_device_temp_memory_size(int64_t value) {
+  
+  _impl_.device_temp_memory_size_ = value;
+}
+inline void CostGraphDef_Node::set_device_temp_memory_size(int64_t value) {
+  _internal_set_device_temp_memory_size(value);
+  // @@protoc_insertion_point(field_set:tensorflow.CostGraphDef.Node.device_temp_memory_size)
+}
+
+// int64 device_persistent_memory_size = 16 [deprecated = true];
+inline void CostGraphDef_Node::clear_device_persistent_memory_size() {
+  _impl_.device_persistent_memory_size_ = int64_t{0};
+}
+inline int64_t CostGraphDef_Node::_internal_device_persistent_memory_size() const {
+  return _impl_.device_persistent_memory_size_;
+}
+inline int64_t CostGraphDef_Node::device_persistent_memory_size() const {
+  // @@protoc_insertion_point(field_get:tensorflow.CostGraphDef.Node.device_persistent_memory_size)
+  return _internal_device_persistent_memory_size();
+}
+inline void CostGraphDef_Node::_internal_set_device_persistent_memory_size(int64_t value) {
+  
+  _impl_.device_persistent_memory_size_ = value;
+}
+inline void CostGraphDef_Node::set_device_persistent_memory_size(int64_t value) {
+  _internal_set_device_persistent_memory_size(value);
+  // @@protoc_insertion_point(field_set:tensorflow.CostGraphDef.Node.device_persistent_memory_size)
+}
+
+// int64 compute_cost = 9;
+inline void CostGraphDef_Node::clear_compute_cost() {
+  _impl_.compute_cost_ = int64_t{0};
+}
+inline int64_t CostGraphDef_Node::_internal_compute_cost() const {
+  return _impl_.compute_cost_;
+}
+inline int64_t CostGraphDef_Node::compute_cost() const {
+  // @@protoc_insertion_point(field_get:tensorflow.CostGraphDef.Node.compute_cost)
+  return _internal_compute_cost();
+}
+inline void CostGraphDef_Node::_internal_set_compute_cost(int64_t value) {
+  
+  _impl_.compute_cost_ = value;
+}
+inline void CostGraphDef_Node::set_compute_cost(int64_t value) {
+  _internal_set_compute_cost(value);
+  // @@protoc_insertion_point(field_set:tensorflow.CostGraphDef.Node.compute_cost)
+}
+
+// int64 compute_time = 14;
+inline void CostGraphDef_Node::clear_compute_time() {
+  _impl_.compute_time_ = int64_t{0};
+}
+inline int64_t CostGraphDef_Node::_internal_compute_time() const {
+  return _impl_.compute_time_;
+}
+inline int64_t CostGraphDef_Node::compute_time() const {
+  // @@protoc_insertion_point(field_get:tensorflow.CostGraphDef.Node.compute_time)
+  return _internal_compute_time();
+}
+inline void CostGraphDef_Node::_internal_set_compute_time(int64_t value) {
+  
+  _impl_.compute_time_ = value;
+}
+inline void CostGraphDef_Node::set_compute_time(int64_t value) {
+  _internal_set_compute_time(value);
+  // @@protoc_insertion_point(field_set:tensorflow.CostGraphDef.Node.compute_time)
+}
+
+// int64 memory_time = 15;
+inline void CostGraphDef_Node::clear_memory_time() {
+  _impl_.memory_time_ = int64_t{0};
+}
+inline int64_t CostGraphDef_Node::_internal_memory_time() const {
+  return _impl_.memory_time_;
+}
+inline int64_t CostGraphDef_Node::memory_time() const {
+  // @@protoc_insertion_point(field_get:tensorflow.CostGraphDef.Node.memory_time)
+  return _internal_memory_time();
+}
+inline void CostGraphDef_Node::_internal_set_memory_time(int64_t value) {
+  
+  _impl_.memory_time_ = value;
+}
+inline void CostGraphDef_Node::set_memory_time(int64_t value) {
+  _internal_set_memory_time(value);
+  // @@protoc_insertion_point(field_set:tensorflow.CostGraphDef.Node.memory_time)
+}
+
+// bool is_final = 7;
+inline void CostGraphDef_Node::clear_is_final() {
+  _impl_.is_final_ = false;
+}
+inline bool CostGraphDef_Node::_internal_is_final() const {
+  return _impl_.is_final_;
+}
+inline bool CostGraphDef_Node::is_final() const {
+  // @@protoc_insertion_point(field_get:tensorflow.CostGraphDef.Node.is_final)
+  return _internal_is_final();
+}
+inline void CostGraphDef_Node::_internal_set_is_final(bool value) {
+  
+  _impl_.is_final_ = value;
+}
+inline void CostGraphDef_Node::set_is_final(bool value) {
+  _internal_set_is_final(value);
+  // @@protoc_insertion_point(field_set:tensorflow.CostGraphDef.Node.is_final)
+}
+
+// repeated int32 control_input = 8;
+inline int CostGraphDef_Node::_internal_control_input_size() const {
+  return _impl_.control_input_.size();
+}
+inline int CostGraphDef_Node::control_input_size() const {
+  return _internal_control_input_size();
+}
+inline void CostGraphDef_Node::clear_control_input() {
+  _impl_.control_input_.Clear();
+}
+inline int32_t CostGraphDef_Node::_internal_control_input(int index) const {
+  return _impl_.control_input_.Get(index);
+}
+inline int32_t CostGraphDef_Node::control_input(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.CostGraphDef.Node.control_input)
+  return _internal_control_input(index);
+}
+inline void CostGraphDef_Node::set_control_input(int index, int32_t value) {
+  _impl_.control_input_.Set(index, value);
+  // @@protoc_insertion_point(field_set:tensorflow.CostGraphDef.Node.control_input)
+}
+inline void CostGraphDef_Node::_internal_add_control_input(int32_t value) {
+  _impl_.control_input_.Add(value);
+}
+inline void CostGraphDef_Node::add_control_input(int32_t value) {
+  _internal_add_control_input(value);
+  // @@protoc_insertion_point(field_add:tensorflow.CostGraphDef.Node.control_input)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+CostGraphDef_Node::_internal_control_input() const {
+  return _impl_.control_input_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+CostGraphDef_Node::control_input() const {
+  // @@protoc_insertion_point(field_list:tensorflow.CostGraphDef.Node.control_input)
+  return _internal_control_input();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+CostGraphDef_Node::_internal_mutable_control_input() {
+  return &_impl_.control_input_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+CostGraphDef_Node::mutable_control_input() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.CostGraphDef.Node.control_input)
+  return _internal_mutable_control_input();
+}
+
+// bool inaccurate = 17;
+inline void CostGraphDef_Node::clear_inaccurate() {
+  _impl_.inaccurate_ = false;
+}
+inline bool CostGraphDef_Node::_internal_inaccurate() const {
+  return _impl_.inaccurate_;
+}
+inline bool CostGraphDef_Node::inaccurate() const {
+  // @@protoc_insertion_point(field_get:tensorflow.CostGraphDef.Node.inaccurate)
+  return _internal_inaccurate();
+}
+inline void CostGraphDef_Node::_internal_set_inaccurate(bool value) {
+  
+  _impl_.inaccurate_ = value;
+}
+inline void CostGraphDef_Node::set_inaccurate(bool value) {
+  _internal_set_inaccurate(value);
+  // @@protoc_insertion_point(field_set:tensorflow.CostGraphDef.Node.inaccurate)
+}
+
+// -------------------------------------------------------------------
+
+// CostGraphDef_AggregatedCost
+
+// float cost = 1;
+inline void CostGraphDef_AggregatedCost::clear_cost() {
+  _impl_.cost_ = 0;
+}
+inline float CostGraphDef_AggregatedCost::_internal_cost() const {
+  return _impl_.cost_;
+}
+inline float CostGraphDef_AggregatedCost::cost() const {
+  // @@protoc_insertion_point(field_get:tensorflow.CostGraphDef.AggregatedCost.cost)
+  return _internal_cost();
+}
+inline void CostGraphDef_AggregatedCost::_internal_set_cost(float value) {
+  
+  _impl_.cost_ = value;
+}
+inline void CostGraphDef_AggregatedCost::set_cost(float value) {
+  _internal_set_cost(value);
+  // @@protoc_insertion_point(field_set:tensorflow.CostGraphDef.AggregatedCost.cost)
+}
+
+// string dimension = 2;
+inline void CostGraphDef_AggregatedCost::clear_dimension() {
+  _impl_.dimension_.ClearToEmpty();
+}
+inline const std::string& CostGraphDef_AggregatedCost::dimension() const {
+  // @@protoc_insertion_point(field_get:tensorflow.CostGraphDef.AggregatedCost.dimension)
+  return _internal_dimension();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void CostGraphDef_AggregatedCost::set_dimension(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.dimension_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.CostGraphDef.AggregatedCost.dimension)
+}
+inline std::string* CostGraphDef_AggregatedCost::mutable_dimension() {
+  std::string* _s = _internal_mutable_dimension();
+  // @@protoc_insertion_point(field_mutable:tensorflow.CostGraphDef.AggregatedCost.dimension)
+  return _s;
+}
+inline const std::string& CostGraphDef_AggregatedCost::_internal_dimension() const {
+  return _impl_.dimension_.Get();
+}
+inline void CostGraphDef_AggregatedCost::_internal_set_dimension(const std::string& value) {
+  
+  _impl_.dimension_.Set(value, GetArenaForAllocation());
+}
+inline std::string* CostGraphDef_AggregatedCost::_internal_mutable_dimension() {
+  
+  return _impl_.dimension_.Mutable(GetArenaForAllocation());
+}
+inline std::string* CostGraphDef_AggregatedCost::release_dimension() {
+  // @@protoc_insertion_point(field_release:tensorflow.CostGraphDef.AggregatedCost.dimension)
+  return _impl_.dimension_.Release();
+}
+inline void CostGraphDef_AggregatedCost::set_allocated_dimension(std::string* dimension) {
+  if (dimension != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.dimension_.SetAllocated(dimension, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.dimension_.IsDefault()) {
+    _impl_.dimension_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.CostGraphDef.AggregatedCost.dimension)
+}
+
+// -------------------------------------------------------------------
+
+// CostGraphDef
+
+// repeated .tensorflow.CostGraphDef.Node node = 1;
+inline int CostGraphDef::_internal_node_size() const {
+  return _impl_.node_.size();
+}
+inline int CostGraphDef::node_size() const {
+  return _internal_node_size();
+}
+inline void CostGraphDef::clear_node() {
+  _impl_.node_.Clear();
+}
+inline ::tensorflow::CostGraphDef_Node* CostGraphDef::mutable_node(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.CostGraphDef.node)
+  return _impl_.node_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::CostGraphDef_Node >*
+CostGraphDef::mutable_node() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.CostGraphDef.node)
+  return &_impl_.node_;
+}
+inline const ::tensorflow::CostGraphDef_Node& CostGraphDef::_internal_node(int index) const {
+  return _impl_.node_.Get(index);
+}
+inline const ::tensorflow::CostGraphDef_Node& CostGraphDef::node(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.CostGraphDef.node)
+  return _internal_node(index);
+}
+inline ::tensorflow::CostGraphDef_Node* CostGraphDef::_internal_add_node() {
+  return _impl_.node_.Add();
+}
+inline ::tensorflow::CostGraphDef_Node* CostGraphDef::add_node() {
+  ::tensorflow::CostGraphDef_Node* _add = _internal_add_node();
+  // @@protoc_insertion_point(field_add:tensorflow.CostGraphDef.node)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::CostGraphDef_Node >&
+CostGraphDef::node() const {
+  // @@protoc_insertion_point(field_list:tensorflow.CostGraphDef.node)
+  return _impl_.node_;
+}
+
+// repeated .tensorflow.CostGraphDef.AggregatedCost cost = 2;
+inline int CostGraphDef::_internal_cost_size() const {
+  return _impl_.cost_.size();
+}
+inline int CostGraphDef::cost_size() const {
+  return _internal_cost_size();
+}
+inline void CostGraphDef::clear_cost() {
+  _impl_.cost_.Clear();
+}
+inline ::tensorflow::CostGraphDef_AggregatedCost* CostGraphDef::mutable_cost(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.CostGraphDef.cost)
+  return _impl_.cost_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::CostGraphDef_AggregatedCost >*
+CostGraphDef::mutable_cost() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.CostGraphDef.cost)
+  return &_impl_.cost_;
+}
+inline const ::tensorflow::CostGraphDef_AggregatedCost& CostGraphDef::_internal_cost(int index) const {
+  return _impl_.cost_.Get(index);
+}
+inline const ::tensorflow::CostGraphDef_AggregatedCost& CostGraphDef::cost(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.CostGraphDef.cost)
+  return _internal_cost(index);
+}
+inline ::tensorflow::CostGraphDef_AggregatedCost* CostGraphDef::_internal_add_cost() {
+  return _impl_.cost_.Add();
+}
+inline ::tensorflow::CostGraphDef_AggregatedCost* CostGraphDef::add_cost() {
+  ::tensorflow::CostGraphDef_AggregatedCost* _add = _internal_add_cost();
+  // @@protoc_insertion_point(field_add:tensorflow.CostGraphDef.cost)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::CostGraphDef_AggregatedCost >&
+CostGraphDef::cost() const {
+  // @@protoc_insertion_point(field_list:tensorflow.CostGraphDef.cost)
+  return _impl_.cost_;
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace tensorflow
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fcost_5fgraph_2eproto
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/cost_graph.proto b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/cost_graph.proto
new file mode 100644
index 0000000000000000000000000000000000000000..42c9e23cfab4c2e76df8ffe50f1f420f3c0ae13f
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/cost_graph.proto
@@ -0,0 +1,89 @@
+syntax = "proto3";
+
+package tensorflow;
+
+import "tensorflow/core/framework/tensor_shape.proto";
+import "tensorflow/core/framework/types.proto";
+
+option cc_enable_arenas = true;
+option java_outer_classname = "CostGraphProtos";
+option java_multiple_files = true;
+option java_package = "org.tensorflow.framework";
+option go_package = "github.com/tensorflow/tensorflow/tensorflow/go/core/framework/cost_graph_go_proto";
+
+message CostGraphDef {
+  message Node {
+    // The name of the node. Names are globally unique.
+    string name = 1;
+
+    // The device of the node. Can be empty if the node is mapped to the
+    // default partition or partitioning hasn't been run yet.
+    string device = 2;
+
+    // The id of the node. Node ids are only unique inside a partition.
+    int32 id = 3;
+
+    // Inputs of this node. They must be executed before this node can be
+    // executed. An input is a particular output of another node, specified
+    // by the node id and the output index.
+    message InputInfo {
+      int32 preceding_node = 1;
+      int32 preceding_port = 2;
+    }
+    repeated InputInfo input_info = 4;
+
+    // Outputs of this node.
+    message OutputInfo {
+      int64 size = 1;
+      // If >= 0, the output is an alias of an input. Note that an alias input
+      // may itself be an alias. The algorithm will therefore need to follow
+      // those pointers.
+      int64 alias_input_port = 2;
+      TensorShapeProto shape = 3;
+      DataType dtype = 4;
+    }
+    repeated OutputInfo output_info = 5;
+
+    // Temporary memory used by this node.
+    int64 temporary_memory_size = 6;
+
+    // Persistent memory used by this node.
+    int64 persistent_memory_size = 12;
+
+    int64 host_temp_memory_size = 10 [deprecated = true];
+    int64 device_temp_memory_size = 11 [deprecated = true];
+    int64 device_persistent_memory_size = 16 [deprecated = true];
+
+    // Estimate of the computational cost of this node, in microseconds.
+    int64 compute_cost = 9;
+
+    // Analytical estimate of the computational cost of this node, in
+    // microseconds.
+    int64 compute_time = 14;
+
+    // Analytical estimate of the memory access cost of this node, in
+    // microseconds.
+    int64 memory_time = 15;
+
+    // If true, the output is permanent: it can't be discarded, because this
+    // node is part of the "final output". Nodes may depend on final nodes.
+    bool is_final = 7;
+
+    // Ids of the control inputs for this node.
+    repeated int32 control_input = 8;
+
+    // Are the costs inaccurate?
+    bool inaccurate = 17;
+  }
+  repeated Node node = 1;
+
+  // Total cost of this graph, typically used for balancing decisions.
+  message AggregatedCost {
+    // Aggregated cost value.
+    float cost = 1;
+
+    // Aggregated cost dimension (e.g. 'memory', 'compute', 'network').
+    string dimension = 2;
+  }
+  repeated AggregatedCost cost = 2;
+}
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/cpp_shape_inference.pb.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/cpp_shape_inference.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..5e40b3c02bbd7d0b75273d041fcd77a7ab7d5511
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/cpp_shape_inference.pb.h
@@ -0,0 +1,1358 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: tensorflow/core/framework/cpp_shape_inference.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fcpp_5fshape_5finference_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fcpp_5fshape_5finference_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3021000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3021009 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+#include "tensorflow/core/framework/full_type.pb.h"
+#include "tensorflow/core/framework/tensor_shape.pb.h"
+#include "tensorflow/core/framework/types.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_tensorflow_2fcore_2fframework_2fcpp_5fshape_5finference_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_tensorflow_2fcore_2fframework_2fcpp_5fshape_5finference_2eproto {
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_tensorflow_2fcore_2fframework_2fcpp_5fshape_5finference_2eproto;
+namespace tensorflow {
+namespace core {
+class CppShapeInferenceInputsNeeded;
+struct CppShapeInferenceInputsNeededDefaultTypeInternal;
+extern CppShapeInferenceInputsNeededDefaultTypeInternal _CppShapeInferenceInputsNeeded_default_instance_;
+class CppShapeInferenceResult;
+struct CppShapeInferenceResultDefaultTypeInternal;
+extern CppShapeInferenceResultDefaultTypeInternal _CppShapeInferenceResult_default_instance_;
+class CppShapeInferenceResult_HandleData;
+struct CppShapeInferenceResult_HandleDataDefaultTypeInternal;
+extern CppShapeInferenceResult_HandleDataDefaultTypeInternal _CppShapeInferenceResult_HandleData_default_instance_;
+class CppShapeInferenceResult_HandleShapeAndType;
+struct CppShapeInferenceResult_HandleShapeAndTypeDefaultTypeInternal;
+extern CppShapeInferenceResult_HandleShapeAndTypeDefaultTypeInternal _CppShapeInferenceResult_HandleShapeAndType_default_instance_;
+}  // namespace core
+}  // namespace tensorflow
+PROTOBUF_NAMESPACE_OPEN
+template<> ::tensorflow::core::CppShapeInferenceInputsNeeded* Arena::CreateMaybeMessage<::tensorflow::core::CppShapeInferenceInputsNeeded>(Arena*);
+template<> ::tensorflow::core::CppShapeInferenceResult* Arena::CreateMaybeMessage<::tensorflow::core::CppShapeInferenceResult>(Arena*);
+template<> ::tensorflow::core::CppShapeInferenceResult_HandleData* Arena::CreateMaybeMessage<::tensorflow::core::CppShapeInferenceResult_HandleData>(Arena*);
+template<> ::tensorflow::core::CppShapeInferenceResult_HandleShapeAndType* Arena::CreateMaybeMessage<::tensorflow::core::CppShapeInferenceResult_HandleShapeAndType>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace tensorflow {
+namespace core {
+
+// ===================================================================
+
+class CppShapeInferenceResult_HandleShapeAndType final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.core.CppShapeInferenceResult.HandleShapeAndType) */ {
+ public:
+  inline CppShapeInferenceResult_HandleShapeAndType() : CppShapeInferenceResult_HandleShapeAndType(nullptr) {}
+  ~CppShapeInferenceResult_HandleShapeAndType() override;
+  explicit PROTOBUF_CONSTEXPR CppShapeInferenceResult_HandleShapeAndType(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  CppShapeInferenceResult_HandleShapeAndType(const CppShapeInferenceResult_HandleShapeAndType& from);
+  CppShapeInferenceResult_HandleShapeAndType(CppShapeInferenceResult_HandleShapeAndType&& from) noexcept
+    : CppShapeInferenceResult_HandleShapeAndType() {
+    *this = ::std::move(from);
+  }
+
+  inline CppShapeInferenceResult_HandleShapeAndType& operator=(const CppShapeInferenceResult_HandleShapeAndType& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline CppShapeInferenceResult_HandleShapeAndType& operator=(CppShapeInferenceResult_HandleShapeAndType&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const CppShapeInferenceResult_HandleShapeAndType& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const CppShapeInferenceResult_HandleShapeAndType* internal_default_instance() {
+    return reinterpret_cast<const CppShapeInferenceResult_HandleShapeAndType*>(
+               &_CppShapeInferenceResult_HandleShapeAndType_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(CppShapeInferenceResult_HandleShapeAndType& a, CppShapeInferenceResult_HandleShapeAndType& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(CppShapeInferenceResult_HandleShapeAndType* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(CppShapeInferenceResult_HandleShapeAndType* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  CppShapeInferenceResult_HandleShapeAndType* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<CppShapeInferenceResult_HandleShapeAndType>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const CppShapeInferenceResult_HandleShapeAndType& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const CppShapeInferenceResult_HandleShapeAndType& from) {
+    CppShapeInferenceResult_HandleShapeAndType::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(CppShapeInferenceResult_HandleShapeAndType* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.core.CppShapeInferenceResult.HandleShapeAndType";
+  }
+  protected:
+  explicit CppShapeInferenceResult_HandleShapeAndType(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kShapeFieldNumber = 1,
+    kTypeFieldNumber = 4,
+    kDtypeFieldNumber = 2,
+  };
+  // .tensorflow.TensorShapeProto shape = 1;
+  bool has_shape() const;
+  private:
+  bool _internal_has_shape() const;
+  public:
+  void clear_shape();
+  const ::tensorflow::TensorShapeProto& shape() const;
+  PROTOBUF_NODISCARD ::tensorflow::TensorShapeProto* release_shape();
+  ::tensorflow::TensorShapeProto* mutable_shape();
+  void set_allocated_shape(::tensorflow::TensorShapeProto* shape);
+  private:
+  const ::tensorflow::TensorShapeProto& _internal_shape() const;
+  ::tensorflow::TensorShapeProto* _internal_mutable_shape();
+  public:
+  void unsafe_arena_set_allocated_shape(
+      ::tensorflow::TensorShapeProto* shape);
+  ::tensorflow::TensorShapeProto* unsafe_arena_release_shape();
+
+  // .tensorflow.FullTypeDef type = 4;
+  bool has_type() const;
+  private:
+  bool _internal_has_type() const;
+  public:
+  void clear_type();
+  const ::tensorflow::FullTypeDef& type() const;
+  PROTOBUF_NODISCARD ::tensorflow::FullTypeDef* release_type();
+  ::tensorflow::FullTypeDef* mutable_type();
+  void set_allocated_type(::tensorflow::FullTypeDef* type);
+  private:
+  const ::tensorflow::FullTypeDef& _internal_type() const;
+  ::tensorflow::FullTypeDef* _internal_mutable_type();
+  public:
+  void unsafe_arena_set_allocated_type(
+      ::tensorflow::FullTypeDef* type);
+  ::tensorflow::FullTypeDef* unsafe_arena_release_type();
+
+  // .tensorflow.DataType dtype = 2;
+  void clear_dtype();
+  ::tensorflow::DataType dtype() const;
+  void set_dtype(::tensorflow::DataType value);
+  private:
+  ::tensorflow::DataType _internal_dtype() const;
+  void _internal_set_dtype(::tensorflow::DataType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.core.CppShapeInferenceResult.HandleShapeAndType)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::tensorflow::TensorShapeProto* shape_;
+    ::tensorflow::FullTypeDef* type_;
+    int dtype_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fcpp_5fshape_5finference_2eproto;
+};
+// -------------------------------------------------------------------
+
+class CppShapeInferenceResult_HandleData final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.core.CppShapeInferenceResult.HandleData) */ {
+ public:
+  inline CppShapeInferenceResult_HandleData() : CppShapeInferenceResult_HandleData(nullptr) {}
+  ~CppShapeInferenceResult_HandleData() override;
+  explicit PROTOBUF_CONSTEXPR CppShapeInferenceResult_HandleData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  CppShapeInferenceResult_HandleData(const CppShapeInferenceResult_HandleData& from);
+  CppShapeInferenceResult_HandleData(CppShapeInferenceResult_HandleData&& from) noexcept
+    : CppShapeInferenceResult_HandleData() {
+    *this = ::std::move(from);
+  }
+
+  inline CppShapeInferenceResult_HandleData& operator=(const CppShapeInferenceResult_HandleData& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline CppShapeInferenceResult_HandleData& operator=(CppShapeInferenceResult_HandleData&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const CppShapeInferenceResult_HandleData& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const CppShapeInferenceResult_HandleData* internal_default_instance() {
+    return reinterpret_cast<const CppShapeInferenceResult_HandleData*>(
+               &_CppShapeInferenceResult_HandleData_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(CppShapeInferenceResult_HandleData& a, CppShapeInferenceResult_HandleData& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(CppShapeInferenceResult_HandleData* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(CppShapeInferenceResult_HandleData* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  CppShapeInferenceResult_HandleData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<CppShapeInferenceResult_HandleData>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const CppShapeInferenceResult_HandleData& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const CppShapeInferenceResult_HandleData& from) {
+    CppShapeInferenceResult_HandleData::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(CppShapeInferenceResult_HandleData* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.core.CppShapeInferenceResult.HandleData";
+  }
+  protected:
+  explicit CppShapeInferenceResult_HandleData(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kShapeAndTypeFieldNumber = 2,
+    kIsSetFieldNumber = 1,
+  };
+  // repeated .tensorflow.core.CppShapeInferenceResult.HandleShapeAndType shape_and_type = 2;
+  int shape_and_type_size() const;
+  private:
+  int _internal_shape_and_type_size() const;
+  public:
+  void clear_shape_and_type();
+  ::tensorflow::core::CppShapeInferenceResult_HandleShapeAndType* mutable_shape_and_type(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::core::CppShapeInferenceResult_HandleShapeAndType >*
+      mutable_shape_and_type();
+  private:
+  const ::tensorflow::core::CppShapeInferenceResult_HandleShapeAndType& _internal_shape_and_type(int index) const;
+  ::tensorflow::core::CppShapeInferenceResult_HandleShapeAndType* _internal_add_shape_and_type();
+  public:
+  const ::tensorflow::core::CppShapeInferenceResult_HandleShapeAndType& shape_and_type(int index) const;
+  ::tensorflow::core::CppShapeInferenceResult_HandleShapeAndType* add_shape_and_type();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::core::CppShapeInferenceResult_HandleShapeAndType >&
+      shape_and_type() const;
+
+  // bool is_set = 1;
+  void clear_is_set();
+  bool is_set() const;
+  void set_is_set(bool value);
+  private:
+  bool _internal_is_set() const;
+  void _internal_set_is_set(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.core.CppShapeInferenceResult.HandleData)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::core::CppShapeInferenceResult_HandleShapeAndType > shape_and_type_;
+    bool is_set_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fcpp_5fshape_5finference_2eproto;
+};
+// -------------------------------------------------------------------
+
+class CppShapeInferenceResult final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.core.CppShapeInferenceResult) */ {
+ public:
+  inline CppShapeInferenceResult() : CppShapeInferenceResult(nullptr) {}
+  ~CppShapeInferenceResult() override;
+  explicit PROTOBUF_CONSTEXPR CppShapeInferenceResult(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  CppShapeInferenceResult(const CppShapeInferenceResult& from);
+  CppShapeInferenceResult(CppShapeInferenceResult&& from) noexcept
+    : CppShapeInferenceResult() {
+    *this = ::std::move(from);
+  }
+
+  inline CppShapeInferenceResult& operator=(const CppShapeInferenceResult& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline CppShapeInferenceResult& operator=(CppShapeInferenceResult&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const CppShapeInferenceResult& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const CppShapeInferenceResult* internal_default_instance() {
+    return reinterpret_cast<const CppShapeInferenceResult*>(
+               &_CppShapeInferenceResult_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(CppShapeInferenceResult& a, CppShapeInferenceResult& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(CppShapeInferenceResult* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(CppShapeInferenceResult* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  CppShapeInferenceResult* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<CppShapeInferenceResult>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const CppShapeInferenceResult& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const CppShapeInferenceResult& from) {
+    CppShapeInferenceResult::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(CppShapeInferenceResult* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.core.CppShapeInferenceResult";
+  }
+  protected:
+  explicit CppShapeInferenceResult(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef CppShapeInferenceResult_HandleShapeAndType HandleShapeAndType;
+  typedef CppShapeInferenceResult_HandleData HandleData;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kShapeFieldNumber = 1,
+    kHandleDataFieldNumber = 4,
+  };
+  // .tensorflow.TensorShapeProto shape = 1;
+  bool has_shape() const;
+  private:
+  bool _internal_has_shape() const;
+  public:
+  void clear_shape();
+  const ::tensorflow::TensorShapeProto& shape() const;
+  PROTOBUF_NODISCARD ::tensorflow::TensorShapeProto* release_shape();
+  ::tensorflow::TensorShapeProto* mutable_shape();
+  void set_allocated_shape(::tensorflow::TensorShapeProto* shape);
+  private:
+  const ::tensorflow::TensorShapeProto& _internal_shape() const;
+  ::tensorflow::TensorShapeProto* _internal_mutable_shape();
+  public:
+  void unsafe_arena_set_allocated_shape(
+      ::tensorflow::TensorShapeProto* shape);
+  ::tensorflow::TensorShapeProto* unsafe_arena_release_shape();
+
+  // .tensorflow.core.CppShapeInferenceResult.HandleData handle_data = 4;
+  bool has_handle_data() const;
+  private:
+  bool _internal_has_handle_data() const;
+  public:
+  void clear_handle_data();
+  const ::tensorflow::core::CppShapeInferenceResult_HandleData& handle_data() const;
+  PROTOBUF_NODISCARD ::tensorflow::core::CppShapeInferenceResult_HandleData* release_handle_data();
+  ::tensorflow::core::CppShapeInferenceResult_HandleData* mutable_handle_data();
+  void set_allocated_handle_data(::tensorflow::core::CppShapeInferenceResult_HandleData* handle_data);
+  private:
+  const ::tensorflow::core::CppShapeInferenceResult_HandleData& _internal_handle_data() const;
+  ::tensorflow::core::CppShapeInferenceResult_HandleData* _internal_mutable_handle_data();
+  public:
+  void unsafe_arena_set_allocated_handle_data(
+      ::tensorflow::core::CppShapeInferenceResult_HandleData* handle_data);
+  ::tensorflow::core::CppShapeInferenceResult_HandleData* unsafe_arena_release_handle_data();
+
+  // @@protoc_insertion_point(class_scope:tensorflow.core.CppShapeInferenceResult)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::tensorflow::TensorShapeProto* shape_;
+    ::tensorflow::core::CppShapeInferenceResult_HandleData* handle_data_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fcpp_5fshape_5finference_2eproto;
+};
+// -------------------------------------------------------------------
+
+class CppShapeInferenceInputsNeeded final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.core.CppShapeInferenceInputsNeeded) */ {
+ public:
+  inline CppShapeInferenceInputsNeeded() : CppShapeInferenceInputsNeeded(nullptr) {}
+  ~CppShapeInferenceInputsNeeded() override;
+  explicit PROTOBUF_CONSTEXPR CppShapeInferenceInputsNeeded(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  CppShapeInferenceInputsNeeded(const CppShapeInferenceInputsNeeded& from);
+  CppShapeInferenceInputsNeeded(CppShapeInferenceInputsNeeded&& from) noexcept
+    : CppShapeInferenceInputsNeeded() {
+    *this = ::std::move(from);
+  }
+
+  inline CppShapeInferenceInputsNeeded& operator=(const CppShapeInferenceInputsNeeded& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline CppShapeInferenceInputsNeeded& operator=(CppShapeInferenceInputsNeeded&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const CppShapeInferenceInputsNeeded& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const CppShapeInferenceInputsNeeded* internal_default_instance() {
+    return reinterpret_cast<const CppShapeInferenceInputsNeeded*>(
+               &_CppShapeInferenceInputsNeeded_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  friend void swap(CppShapeInferenceInputsNeeded& a, CppShapeInferenceInputsNeeded& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(CppShapeInferenceInputsNeeded* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(CppShapeInferenceInputsNeeded* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  CppShapeInferenceInputsNeeded* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<CppShapeInferenceInputsNeeded>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const CppShapeInferenceInputsNeeded& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const CppShapeInferenceInputsNeeded& from) {
+    CppShapeInferenceInputsNeeded::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(CppShapeInferenceInputsNeeded* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.core.CppShapeInferenceInputsNeeded";
+  }
+  protected:
+  explicit CppShapeInferenceInputsNeeded(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kInputTensorsNeededFieldNumber = 1,
+    kInputTensorsAsShapesNeededFieldNumber = 2,
+  };
+  // repeated int32 input_tensors_needed = 1;
+  int input_tensors_needed_size() const;
+  private:
+  int _internal_input_tensors_needed_size() const;
+  public:
+  void clear_input_tensors_needed();
+  private:
+  int32_t _internal_input_tensors_needed(int index) const;
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+      _internal_input_tensors_needed() const;
+  void _internal_add_input_tensors_needed(int32_t value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+      _internal_mutable_input_tensors_needed();
+  public:
+  int32_t input_tensors_needed(int index) const;
+  void set_input_tensors_needed(int index, int32_t value);
+  void add_input_tensors_needed(int32_t value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+      input_tensors_needed() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+      mutable_input_tensors_needed();
+
+  // repeated int32 input_tensors_as_shapes_needed = 2;
+  int input_tensors_as_shapes_needed_size() const;
+  private:
+  int _internal_input_tensors_as_shapes_needed_size() const;
+  public:
+  void clear_input_tensors_as_shapes_needed();
+  private:
+  int32_t _internal_input_tensors_as_shapes_needed(int index) const;
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+      _internal_input_tensors_as_shapes_needed() const;
+  void _internal_add_input_tensors_as_shapes_needed(int32_t value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+      _internal_mutable_input_tensors_as_shapes_needed();
+  public:
+  int32_t input_tensors_as_shapes_needed(int index) const;
+  void set_input_tensors_as_shapes_needed(int index, int32_t value);
+  void add_input_tensors_as_shapes_needed(int32_t value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+      input_tensors_as_shapes_needed() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+      mutable_input_tensors_as_shapes_needed();
+
+  // @@protoc_insertion_point(class_scope:tensorflow.core.CppShapeInferenceInputsNeeded)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > input_tensors_needed_;
+    mutable std::atomic<int> _input_tensors_needed_cached_byte_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > input_tensors_as_shapes_needed_;
+    mutable std::atomic<int> _input_tensors_as_shapes_needed_cached_byte_size_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fcpp_5fshape_5finference_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// CppShapeInferenceResult_HandleShapeAndType
+
+// .tensorflow.TensorShapeProto shape = 1;
+inline bool CppShapeInferenceResult_HandleShapeAndType::_internal_has_shape() const {
+  return this != internal_default_instance() && _impl_.shape_ != nullptr;
+}
+inline bool CppShapeInferenceResult_HandleShapeAndType::has_shape() const {
+  return _internal_has_shape();
+}
+inline const ::tensorflow::TensorShapeProto& CppShapeInferenceResult_HandleShapeAndType::_internal_shape() const {
+  const ::tensorflow::TensorShapeProto* p = _impl_.shape_;
+  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::TensorShapeProto&>(
+      ::tensorflow::_TensorShapeProto_default_instance_);
+}
+inline const ::tensorflow::TensorShapeProto& CppShapeInferenceResult_HandleShapeAndType::shape() const {
+  // @@protoc_insertion_point(field_get:tensorflow.core.CppShapeInferenceResult.HandleShapeAndType.shape)
+  return _internal_shape();
+}
+inline void CppShapeInferenceResult_HandleShapeAndType::unsafe_arena_set_allocated_shape(
+    ::tensorflow::TensorShapeProto* shape) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.shape_);
+  }
+  _impl_.shape_ = shape;
+  if (shape) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.core.CppShapeInferenceResult.HandleShapeAndType.shape)
+}
+inline ::tensorflow::TensorShapeProto* CppShapeInferenceResult_HandleShapeAndType::release_shape() {
+  
+  ::tensorflow::TensorShapeProto* temp = _impl_.shape_;
+  _impl_.shape_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::tensorflow::TensorShapeProto* CppShapeInferenceResult_HandleShapeAndType::unsafe_arena_release_shape() {
+  // @@protoc_insertion_point(field_release:tensorflow.core.CppShapeInferenceResult.HandleShapeAndType.shape)
+  
+  ::tensorflow::TensorShapeProto* temp = _impl_.shape_;
+  _impl_.shape_ = nullptr;
+  return temp;
+}
+inline ::tensorflow::TensorShapeProto* CppShapeInferenceResult_HandleShapeAndType::_internal_mutable_shape() {
+  
+  if (_impl_.shape_ == nullptr) {
+    auto* p = CreateMaybeMessage<::tensorflow::TensorShapeProto>(GetArenaForAllocation());
+    _impl_.shape_ = p;
+  }
+  return _impl_.shape_;
+}
+inline ::tensorflow::TensorShapeProto* CppShapeInferenceResult_HandleShapeAndType::mutable_shape() {
+  ::tensorflow::TensorShapeProto* _msg = _internal_mutable_shape();
+  // @@protoc_insertion_point(field_mutable:tensorflow.core.CppShapeInferenceResult.HandleShapeAndType.shape)
+  return _msg;
+}
+inline void CppShapeInferenceResult_HandleShapeAndType::set_allocated_shape(::tensorflow::TensorShapeProto* shape) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.shape_);
+  }
+  if (shape) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(shape));
+    if (message_arena != submessage_arena) {
+      shape = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, shape, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.shape_ = shape;
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.core.CppShapeInferenceResult.HandleShapeAndType.shape)
+}
+
+// .tensorflow.DataType dtype = 2;
+inline void CppShapeInferenceResult_HandleShapeAndType::clear_dtype() {
+  _impl_.dtype_ = 0;
+}
+inline ::tensorflow::DataType CppShapeInferenceResult_HandleShapeAndType::_internal_dtype() const {
+  return static_cast< ::tensorflow::DataType >(_impl_.dtype_);
+}
+inline ::tensorflow::DataType CppShapeInferenceResult_HandleShapeAndType::dtype() const {
+  // @@protoc_insertion_point(field_get:tensorflow.core.CppShapeInferenceResult.HandleShapeAndType.dtype)
+  return _internal_dtype();
+}
+inline void CppShapeInferenceResult_HandleShapeAndType::_internal_set_dtype(::tensorflow::DataType value) {
+  
+  _impl_.dtype_ = value;
+}
+inline void CppShapeInferenceResult_HandleShapeAndType::set_dtype(::tensorflow::DataType value) {
+  _internal_set_dtype(value);
+  // @@protoc_insertion_point(field_set:tensorflow.core.CppShapeInferenceResult.HandleShapeAndType.dtype)
+}
+
+// .tensorflow.FullTypeDef type = 4;
+inline bool CppShapeInferenceResult_HandleShapeAndType::_internal_has_type() const {
+  return this != internal_default_instance() && _impl_.type_ != nullptr;
+}
+inline bool CppShapeInferenceResult_HandleShapeAndType::has_type() const {
+  return _internal_has_type();
+}
+inline const ::tensorflow::FullTypeDef& CppShapeInferenceResult_HandleShapeAndType::_internal_type() const {
+  const ::tensorflow::FullTypeDef* p = _impl_.type_;
+  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::FullTypeDef&>(
+      ::tensorflow::_FullTypeDef_default_instance_);
+}
+inline const ::tensorflow::FullTypeDef& CppShapeInferenceResult_HandleShapeAndType::type() const {
+  // @@protoc_insertion_point(field_get:tensorflow.core.CppShapeInferenceResult.HandleShapeAndType.type)
+  return _internal_type();
+}
+inline void CppShapeInferenceResult_HandleShapeAndType::unsafe_arena_set_allocated_type(
+    ::tensorflow::FullTypeDef* type) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.type_);
+  }
+  _impl_.type_ = type;
+  if (type) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.core.CppShapeInferenceResult.HandleShapeAndType.type)
+}
+inline ::tensorflow::FullTypeDef* CppShapeInferenceResult_HandleShapeAndType::release_type() {
+  
+  ::tensorflow::FullTypeDef* temp = _impl_.type_;
+  _impl_.type_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::tensorflow::FullTypeDef* CppShapeInferenceResult_HandleShapeAndType::unsafe_arena_release_type() {
+  // @@protoc_insertion_point(field_release:tensorflow.core.CppShapeInferenceResult.HandleShapeAndType.type)
+  
+  ::tensorflow::FullTypeDef* temp = _impl_.type_;
+  _impl_.type_ = nullptr;
+  return temp;
+}
+inline ::tensorflow::FullTypeDef* CppShapeInferenceResult_HandleShapeAndType::_internal_mutable_type() {
+  
+  if (_impl_.type_ == nullptr) {
+    auto* p = CreateMaybeMessage<::tensorflow::FullTypeDef>(GetArenaForAllocation());
+    _impl_.type_ = p;
+  }
+  return _impl_.type_;
+}
+inline ::tensorflow::FullTypeDef* CppShapeInferenceResult_HandleShapeAndType::mutable_type() {
+  ::tensorflow::FullTypeDef* _msg = _internal_mutable_type();
+  // @@protoc_insertion_point(field_mutable:tensorflow.core.CppShapeInferenceResult.HandleShapeAndType.type)
+  return _msg;
+}
+inline void CppShapeInferenceResult_HandleShapeAndType::set_allocated_type(::tensorflow::FullTypeDef* type) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.type_);
+  }
+  if (type) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type));
+    if (message_arena != submessage_arena) {
+      type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, type, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.type_ = type;
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.core.CppShapeInferenceResult.HandleShapeAndType.type)
+}
+
+// -------------------------------------------------------------------
+
+// CppShapeInferenceResult_HandleData
+
+// bool is_set = 1;
+inline void CppShapeInferenceResult_HandleData::clear_is_set() {
+  _impl_.is_set_ = false;
+}
+inline bool CppShapeInferenceResult_HandleData::_internal_is_set() const {
+  return _impl_.is_set_;
+}
+inline bool CppShapeInferenceResult_HandleData::is_set() const {
+  // @@protoc_insertion_point(field_get:tensorflow.core.CppShapeInferenceResult.HandleData.is_set)
+  return _internal_is_set();
+}
+inline void CppShapeInferenceResult_HandleData::_internal_set_is_set(bool value) {
+  
+  _impl_.is_set_ = value;
+}
+inline void CppShapeInferenceResult_HandleData::set_is_set(bool value) {
+  _internal_set_is_set(value);
+  // @@protoc_insertion_point(field_set:tensorflow.core.CppShapeInferenceResult.HandleData.is_set)
+}
+
+// repeated .tensorflow.core.CppShapeInferenceResult.HandleShapeAndType shape_and_type = 2;
+inline int CppShapeInferenceResult_HandleData::_internal_shape_and_type_size() const {
+  return _impl_.shape_and_type_.size();
+}
+inline int CppShapeInferenceResult_HandleData::shape_and_type_size() const {
+  return _internal_shape_and_type_size();
+}
+inline void CppShapeInferenceResult_HandleData::clear_shape_and_type() {
+  _impl_.shape_and_type_.Clear();
+}
+inline ::tensorflow::core::CppShapeInferenceResult_HandleShapeAndType* CppShapeInferenceResult_HandleData::mutable_shape_and_type(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.core.CppShapeInferenceResult.HandleData.shape_and_type)
+  return _impl_.shape_and_type_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::core::CppShapeInferenceResult_HandleShapeAndType >*
+CppShapeInferenceResult_HandleData::mutable_shape_and_type() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.core.CppShapeInferenceResult.HandleData.shape_and_type)
+  return &_impl_.shape_and_type_;
+}
+inline const ::tensorflow::core::CppShapeInferenceResult_HandleShapeAndType& CppShapeInferenceResult_HandleData::_internal_shape_and_type(int index) const {
+  return _impl_.shape_and_type_.Get(index);
+}
+inline const ::tensorflow::core::CppShapeInferenceResult_HandleShapeAndType& CppShapeInferenceResult_HandleData::shape_and_type(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.core.CppShapeInferenceResult.HandleData.shape_and_type)
+  return _internal_shape_and_type(index);
+}
+inline ::tensorflow::core::CppShapeInferenceResult_HandleShapeAndType* CppShapeInferenceResult_HandleData::_internal_add_shape_and_type() {
+  return _impl_.shape_and_type_.Add();
+}
+inline ::tensorflow::core::CppShapeInferenceResult_HandleShapeAndType* CppShapeInferenceResult_HandleData::add_shape_and_type() {
+  ::tensorflow::core::CppShapeInferenceResult_HandleShapeAndType* _add = _internal_add_shape_and_type();
+  // @@protoc_insertion_point(field_add:tensorflow.core.CppShapeInferenceResult.HandleData.shape_and_type)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::core::CppShapeInferenceResult_HandleShapeAndType >&
+CppShapeInferenceResult_HandleData::shape_and_type() const {
+  // @@protoc_insertion_point(field_list:tensorflow.core.CppShapeInferenceResult.HandleData.shape_and_type)
+  return _impl_.shape_and_type_;
+}
+
+// -------------------------------------------------------------------
+
+// CppShapeInferenceResult
+
+// .tensorflow.TensorShapeProto shape = 1;
+inline bool CppShapeInferenceResult::_internal_has_shape() const {
+  return this != internal_default_instance() && _impl_.shape_ != nullptr;
+}
+inline bool CppShapeInferenceResult::has_shape() const {
+  return _internal_has_shape();
+}
+inline const ::tensorflow::TensorShapeProto& CppShapeInferenceResult::_internal_shape() const {
+  const ::tensorflow::TensorShapeProto* p = _impl_.shape_;
+  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::TensorShapeProto&>(
+      ::tensorflow::_TensorShapeProto_default_instance_);
+}
+inline const ::tensorflow::TensorShapeProto& CppShapeInferenceResult::shape() const {
+  // @@protoc_insertion_point(field_get:tensorflow.core.CppShapeInferenceResult.shape)
+  return _internal_shape();
+}
+inline void CppShapeInferenceResult::unsafe_arena_set_allocated_shape(
+    ::tensorflow::TensorShapeProto* shape) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.shape_);
+  }
+  _impl_.shape_ = shape;
+  if (shape) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.core.CppShapeInferenceResult.shape)
+}
+inline ::tensorflow::TensorShapeProto* CppShapeInferenceResult::release_shape() {
+  
+  ::tensorflow::TensorShapeProto* temp = _impl_.shape_;
+  _impl_.shape_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::tensorflow::TensorShapeProto* CppShapeInferenceResult::unsafe_arena_release_shape() {
+  // @@protoc_insertion_point(field_release:tensorflow.core.CppShapeInferenceResult.shape)
+  
+  ::tensorflow::TensorShapeProto* temp = _impl_.shape_;
+  _impl_.shape_ = nullptr;
+  return temp;
+}
+inline ::tensorflow::TensorShapeProto* CppShapeInferenceResult::_internal_mutable_shape() {
+  
+  if (_impl_.shape_ == nullptr) {
+    auto* p = CreateMaybeMessage<::tensorflow::TensorShapeProto>(GetArenaForAllocation());
+    _impl_.shape_ = p;
+  }
+  return _impl_.shape_;
+}
+inline ::tensorflow::TensorShapeProto* CppShapeInferenceResult::mutable_shape() {
+  ::tensorflow::TensorShapeProto* _msg = _internal_mutable_shape();
+  // @@protoc_insertion_point(field_mutable:tensorflow.core.CppShapeInferenceResult.shape)
+  return _msg;
+}
+inline void CppShapeInferenceResult::set_allocated_shape(::tensorflow::TensorShapeProto* shape) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.shape_);
+  }
+  if (shape) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(shape));
+    if (message_arena != submessage_arena) {
+      shape = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, shape, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.shape_ = shape;
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.core.CppShapeInferenceResult.shape)
+}
+
+// .tensorflow.core.CppShapeInferenceResult.HandleData handle_data = 4;
+inline bool CppShapeInferenceResult::_internal_has_handle_data() const {
+  return this != internal_default_instance() && _impl_.handle_data_ != nullptr;
+}
+inline bool CppShapeInferenceResult::has_handle_data() const {
+  return _internal_has_handle_data();
+}
+inline void CppShapeInferenceResult::clear_handle_data() {
+  if (GetArenaForAllocation() == nullptr && _impl_.handle_data_ != nullptr) {
+    delete _impl_.handle_data_;
+  }
+  _impl_.handle_data_ = nullptr;
+}
+inline const ::tensorflow::core::CppShapeInferenceResult_HandleData& CppShapeInferenceResult::_internal_handle_data() const {
+  const ::tensorflow::core::CppShapeInferenceResult_HandleData* p = _impl_.handle_data_;
+  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::core::CppShapeInferenceResult_HandleData&>(
+      ::tensorflow::core::_CppShapeInferenceResult_HandleData_default_instance_);
+}
+inline const ::tensorflow::core::CppShapeInferenceResult_HandleData& CppShapeInferenceResult::handle_data() const {
+  // @@protoc_insertion_point(field_get:tensorflow.core.CppShapeInferenceResult.handle_data)
+  return _internal_handle_data();
+}
+inline void CppShapeInferenceResult::unsafe_arena_set_allocated_handle_data(
+    ::tensorflow::core::CppShapeInferenceResult_HandleData* handle_data) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.handle_data_);
+  }
+  _impl_.handle_data_ = handle_data;
+  if (handle_data) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.core.CppShapeInferenceResult.handle_data)
+}
+inline ::tensorflow::core::CppShapeInferenceResult_HandleData* CppShapeInferenceResult::release_handle_data() {
+  
+  ::tensorflow::core::CppShapeInferenceResult_HandleData* temp = _impl_.handle_data_;
+  _impl_.handle_data_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::tensorflow::core::CppShapeInferenceResult_HandleData* CppShapeInferenceResult::unsafe_arena_release_handle_data() {
+  // @@protoc_insertion_point(field_release:tensorflow.core.CppShapeInferenceResult.handle_data)
+  
+  ::tensorflow::core::CppShapeInferenceResult_HandleData* temp = _impl_.handle_data_;
+  _impl_.handle_data_ = nullptr;
+  return temp;
+}
+inline ::tensorflow::core::CppShapeInferenceResult_HandleData* CppShapeInferenceResult::_internal_mutable_handle_data() {
+  
+  if (_impl_.handle_data_ == nullptr) {
+    auto* p = CreateMaybeMessage<::tensorflow::core::CppShapeInferenceResult_HandleData>(GetArenaForAllocation());
+    _impl_.handle_data_ = p;
+  }
+  return _impl_.handle_data_;
+}
+inline ::tensorflow::core::CppShapeInferenceResult_HandleData* CppShapeInferenceResult::mutable_handle_data() {
+  ::tensorflow::core::CppShapeInferenceResult_HandleData* _msg = _internal_mutable_handle_data();
+  // @@protoc_insertion_point(field_mutable:tensorflow.core.CppShapeInferenceResult.handle_data)
+  return _msg;
+}
+inline void CppShapeInferenceResult::set_allocated_handle_data(::tensorflow::core::CppShapeInferenceResult_HandleData* handle_data) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.handle_data_;
+  }
+  if (handle_data) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(handle_data);
+    if (message_arena != submessage_arena) {
+      handle_data = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, handle_data, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.handle_data_ = handle_data;
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.core.CppShapeInferenceResult.handle_data)
+}
+
+// -------------------------------------------------------------------
+
+// CppShapeInferenceInputsNeeded
+
+// repeated int32 input_tensors_needed = 1;
+inline int CppShapeInferenceInputsNeeded::_internal_input_tensors_needed_size() const {
+  return _impl_.input_tensors_needed_.size();
+}
+inline int CppShapeInferenceInputsNeeded::input_tensors_needed_size() const {
+  return _internal_input_tensors_needed_size();
+}
+inline void CppShapeInferenceInputsNeeded::clear_input_tensors_needed() {
+  _impl_.input_tensors_needed_.Clear();
+}
+inline int32_t CppShapeInferenceInputsNeeded::_internal_input_tensors_needed(int index) const {
+  return _impl_.input_tensors_needed_.Get(index);
+}
+inline int32_t CppShapeInferenceInputsNeeded::input_tensors_needed(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.core.CppShapeInferenceInputsNeeded.input_tensors_needed)
+  return _internal_input_tensors_needed(index);
+}
+inline void CppShapeInferenceInputsNeeded::set_input_tensors_needed(int index, int32_t value) {
+  _impl_.input_tensors_needed_.Set(index, value);
+  // @@protoc_insertion_point(field_set:tensorflow.core.CppShapeInferenceInputsNeeded.input_tensors_needed)
+}
+inline void CppShapeInferenceInputsNeeded::_internal_add_input_tensors_needed(int32_t value) {
+  _impl_.input_tensors_needed_.Add(value);
+}
+inline void CppShapeInferenceInputsNeeded::add_input_tensors_needed(int32_t value) {
+  _internal_add_input_tensors_needed(value);
+  // @@protoc_insertion_point(field_add:tensorflow.core.CppShapeInferenceInputsNeeded.input_tensors_needed)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+CppShapeInferenceInputsNeeded::_internal_input_tensors_needed() const {
+  return _impl_.input_tensors_needed_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+CppShapeInferenceInputsNeeded::input_tensors_needed() const {
+  // @@protoc_insertion_point(field_list:tensorflow.core.CppShapeInferenceInputsNeeded.input_tensors_needed)
+  return _internal_input_tensors_needed();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+CppShapeInferenceInputsNeeded::_internal_mutable_input_tensors_needed() {
+  return &_impl_.input_tensors_needed_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+CppShapeInferenceInputsNeeded::mutable_input_tensors_needed() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.core.CppShapeInferenceInputsNeeded.input_tensors_needed)
+  return _internal_mutable_input_tensors_needed();
+}
+
+// repeated int32 input_tensors_as_shapes_needed = 2;
+inline int CppShapeInferenceInputsNeeded::_internal_input_tensors_as_shapes_needed_size() const {
+  return _impl_.input_tensors_as_shapes_needed_.size();
+}
+inline int CppShapeInferenceInputsNeeded::input_tensors_as_shapes_needed_size() const {
+  return _internal_input_tensors_as_shapes_needed_size();
+}
+inline void CppShapeInferenceInputsNeeded::clear_input_tensors_as_shapes_needed() {
+  _impl_.input_tensors_as_shapes_needed_.Clear();
+}
+inline int32_t CppShapeInferenceInputsNeeded::_internal_input_tensors_as_shapes_needed(int index) const {
+  return _impl_.input_tensors_as_shapes_needed_.Get(index);
+}
+inline int32_t CppShapeInferenceInputsNeeded::input_tensors_as_shapes_needed(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.core.CppShapeInferenceInputsNeeded.input_tensors_as_shapes_needed)
+  return _internal_input_tensors_as_shapes_needed(index);
+}
+inline void CppShapeInferenceInputsNeeded::set_input_tensors_as_shapes_needed(int index, int32_t value) {
+  _impl_.input_tensors_as_shapes_needed_.Set(index, value);
+  // @@protoc_insertion_point(field_set:tensorflow.core.CppShapeInferenceInputsNeeded.input_tensors_as_shapes_needed)
+}
+inline void CppShapeInferenceInputsNeeded::_internal_add_input_tensors_as_shapes_needed(int32_t value) {
+  _impl_.input_tensors_as_shapes_needed_.Add(value);
+}
+inline void CppShapeInferenceInputsNeeded::add_input_tensors_as_shapes_needed(int32_t value) {
+  _internal_add_input_tensors_as_shapes_needed(value);
+  // @@protoc_insertion_point(field_add:tensorflow.core.CppShapeInferenceInputsNeeded.input_tensors_as_shapes_needed)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+CppShapeInferenceInputsNeeded::_internal_input_tensors_as_shapes_needed() const {
+  return _impl_.input_tensors_as_shapes_needed_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+CppShapeInferenceInputsNeeded::input_tensors_as_shapes_needed() const {
+  // @@protoc_insertion_point(field_list:tensorflow.core.CppShapeInferenceInputsNeeded.input_tensors_as_shapes_needed)
+  return _internal_input_tensors_as_shapes_needed();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+CppShapeInferenceInputsNeeded::_internal_mutable_input_tensors_as_shapes_needed() {
+  return &_impl_.input_tensors_as_shapes_needed_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+CppShapeInferenceInputsNeeded::mutable_input_tensors_as_shapes_needed() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.core.CppShapeInferenceInputsNeeded.input_tensors_as_shapes_needed)
+  return _internal_mutable_input_tensors_as_shapes_needed();
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace core
+}  // namespace tensorflow
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fcpp_5fshape_5finference_2eproto
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/cpp_shape_inference.proto b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/cpp_shape_inference.proto
new file mode 100644
index 0000000000000000000000000000000000000000..4cdbf5dd5c80cab7e093669a12a6c0829c2cb83c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/cpp_shape_inference.proto
@@ -0,0 +1,36 @@
+syntax = "proto3";
+
+package tensorflow.core;
+
+import "tensorflow/core/framework/full_type.proto";
+import "tensorflow/core/framework/tensor_shape.proto";
+import "tensorflow/core/framework/types.proto";
+
+option cc_enable_arenas = true;
+option go_package = "github.com/tensorflow/tensorflow/tensorflow/go/python/framework/cpp_shape_inference_go_proto";
+
+message CppShapeInferenceResult {
+  message HandleShapeAndType {
+    reserved 3;
+
+    TensorShapeProto shape = 1;
+    DataType dtype = 2;
+    FullTypeDef type = 4;
+  }
+  message HandleData {
+    bool is_set = 1;
+
+    // Only valid if <is_set>.
+    repeated HandleShapeAndType shape_and_type = 2;
+  }
+  TensorShapeProto shape = 1;
+
+  reserved 2;  // was handle_shape
+  reserved 3;  // was handle_dtype
+  HandleData handle_data = 4;
+}
+
+message CppShapeInferenceInputsNeeded {
+  repeated int32 input_tensors_needed = 1;
+  repeated int32 input_tensors_as_shapes_needed = 2;
+}
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/dataset.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/dataset.h
new file mode 100644
index 0000000000000000000000000000000000000000..a174234a86e483ed81412fc258ecc28233f82d4c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/dataset.h
@@ -0,0 +1,1690 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_FRAMEWORK_DATASET_H_
+#define TENSORFLOW_CORE_FRAMEWORK_DATASET_H_
+
+#include <deque>
+#include <iterator>
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include "absl/container/flat_hash_map.h"
+#include "absl/container/flat_hash_set.h"
+#include "absl/memory/memory.h"
+#include "absl/strings/str_cat.h"
+#include "tensorflow/core/framework/attr_value.pb.h"
+#include "tensorflow/core/framework/attr_value_util.h"
+#include "tensorflow/core/framework/cancellation.h"
+#include "tensorflow/core/framework/collective.h"
+#include "tensorflow/core/framework/dataset_metadata.pb.h"
+#include "tensorflow/core/framework/dataset_options.pb.h"
+#include "tensorflow/core/framework/dataset_stateful_op_allowlist.h"
+#include "tensorflow/core/framework/function.h"
+#include "tensorflow/core/framework/function_handle_cache.h"
+#include "tensorflow/core/framework/graph.pb.h"
+#include "tensorflow/core/framework/model.h"
+#include "tensorflow/core/framework/node_def.pb.h"
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/register_types.h"
+#include "tensorflow/core/framework/thread_factory.h"
+#include "tensorflow/core/framework/types.pb.h"
+#include "tensorflow/core/framework/variant_encode_decode.h"
+#include "tensorflow/core/framework/variant_tensor_data.h"
+#include "tensorflow/core/lib/core/errors.h"
+#include "tensorflow/core/lib/core/threadpool.h"
+#include "tensorflow/core/lib/core/threadpool_interface.h"
+#include "tensorflow/core/lib/strings/str_util.h"
+#include "tensorflow/core/lib/strings/strcat.h"
+#include "tensorflow/core/platform/cpu_info.h"
+#include "tensorflow/core/platform/env.h"
+#include "tensorflow/core/platform/errors.h"
+#include "tensorflow/core/platform/mutex.h"
+#include "tensorflow/core/platform/refcount.h"
+#include "tensorflow/core/platform/status.h"
+#include "tensorflow/core/platform/tracing.h"
+#include "tsl/platform/errors.h"
+#include "tsl/platform/thread_annotations.h"
+
+// Polymorphic datasets should support all primitive TensorFlow
+// types. Use this macro to expand `m(T)` once for each primitive type
+// `T`, e.g. to build a `switch` statement.
+#define TF_CALL_DATASET_TYPES(m) TF_CALL_ALL_TYPES(m) TF_CALL_QUANTIZED_TYPES(m)
+
+namespace tensorflow {
+
+// Forward declarations to avoid introducing a dependency on headers in
+// "tensorflow/core/graph/...".
+class GraphDefBuilder;
+class Node;
+
+namespace data {
+
+namespace internal {
+// Merges Options from source to destination. If there is a conflict on a field,
+// the field value from the source takes precedence.
+void MergeOptions(const protobuf::Message& source,
+                  protobuf::Message* destination);
+void MergeOptions(const protobuf::MessageLite& source,
+                  protobuf::MessageLite* destination);
+}  // namespace internal
+
+using TraceMeMetadata = std::vector<std::pair<StringPiece, string>>;
+
+constexpr char kTFDataFunction[] = "_tf_data_function";
+
+constexpr int kInfiniteCardinality = -1;
+constexpr int kUnknownCardinality = -2;
+
+// This constant is a magic number that is used (as a prefix) to identify keys
+// used for serialization of iterator state.
+constexpr char kFullNameRandomHex[] = "60d899aa0d8ce4351e7c3b419e92d25b";
+constexpr int kFullNameRandomHexLen = std::size(kFullNameRandomHex) - 1;
+constexpr char kPipe[] = "|";
+constexpr char kColon[] = ":";
+
+constexpr char kTFDataResourceTag[] = "tfdata";
+constexpr char kTraceInfoUnavailable[] = "unavailable";
+constexpr char kMetadata[] = "metadata";
+
+constexpr char kCardinalityAttrForRewrite[] = "_cardinality";
+
+class DatasetBase;
+class IteratorContext;
+class SerializationContext;
+
+inline bool IsTFDataFunction(const FunctionDef& func) {
+  auto iter = func.attr().find(data::kTFDataFunction);
+  return (iter != func.attr().end() && iter->second.b());
+}
+
+// Interface for reading values from a key-value store.
+// Used for restoring iterator state. This class is thread safe.
+// Please see comment on IteratorStateWriter for guidance around using the
+// Read*(key, val) vs Read*(name, key, val).
+class IteratorStateReader {
+ public:
+  // Determines whether the iterator state contains the given key.
+  virtual bool Contains(StringPiece key) const = 0;
+  virtual bool Contains(StringPiece name, StringPiece key) const = 0;
+
+  // Reads an integer for the given key.
+  virtual Status ReadScalar(StringPiece key, int64_t* val) const = 0;
+  virtual Status ReadScalar(StringPiece name, StringPiece key,
+                            int64_t* val) const = 0;
+
+  // Reads a string for the given key.
+  virtual Status ReadScalar(StringPiece key, tstring* val) const = 0;
+  virtual Status ReadScalar(StringPiece name, StringPiece key,
+                            tstring* val) const = 0;
+
+  // Reads a tensor for the given key.
+  // TODO(jsimsa): Remove non-FLR overrides once all callers are updated.
+  virtual Status ReadTensor(StringPiece key, Tensor* val) const = 0;
+  virtual Status ReadTensor(FunctionLibraryRuntime* flr, StringPiece key,
+                            Tensor* val) const = 0;
+  virtual Status ReadTensor(StringPiece name, StringPiece key,
+                            Tensor* val) const = 0;
+  virtual Status ReadTensor(FunctionLibraryRuntime* flr, StringPiece name,
+                            StringPiece key, Tensor* val) const = 0;
+
+  virtual ~IteratorStateReader() {}
+};
+
+// Interface for writing values to a key-value store.
+// Used for saving iterator state. Not thread safe.
+// The IteratorStateWriter creates a tensor for each unique iterator name it
+// sees. For the Write*(key, val) API's the key is expected to encode this
+// name as keys are required to be produced using the full_name() method.
+// Each tensor has an upper limit of 2 GB and so if the state for an iterator
+// might exceed the 2 GB limit, you can pass an explicit name in via the
+// Write*(name, key, val) APIs allowing you to further split up the state
+// into more manageable chunks.
+class IteratorStateWriter {
+ public:
+  // Writes an integer for the given key.
+  virtual Status WriteScalar(StringPiece key, const int64_t val) = 0;
+  virtual Status WriteScalar(StringPiece name, StringPiece key,
+                             const int64_t val) = 0;
+
+  // Writes a string for the given key.
+  virtual Status WriteScalar(StringPiece key, const tstring& val) = 0;
+  virtual Status WriteScalar(StringPiece name, StringPiece key,
+                             const tstring& val) = 0;
+
+  // Writes a tensor for the given key.
+  virtual Status WriteTensor(StringPiece key, const Tensor& val) = 0;
+  virtual Status WriteTensor(StringPiece name, StringPiece key,
+                             const Tensor& val) = 0;
+
+  virtual ~IteratorStateWriter() {}
+};
+
+// Generates a full name key for iterator checkpointing. All keys generated for
+// iterator checkpoints should go through this function.
+std::string FullName(const std::string& prefix, const std::string& name);
+
+// Extracts iterator prefix from key generated by `FullName`.
+Status ExtractIteratorPrefix(StringPiece key, string* prefix);
+
+// Interface for objects that can be checkpointed.
+class Checkpointable {
+ public:
+  Checkpointable() = default;
+  virtual ~Checkpointable() = default;
+
+  virtual Status Save(SerializationContext* ctx,
+                      IteratorStateWriter* writer) = 0;
+  virtual Status Restore(IteratorContext* ctx, IteratorStateReader* reader) = 0;
+};
+
+// Wrapper around GraphDefBuilder. Used to serialize Dataset graph.
+class GraphDefBuilderWrapper {
+ public:
+  explicit GraphDefBuilderWrapper(GraphDefBuilder* b) : b_(b) {}
+
+  // Adds a Const node with scalar value to the Graph.
+  // `*output` contains a pointer to the output `Node`. It is guaranteed to be
+  // non-null if the method returns with an OK status.
+  // The returned Node pointer is owned by the backing Graph of GraphDefBuilder.
+  template <typename T>
+  Status AddScalar(const T& val, Node** output) {
+    Tensor val_t = Tensor(DataTypeToEnum<T>::v(), TensorShape({}));
+    val_t.scalar<T>()() = val;
+    AddTensorInternal(val_t, output);
+    if (*output == nullptr) {
+      return errors::Internal("AddScalar: Failed to build Const op.");
+    }
+    return OkStatus();
+  }
+
+  // Adds a Const node with vector value to the Graph.
+  // `*output` contains a pointer to the output `Node`. It is guaranteed to be
+  // non-null if the method returns with an OK status.
+  // The returned Node pointer is owned by the backing Graph of GraphDefBuilder.
+  // TODO(shivaniagrawal): Consider changing to gtl::ArraySlice?
+  template <typename T>
+  Status AddVector(const std::vector<T>& val, Node** output) {
+    Tensor val_t = Tensor(DataTypeToEnum<T>::v(),
+                          TensorShape({static_cast<int64_t>(val.size())}));
+    for (size_t i = 0; i < val.size(); i++) {
+      val_t.flat<T>()(i) = val[i];
+    }
+    AddTensorInternal(val_t, output);
+    if (*output == nullptr) {
+      return errors::Internal("AddVector: Failed to build Const op.");
+    }
+    return OkStatus();
+  }
+
+  Status AddVector(const std::vector<string>& val, Node** output) {
+    Tensor val_t = Tensor(DataTypeToEnum<tstring>::v(),
+                          TensorShape({static_cast<int64_t>(val.size())}));
+    for (size_t i = 0; i < val.size(); i++) {
+      val_t.flat<tstring>()(i) = val[i];
+    }
+    AddTensorInternal(val_t, output);
+    if (*output == nullptr) {
+      return errors::Internal("AddVector: Failed to build Const op.");
+    }
+    return OkStatus();
+  }
+
+  // Adds a `Const` node for the given tensor value to the graph.
+  //
+  // `*output` contains a pointer to the output `Node`. It is guaranteed to be
+  // non-null if the method returns with an OK status. The returned `Node`
+  // pointer is owned by the backing graph of `GraphDefBuilder`.
+  Status AddTensor(const Tensor& val, Node** output) {
+    AddTensorInternal(val, output);
+    if (*output == nullptr) {
+      return errors::Internal("AddTensor: Failed to build Const op.");
+    }
+    return OkStatus();
+  }
+
+  // Adds a `Placeholder` node for the given tensor value to the graph.
+  //
+  // `*output` contains a pointer to the output `Node`. It is guaranteed to be
+  // non-null if the method returns with an OK status. The returned `Node`
+  // pointer is owned by the backing graph of `GraphDefBuilder`.
+  Status AddPlaceholder(const Tensor& val, Node** output) {
+    AddPlaceholderInternal(val, output);
+    if (*output == nullptr) {
+      return errors::Internal(
+          "AddPlaceholder: Failed to build Placeholder op.");
+    }
+    return OkStatus();
+  }
+
+  // Adds a node for the given dataset to the `Graph`. The value of
+  // `DatasetBase::type_string()` is used as the op type for the node. Values
+  // for the `output_types` and `output_shapes` node attributes are also written
+  // if those attributes are defined in the `OpDef`.
+  //
+  // If `use_dataset_name` is set, the value of `DatasetBase::node_name()` is
+  // used as the op name for the node. This argument should only be set when
+  // serializing `DatasetBase` instances which might not have been created
+  // through op kernel execution to make sure the dataset op name is preserved
+  // across serialization boundaries, which is in turn needed to make sure
+  // iterator checkpoints are valid across serialization boundaries. When
+  // `use_dataset_name` is set, the caller is responsible for making sure that
+  // the op name is unique across the graph.
+  //
+  // `*output` contains a pointer to the output `Node`. It is guaranteed to be
+  // non-null if the method returns with an OK status. The returned `Node`
+  // pointer is owned by the backing `Graph` of `GraphDefBuilder`.
+  Status AddDataset(const DatasetBase* dataset,
+                    const std::vector<Node*>& inputs, Node** output);
+  Status AddDataset(const DatasetBase* dataset,
+                    const std::vector<Node*>& inputs,
+                    const std::vector<std::pair<StringPiece, AttrValue>>& attrs,
+                    Node** output);
+  Status AddDataset(
+      const DatasetBase* dataset,
+      const std::vector<std::pair<size_t, Node*>>& inputs,
+      const std::vector<std::pair<size_t, gtl::ArraySlice<Node*>>>& list_inputs,
+      const std::vector<std::pair<StringPiece, AttrValue>>& attrs,
+      Node** output);
+  Status AddDataset(
+      const DatasetBase* dataset,
+      const std::vector<std::pair<size_t, Node*>>& inputs,
+      const std::vector<std::pair<size_t, gtl::ArraySlice<Node*>>>& list_inputs,
+      const std::vector<std::pair<StringPiece, AttrValue>>& attrs,
+      bool use_dataset_name, Node** output);
+
+  // Adds a user-defined function with name `function_name` to the graph and
+  // recursively adds all functions it references. If a function with a matching
+  // name has already been added, returns with OK status. If a user-defined with
+  // name `function_name` is not found in the context's function library,
+  // returns an InvalidArgumentError. If the function with name `function_name`
+  // or any of its dependent functions are stateful, and the context does not
+  // explicitly permit stateful functions, returns an InvalidArgument error.
+  Status AddFunction(SerializationContext* ctx, const string& function_name,
+                     const FunctionLibraryDefinition& lib_def);
+
+  template <typename T>
+  void BuildAttrValue(const T& value, AttrValue* attr) {
+    SetAttrValue(value, attr);
+  }
+
+  template <typename T>
+  AttrValue BuildAttrValue(const T& value) {
+    AttrValue attr;
+    SetAttrValue(value, &attr);
+    return attr;
+  }
+
+ protected:
+  GraphDefBuilder* builder() { return b_; }
+
+ private:
+  void AddPlaceholderInternal(const Tensor& val, Node** output);
+  void AddTensorInternal(const Tensor& val, Node** output);
+  bool HasAttr(const string& op_type_name, const string& attr_name) const;
+
+  bool HasAttr(const OpDef* op_def, const string& attr_name) const {
+    for (const auto& attr : op_def->attr()) {
+      if (attr.name() == attr_name) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  Status AddAttrFunctions(SerializationContext* ctx,
+                          const AttrValue& attr_value,
+                          const FunctionLibraryDefinition& lib_def) {
+    if (attr_value.has_func()) {
+      TF_RETURN_IF_ERROR(AddFunction(ctx, attr_value.func().name(), lib_def));
+    } else if (attr_value.has_list()) {
+      for (const NameAttrList& name_attr_list : attr_value.list().func()) {
+        TF_RETURN_IF_ERROR(AddFunction(ctx, name_attr_list.name(), lib_def));
+      }
+    }
+    return OkStatus();
+  }
+
+  GraphDefBuilder* b_;
+};
+
+class StatsAggregator;
+
+// A utility class for running a function and ensuring that there is always a
+// `tensorflow::data` symbol on the stack.
+class Runner {
+ public:
+  virtual ~Runner() {}
+
+  // Runs the given function.
+  virtual void Run(const std::function<void()>& f) = 0;
+
+  // Returns a global singleton Runner.
+  static Runner* get();
+};
+
+// A class which provides a sequence of splits. Splits represent subdivisions of
+// a dataset, e.g. filenames or ranges within files. We use splitting to
+// partition input data into smaller pieces for distributed processing (see
+// go/tf-data-splitting-design).
+//
+// Datasets provide a `MakeSplitProvider` method to expose a listing of their
+// splits.
+//
+// Iterators created with a split provider will only iterate over the splits
+// provided by the split provider.
+class SplitProvider {
+ public:
+  virtual ~SplitProvider() {}
+  // Stores the next split in `*split`, setting `*end_of_splits` to indicate
+  // whether there were any splits left.
+  virtual Status GetNext(Tensor* split, bool* end_of_splits) = 0;
+  // Resets the split provider to its beginning.
+  virtual Status Reset() = 0;
+  // Saves the state of this split provider.
+  virtual Status Save(std::function<std::string(std::string)> full_name,
+                      IteratorStateWriter* writer) = 0;
+  // Restores the state of this split provider.
+  virtual Status Restore(std::function<std::string(std::string)> full_name,
+                         IteratorStateReader* reader) = 0;
+};
+
+// Returns the runner threadpool size from an OpKernelContext.
+int32_t GetRunnerThreadpoolSizeFromOpKernelContext(OpKernelContext* ctx);
+
+// In-memory representation of a checkpoint. The checkpoint is represented as a
+// collection of key-value pairs and are expected to be written using the
+// `IteratorStateWriter` interface.
+//
+// The implementation is not thread-safe.
+class MemoryCheckpoint : public IteratorStateWriter {
+ public:
+  // IdRegistry maintains a bi-directional mapping between string and integer
+  // representations of checkpoint keys.
+  //
+  // The reason we need both is that integer ids are used for fast lookups and
+  // comparisons, while string ids are used for prefix matching.
+  class IdRegistry {
+   public:
+    IdRegistry() = default;
+
+    // Adds the given string id to the registry, generating a unique integer id
+    // for it. If the string id already exists, its integer id is returned.
+    int64_t Add(const std::string& prefix, const std::string& key);
+
+    // Gets all integer ids for string ids matching the given prefix.
+    std::vector<int64_t> GetMatchingIds(const std::string& prefix_to_match);
+
+    // Gets the string id for the given integer id.
+    std::pair<std::string, std::string> Get(int64_t id);
+
+    // Removes the entries matching the given integer ids from the registry.
+    void RemoveIds(const std::vector<int64_t>& ids);
+
+   private:
+    mutex mu_;
+    int64_t next_id_ TF_GUARDED_BY(mu_) = 0;
+    absl::flat_hash_map<int64_t, std::pair<std::string, std::string>>
+        int_to_string_ TF_GUARDED_BY(mu_);
+    absl::flat_hash_map<std::pair<std::string, std::string>, int64_t>
+        string_to_int_ TF_GUARDED_BY(mu_);
+  };
+
+  MemoryCheckpoint() = delete;
+  explicit MemoryCheckpoint(std::shared_ptr<IdRegistry> registry)
+      : id_registry_(registry) {}
+
+  MemoryCheckpoint(MemoryCheckpoint&& other) = default;
+
+  static MemoryCheckpoint CreateRootCheckpoint(
+      std::shared_ptr<IdRegistry> registry) {
+    return MemoryCheckpoint(/*id_registry*/ registry, /*is_root=*/true);
+  }
+
+  // BEGIN implementation of `IteratorStateWriter` interface
+  Status WriteScalar(StringPiece key, int64_t val) override {
+    string prefix;
+    TF_RETURN_IF_ERROR(ExtractIteratorPrefix(key, &prefix));
+    return WriteScalar(prefix, key, val);
+  }
+  Status WriteScalar(StringPiece name, StringPiece key, int64_t val) override {
+    auto id = id_registry_->Add(string(name), string(key));
+    int_values_[id] = val;
+    return OkStatus();
+  }
+  Status WriteScalar(StringPiece key, const tstring& val) override {
+    string prefix;
+    TF_RETURN_IF_ERROR(ExtractIteratorPrefix(key, &prefix));
+    return WriteScalar(prefix, key, val);
+  }
+  Status WriteScalar(StringPiece name, StringPiece key,
+                     const tstring& val) override {
+    auto id = id_registry_->Add(string(name), string(key));
+    str_values_[id] = val;
+    return OkStatus();
+  }
+  Status WriteTensor(StringPiece key, const Tensor& val) override {
+    string prefix;
+    TF_RETURN_IF_ERROR(ExtractIteratorPrefix(key, &prefix));
+    return WriteTensor(prefix, key, val);
+  }
+  Status WriteTensor(StringPiece name, StringPiece key,
+                     const Tensor& val) override {
+    auto id = id_registry_->Add(string(name), string(key));
+    tensor_values_[id] = val;
+    return OkStatus();
+  }
+  // END implementation of `IteratorStateWriter` interface
+
+  // String representation for the in-memory checkpoint suitable for debugging.
+  std::string DebugString() const;
+
+  // Returns the status of the in-memory checkpoint.
+  Status GetStatus() const { return status_; }
+
+  // Merges state of another checkpoint into this checkpoint, overwriting
+  // existing state (if applicable).
+  //
+  // Merge also garbage collects state that is no longer needed.
+  void Merge(MemoryCheckpoint* other);
+
+  // Purge removes all keys with given prefix from checkpoint. It also adds the
+  // prefix for tracking unless it is the root checkpoint.
+  void Purge(const std::string& prefix);
+
+  // Stores the in-memory checkpoint to the given writer.
+  Status Save(IteratorStateWriter* writer) const;
+
+  // Updates the status of the in-memory checkpoint with the given status.
+  void UpdateStatus(Status status) { status_.Update(status); }
+
+ private:
+  explicit MemoryCheckpoint(std::shared_ptr<IdRegistry> registry, bool is_root)
+      : is_root_(is_root), id_registry_(registry) {}
+  MemoryCheckpoint(const MemoryCheckpoint&) = delete;
+  void operator=(const MemoryCheckpoint&) = delete;
+
+  Status status_ = OkStatus();
+  // Only set to true for the checkpoint in IteratorResource.
+  // Root checkpoint does not track expired prefixes.
+  const bool is_root_ = false;
+  absl::flat_hash_map<int64_t, int64_t> int_values_;
+  absl::flat_hash_map<int64_t, std::string> str_values_;
+  absl::flat_hash_map<int64_t, Tensor> tensor_values_;
+
+  // Keeps track of expired prefixes for propagation. Cleaned after it's merged.
+  absl::flat_hash_set<std::string> expired_prefixes_;
+
+  std::shared_ptr<IdRegistry> id_registry_;
+};
+
+// Aggregates runtime support needed for dataset and iterator serialization.
+class SerializationContext {
+ public:
+  // Handles the external state according to the external state policy.
+  Status HandleCheckExternalStateStatus(Status s) {
+    if (s.ok()) {
+      return s;
+    }
+    switch (params_.external_state_policy) {
+      case ExternalStatePolicy::POLICY_WARN:
+        LOG(WARNING) << s.ToString();
+        return OkStatus();
+      case ExternalStatePolicy::POLICY_IGNORE:
+        VLOG(2) << "Ignoring error status: " << s.ToString();
+        return OkStatus();
+      case ExternalStatePolicy::POLICY_FAIL:
+        return s;
+      default:
+        return errors::InvalidArgument("Unexpected value of external policy: ",
+                                       params_.external_state_policy);
+    }
+  }
+
+  struct Params {
+    explicit Params() = default;
+
+    explicit Params(OpKernelContext* ctx)
+        : resource_mgr(ctx->resource_manager()),
+          device_name(ctx->device()->attributes().name()) {}
+
+    std::vector<std::pair<string, Tensor>>* input_list = nullptr;  // Not owned.
+
+    // Indicates what to do if the dataset depends on external state.
+    ExternalStatePolicy external_state_policy =
+        ExternalStatePolicy::POLICY_WARN;
+
+    // Indicates whether the serialization is for rewrites.
+    //
+    // If true:
+    //   * A dataset that doesn't implement serialization is replaced with a
+    //     placeholder returned in `input_list`.
+    //   * Data tensors are replaced with a placeholder returned in
+    //     `input_list`.
+    //   * Datasets that use random seeds should not serialize the random seeds.
+    //     This doesn't affect datasets that use fixed seeds; fixed seeds will
+    //     always be preserved.
+    //   * Cardinality is serialized as an unregistered attribute
+    //     `_cardinality`.
+    // If false:
+    //   * A dataset that doesn't implement serialization should result in an
+    //     error.
+    //   * Data tensors (potentially large) should be serialized.
+    //   * Datasets that use random seeds should serialize the random seeds.
+    bool is_graph_rewrite = false;
+
+    // A resource manager for looking up resources during serialization.
+    ResourceMgr* resource_mgr;
+
+    // The name of the device doing the serialization.
+    std::string device_name;
+
+    // Determines whether checkpointing should represent input pipeline state
+    // symbolically, using cursors into source iterators, or explicitly, by
+    // storing internal state of each iterator.
+    bool symbolic_checkpoint = false;
+  };
+
+  explicit SerializationContext(Params params) : params_(params) {}
+
+  std::vector<std::pair<string, Tensor>>* input_list() {
+    return params_.input_list;
+  }
+
+  ExternalStatePolicy external_state_policy() const {
+    return params_.external_state_policy;
+  }
+
+  bool is_graph_rewrite() const { return params_.is_graph_rewrite; }
+
+  const ResourceMgr* resource_mgr() const { return params_.resource_mgr; }
+
+  const std::string& device_name() const { return params_.device_name; }
+
+  bool symbolic_checkpoint() const { return params_.symbolic_checkpoint; }
+
+ private:
+  Params params_;
+
+  SerializationContext(const SerializationContext&) = delete;
+  void operator=(const SerializationContext&) = delete;
+};
+
+// Specifies the tf.data pipeline run mode.
+enum RunMode { DEFAULT, STANDALONE };
+
+// A cut-down version of `OpKernelContext` for running computations in
+// iterators. Note that we cannot simply use `OpKernelContext` here because we
+// might run computation in an iterator whose lifetime is not nested within the
+// lifetime of a single `OpKernelContext` (e.g. asynchronous prefetching).
+//
+// TODO(mrry): We're making some daring assumptions about the lifetime of the
+// runner passed in here. A runner will be deleted when the original step ends,
+// but all existing runners only close over session-lifetime (or longer-lived)
+// state, so we can make a copy of the function. There's nothing in the
+// definition of the API from which we took the runner to guarantee that what we
+// are doing is safe. We should formalize the properties here.
+class IteratorContext {
+ public:
+  struct Params {
+    explicit Params(IteratorContext* ctx)
+        : allocator_getter(ctx->allocator_getter()),
+          cancellation_manager(ctx->cancellation_manager()),
+          collective_executor(ctx->collective_executor()),
+          env(ctx->env()),
+          flr(ctx->flr()),
+          function_handle_cache(ctx->function_handle_cache()),
+          interleave_depth(ctx->interleave_depth()),
+          is_restoring(ctx->is_restoring()),
+          model(ctx->model()),
+          ram_budget_manager(ctx->ram_budget_manager()),
+          resource_mgr(ctx->resource_mgr()),
+          runner(*(ctx->runner())),
+          runner_threadpool_size(ctx->runner_threadpool_size()),
+          split_providers(ctx->split_providers()),
+          stats_aggregator(ctx->stats_aggregator()),
+          symbolic_checkpoint(ctx->symbolic_checkpoint()),
+          thread_factory(ctx->thread_factory()),
+          thread_pool(ctx->thread_pool()),
+          id_registry(ctx->id_registry()),
+          warm_start(ctx->warm_start()) {}
+
+    explicit Params(OpKernelContext* ctx)
+        : collective_executor(ctx->collective_executor()),
+          env(ctx->env()),
+          flr(ctx->function_library()) {
+      // NOTE: need reinterpret_cast because function.h forward-declares Device.
+      DeviceBase* device =
+          reinterpret_cast<DeviceBase*>(ctx->function_library()->device());
+      allocator_getter = [device](AllocatorAttributes attrs) {
+        return device->GetAllocator(attrs);
+      };
+
+      runner_threadpool_size = GetRunnerThreadpoolSizeFromOpKernelContext(ctx);
+
+      // NOTE: Wrap every runner invocation in a call to Runner()->Run(), so
+      // that a symbol in the tensorflow::data namespace is always on the stack
+      // when executing a function inside a Dataset.
+      runner = std::bind(
+          [](
+              // Note: `runner` is a const reference to avoid copying it.
+              const std::function<void(std::function<void()>)>& ctx_runner,
+              std::function<void()> fn) {
+            std::function<void()> wrapped_fn = std::bind(
+                [](const std::function<void()>& fn) { Runner::get()->Run(fn); },
+                std::move(fn));
+            ctx_runner(std::move(wrapped_fn));
+          },
+          *ctx->runner(), std::placeholders::_1);
+    }
+
+    // The Allocator to be used to allocate the output of an iterator.
+    std::function<Allocator*(AllocatorAttributes)> allocator_getter = nullptr;
+
+    // The CancellationManager to be used to cancel execution of ops.
+    CancellationManager* cancellation_manager = nullptr;
+
+    // Collective support.
+    CollectiveExecutor* collective_executor = nullptr;
+
+    // Interface to operating system functionality.
+    Env* env = nullptr;
+
+    // The FunctionLibraryRuntime object to be used to make function calls.
+    FunctionLibraryRuntime* flr = nullptr;
+
+    // A FunctionHandleCache that owns all the function handles. Not owned.
+    FunctionHandleCache* function_handle_cache = nullptr;
+
+    // Records the number of ParallelInterleave operations in the path from the
+    // root node to this node (not including this node) in the input pipeline
+    // tree.
+    int64 interleave_depth = 0;
+
+    // Marks whether the iterator is restored from a checkpoint.
+    bool is_restoring = false;
+
+    // If non-null, identifies the object used for performance modeling.
+    std::shared_ptr<model::Model> model = nullptr;
+
+    // Manager for the ram budget when using autotune.
+    std::shared_ptr<model::RamBudgetManager> ram_budget_manager = nullptr;
+
+    // The input pipeline options.
+    const Options* options = nullptr;
+
+    // A resource manager for storing dataset-related state, e.g. random
+    // seeds or cached tensors. Not owned.
+    ResourceMgr* resource_mgr = nullptr;
+
+    // Function call support.
+    std::function<void(std::function<void()>)> runner = nullptr;
+
+    // Number of threads used for executing user-defined functions.
+    int32 runner_threadpool_size = 0;
+
+    // Split providers indicating which splits to process. May be empty,
+    // indicating that the iterator should process all splits.
+    std::vector<std::shared_ptr<SplitProvider>> split_providers;
+
+    // The `StatsAggregator` object to record statistics about the iterator.
+    //
+    // TODO(b/147325552): Remove this API and any of its uses after we switch to
+    // using C++ based implementation for tf.data options (on 4/12/2021).
+    std::shared_ptr<StatsAggregator> stats_aggregator = nullptr;
+
+    // Indicates whether to use symbolic checkpointing.
+    bool symbolic_checkpoint = false;
+
+    // A factory for creating threads to perform blocking work.
+    std::shared_ptr<ThreadFactory> thread_factory = nullptr;
+
+    // A shared thread pool to schedule computation into.
+    thread::ThreadPoolInterface* thread_pool = nullptr;
+
+    std::shared_ptr<MemoryCheckpoint::IdRegistry> id_registry =
+        std::make_shared<MemoryCheckpoint::IdRegistry>();
+
+    // If `true` background threads of asynchronous operations are started when
+    // the iterator is created. Otherwise, they are started upon first `GetNext`
+    // request. Default value is set to false to ensure backward compatibility.
+    bool warm_start = false;
+
+    // Specifies the tf.data pipeline run mode.
+    RunMode run_mode = RunMode::DEFAULT;
+  };
+
+  explicit IteratorContext(IteratorContext* ctx)
+      : IteratorContext(Params{ctx}) {}
+
+  explicit IteratorContext(OpKernelContext* ctx)
+      : IteratorContext(Params{ctx}) {}
+
+  explicit IteratorContext(Params params)
+      : params_(std::move(params)),
+        checkpoint_(MemoryCheckpoint{params_.id_registry}) {}
+
+  IteratorContext(const IteratorContext& other)
+      : IteratorContext(Params{other.params_}) {
+    // MemoryCheckpoint should not be copied over as the child context should
+    // not care what's in the checkpoint of parent context.
+  }
+
+  std::shared_ptr<MemoryCheckpoint::IdRegistry> id_registry() {
+    return params_.id_registry;
+  }
+
+  Allocator* allocator(AllocatorAttributes attrs) {
+    return params_.allocator_getter(attrs);
+  }
+
+  std::function<Allocator*(AllocatorAttributes)> allocator_getter() {
+    return params_.allocator_getter;
+  }
+
+  CancellationManager* cancellation_manager() {
+    return params_.cancellation_manager;
+  }
+
+  CollectiveExecutor* collective_executor() {
+    return params_.collective_executor;
+  }
+
+  Env* env() const { return params_.env; }
+
+  FunctionLibraryRuntime* flr() { return params_.flr; }
+
+  FunctionHandleCache* function_handle_cache() {
+    return params_.function_handle_cache;
+  }
+
+  MemoryCheckpoint* checkpoint() { return &checkpoint_; }
+
+  int64 interleave_depth() { return params_.interleave_depth; }
+
+  bool is_restoring() { return params_.is_restoring; }
+
+  const std::shared_ptr<model::Model>& model() const { return params_.model; }
+
+  const std::shared_ptr<model::RamBudgetManager>& ram_budget_manager() {
+    return params_.ram_budget_manager;
+  }
+
+  ResourceMgr* resource_mgr() { return params_.resource_mgr; }
+
+  std::function<void(std::function<void()>)>* runner() {
+    return &params_.runner;
+  }
+
+  int32 runner_threadpool_size() { return params_.runner_threadpool_size; }
+
+  std::vector<std::shared_ptr<SplitProvider>> split_providers() const {
+    return params_.split_providers;
+  }
+
+  std::shared_ptr<StatsAggregator> stats_aggregator() {
+    return params_.stats_aggregator;
+  }
+
+  bool symbolic_checkpoint() { return params_.symbolic_checkpoint; }
+
+  const std::shared_ptr<ThreadFactory>& thread_factory() {
+    return params_.thread_factory;
+  }
+
+  thread::ThreadPoolInterface* thread_pool() { return params_.thread_pool; }
+
+  bool warm_start() { return params_.warm_start; }
+
+  RunMode run_mode() { return params_.run_mode; }
+
+  std::unique_ptr<thread::ThreadPool> CreateThreadPool(const string& name,
+                                                       int num_threads) {
+    if (params_.thread_pool) {
+      // Create a `ThreadPool` instance by wrapping `params_.thread_pool` (which
+      // is an instance of `thread::ThreadPoolInterface`). Notably, the
+      // ownership of `params_.thread_pool` is *not* transferred onto the newly
+      // created `ThreadPool` instance.
+      return absl::make_unique<thread::ThreadPool>(params_.thread_pool);
+    } else {
+      return absl::make_unique<thread::ThreadPool>(params_.env, ThreadOptions(),
+                                                   name, num_threads,
+                                                   /*low_latency_hint=*/false);
+    }
+  }
+
+  // Merges the given checkpoint with the checkpoint of this context.
+  //
+  // The intended for this API is that methods, such as
+  // `IteratorBase::Initialize`, `IteratorBase::GetNextInternal`, or
+  // `IteratorBase::RestoreInternal` that store data in the in-memory
+  // checkpoint, use a separate instance of `IteratorContext` for a nested call,
+  // then the checkpoint collected by the `IteratorContext` instance passed into
+  // the callee should be merged into the `IteratorContext` of the caller:
+  //
+  // ```
+  // Status GetNextInternal(IteratorContext* ctx, ...) {
+  //   ...
+  //   IteratorContext nested_ctx(...);
+  //   TF_RETURN_IF_ERROR(input_impl_->GetNext(&nested_ctx, ...));
+  //   ctx->MergeCheckpoint(nested_ctx->checkpoint());
+  //   ...
+  // }
+  // ```
+  void MergeCheckpoint(MemoryCheckpoint* checkpoint) {
+    if (symbolic_checkpoint()) {
+      checkpoint_.Merge(checkpoint);
+    }
+  }
+
+  // Removes any keys with the given prefix from the checkpoint.
+  //
+  // The intended use for this API is to clean the stale state in checkpoint,
+  // e.g. when a pipeline created by `flat_map` is exhausted, the state
+  // associated with the iterator of that pipeline is no longer needed and
+  // should be removed.
+  void PurgeCheckpoint(const std::string& prefix) {
+    if (symbolic_checkpoint()) {
+      checkpoint_.Purge(prefix);
+    }
+  }
+
+  // Saves the state of the given iterator into the checkpoint.
+  void SaveCheckpoint(Checkpointable* iterator) {
+    if (symbolic_checkpoint()) {
+      SerializationContext::Params params;
+      params.symbolic_checkpoint = true;
+      SerializationContext ctx(std::move(params));
+      checkpoint_.UpdateStatus(iterator->Save(&ctx, &checkpoint_));
+    }
+  }
+
+  std::unique_ptr<Thread> StartThread(const string& name,
+                                      std::function<void()> fn) {
+    if (params_.thread_factory) {
+      return params_.thread_factory->StartThread(name, std::move(fn));
+    } else {
+      return absl::WrapUnique(
+          Env::Default()->StartThread({}, name, std::move(fn)));
+    }
+  }
+
+  // Updates the status of the checkpoint with the given status.
+  void UpdateCheckpointStatus(std::function<Status()> status_fn) {
+    if (symbolic_checkpoint()) {
+      checkpoint_.UpdateStatus(status_fn());
+    }
+  }
+
+ private:
+  Params params_;
+  MemoryCheckpoint checkpoint_;
+};
+
+// Represents the current position in a range of outputs, where the
+// range of outputs is typically represented by an `DatasetBase`,
+// defined below.
+class IteratorBase : public Checkpointable {
+ public:
+  virtual ~IteratorBase() {
+    for (auto rit = cleanup_fns_.rbegin(); rit != cleanup_fns_.rend(); ++rit) {
+      (*rit)();
+    }
+  }
+
+  // Gets the next output from the range that this iterator is traversing.
+  //
+  // If at least one output remains in this iterator's range, that
+  // output will be stored in `*out_tensors` and `false` will be
+  // stored in `*end_of_sequence`.
+  //
+  // If no more outputs remain in this iterator's range, `true` will be stored
+  // in `*end_of_sequence`, and `*out_tensors` will be empty.
+  //
+  // Implementations should never return `OutOfRange` error. If at end of
+  // sequence, set `*end_of_sequence = true` and return `OkStatus()`.
+  // Internally raised `OutOfRange` errors that do not imply end of sequence
+  // should be converted to a different error type before being propagated to
+  // the caller.
+  //
+  // Implementations must explicitly set `*end_of_sequence = false` if an
+  // `OkStatus()` status is returned and the iterator is not at the end of the
+  // sequence.
+  //
+  // `out_tensors` and `end_of_sequence` are output parameters. `*out_tensors`
+  // and `*end_of_sequence` should not be read by implementations of `GetNext`
+  // before they are assigned.
+  //
+  // This method is thread-safe.
+  //
+  // TODO(mrry): Define `GetNextAsync()` or `GetNextManyAsync()`, and
+  // potentially remove this method.
+  virtual Status GetNext(IteratorContext* ctx, std::vector<Tensor>* out_tensors,
+                         bool* end_of_sequence) = 0;
+
+  Status GetNext(IteratorContext&& ctx, std::vector<Tensor>* out_tensors,
+                 bool* end_of_sequence) {
+    return GetNext(&ctx, out_tensors, end_of_sequence);
+  }
+
+  // Skips the next `num_to_skip` outputs from the range that this iterator
+  // is traversing.
+  //
+  // If there are not enough outputs to skip, it will set
+  // `*end_of_sequence = true` and return `OkStatus()`. `*num_skipped` will
+  // store the number of outputs that are skipped. When `*end_of_sequence` is
+  // `false`, `*num_skipped` should equal to `num_to_skip`.
+  virtual Status Skip(IteratorContext* ctx, int num_to_skip,
+                      bool* end_of_sequence, int* num_skipped) = 0;
+
+  virtual Status Skip(IteratorContext&& ctx, int num_to_skip,
+                      bool* end_of_sequence, int* num_skipped) {
+    return Skip(&ctx, num_to_skip, end_of_sequence, num_skipped);
+  }
+
+  // Returns a vector of DataType values, representing the respective
+  // element types of each tuple component in the outputs of this
+  // iterator.
+  virtual const DataTypeVector& output_dtypes() const = 0;
+
+  // Returns a vector of tensor shapes, representing the respective
+  // (and possibly partially defined) shapes of each tuple component
+  // in the outputs of this iterator.
+  virtual const std::vector<PartialTensorShape>& output_shapes() const = 0;
+
+  // Returns a string that identifies the sequence of iterators leading up to
+  // this iterator.
+  virtual const string& prefix() const = 0;
+
+  // Indicates whether the iterator is compatible with symbolic checkpointing.
+  virtual bool SymbolicCheckpointCompatible() const { return false; }
+
+  // Performs initialization that needs to happen outside of a constructor to
+  // properly propagate errors.
+  virtual Status Initialize(IteratorContext* ctx) { return OkStatus(); }
+
+  // Performs initialization of the base iterator.
+  Status InitializeBase(IteratorContext* ctx, const IteratorBase* parent);
+
+  // Saves the state of this iterator.
+  Status Save(SerializationContext* ctx, IteratorStateWriter* writer) override {
+    int64_t start_us = EnvTime::NowMicros();
+    TF_RETURN_IF_ERROR(SaveInternal(ctx, writer));
+    VLOG(1) << "Saved " << prefix() << " in "
+            << (EnvTime::NowMicros() - start_us) << "us";
+    return OkStatus();
+  }
+
+  // Restores the state of this iterator.
+  Status Restore(IteratorContext* ctx, IteratorStateReader* reader) override {
+    int64_t start_us = EnvTime::NowMicros();
+    TF_RETURN_IF_ERROR(RestoreInternal(ctx, reader));
+    ctx->SaveCheckpoint(this);
+    VLOG(1) << "Restored " << prefix() << " in "
+            << (EnvTime::NowMicros() - start_us) << "us";
+    return OkStatus();
+  }
+
+  // Returns the total number of bytes buffered by the iterator across all nodes
+  // in the subtree for which autotuning is enabled.
+  int64_t TotalBufferedBytes() const {
+    if (node_) return node_->TotalBufferedBytes();
+    return 0;
+  }
+
+ protected:
+  // Returns a node that models this iterator.
+  virtual std::shared_ptr<model::Node> CreateNode(
+      IteratorContext* ctx, model::Node::Args args) const = 0;
+
+  // This is needed so that sub-classes of IteratorBase can call
+  // `SaveInternal` on their input iterators.
+  Status SaveInput(SerializationContext* ctx, IteratorStateWriter* writer,
+                   const std::unique_ptr<IteratorBase>& input) {
+    if (ctx->symbolic_checkpoint()) {
+      return OkStatus();
+    }
+    return input->Save(ctx, writer);
+  }
+
+  // This is needed so that sub-classes of IteratorBase can call
+  // `RestoreInternal` on their input iterators.
+  Status RestoreInput(IteratorContext* ctx, IteratorStateReader* reader,
+                      const std::unique_ptr<IteratorBase>& input) {
+    return input->Restore(ctx, reader);
+  }
+
+  Status RestoreInput(IteratorContext&& ctx, IteratorStateReader* reader,
+                      const std::unique_ptr<IteratorBase>& input) {
+    return RestoreInput(&ctx, reader, input);
+  }
+
+  // Saves the state of this iterator.
+  //
+  // This method is used to store the state of the iterator in a checkpoint.
+  // implementations have an override.
+  virtual Status SaveInternal(SerializationContext* ctx,
+                              IteratorStateWriter* writer) = 0;
+
+  // Restores the state of this iterator.
+  //
+  // This method is used to restore the state of the iterator from a checkpoint.
+  //
+  // Implementations may assume that the iterator is in a clean state. That is,
+  // its `Initialize` method has been called, but its `GetNext` method has
+  // never been called.
+  // implementations have an override.
+  virtual Status RestoreInternal(IteratorContext* ctx,
+                                 IteratorStateReader* reader) = 0;
+
+  // Returns a pointer to the node representing this iterator in the performance
+  // model. It may be null, if performance modeling is not enabled for this
+  // iterator.
+  std::shared_ptr<model::Node> model_node() const { return node_; }
+
+  // Returns the number of elements produced by this iterator.
+  int64_t num_elements() const {
+    if (node_) return node_->num_elements();
+    return 0;
+  }
+
+ private:
+  // For access to `AddCleanupFunction` and `Restore`.
+  friend class DatasetBase;
+  friend class DatasetBaseIterator;  // for access to `node_`
+
+  std::vector<std::function<void()>> cleanup_fns_;
+  std::shared_ptr<model::Node> node_ = nullptr;
+  const IteratorBase* parent_ = nullptr;  // Not owned.
+  uint64_t id_ = 0;
+  uint64_t parent_id_ = 0;
+};
+
+// Represents runtime information needed to construct a dataset.
+class DatasetContext {
+ public:
+  struct Params {
+    string type_string;  // op type name of this dataset.
+    string node_name;    // graph node name of this dataset op, uniquely
+                         // identifying the dataset in the graph.
+  };
+
+  explicit DatasetContext(Params params) : params_(std::move(params)) {}
+
+  explicit DatasetContext(OpKernelContext* ctx) {
+    params_.type_string = ctx->op_kernel().type_string();
+    params_.node_name = ctx->op_kernel().name();
+  }
+
+  const string& type_string() const { return params_.type_string; }
+  const string& node_name() const { return params_.node_name; }
+
+ private:
+  Params params_;
+};
+
+// Returns the number of bytes allocated for the given tensor.
+int64_t GetAllocatedBytes(const std::vector<Tensor>& element);
+
+// Returns the estimated memory usage in bytes of the given tensor.
+int64_t GetTotalBytes(const std::vector<Tensor>& element);
+
+// Validates and extracts a `DatasetBase` object from `tensor`.
+//
+// `tensor` must have been written by a call to SetVariantTensorToDataset().
+//
+// The retrieved pointer is a borrowed reference to the dataset, which is owned
+// by the tensor. The consumer must either acquire its own reference to the
+// dataset by calling `(*out_dataset)->Ref()`, or ensure that `tensor` is not
+// destroyed or mutated while the retrieved pointer is in use.
+Status GetDatasetFromVariantTensor(const Tensor& tensor,
+                                   DatasetBase** out_dataset);
+
+// Stores a `DatasetBase` object in `tensor`.
+//
+// The ownership of `dataset` is transferred to `tensor`.
+Status StoreDatasetInVariantTensor(DatasetBase* dataset, Tensor* tensor);
+
+// Represents a (potentially infinite) range of outputs, where each
+// output is a tuple of tensors.
+class DatasetBase : public core::RefCounted {
+ public:
+  // Key for storing the Dataset graph in the serialized format.
+  TF_EXPORT static const char kDatasetGraphKey[];
+
+  // Key for storing the output node of the Dataset graph in the serialized
+  // format.
+  TF_EXPORT static const char kDatasetGraphOutputNodeKey[];
+
+  explicit DatasetBase(DatasetContext&& ctx)
+      : type_string_(ctx.type_string()), node_name_(ctx.node_name()) {}
+
+  // Op type name of this dataset.
+  const string& type_string() const { return type_string_; }
+
+  // Graph node name of this dataset op, uniquely identifying the dataset in
+  // the graph.
+  const string& node_name() const { return node_name_; }
+
+  const Metadata& metadata() const { return metadata_; }
+
+  const Options& options() const { return options_; }
+
+  int64_t num_sources() const { return num_sources_; }
+
+  // Initializes the dataset using the given metadata.
+  void Initialize(const Metadata& metadata);
+
+  // Returns a new iterator for iterating over the range of elements in
+  // this dataset.
+  //
+  // This method may be called multiple times on the same instance,
+  // and the resulting iterators will have distinct state. Each
+  // iterator will traverse all elements in this dataset from the
+  // start.
+  //
+  // The prefix identifies the sequence of iterators leading up to the newly
+  // created iterator.
+  Status MakeIterator(IteratorContext* ctx, const IteratorBase* parent,
+                      const string& output_prefix,
+                      std::unique_ptr<IteratorBase>* iterator) const;
+
+  Status MakeIterator(IteratorContext&& ctx, const IteratorBase* parent,
+                      const string& output_prefix,
+                      std::unique_ptr<IteratorBase>* iterator) const {
+    return MakeIterator(&ctx, parent, output_prefix, iterator);
+  }
+
+  // Returns a new iterator restored from the checkpoint data in `reader`.
+  Status MakeIteratorFromCheckpoint(
+      IteratorContext* ctx, const string& output_prefix,
+      IteratorStateReader* reader,
+      std::unique_ptr<IteratorBase>* iterator) const {
+    std::unique_ptr<IteratorBase> it;
+    IteratorContext::Params params(ctx);
+    params.is_restoring = true;
+    IteratorContext restore_ctx(std::move(params));
+    TF_RETURN_IF_ERROR(MakeIterator(&restore_ctx,
+                                    /*parent=*/nullptr, output_prefix, &it));
+    TF_RETURN_IF_ERROR(it->Restore(&restore_ctx, reader));
+    ctx->MergeCheckpoint(restore_ctx.checkpoint());
+    *iterator = std::move(it);
+    return OkStatus();
+  }
+
+  Status MakeIteratorFromCheckpoint(
+      IteratorContext&& ctx, const string& output_prefix,
+      IteratorStateReader* reader,
+      std::unique_ptr<IteratorBase>* iterator) const {
+    return MakeIteratorFromCheckpoint(&ctx, output_prefix, reader, iterator);
+  }
+
+  // Returns a split provider which partitions the dataset's data into splits
+  // and provides them in a sequence. The split provider is stored in
+  // `*split_provider`.
+  virtual Status MakeSplitProviders(
+      std::vector<std::unique_ptr<SplitProvider>>* split_providers) const;
+
+  // Returns a vector of DataType values, representing the respective
+  // element types of each tuple component in the outputs of this
+  // dataset.
+  virtual const DataTypeVector& output_dtypes() const = 0;
+
+  // Returns a vector of tensor shapes, representing the respective
+  // (and possibly partially defined) shapes of each tuple component
+  // in the outputs of this dataset.
+  virtual const std::vector<PartialTensorShape>& output_shapes() const = 0;
+
+  // Returns the number of bytes allocated for tensors of this dataset.
+  virtual int64_t AllocatedBytes() const { return 0; }
+
+  // Returns the estimated number of bytes used for tensors of this dataset.
+  virtual int64_t TotalBytes() const { return 0; }
+
+  // Returns the cardinality of this dataset.
+  // TODO(shilpakrish): Remove this overload once all callers are migrated
+  // to the API which passes in the options parameter.
+  ABSL_DEPRECATED("Use the overload that passes in the options parameter.")
+  int64_t Cardinality() const;
+
+  // Returns the cardinality of this dataset based on the options.
+  int64_t Cardinality(CardinalityOptions options) const;
+
+  // Internal implementation of cardinality for a dataset based on the options.
+  virtual int64_t CardinalityInternal(CardinalityOptions options) const
+      TF_EXCLUSIVE_LOCKS_REQUIRED(cardinality_mu_) {
+    return kUnknownCardinality;
+  }
+
+  // A human-readable debug string for this dataset.
+  virtual string DebugString() const = 0;
+
+  // Stores the dataset's input datasets in `*inputs`. The pointers stored in
+  // `*inputs` are borrowed. The only valid non-ok return status is
+  // UNIMPLEMENTED in case `InputDatasets` is not implemented by a dataset
+  // subclass. Implementing `InputDatasets` enables `DatasetBase` to provide a
+  // default implementation of `MakeSplitProvider` when there is a single input
+  // dataset.
+  virtual Status InputDatasets(std::vector<const DatasetBase*>* inputs) const;
+
+  // Indicates whether the dataset depends on any external state which would
+  // prevent it from being serializable. If so, the method returns
+  // `errors::FailedPrecondition` with a message that identifies the external
+  // state. Otherwise, the method returns `OkStatus()`.
+  virtual Status CheckExternalState() const = 0;
+
+  // Indicates whether the dataset is compatible with random access.
+  Status CheckRandomAccessCompatible(const int64 index) const;
+
+  // Return the element at a particular index for a randomly accessible dataset.
+  virtual Status Get(OpKernelContext* ctx, int64 index,
+                     std::vector<Tensor>* out_tensors) const;
+
+  // Return a finalized version of the dataset.  The returned DatasetBase is
+  // unowned and lives for as long as this dataset.
+  virtual StatusOr<DatasetBase*> Finalize(
+      OpKernelContext* ctx,
+      std::function<StatusOr<core::RefCountPtr<DatasetBase>>()>
+          make_finalized_dataset) const;
+
+  // Wrapper around a GraphDefBuilder which provides support for serializing
+  // Datasets as GraphDefs.
+  class DatasetGraphDefBuilder : public GraphDefBuilderWrapper {
+   public:
+    explicit DatasetGraphDefBuilder(GraphDefBuilder* b)
+        : GraphDefBuilderWrapper(b) {}
+    Status AddInputDataset(SerializationContext* ctx,
+                           const DatasetBase* dataset, Node** output);
+    Status AddDatasetOrTensor(SerializationContext* ctx, const Tensor& val,
+                              Node** output);
+    Status AddIdentity(SerializationContext* ctx,
+                       const std::string& name_prefix, Node** input,
+                       Node** output);
+
+   private:
+    Status AddDatasetOrTensorHelper(SerializationContext* ctx,
+                                    const Tensor& val, Node** output);
+    Status AddResourceHelper(SerializationContext* ctx, const Tensor& val,
+                             Node** output);
+  };
+
+ protected:
+  friend class CapturedFunction;
+
+  // Serializes the dataset into a `GraphDef`, which has two uses:
+  //
+  // 1) To perform static input pipeline optimizations, tf.data serializes the
+  // dataset graph, applies graph rewrites, and then deserializes the graph.
+  // If a subclass of `DatasetBase` does not implement this method, then it will
+  // be excluded from static optimizations (and so will any upstream datasets).
+  //
+  // 2) To save the dataset so that it can restore at a later point (possibly in
+  // different environment). If a subclass of `DatasetBase` does not implement
+  // this method, then this migration will not be possible.
+  virtual Status AsGraphDefInternal(SerializationContext* ctx,
+                                    DatasetGraphDefBuilder* b,
+                                    Node** node) const = 0;
+
+  virtual std::unique_ptr<IteratorBase> MakeIteratorInternal(
+      const string& prefix) const = 0;
+
+  void set_options(const Options& options) { options_ = options; }
+
+ private:
+  // Computes and stores the cardinality of a given dataset.
+  Status ComputeCardinality();
+
+  // Computes the number of source datasets feeding into this dataset. A source
+  // dataset is a leaf in the subtree of dataset inputs.
+  Status ComputeNumSources();
+
+  // Merges options from inputs to this dataset. If there is a conflict in a
+  // field value, the options set on this dataset takes precedence over those in
+  // the inputs. The order of precedence on the inputs is in the same order as
+  // how they appear for this dataset.
+  Status MergeOptionsFromInputs();
+
+  const string type_string_;
+  const string node_name_;
+  Metadata metadata_;
+  Options options_;
+  mutable mutex mu_;
+  mutable mutex cardinality_mu_;
+  mutable core::RefCountPtr<DatasetBase> finalized_dataset_;
+  //  The number of source datasets feeding into the dataset. A source dataset
+  //  is a leaf in the subtree of dataset inputs.
+  int64_t num_sources_ = -1;
+  mutable int64_t cardinality_ TF_GUARDED_BY(cardinality_mu_) =
+      kUnknownCardinality;
+};
+
+// Represents an iterator that is associated with a particular dataset.
+class DatasetBaseIterator : public IteratorBase {
+ public:
+  struct BaseParams {
+    // Owns one reference on the shared dataset object.
+    const DatasetBase* dataset;
+
+    // Identifies the sequence of iterators leading up to this iterator.
+    const string prefix;
+  };
+
+  explicit DatasetBaseIterator(const BaseParams& params);
+
+  ~DatasetBaseIterator() override;
+
+  virtual const DatasetBase* dataset() const { return params_.dataset; }
+
+  const DataTypeVector& output_dtypes() const override {
+    return params_.dataset->output_dtypes();
+  }
+
+  const std::vector<PartialTensorShape>& output_shapes() const override {
+    return params_.dataset->output_shapes();
+  }
+
+  const string& prefix() const override { return params_.prefix; }
+
+  // Returns a name to be used for the TraceMe event.
+  //
+  // NOTE: TraceMe supports passing key-value pairs of "arguments" using the
+  // following format "name#arg_1=value_,...,arg_n=value_n".
+  string BuildTraceMeName();
+
+  Status GetNext(IteratorContext* ctx, std::vector<Tensor>* out_tensors,
+                 bool* end_of_sequence) final;
+
+  Status GetNext(IteratorContext&& ctx, std::vector<Tensor>* out_tensors,
+                 bool* end_of_sequence) {
+    return GetNext(&ctx, out_tensors, end_of_sequence);
+  }
+
+  Status Skip(IteratorContext* ctx, int num_to_skip, bool* end_of_sequence,
+              int* num_skipped) final;
+
+  Status Save(SerializationContext* ctx, IteratorStateWriter* writer) final {
+    VLOG(2) << "Attempting to save checkpoints on iterator (prefix: "
+            << prefix() << ") from " << dataset()->DebugString();
+    return IteratorBase::Save(ctx, writer);
+  }
+
+ protected:
+  Status Restore(IteratorContext* ctx, IteratorStateReader* reader) final {
+    VLOG(2) << "Attempting to restore checkpoints on iterator (prefix: "
+            << prefix() << ") from " << dataset()->DebugString();
+    return IteratorBase::Restore(ctx, reader);
+  }
+
+  // Internal implementation of GetNext that is wrapped in tracing logic.
+  //
+  // See the docstring of `GetNext` method regaring the contract for
+  // `out_tensors` and `end_of_sequence`. Implementations may assume that
+  // `*out_tensors` is empty.
+  virtual Status GetNextInternal(IteratorContext* ctx,
+                                 std::vector<Tensor>* out_tensors,
+                                 bool* end_of_sequence) = 0;
+
+  // Internal implementation of Skip that is wrapped in tracing logic
+  virtual Status SkipInternal(IteratorContext* ctx, int num_to_skip,
+                              bool* end_of_sequence, int* num_skipped);
+
+  string full_name(const string& name) const {
+    return FullName(params_.prefix, name);
+  }
+
+  // Returns a map of key-value pairs to included in the TraceMe string.
+  virtual TraceMeMetadata GetTraceMeMetadata() const { return {}; }
+
+  // By default we model iterators using an unknown node, which acts as
+  // pass-through with respect to performance modeling.
+  std::shared_ptr<model::Node> CreateNode(
+      IteratorContext* ctx, model::Node::Args args) const override {
+    return model::MakeUnknownNode(std::move(args));
+  }
+
+  // When modeling is enabled, this method disables autotuning for the given
+  // iterator (and the transitive closure of its inputs).
+  void DisableAutotune(IteratorContext* ctx, IteratorBase* iterator) {
+    if (iterator->node_) {
+      iterator->node_->set_autotune(false);
+    }
+  }
+
+  // When modeling is enabled, this method enables autotuning for the given
+  // iterator (and the transitive closure of its inputs).
+  void EnableAutotune(IteratorContext* ctx, IteratorBase* iterator) {
+    if (iterator->node_) {
+      iterator->node_->set_autotune(true);
+    }
+  }
+
+  // When modeling is enabled, this method records the fact that this iterator
+  // has dequeued an element from an internal buffer.
+  void RecordBufferDequeue(IteratorContext* ctx,
+                           const std::vector<Tensor>& element) {
+    if (collect_resource_usage(ctx)) {
+      node_->record_buffer_event(-GetAllocatedBytes(element), -1);
+      DCHECK_GE(node_->buffered_elements(), 0);
+    }
+  }
+
+  // When modeling is enabled, this method records the fact that this iterator
+  // has enqueued an element in an internal buffer.
+  void RecordBufferEnqueue(IteratorContext* ctx,
+                           const std::vector<Tensor>& element) {
+    if (collect_resource_usage(ctx)) {
+      node_->record_buffer_event(GetAllocatedBytes(element), 1);
+    }
+  }
+
+  // When modeling is enabled, this method records the fact that this iterator
+  // has produced an element and its size in bytes.
+  void RecordElement(IteratorContext* ctx, std::vector<Tensor>* out_tensors) {
+    if (collect_resource_usage(ctx)) {
+      int64_t num_bytes = GetAllocatedBytes(*out_tensors);
+      node_->record_element();
+      node_->record_bytes_produced(num_bytes);
+      if (node_->output()) {
+        node_->output()->record_bytes_consumed(num_bytes);
+      }
+    }
+  }
+
+  // When modeling is enabled, this method records the fact that a thread of
+  // this iterator has started work.
+  void RecordStart(IteratorContext* ctx) {
+    if (collect_resource_usage(ctx)) {
+      int64_t now_nanos = EnvTime::NowNanos();
+      node_->record_start(now_nanos);
+    }
+  }
+
+  // When modeling is enabled, this method records the fact that a thread of
+  // this iterator has stopped work.
+  void RecordStop(IteratorContext* ctx) {
+    if (collect_resource_usage(ctx)) {
+      int64_t now_nanos = EnvTime::NowNanos();
+      node_->record_stop(now_nanos);
+    }
+  }
+
+  // Returns whether work is currently being recorded, i.e. whether we are
+  // currently between a `RecordStart` and a `RecordStop`.
+  bool IsRecording(IteratorContext* ctx) {
+    return node_ && node_->is_recording();
+  }
+
+ private:
+  bool collect_resource_usage(IteratorContext* ctx) {
+    return ctx->model() && node_;
+  }
+
+  string traceme_metadata_;
+  BaseParams params_;
+};
+
+// Represents an iterator that is associated with a particular dataset
+// with a particular type.
+template <class DatasetType>
+class DatasetIterator : public DatasetBaseIterator {
+ public:
+  struct Params {
+    // Borrowed pointer to the dataset.
+    const DatasetType* dataset;
+
+    // Identifies the sequence of iterators leading up to this iterator.
+    const string prefix;
+  };
+
+  explicit DatasetIterator(const Params& params)
+      : DatasetBaseIterator({params.dataset, params.prefix}),
+        typed_dataset_(params.dataset) {}
+
+  // The dataset from which this iterator was created.
+  const DatasetType* dataset() const final { return typed_dataset_; }
+
+ private:
+  const DatasetType* const typed_dataset_;  // Not owned.
+};
+
+template <typename T>
+Status ParseScalarArgument(OpKernelContext* ctx,
+                           const StringPiece& argument_name, T* output) {
+  const Tensor* argument_t;
+  TF_RETURN_IF_ERROR(ctx->input(argument_name, &argument_t));
+  if (!TensorShapeUtils::IsScalar(argument_t->shape())) {
+    return errors::InvalidArgument(argument_name, " must be a scalar");
+  }
+  *output = argument_t->scalar<T>()();
+  return OkStatus();
+}
+
+template <typename T>
+Status ParseVectorArgument(OpKernelContext* ctx,
+                           const StringPiece& argument_name,
+                           std::vector<T>* output) {
+  const Tensor* argument_t;
+  TF_RETURN_IF_ERROR(ctx->input(argument_name, &argument_t));
+  if (!TensorShapeUtils::IsVector(argument_t->shape())) {
+    return errors::InvalidArgument(argument_name, " must be a vector");
+  }
+  int size = argument_t->vec<T>().size();
+  output->reserve(size);
+  for (int i = 0; i < size; ++i) {
+    output->push_back(argument_t->vec<T>()(i));
+  }
+  return OkStatus();
+}
+
+// Encapsulates the work required to plug a DatasetBase into the core TensorFlow
+// graph execution engine.
+class DatasetOpKernel : public OpKernel {
+ public:
+  explicit DatasetOpKernel(OpKernelConstruction* ctx) : OpKernel(ctx) {
+    if (ctx->HasAttr(kMetadata)) {
+      std::string serialized_metadata;
+      OP_REQUIRES_OK(ctx, ctx->GetAttr(kMetadata, &serialized_metadata));
+      OP_REQUIRES(ctx, metadata_.ParseFromString(serialized_metadata),
+                  errors::InvalidArgument(absl::StrCat(
+                      "Could not parse the 'metadata' attribute.")));
+    }
+  }
+
+  void Compute(OpKernelContext* ctx) final;
+
+  // Checks whether the given op is a tf.data operation.
+  //
+  // NOTE: The check uses a heuristic and can produce both false positives and
+  // false negatives. In particular, tf.data operations are expected to use
+  // names that end with "Dataset" or "DatasetV[0-9]+".
+  static bool IsDatasetOp(const OpDef& op_def);
+
+  string TraceString(const OpKernelContext& ctx, bool verbose) const override;
+
+ protected:
+  // Subclasses should implement this method. It will be called during Compute
+  // execution.
+  virtual void MakeDataset(OpKernelContext* ctx, DatasetBase** output) = 0;
+
+ private:
+  Metadata metadata_;
+};
+
+// Encapsulates the work required to plug unary Datasets into the core
+// TensorFlow graph execution engine.
+class UnaryDatasetOpKernel : public DatasetOpKernel {
+ public:
+  explicit UnaryDatasetOpKernel(OpKernelConstruction* ctx)
+      : DatasetOpKernel(ctx) {}
+
+ protected:
+  void MakeDataset(OpKernelContext* ctx, DatasetBase** output) final;
+  virtual void MakeDataset(OpKernelContext* ctx, DatasetBase* input,
+                           DatasetBase** output) = 0;
+};
+
+// Encapsulates the work required to plug binary Datasets into the core
+// TensorFlow graph execution engine.
+class BinaryDatasetOpKernel : public DatasetOpKernel {
+ public:
+  explicit BinaryDatasetOpKernel(OpKernelConstruction* ctx)
+      : DatasetOpKernel(ctx) {}
+
+ protected:
+  void MakeDataset(OpKernelContext* ctx, DatasetBase** output) final;
+  virtual void MakeDataset(OpKernelContext* ctx, DatasetBase* input,
+                           DatasetBase* another_input,
+                           DatasetBase** output) = 0;
+};
+
+// A simple background worker that executes closures asynchronously and without
+// blocking.
+//
+// A `BackgroundWorker` is used to offload blocking work from an `AsyncOpKernel`
+// to avoid blocking an executor thread that may be required by the blocking
+// work.
+//
+// NOTE(mrry): We do not use a regular `tensorflow::thread::ThreadPool` for this
+// purpose because its current implementation (in Eigen) uses a finite-length
+// queue and will block the caller when full. This can lead to deadlock under
+// heavy load. Since the number of concurrent work items in each user of a
+// `BackgroundWorker` is at most one per op invocation, the dynamic allocation
+// overhead is tolerable.
+class BackgroundWorker {
+ public:
+  BackgroundWorker(Env* env, const char* name);
+
+  ~BackgroundWorker();
+
+  void Schedule(std::function<void()> work_item);
+
+ private:
+  void WorkerLoop();
+
+  Env* const env_;
+  const char* const name_;
+
+  std::unique_ptr<Thread> thread_;
+  mutex mu_;
+  condition_variable cond_var_;
+  bool cancelled_ TF_GUARDED_BY(mu_) = false;
+  std::deque<std::function<void()>> work_queue_ TF_GUARDED_BY(mu_);
+};
+
+}  // namespace data
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_DATASET_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/dataset.pb.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/dataset.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..fb7c775b34b65a7f72ed555a1b149d89a39ccd6d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/dataset.pb.h
@@ -0,0 +1,939 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: tensorflow/core/framework/dataset.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fdataset_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fdataset_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3021000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3021009 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+#include "tensorflow/core/framework/tensor.pb.h"
+#include "tensorflow/core/framework/tensor_shape.pb.h"
+#include "tensorflow/core/framework/types.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_tensorflow_2fcore_2fframework_2fdataset_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_tensorflow_2fcore_2fframework_2fdataset_2eproto {
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_tensorflow_2fcore_2fframework_2fdataset_2eproto;
+namespace tensorflow {
+namespace data {
+class CompressedComponentMetadata;
+struct CompressedComponentMetadataDefaultTypeInternal;
+extern CompressedComponentMetadataDefaultTypeInternal _CompressedComponentMetadata_default_instance_;
+class CompressedElement;
+struct CompressedElementDefaultTypeInternal;
+extern CompressedElementDefaultTypeInternal _CompressedElement_default_instance_;
+class UncompressedElement;
+struct UncompressedElementDefaultTypeInternal;
+extern UncompressedElementDefaultTypeInternal _UncompressedElement_default_instance_;
+}  // namespace data
+}  // namespace tensorflow
+PROTOBUF_NAMESPACE_OPEN
+template<> ::tensorflow::data::CompressedComponentMetadata* Arena::CreateMaybeMessage<::tensorflow::data::CompressedComponentMetadata>(Arena*);
+template<> ::tensorflow::data::CompressedElement* Arena::CreateMaybeMessage<::tensorflow::data::CompressedElement>(Arena*);
+template<> ::tensorflow::data::UncompressedElement* Arena::CreateMaybeMessage<::tensorflow::data::UncompressedElement>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace tensorflow {
+namespace data {
+
+// ===================================================================
+
+class CompressedComponentMetadata final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.data.CompressedComponentMetadata) */ {
+ public:
+  inline CompressedComponentMetadata() : CompressedComponentMetadata(nullptr) {}
+  ~CompressedComponentMetadata() override;
+  explicit PROTOBUF_CONSTEXPR CompressedComponentMetadata(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  CompressedComponentMetadata(const CompressedComponentMetadata& from);
+  CompressedComponentMetadata(CompressedComponentMetadata&& from) noexcept
+    : CompressedComponentMetadata() {
+    *this = ::std::move(from);
+  }
+
+  inline CompressedComponentMetadata& operator=(const CompressedComponentMetadata& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline CompressedComponentMetadata& operator=(CompressedComponentMetadata&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const CompressedComponentMetadata& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const CompressedComponentMetadata* internal_default_instance() {
+    return reinterpret_cast<const CompressedComponentMetadata*>(
+               &_CompressedComponentMetadata_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(CompressedComponentMetadata& a, CompressedComponentMetadata& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(CompressedComponentMetadata* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(CompressedComponentMetadata* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  CompressedComponentMetadata* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<CompressedComponentMetadata>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const CompressedComponentMetadata& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const CompressedComponentMetadata& from) {
+    CompressedComponentMetadata::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(CompressedComponentMetadata* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.data.CompressedComponentMetadata";
+  }
+  protected:
+  explicit CompressedComponentMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kUncompressedBytesFieldNumber = 4,
+    kTensorShapeFieldNumber = 2,
+    kDtypeFieldNumber = 1,
+  };
+  // repeated uint64 uncompressed_bytes = 4;
+  int uncompressed_bytes_size() const;
+  private:
+  int _internal_uncompressed_bytes_size() const;
+  public:
+  void clear_uncompressed_bytes();
+  private:
+  uint64_t _internal_uncompressed_bytes(int index) const;
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
+      _internal_uncompressed_bytes() const;
+  void _internal_add_uncompressed_bytes(uint64_t value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
+      _internal_mutable_uncompressed_bytes();
+  public:
+  uint64_t uncompressed_bytes(int index) const;
+  void set_uncompressed_bytes(int index, uint64_t value);
+  void add_uncompressed_bytes(uint64_t value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
+      uncompressed_bytes() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
+      mutable_uncompressed_bytes();
+
+  // .tensorflow.TensorShapeProto tensor_shape = 2;
+  bool has_tensor_shape() const;
+  private:
+  bool _internal_has_tensor_shape() const;
+  public:
+  void clear_tensor_shape();
+  const ::tensorflow::TensorShapeProto& tensor_shape() const;
+  PROTOBUF_NODISCARD ::tensorflow::TensorShapeProto* release_tensor_shape();
+  ::tensorflow::TensorShapeProto* mutable_tensor_shape();
+  void set_allocated_tensor_shape(::tensorflow::TensorShapeProto* tensor_shape);
+  private:
+  const ::tensorflow::TensorShapeProto& _internal_tensor_shape() const;
+  ::tensorflow::TensorShapeProto* _internal_mutable_tensor_shape();
+  public:
+  void unsafe_arena_set_allocated_tensor_shape(
+      ::tensorflow::TensorShapeProto* tensor_shape);
+  ::tensorflow::TensorShapeProto* unsafe_arena_release_tensor_shape();
+
+  // .tensorflow.DataType dtype = 1;
+  void clear_dtype();
+  ::tensorflow::DataType dtype() const;
+  void set_dtype(::tensorflow::DataType value);
+  private:
+  ::tensorflow::DataType _internal_dtype() const;
+  void _internal_set_dtype(::tensorflow::DataType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.data.CompressedComponentMetadata)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t > uncompressed_bytes_;
+    mutable std::atomic<int> _uncompressed_bytes_cached_byte_size_;
+    ::tensorflow::TensorShapeProto* tensor_shape_;
+    int dtype_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fdataset_2eproto;
+};
+// -------------------------------------------------------------------
+
+class CompressedElement final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.data.CompressedElement) */ {
+ public:
+  inline CompressedElement() : CompressedElement(nullptr) {}
+  ~CompressedElement() override;
+  explicit PROTOBUF_CONSTEXPR CompressedElement(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  CompressedElement(const CompressedElement& from);
+  CompressedElement(CompressedElement&& from) noexcept
+    : CompressedElement() {
+    *this = ::std::move(from);
+  }
+
+  inline CompressedElement& operator=(const CompressedElement& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline CompressedElement& operator=(CompressedElement&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const CompressedElement& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const CompressedElement* internal_default_instance() {
+    return reinterpret_cast<const CompressedElement*>(
+               &_CompressedElement_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(CompressedElement& a, CompressedElement& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(CompressedElement* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(CompressedElement* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  CompressedElement* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<CompressedElement>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const CompressedElement& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const CompressedElement& from) {
+    CompressedElement::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(CompressedElement* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.data.CompressedElement";
+  }
+  protected:
+  explicit CompressedElement(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kComponentMetadataFieldNumber = 2,
+    kDataFieldNumber = 1,
+    kVersionFieldNumber = 3,
+  };
+  // repeated .tensorflow.data.CompressedComponentMetadata component_metadata = 2;
+  int component_metadata_size() const;
+  private:
+  int _internal_component_metadata_size() const;
+  public:
+  void clear_component_metadata();
+  ::tensorflow::data::CompressedComponentMetadata* mutable_component_metadata(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::data::CompressedComponentMetadata >*
+      mutable_component_metadata();
+  private:
+  const ::tensorflow::data::CompressedComponentMetadata& _internal_component_metadata(int index) const;
+  ::tensorflow::data::CompressedComponentMetadata* _internal_add_component_metadata();
+  public:
+  const ::tensorflow::data::CompressedComponentMetadata& component_metadata(int index) const;
+  ::tensorflow::data::CompressedComponentMetadata* add_component_metadata();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::data::CompressedComponentMetadata >&
+      component_metadata() const;
+
+  // bytes data = 1;
+  void clear_data();
+  const std::string& data() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_data(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_data();
+  PROTOBUF_NODISCARD std::string* release_data();
+  void set_allocated_data(std::string* data);
+  private:
+  const std::string& _internal_data() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_data(const std::string& value);
+  std::string* _internal_mutable_data();
+  public:
+
+  // int32 version = 3;
+  void clear_version();
+  int32_t version() const;
+  void set_version(int32_t value);
+  private:
+  int32_t _internal_version() const;
+  void _internal_set_version(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.data.CompressedElement)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::data::CompressedComponentMetadata > component_metadata_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr data_;
+    int32_t version_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fdataset_2eproto;
+};
+// -------------------------------------------------------------------
+
+class UncompressedElement final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.data.UncompressedElement) */ {
+ public:
+  inline UncompressedElement() : UncompressedElement(nullptr) {}
+  ~UncompressedElement() override;
+  explicit PROTOBUF_CONSTEXPR UncompressedElement(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  UncompressedElement(const UncompressedElement& from);
+  UncompressedElement(UncompressedElement&& from) noexcept
+    : UncompressedElement() {
+    *this = ::std::move(from);
+  }
+
+  inline UncompressedElement& operator=(const UncompressedElement& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline UncompressedElement& operator=(UncompressedElement&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const UncompressedElement& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const UncompressedElement* internal_default_instance() {
+    return reinterpret_cast<const UncompressedElement*>(
+               &_UncompressedElement_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(UncompressedElement& a, UncompressedElement& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(UncompressedElement* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(UncompressedElement* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  UncompressedElement* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<UncompressedElement>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const UncompressedElement& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const UncompressedElement& from) {
+    UncompressedElement::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(UncompressedElement* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.data.UncompressedElement";
+  }
+  protected:
+  explicit UncompressedElement(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kComponentsFieldNumber = 1,
+  };
+  // repeated .tensorflow.TensorProto components = 1;
+  int components_size() const;
+  private:
+  int _internal_components_size() const;
+  public:
+  void clear_components();
+  ::tensorflow::TensorProto* mutable_components(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TensorProto >*
+      mutable_components();
+  private:
+  const ::tensorflow::TensorProto& _internal_components(int index) const;
+  ::tensorflow::TensorProto* _internal_add_components();
+  public:
+  const ::tensorflow::TensorProto& components(int index) const;
+  ::tensorflow::TensorProto* add_components();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TensorProto >&
+      components() const;
+
+  // @@protoc_insertion_point(class_scope:tensorflow.data.UncompressedElement)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TensorProto > components_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fdataset_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// CompressedComponentMetadata
+
+// .tensorflow.DataType dtype = 1;
+inline void CompressedComponentMetadata::clear_dtype() {
+  _impl_.dtype_ = 0;
+}
+inline ::tensorflow::DataType CompressedComponentMetadata::_internal_dtype() const {
+  return static_cast< ::tensorflow::DataType >(_impl_.dtype_);
+}
+inline ::tensorflow::DataType CompressedComponentMetadata::dtype() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.CompressedComponentMetadata.dtype)
+  return _internal_dtype();
+}
+inline void CompressedComponentMetadata::_internal_set_dtype(::tensorflow::DataType value) {
+  
+  _impl_.dtype_ = value;
+}
+inline void CompressedComponentMetadata::set_dtype(::tensorflow::DataType value) {
+  _internal_set_dtype(value);
+  // @@protoc_insertion_point(field_set:tensorflow.data.CompressedComponentMetadata.dtype)
+}
+
+// .tensorflow.TensorShapeProto tensor_shape = 2;
+inline bool CompressedComponentMetadata::_internal_has_tensor_shape() const {
+  return this != internal_default_instance() && _impl_.tensor_shape_ != nullptr;
+}
+inline bool CompressedComponentMetadata::has_tensor_shape() const {
+  return _internal_has_tensor_shape();
+}
+inline const ::tensorflow::TensorShapeProto& CompressedComponentMetadata::_internal_tensor_shape() const {
+  const ::tensorflow::TensorShapeProto* p = _impl_.tensor_shape_;
+  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::TensorShapeProto&>(
+      ::tensorflow::_TensorShapeProto_default_instance_);
+}
+inline const ::tensorflow::TensorShapeProto& CompressedComponentMetadata::tensor_shape() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.CompressedComponentMetadata.tensor_shape)
+  return _internal_tensor_shape();
+}
+inline void CompressedComponentMetadata::unsafe_arena_set_allocated_tensor_shape(
+    ::tensorflow::TensorShapeProto* tensor_shape) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.tensor_shape_);
+  }
+  _impl_.tensor_shape_ = tensor_shape;
+  if (tensor_shape) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.data.CompressedComponentMetadata.tensor_shape)
+}
+inline ::tensorflow::TensorShapeProto* CompressedComponentMetadata::release_tensor_shape() {
+  
+  ::tensorflow::TensorShapeProto* temp = _impl_.tensor_shape_;
+  _impl_.tensor_shape_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::tensorflow::TensorShapeProto* CompressedComponentMetadata::unsafe_arena_release_tensor_shape() {
+  // @@protoc_insertion_point(field_release:tensorflow.data.CompressedComponentMetadata.tensor_shape)
+  
+  ::tensorflow::TensorShapeProto* temp = _impl_.tensor_shape_;
+  _impl_.tensor_shape_ = nullptr;
+  return temp;
+}
+inline ::tensorflow::TensorShapeProto* CompressedComponentMetadata::_internal_mutable_tensor_shape() {
+  
+  if (_impl_.tensor_shape_ == nullptr) {
+    auto* p = CreateMaybeMessage<::tensorflow::TensorShapeProto>(GetArenaForAllocation());
+    _impl_.tensor_shape_ = p;
+  }
+  return _impl_.tensor_shape_;
+}
+inline ::tensorflow::TensorShapeProto* CompressedComponentMetadata::mutable_tensor_shape() {
+  ::tensorflow::TensorShapeProto* _msg = _internal_mutable_tensor_shape();
+  // @@protoc_insertion_point(field_mutable:tensorflow.data.CompressedComponentMetadata.tensor_shape)
+  return _msg;
+}
+inline void CompressedComponentMetadata::set_allocated_tensor_shape(::tensorflow::TensorShapeProto* tensor_shape) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.tensor_shape_);
+  }
+  if (tensor_shape) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(tensor_shape));
+    if (message_arena != submessage_arena) {
+      tensor_shape = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, tensor_shape, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.tensor_shape_ = tensor_shape;
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.data.CompressedComponentMetadata.tensor_shape)
+}
+
+// repeated uint64 uncompressed_bytes = 4;
+inline int CompressedComponentMetadata::_internal_uncompressed_bytes_size() const {
+  return _impl_.uncompressed_bytes_.size();
+}
+inline int CompressedComponentMetadata::uncompressed_bytes_size() const {
+  return _internal_uncompressed_bytes_size();
+}
+inline void CompressedComponentMetadata::clear_uncompressed_bytes() {
+  _impl_.uncompressed_bytes_.Clear();
+}
+inline uint64_t CompressedComponentMetadata::_internal_uncompressed_bytes(int index) const {
+  return _impl_.uncompressed_bytes_.Get(index);
+}
+inline uint64_t CompressedComponentMetadata::uncompressed_bytes(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.CompressedComponentMetadata.uncompressed_bytes)
+  return _internal_uncompressed_bytes(index);
+}
+inline void CompressedComponentMetadata::set_uncompressed_bytes(int index, uint64_t value) {
+  _impl_.uncompressed_bytes_.Set(index, value);
+  // @@protoc_insertion_point(field_set:tensorflow.data.CompressedComponentMetadata.uncompressed_bytes)
+}
+inline void CompressedComponentMetadata::_internal_add_uncompressed_bytes(uint64_t value) {
+  _impl_.uncompressed_bytes_.Add(value);
+}
+inline void CompressedComponentMetadata::add_uncompressed_bytes(uint64_t value) {
+  _internal_add_uncompressed_bytes(value);
+  // @@protoc_insertion_point(field_add:tensorflow.data.CompressedComponentMetadata.uncompressed_bytes)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
+CompressedComponentMetadata::_internal_uncompressed_bytes() const {
+  return _impl_.uncompressed_bytes_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
+CompressedComponentMetadata::uncompressed_bytes() const {
+  // @@protoc_insertion_point(field_list:tensorflow.data.CompressedComponentMetadata.uncompressed_bytes)
+  return _internal_uncompressed_bytes();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
+CompressedComponentMetadata::_internal_mutable_uncompressed_bytes() {
+  return &_impl_.uncompressed_bytes_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
+CompressedComponentMetadata::mutable_uncompressed_bytes() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.data.CompressedComponentMetadata.uncompressed_bytes)
+  return _internal_mutable_uncompressed_bytes();
+}
+
+// -------------------------------------------------------------------
+
+// CompressedElement
+
+// bytes data = 1;
+inline void CompressedElement::clear_data() {
+  _impl_.data_.ClearToEmpty();
+}
+inline const std::string& CompressedElement::data() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.CompressedElement.data)
+  return _internal_data();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void CompressedElement::set_data(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.data_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.data.CompressedElement.data)
+}
+inline std::string* CompressedElement::mutable_data() {
+  std::string* _s = _internal_mutable_data();
+  // @@protoc_insertion_point(field_mutable:tensorflow.data.CompressedElement.data)
+  return _s;
+}
+inline const std::string& CompressedElement::_internal_data() const {
+  return _impl_.data_.Get();
+}
+inline void CompressedElement::_internal_set_data(const std::string& value) {
+  
+  _impl_.data_.Set(value, GetArenaForAllocation());
+}
+inline std::string* CompressedElement::_internal_mutable_data() {
+  
+  return _impl_.data_.Mutable(GetArenaForAllocation());
+}
+inline std::string* CompressedElement::release_data() {
+  // @@protoc_insertion_point(field_release:tensorflow.data.CompressedElement.data)
+  return _impl_.data_.Release();
+}
+inline void CompressedElement::set_allocated_data(std::string* data) {
+  if (data != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.data_.SetAllocated(data, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.data_.IsDefault()) {
+    _impl_.data_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.data.CompressedElement.data)
+}
+
+// repeated .tensorflow.data.CompressedComponentMetadata component_metadata = 2;
+inline int CompressedElement::_internal_component_metadata_size() const {
+  return _impl_.component_metadata_.size();
+}
+inline int CompressedElement::component_metadata_size() const {
+  return _internal_component_metadata_size();
+}
+inline void CompressedElement::clear_component_metadata() {
+  _impl_.component_metadata_.Clear();
+}
+inline ::tensorflow::data::CompressedComponentMetadata* CompressedElement::mutable_component_metadata(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.data.CompressedElement.component_metadata)
+  return _impl_.component_metadata_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::data::CompressedComponentMetadata >*
+CompressedElement::mutable_component_metadata() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.data.CompressedElement.component_metadata)
+  return &_impl_.component_metadata_;
+}
+inline const ::tensorflow::data::CompressedComponentMetadata& CompressedElement::_internal_component_metadata(int index) const {
+  return _impl_.component_metadata_.Get(index);
+}
+inline const ::tensorflow::data::CompressedComponentMetadata& CompressedElement::component_metadata(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.CompressedElement.component_metadata)
+  return _internal_component_metadata(index);
+}
+inline ::tensorflow::data::CompressedComponentMetadata* CompressedElement::_internal_add_component_metadata() {
+  return _impl_.component_metadata_.Add();
+}
+inline ::tensorflow::data::CompressedComponentMetadata* CompressedElement::add_component_metadata() {
+  ::tensorflow::data::CompressedComponentMetadata* _add = _internal_add_component_metadata();
+  // @@protoc_insertion_point(field_add:tensorflow.data.CompressedElement.component_metadata)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::data::CompressedComponentMetadata >&
+CompressedElement::component_metadata() const {
+  // @@protoc_insertion_point(field_list:tensorflow.data.CompressedElement.component_metadata)
+  return _impl_.component_metadata_;
+}
+
+// int32 version = 3;
+inline void CompressedElement::clear_version() {
+  _impl_.version_ = 0;
+}
+inline int32_t CompressedElement::_internal_version() const {
+  return _impl_.version_;
+}
+inline int32_t CompressedElement::version() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.CompressedElement.version)
+  return _internal_version();
+}
+inline void CompressedElement::_internal_set_version(int32_t value) {
+  
+  _impl_.version_ = value;
+}
+inline void CompressedElement::set_version(int32_t value) {
+  _internal_set_version(value);
+  // @@protoc_insertion_point(field_set:tensorflow.data.CompressedElement.version)
+}
+
+// -------------------------------------------------------------------
+
+// UncompressedElement
+
+// repeated .tensorflow.TensorProto components = 1;
+inline int UncompressedElement::_internal_components_size() const {
+  return _impl_.components_.size();
+}
+inline int UncompressedElement::components_size() const {
+  return _internal_components_size();
+}
+inline ::tensorflow::TensorProto* UncompressedElement::mutable_components(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.data.UncompressedElement.components)
+  return _impl_.components_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TensorProto >*
+UncompressedElement::mutable_components() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.data.UncompressedElement.components)
+  return &_impl_.components_;
+}
+inline const ::tensorflow::TensorProto& UncompressedElement::_internal_components(int index) const {
+  return _impl_.components_.Get(index);
+}
+inline const ::tensorflow::TensorProto& UncompressedElement::components(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.UncompressedElement.components)
+  return _internal_components(index);
+}
+inline ::tensorflow::TensorProto* UncompressedElement::_internal_add_components() {
+  return _impl_.components_.Add();
+}
+inline ::tensorflow::TensorProto* UncompressedElement::add_components() {
+  ::tensorflow::TensorProto* _add = _internal_add_components();
+  // @@protoc_insertion_point(field_add:tensorflow.data.UncompressedElement.components)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TensorProto >&
+UncompressedElement::components() const {
+  // @@protoc_insertion_point(field_list:tensorflow.data.UncompressedElement.components)
+  return _impl_.components_;
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace data
+}  // namespace tensorflow
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fdataset_2eproto
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/dataset.proto b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/dataset.proto
new file mode 100644
index 0000000000000000000000000000000000000000..9dfd03b2ddbed1b9a4f058a3c97796a03998516a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/dataset.proto
@@ -0,0 +1,47 @@
+syntax = "proto3";
+
+package tensorflow.data;
+
+import "tensorflow/core/framework/tensor.proto";
+import "tensorflow/core/framework/tensor_shape.proto";
+import "tensorflow/core/framework/types.proto";
+
+option cc_enable_arenas = true;
+
+// This file contains protocol buffers for working with tf.data Datasets.
+
+// Metadata describing a compressed component of a dataset element.
+message CompressedComponentMetadata {
+  // The dtype of the component tensor.
+  .tensorflow.DataType dtype = 1;
+
+  // The shape of the component tensor.
+  .tensorflow.TensorShapeProto tensor_shape = 2;
+
+  // The amount of uncompressed tensor data.
+  // - For string tensors, there is an element for each string indicating the
+  // size of the string.
+  // - For all other tensors, there is a single element indicating the size of
+  // the tensor.
+  repeated uint64 uncompressed_bytes = 4;
+
+  reserved 3;
+}
+
+message CompressedElement {
+  // Compressed tensor bytes for all components of the element.
+  bytes data = 1;
+  // Metadata for the components of the element.
+  repeated CompressedComponentMetadata component_metadata = 2;
+  // Version of the CompressedElement. CompressedElements may be stored on disk
+  // and read back by later versions of code, so we store a version number to
+  // help readers understand which version they are reading. When you add a new
+  // field to this proto, you need to increment kCompressedElementVersion in
+  // tensorflow/core/data/compression_utils.cc.
+  int32 version = 3;
+}
+
+// An uncompressed dataset element.
+message UncompressedElement {
+  repeated TensorProto components = 1;
+}
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/dataset_metadata.pb.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/dataset_metadata.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..c79ed9746f200734c8e2f8c4453b2d55bf0b14df
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/dataset_metadata.pb.h
@@ -0,0 +1,286 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: tensorflow/core/framework/dataset_metadata.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fdataset_5fmetadata_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fdataset_5fmetadata_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3021000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3021009 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_tensorflow_2fcore_2fframework_2fdataset_5fmetadata_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_tensorflow_2fcore_2fframework_2fdataset_5fmetadata_2eproto {
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_tensorflow_2fcore_2fframework_2fdataset_5fmetadata_2eproto;
+namespace tensorflow {
+namespace data {
+class Metadata;
+struct MetadataDefaultTypeInternal;
+extern MetadataDefaultTypeInternal _Metadata_default_instance_;
+}  // namespace data
+}  // namespace tensorflow
+PROTOBUF_NAMESPACE_OPEN
+template<> ::tensorflow::data::Metadata* Arena::CreateMaybeMessage<::tensorflow::data::Metadata>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace tensorflow {
+namespace data {
+
+// ===================================================================
+
+class Metadata final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.data.Metadata) */ {
+ public:
+  inline Metadata() : Metadata(nullptr) {}
+  ~Metadata() override;
+  explicit PROTOBUF_CONSTEXPR Metadata(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Metadata(const Metadata& from);
+  Metadata(Metadata&& from) noexcept
+    : Metadata() {
+    *this = ::std::move(from);
+  }
+
+  inline Metadata& operator=(const Metadata& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Metadata& operator=(Metadata&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Metadata& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Metadata* internal_default_instance() {
+    return reinterpret_cast<const Metadata*>(
+               &_Metadata_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(Metadata& a, Metadata& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Metadata* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Metadata* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Metadata* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Metadata>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Metadata& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Metadata& from) {
+    Metadata::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Metadata* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.data.Metadata";
+  }
+  protected:
+  explicit Metadata(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNameFieldNumber = 1,
+  };
+  // bytes name = 1;
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.data.Metadata)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fdataset_5fmetadata_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// Metadata
+
+// bytes name = 1;
+inline void Metadata::clear_name() {
+  _impl_.name_.ClearToEmpty();
+}
+inline const std::string& Metadata::name() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.Metadata.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Metadata::set_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.name_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.data.Metadata.name)
+}
+inline std::string* Metadata::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:tensorflow.data.Metadata.name)
+  return _s;
+}
+inline const std::string& Metadata::_internal_name() const {
+  return _impl_.name_.Get();
+}
+inline void Metadata::_internal_set_name(const std::string& value) {
+  
+  _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Metadata::_internal_mutable_name() {
+  
+  return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Metadata::release_name() {
+  // @@protoc_insertion_point(field_release:tensorflow.data.Metadata.name)
+  return _impl_.name_.Release();
+}
+inline void Metadata::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.data.Metadata.name)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace data
+}  // namespace tensorflow
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fdataset_5fmetadata_2eproto
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/dataset_metadata.proto b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/dataset_metadata.proto
new file mode 100644
index 0000000000000000000000000000000000000000..0e667dd48d1d78bdf30be57fdcd73b7e1a6ea2cf
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/dataset_metadata.proto
@@ -0,0 +1,10 @@
+syntax = "proto3";
+
+package tensorflow.data;
+
+option go_package = "github.com/tensorflow/tensorflow/tensorflow/go/core/framework/dataset_metadata_go_proto";
+
+// next: 2
+message Metadata {
+  bytes name = 1;
+}
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/dataset_options.pb.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/dataset_options.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..874741ec9a1af6bc862f141418e43d1735c432a1
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/dataset_options.pb.h
@@ -0,0 +1,3372 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: tensorflow/core/framework/dataset_options.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fdataset_5foptions_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fdataset_5foptions_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3021000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3021009 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "tensorflow/core/framework/model.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_tensorflow_2fcore_2fframework_2fdataset_5foptions_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_tensorflow_2fcore_2fframework_2fdataset_5foptions_2eproto {
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_tensorflow_2fcore_2fframework_2fdataset_5foptions_2eproto;
+namespace tensorflow {
+namespace data {
+class AutotuneOptions;
+struct AutotuneOptionsDefaultTypeInternal;
+extern AutotuneOptionsDefaultTypeInternal _AutotuneOptions_default_instance_;
+class CardinalityOptions;
+struct CardinalityOptionsDefaultTypeInternal;
+extern CardinalityOptionsDefaultTypeInternal _CardinalityOptions_default_instance_;
+class DistributeOptions;
+struct DistributeOptionsDefaultTypeInternal;
+extern DistributeOptionsDefaultTypeInternal _DistributeOptions_default_instance_;
+class OptimizationOptions;
+struct OptimizationOptionsDefaultTypeInternal;
+extern OptimizationOptionsDefaultTypeInternal _OptimizationOptions_default_instance_;
+class Options;
+struct OptionsDefaultTypeInternal;
+extern OptionsDefaultTypeInternal _Options_default_instance_;
+class ThreadingOptions;
+struct ThreadingOptionsDefaultTypeInternal;
+extern ThreadingOptionsDefaultTypeInternal _ThreadingOptions_default_instance_;
+}  // namespace data
+}  // namespace tensorflow
+PROTOBUF_NAMESPACE_OPEN
+template<> ::tensorflow::data::AutotuneOptions* Arena::CreateMaybeMessage<::tensorflow::data::AutotuneOptions>(Arena*);
+template<> ::tensorflow::data::CardinalityOptions* Arena::CreateMaybeMessage<::tensorflow::data::CardinalityOptions>(Arena*);
+template<> ::tensorflow::data::DistributeOptions* Arena::CreateMaybeMessage<::tensorflow::data::DistributeOptions>(Arena*);
+template<> ::tensorflow::data::OptimizationOptions* Arena::CreateMaybeMessage<::tensorflow::data::OptimizationOptions>(Arena*);
+template<> ::tensorflow::data::Options* Arena::CreateMaybeMessage<::tensorflow::data::Options>(Arena*);
+template<> ::tensorflow::data::ThreadingOptions* Arena::CreateMaybeMessage<::tensorflow::data::ThreadingOptions>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace tensorflow {
+namespace data {
+
+enum CardinalityOptions_ComputeLevel : int {
+  CardinalityOptions_ComputeLevel_CARDINALITY_COMPUTE_UNSPECIFIED = 0,
+  CardinalityOptions_ComputeLevel_CARDINALITY_COMPUTE_LOW = 1,
+  CardinalityOptions_ComputeLevel_CARDINALITY_COMPUTE_MODERATE = 2,
+  CardinalityOptions_ComputeLevel_CardinalityOptions_ComputeLevel_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
+  CardinalityOptions_ComputeLevel_CardinalityOptions_ComputeLevel_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
+};
+bool CardinalityOptions_ComputeLevel_IsValid(int value);
+constexpr CardinalityOptions_ComputeLevel CardinalityOptions_ComputeLevel_ComputeLevel_MIN = CardinalityOptions_ComputeLevel_CARDINALITY_COMPUTE_UNSPECIFIED;
+constexpr CardinalityOptions_ComputeLevel CardinalityOptions_ComputeLevel_ComputeLevel_MAX = CardinalityOptions_ComputeLevel_CARDINALITY_COMPUTE_MODERATE;
+constexpr int CardinalityOptions_ComputeLevel_ComputeLevel_ARRAYSIZE = CardinalityOptions_ComputeLevel_ComputeLevel_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CardinalityOptions_ComputeLevel_descriptor();
+template<typename T>
+inline const std::string& CardinalityOptions_ComputeLevel_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, CardinalityOptions_ComputeLevel>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function CardinalityOptions_ComputeLevel_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    CardinalityOptions_ComputeLevel_descriptor(), enum_t_value);
+}
+inline bool CardinalityOptions_ComputeLevel_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CardinalityOptions_ComputeLevel* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<CardinalityOptions_ComputeLevel>(
+    CardinalityOptions_ComputeLevel_descriptor(), name, value);
+}
+enum AutoShardPolicy : int {
+  AUTO = 0,
+  FILE = 1,
+  DATA = 2,
+  HINT = 3,
+  OFF = -1,
+  AutoShardPolicy_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
+  AutoShardPolicy_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
+};
+bool AutoShardPolicy_IsValid(int value);
+constexpr AutoShardPolicy AutoShardPolicy_MIN = OFF;
+constexpr AutoShardPolicy AutoShardPolicy_MAX = HINT;
+constexpr int AutoShardPolicy_ARRAYSIZE = AutoShardPolicy_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* AutoShardPolicy_descriptor();
+template<typename T>
+inline const std::string& AutoShardPolicy_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, AutoShardPolicy>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function AutoShardPolicy_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    AutoShardPolicy_descriptor(), enum_t_value);
+}
+inline bool AutoShardPolicy_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, AutoShardPolicy* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<AutoShardPolicy>(
+    AutoShardPolicy_descriptor(), name, value);
+}
+enum ExternalStatePolicy : int {
+  POLICY_WARN = 0,
+  POLICY_IGNORE = 1,
+  POLICY_FAIL = 2,
+  ExternalStatePolicy_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
+  ExternalStatePolicy_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
+};
+bool ExternalStatePolicy_IsValid(int value);
+constexpr ExternalStatePolicy ExternalStatePolicy_MIN = POLICY_WARN;
+constexpr ExternalStatePolicy ExternalStatePolicy_MAX = POLICY_FAIL;
+constexpr int ExternalStatePolicy_ARRAYSIZE = ExternalStatePolicy_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ExternalStatePolicy_descriptor();
+template<typename T>
+inline const std::string& ExternalStatePolicy_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ExternalStatePolicy>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ExternalStatePolicy_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    ExternalStatePolicy_descriptor(), enum_t_value);
+}
+inline bool ExternalStatePolicy_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ExternalStatePolicy* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ExternalStatePolicy>(
+    ExternalStatePolicy_descriptor(), name, value);
+}
+// ===================================================================
+
+class AutotuneOptions final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.data.AutotuneOptions) */ {
+ public:
+  inline AutotuneOptions() : AutotuneOptions(nullptr) {}
+  ~AutotuneOptions() override;
+  explicit PROTOBUF_CONSTEXPR AutotuneOptions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  AutotuneOptions(const AutotuneOptions& from);
+  AutotuneOptions(AutotuneOptions&& from) noexcept
+    : AutotuneOptions() {
+    *this = ::std::move(from);
+  }
+
+  inline AutotuneOptions& operator=(const AutotuneOptions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline AutotuneOptions& operator=(AutotuneOptions&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const AutotuneOptions& default_instance() {
+    return *internal_default_instance();
+  }
+  enum OptionalEnabledCase {
+    kEnabled = 1,
+    OPTIONAL_ENABLED_NOT_SET = 0,
+  };
+
+  enum OptionalCpuBudgetCase {
+    kCpuBudget = 2,
+    OPTIONAL_CPU_BUDGET_NOT_SET = 0,
+  };
+
+  enum OptionalRamBudgetCase {
+    kRamBudget = 3,
+    OPTIONAL_RAM_BUDGET_NOT_SET = 0,
+  };
+
+  enum OptionalAutotuneAlgorithmCase {
+    kAutotuneAlgorithm = 4,
+    OPTIONAL_AUTOTUNE_ALGORITHM_NOT_SET = 0,
+  };
+
+  static inline const AutotuneOptions* internal_default_instance() {
+    return reinterpret_cast<const AutotuneOptions*>(
+               &_AutotuneOptions_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(AutotuneOptions& a, AutotuneOptions& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(AutotuneOptions* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(AutotuneOptions* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  AutotuneOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<AutotuneOptions>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const AutotuneOptions& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const AutotuneOptions& from) {
+    AutotuneOptions::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(AutotuneOptions* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.data.AutotuneOptions";
+  }
+  protected:
+  explicit AutotuneOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kEnabledFieldNumber = 1,
+    kCpuBudgetFieldNumber = 2,
+    kRamBudgetFieldNumber = 3,
+    kAutotuneAlgorithmFieldNumber = 4,
+  };
+  // bool enabled = 1;
+  bool has_enabled() const;
+  private:
+  bool _internal_has_enabled() const;
+  public:
+  void clear_enabled();
+  bool enabled() const;
+  void set_enabled(bool value);
+  private:
+  bool _internal_enabled() const;
+  void _internal_set_enabled(bool value);
+  public:
+
+  // int32 cpu_budget = 2;
+  bool has_cpu_budget() const;
+  private:
+  bool _internal_has_cpu_budget() const;
+  public:
+  void clear_cpu_budget();
+  int32_t cpu_budget() const;
+  void set_cpu_budget(int32_t value);
+  private:
+  int32_t _internal_cpu_budget() const;
+  void _internal_set_cpu_budget(int32_t value);
+  public:
+
+  // int64 ram_budget = 3;
+  bool has_ram_budget() const;
+  private:
+  bool _internal_has_ram_budget() const;
+  public:
+  void clear_ram_budget();
+  int64_t ram_budget() const;
+  void set_ram_budget(int64_t value);
+  private:
+  int64_t _internal_ram_budget() const;
+  void _internal_set_ram_budget(int64_t value);
+  public:
+
+  // .tensorflow.data.model.AutotuneAlgorithm autotune_algorithm = 4;
+  bool has_autotune_algorithm() const;
+  private:
+  bool _internal_has_autotune_algorithm() const;
+  public:
+  void clear_autotune_algorithm();
+  ::tensorflow::data::model::AutotuneAlgorithm autotune_algorithm() const;
+  void set_autotune_algorithm(::tensorflow::data::model::AutotuneAlgorithm value);
+  private:
+  ::tensorflow::data::model::AutotuneAlgorithm _internal_autotune_algorithm() const;
+  void _internal_set_autotune_algorithm(::tensorflow::data::model::AutotuneAlgorithm value);
+  public:
+
+  void clear_optional_enabled();
+  OptionalEnabledCase optional_enabled_case() const;
+  void clear_optional_cpu_budget();
+  OptionalCpuBudgetCase optional_cpu_budget_case() const;
+  void clear_optional_ram_budget();
+  OptionalRamBudgetCase optional_ram_budget_case() const;
+  void clear_optional_autotune_algorithm();
+  OptionalAutotuneAlgorithmCase optional_autotune_algorithm_case() const;
+  // @@protoc_insertion_point(class_scope:tensorflow.data.AutotuneOptions)
+ private:
+  class _Internal;
+  void set_has_enabled();
+  void set_has_cpu_budget();
+  void set_has_ram_budget();
+  void set_has_autotune_algorithm();
+
+  inline bool has_optional_enabled() const;
+  inline void clear_has_optional_enabled();
+
+  inline bool has_optional_cpu_budget() const;
+  inline void clear_has_optional_cpu_budget();
+
+  inline bool has_optional_ram_budget() const;
+  inline void clear_has_optional_ram_budget();
+
+  inline bool has_optional_autotune_algorithm() const;
+  inline void clear_has_optional_autotune_algorithm();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    union OptionalEnabledUnion {
+      constexpr OptionalEnabledUnion() : _constinit_{} {}
+        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+      bool enabled_;
+    } optional_enabled_;
+    union OptionalCpuBudgetUnion {
+      constexpr OptionalCpuBudgetUnion() : _constinit_{} {}
+        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+      int32_t cpu_budget_;
+    } optional_cpu_budget_;
+    union OptionalRamBudgetUnion {
+      constexpr OptionalRamBudgetUnion() : _constinit_{} {}
+        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+      int64_t ram_budget_;
+    } optional_ram_budget_;
+    union OptionalAutotuneAlgorithmUnion {
+      constexpr OptionalAutotuneAlgorithmUnion() : _constinit_{} {}
+        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+      int autotune_algorithm_;
+    } optional_autotune_algorithm_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    uint32_t _oneof_case_[4];
+
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fdataset_5foptions_2eproto;
+};
+// -------------------------------------------------------------------
+
+class CardinalityOptions final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.data.CardinalityOptions) */ {
+ public:
+  inline CardinalityOptions() : CardinalityOptions(nullptr) {}
+  ~CardinalityOptions() override;
+  explicit PROTOBUF_CONSTEXPR CardinalityOptions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  CardinalityOptions(const CardinalityOptions& from);
+  CardinalityOptions(CardinalityOptions&& from) noexcept
+    : CardinalityOptions() {
+    *this = ::std::move(from);
+  }
+
+  inline CardinalityOptions& operator=(const CardinalityOptions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline CardinalityOptions& operator=(CardinalityOptions&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const CardinalityOptions& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const CardinalityOptions* internal_default_instance() {
+    return reinterpret_cast<const CardinalityOptions*>(
+               &_CardinalityOptions_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(CardinalityOptions& a, CardinalityOptions& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(CardinalityOptions* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(CardinalityOptions* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  CardinalityOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<CardinalityOptions>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const CardinalityOptions& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const CardinalityOptions& from) {
+    CardinalityOptions::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(CardinalityOptions* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.data.CardinalityOptions";
+  }
+  protected:
+  explicit CardinalityOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef CardinalityOptions_ComputeLevel ComputeLevel;
+  static constexpr ComputeLevel CARDINALITY_COMPUTE_UNSPECIFIED =
+    CardinalityOptions_ComputeLevel_CARDINALITY_COMPUTE_UNSPECIFIED;
+  static constexpr ComputeLevel CARDINALITY_COMPUTE_LOW =
+    CardinalityOptions_ComputeLevel_CARDINALITY_COMPUTE_LOW;
+  static constexpr ComputeLevel CARDINALITY_COMPUTE_MODERATE =
+    CardinalityOptions_ComputeLevel_CARDINALITY_COMPUTE_MODERATE;
+  static inline bool ComputeLevel_IsValid(int value) {
+    return CardinalityOptions_ComputeLevel_IsValid(value);
+  }
+  static constexpr ComputeLevel ComputeLevel_MIN =
+    CardinalityOptions_ComputeLevel_ComputeLevel_MIN;
+  static constexpr ComputeLevel ComputeLevel_MAX =
+    CardinalityOptions_ComputeLevel_ComputeLevel_MAX;
+  static constexpr int ComputeLevel_ARRAYSIZE =
+    CardinalityOptions_ComputeLevel_ComputeLevel_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  ComputeLevel_descriptor() {
+    return CardinalityOptions_ComputeLevel_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& ComputeLevel_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, ComputeLevel>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function ComputeLevel_Name.");
+    return CardinalityOptions_ComputeLevel_Name(enum_t_value);
+  }
+  static inline bool ComputeLevel_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      ComputeLevel* value) {
+    return CardinalityOptions_ComputeLevel_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kComputeLevelFieldNumber = 1,
+  };
+  // .tensorflow.data.CardinalityOptions.ComputeLevel compute_level = 1;
+  void clear_compute_level();
+  ::tensorflow::data::CardinalityOptions_ComputeLevel compute_level() const;
+  void set_compute_level(::tensorflow::data::CardinalityOptions_ComputeLevel value);
+  private:
+  ::tensorflow::data::CardinalityOptions_ComputeLevel _internal_compute_level() const;
+  void _internal_set_compute_level(::tensorflow::data::CardinalityOptions_ComputeLevel value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.data.CardinalityOptions)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    int compute_level_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fdataset_5foptions_2eproto;
+};
+// -------------------------------------------------------------------
+
+class DistributeOptions final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.data.DistributeOptions) */ {
+ public:
+  inline DistributeOptions() : DistributeOptions(nullptr) {}
+  ~DistributeOptions() override;
+  explicit PROTOBUF_CONSTEXPR DistributeOptions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DistributeOptions(const DistributeOptions& from);
+  DistributeOptions(DistributeOptions&& from) noexcept
+    : DistributeOptions() {
+    *this = ::std::move(from);
+  }
+
+  inline DistributeOptions& operator=(const DistributeOptions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DistributeOptions& operator=(DistributeOptions&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const DistributeOptions& default_instance() {
+    return *internal_default_instance();
+  }
+  enum OptionalNumDevicesCase {
+    kNumDevices = 2,
+    OPTIONAL_NUM_DEVICES_NOT_SET = 0,
+  };
+
+  static inline const DistributeOptions* internal_default_instance() {
+    return reinterpret_cast<const DistributeOptions*>(
+               &_DistributeOptions_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(DistributeOptions& a, DistributeOptions& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DistributeOptions* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(DistributeOptions* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  DistributeOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<DistributeOptions>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const DistributeOptions& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const DistributeOptions& from) {
+    DistributeOptions::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(DistributeOptions* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.data.DistributeOptions";
+  }
+  protected:
+  explicit DistributeOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kAutoShardPolicyFieldNumber = 1,
+    kNumDevicesFieldNumber = 2,
+  };
+  // .tensorflow.data.AutoShardPolicy auto_shard_policy = 1;
+  void clear_auto_shard_policy();
+  ::tensorflow::data::AutoShardPolicy auto_shard_policy() const;
+  void set_auto_shard_policy(::tensorflow::data::AutoShardPolicy value);
+  private:
+  ::tensorflow::data::AutoShardPolicy _internal_auto_shard_policy() const;
+  void _internal_set_auto_shard_policy(::tensorflow::data::AutoShardPolicy value);
+  public:
+
+  // int32 num_devices = 2;
+  bool has_num_devices() const;
+  private:
+  bool _internal_has_num_devices() const;
+  public:
+  void clear_num_devices();
+  int32_t num_devices() const;
+  void set_num_devices(int32_t value);
+  private:
+  int32_t _internal_num_devices() const;
+  void _internal_set_num_devices(int32_t value);
+  public:
+
+  void clear_optional_num_devices();
+  OptionalNumDevicesCase optional_num_devices_case() const;
+  // @@protoc_insertion_point(class_scope:tensorflow.data.DistributeOptions)
+ private:
+  class _Internal;
+  void set_has_num_devices();
+
+  inline bool has_optional_num_devices() const;
+  inline void clear_has_optional_num_devices();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    int auto_shard_policy_;
+    union OptionalNumDevicesUnion {
+      constexpr OptionalNumDevicesUnion() : _constinit_{} {}
+        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+      int32_t num_devices_;
+    } optional_num_devices_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    uint32_t _oneof_case_[1];
+
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fdataset_5foptions_2eproto;
+};
+// -------------------------------------------------------------------
+
+class OptimizationOptions final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.data.OptimizationOptions) */ {
+ public:
+  inline OptimizationOptions() : OptimizationOptions(nullptr) {}
+  ~OptimizationOptions() override;
+  explicit PROTOBUF_CONSTEXPR OptimizationOptions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  OptimizationOptions(const OptimizationOptions& from);
+  OptimizationOptions(OptimizationOptions&& from) noexcept
+    : OptimizationOptions() {
+    *this = ::std::move(from);
+  }
+
+  inline OptimizationOptions& operator=(const OptimizationOptions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline OptimizationOptions& operator=(OptimizationOptions&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const OptimizationOptions& default_instance() {
+    return *internal_default_instance();
+  }
+  enum OptionalApplyDefaultOptimizationsCase {
+    kApplyDefaultOptimizations = 1,
+    OPTIONAL_APPLY_DEFAULT_OPTIMIZATIONS_NOT_SET = 0,
+  };
+
+  enum OptionalFilterFusionCase {
+    kFilterFusion = 6,
+    OPTIONAL_FILTER_FUSION_NOT_SET = 0,
+  };
+
+  enum OptionalMapAndBatchFusionCase {
+    kMapAndBatchFusion = 9,
+    OPTIONAL_MAP_AND_BATCH_FUSION_NOT_SET = 0,
+  };
+
+  enum OptionalMapAndFilterFusionCase {
+    kMapAndFilterFusion = 10,
+    OPTIONAL_MAP_AND_FILTER_FUSION_NOT_SET = 0,
+  };
+
+  enum OptionalMapFusionCase {
+    kMapFusion = 11,
+    OPTIONAL_MAP_FUSION_NOT_SET = 0,
+  };
+
+  enum OptionalMapParallelizationCase {
+    kMapParallelization = 12,
+    OPTIONAL_MAP_PARALLELIZATION_NOT_SET = 0,
+  };
+
+  enum OptionalNoopEliminationCase {
+    kNoopElimination = 14,
+    OPTIONAL_NOOP_ELIMINATION_NOT_SET = 0,
+  };
+
+  enum OptionalParallelBatchCase {
+    kParallelBatch = 15,
+    OPTIONAL_PARALLEL_BATCH_NOT_SET = 0,
+  };
+
+  enum OptionalShuffleAndRepeatFusionCase {
+    kShuffleAndRepeatFusion = 17,
+    OPTIONAL_SHUFFLE_AND_REPEAT_FUSION_NOT_SET = 0,
+  };
+
+  enum OptionalFilterParallelizationCase {
+    kFilterParallelization = 18,
+    OPTIONAL_FILTER_PARALLELIZATION_NOT_SET = 0,
+  };
+
+  enum OptionalInjectPrefetchCase {
+    kInjectPrefetch = 19,
+    OPTIONAL_INJECT_PREFETCH_NOT_SET = 0,
+  };
+
+  static inline const OptimizationOptions* internal_default_instance() {
+    return reinterpret_cast<const OptimizationOptions*>(
+               &_OptimizationOptions_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  friend void swap(OptimizationOptions& a, OptimizationOptions& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(OptimizationOptions* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(OptimizationOptions* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  OptimizationOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<OptimizationOptions>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const OptimizationOptions& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const OptimizationOptions& from) {
+    OptimizationOptions::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(OptimizationOptions* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.data.OptimizationOptions";
+  }
+  protected:
+  explicit OptimizationOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kApplyDefaultOptimizationsFieldNumber = 1,
+    kFilterFusionFieldNumber = 6,
+    kMapAndBatchFusionFieldNumber = 9,
+    kMapAndFilterFusionFieldNumber = 10,
+    kMapFusionFieldNumber = 11,
+    kMapParallelizationFieldNumber = 12,
+    kNoopEliminationFieldNumber = 14,
+    kParallelBatchFieldNumber = 15,
+    kShuffleAndRepeatFusionFieldNumber = 17,
+    kFilterParallelizationFieldNumber = 18,
+    kInjectPrefetchFieldNumber = 19,
+  };
+  // bool apply_default_optimizations = 1;
+  bool has_apply_default_optimizations() const;
+  private:
+  bool _internal_has_apply_default_optimizations() const;
+  public:
+  void clear_apply_default_optimizations();
+  bool apply_default_optimizations() const;
+  void set_apply_default_optimizations(bool value);
+  private:
+  bool _internal_apply_default_optimizations() const;
+  void _internal_set_apply_default_optimizations(bool value);
+  public:
+
+  // bool filter_fusion = 6;
+  bool has_filter_fusion() const;
+  private:
+  bool _internal_has_filter_fusion() const;
+  public:
+  void clear_filter_fusion();
+  bool filter_fusion() const;
+  void set_filter_fusion(bool value);
+  private:
+  bool _internal_filter_fusion() const;
+  void _internal_set_filter_fusion(bool value);
+  public:
+
+  // bool map_and_batch_fusion = 9;
+  bool has_map_and_batch_fusion() const;
+  private:
+  bool _internal_has_map_and_batch_fusion() const;
+  public:
+  void clear_map_and_batch_fusion();
+  bool map_and_batch_fusion() const;
+  void set_map_and_batch_fusion(bool value);
+  private:
+  bool _internal_map_and_batch_fusion() const;
+  void _internal_set_map_and_batch_fusion(bool value);
+  public:
+
+  // bool map_and_filter_fusion = 10;
+  bool has_map_and_filter_fusion() const;
+  private:
+  bool _internal_has_map_and_filter_fusion() const;
+  public:
+  void clear_map_and_filter_fusion();
+  bool map_and_filter_fusion() const;
+  void set_map_and_filter_fusion(bool value);
+  private:
+  bool _internal_map_and_filter_fusion() const;
+  void _internal_set_map_and_filter_fusion(bool value);
+  public:
+
+  // bool map_fusion = 11;
+  bool has_map_fusion() const;
+  private:
+  bool _internal_has_map_fusion() const;
+  public:
+  void clear_map_fusion();
+  bool map_fusion() const;
+  void set_map_fusion(bool value);
+  private:
+  bool _internal_map_fusion() const;
+  void _internal_set_map_fusion(bool value);
+  public:
+
+  // bool map_parallelization = 12;
+  bool has_map_parallelization() const;
+  private:
+  bool _internal_has_map_parallelization() const;
+  public:
+  void clear_map_parallelization();
+  bool map_parallelization() const;
+  void set_map_parallelization(bool value);
+  private:
+  bool _internal_map_parallelization() const;
+  void _internal_set_map_parallelization(bool value);
+  public:
+
+  // bool noop_elimination = 14;
+  bool has_noop_elimination() const;
+  private:
+  bool _internal_has_noop_elimination() const;
+  public:
+  void clear_noop_elimination();
+  bool noop_elimination() const;
+  void set_noop_elimination(bool value);
+  private:
+  bool _internal_noop_elimination() const;
+  void _internal_set_noop_elimination(bool value);
+  public:
+
+  // bool parallel_batch = 15;
+  bool has_parallel_batch() const;
+  private:
+  bool _internal_has_parallel_batch() const;
+  public:
+  void clear_parallel_batch();
+  bool parallel_batch() const;
+  void set_parallel_batch(bool value);
+  private:
+  bool _internal_parallel_batch() const;
+  void _internal_set_parallel_batch(bool value);
+  public:
+
+  // bool shuffle_and_repeat_fusion = 17;
+  bool has_shuffle_and_repeat_fusion() const;
+  private:
+  bool _internal_has_shuffle_and_repeat_fusion() const;
+  public:
+  void clear_shuffle_and_repeat_fusion();
+  bool shuffle_and_repeat_fusion() const;
+  void set_shuffle_and_repeat_fusion(bool value);
+  private:
+  bool _internal_shuffle_and_repeat_fusion() const;
+  void _internal_set_shuffle_and_repeat_fusion(bool value);
+  public:
+
+  // bool filter_parallelization = 18;
+  bool has_filter_parallelization() const;
+  private:
+  bool _internal_has_filter_parallelization() const;
+  public:
+  void clear_filter_parallelization();
+  bool filter_parallelization() const;
+  void set_filter_parallelization(bool value);
+  private:
+  bool _internal_filter_parallelization() const;
+  void _internal_set_filter_parallelization(bool value);
+  public:
+
+  // bool inject_prefetch = 19;
+  bool has_inject_prefetch() const;
+  private:
+  bool _internal_has_inject_prefetch() const;
+  public:
+  void clear_inject_prefetch();
+  bool inject_prefetch() const;
+  void set_inject_prefetch(bool value);
+  private:
+  bool _internal_inject_prefetch() const;
+  void _internal_set_inject_prefetch(bool value);
+  public:
+
+  void clear_optional_apply_default_optimizations();
+  OptionalApplyDefaultOptimizationsCase optional_apply_default_optimizations_case() const;
+  void clear_optional_filter_fusion();
+  OptionalFilterFusionCase optional_filter_fusion_case() const;
+  void clear_optional_map_and_batch_fusion();
+  OptionalMapAndBatchFusionCase optional_map_and_batch_fusion_case() const;
+  void clear_optional_map_and_filter_fusion();
+  OptionalMapAndFilterFusionCase optional_map_and_filter_fusion_case() const;
+  void clear_optional_map_fusion();
+  OptionalMapFusionCase optional_map_fusion_case() const;
+  void clear_optional_map_parallelization();
+  OptionalMapParallelizationCase optional_map_parallelization_case() const;
+  void clear_optional_noop_elimination();
+  OptionalNoopEliminationCase optional_noop_elimination_case() const;
+  void clear_optional_parallel_batch();
+  OptionalParallelBatchCase optional_parallel_batch_case() const;
+  void clear_optional_shuffle_and_repeat_fusion();
+  OptionalShuffleAndRepeatFusionCase optional_shuffle_and_repeat_fusion_case() const;
+  void clear_optional_filter_parallelization();
+  OptionalFilterParallelizationCase optional_filter_parallelization_case() const;
+  void clear_optional_inject_prefetch();
+  OptionalInjectPrefetchCase optional_inject_prefetch_case() const;
+  // @@protoc_insertion_point(class_scope:tensorflow.data.OptimizationOptions)
+ private:
+  class _Internal;
+  void set_has_apply_default_optimizations();
+  void set_has_filter_fusion();
+  void set_has_map_and_batch_fusion();
+  void set_has_map_and_filter_fusion();
+  void set_has_map_fusion();
+  void set_has_map_parallelization();
+  void set_has_noop_elimination();
+  void set_has_parallel_batch();
+  void set_has_shuffle_and_repeat_fusion();
+  void set_has_filter_parallelization();
+  void set_has_inject_prefetch();
+
+  inline bool has_optional_apply_default_optimizations() const;
+  inline void clear_has_optional_apply_default_optimizations();
+
+  inline bool has_optional_filter_fusion() const;
+  inline void clear_has_optional_filter_fusion();
+
+  inline bool has_optional_map_and_batch_fusion() const;
+  inline void clear_has_optional_map_and_batch_fusion();
+
+  inline bool has_optional_map_and_filter_fusion() const;
+  inline void clear_has_optional_map_and_filter_fusion();
+
+  inline bool has_optional_map_fusion() const;
+  inline void clear_has_optional_map_fusion();
+
+  inline bool has_optional_map_parallelization() const;
+  inline void clear_has_optional_map_parallelization();
+
+  inline bool has_optional_noop_elimination() const;
+  inline void clear_has_optional_noop_elimination();
+
+  inline bool has_optional_parallel_batch() const;
+  inline void clear_has_optional_parallel_batch();
+
+  inline bool has_optional_shuffle_and_repeat_fusion() const;
+  inline void clear_has_optional_shuffle_and_repeat_fusion();
+
+  inline bool has_optional_filter_parallelization() const;
+  inline void clear_has_optional_filter_parallelization();
+
+  inline bool has_optional_inject_prefetch() const;
+  inline void clear_has_optional_inject_prefetch();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    union OptionalApplyDefaultOptimizationsUnion {
+      constexpr OptionalApplyDefaultOptimizationsUnion() : _constinit_{} {}
+        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+      bool apply_default_optimizations_;
+    } optional_apply_default_optimizations_;
+    union OptionalFilterFusionUnion {
+      constexpr OptionalFilterFusionUnion() : _constinit_{} {}
+        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+      bool filter_fusion_;
+    } optional_filter_fusion_;
+    union OptionalMapAndBatchFusionUnion {
+      constexpr OptionalMapAndBatchFusionUnion() : _constinit_{} {}
+        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+      bool map_and_batch_fusion_;
+    } optional_map_and_batch_fusion_;
+    union OptionalMapAndFilterFusionUnion {
+      constexpr OptionalMapAndFilterFusionUnion() : _constinit_{} {}
+        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+      bool map_and_filter_fusion_;
+    } optional_map_and_filter_fusion_;
+    union OptionalMapFusionUnion {
+      constexpr OptionalMapFusionUnion() : _constinit_{} {}
+        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+      bool map_fusion_;
+    } optional_map_fusion_;
+    union OptionalMapParallelizationUnion {
+      constexpr OptionalMapParallelizationUnion() : _constinit_{} {}
+        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+      bool map_parallelization_;
+    } optional_map_parallelization_;
+    union OptionalNoopEliminationUnion {
+      constexpr OptionalNoopEliminationUnion() : _constinit_{} {}
+        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+      bool noop_elimination_;
+    } optional_noop_elimination_;
+    union OptionalParallelBatchUnion {
+      constexpr OptionalParallelBatchUnion() : _constinit_{} {}
+        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+      bool parallel_batch_;
+    } optional_parallel_batch_;
+    union OptionalShuffleAndRepeatFusionUnion {
+      constexpr OptionalShuffleAndRepeatFusionUnion() : _constinit_{} {}
+        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+      bool shuffle_and_repeat_fusion_;
+    } optional_shuffle_and_repeat_fusion_;
+    union OptionalFilterParallelizationUnion {
+      constexpr OptionalFilterParallelizationUnion() : _constinit_{} {}
+        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+      bool filter_parallelization_;
+    } optional_filter_parallelization_;
+    union OptionalInjectPrefetchUnion {
+      constexpr OptionalInjectPrefetchUnion() : _constinit_{} {}
+        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+      bool inject_prefetch_;
+    } optional_inject_prefetch_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    uint32_t _oneof_case_[11];
+
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fdataset_5foptions_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ThreadingOptions final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.data.ThreadingOptions) */ {
+ public:
+  inline ThreadingOptions() : ThreadingOptions(nullptr) {}
+  ~ThreadingOptions() override;
+  explicit PROTOBUF_CONSTEXPR ThreadingOptions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ThreadingOptions(const ThreadingOptions& from);
+  ThreadingOptions(ThreadingOptions&& from) noexcept
+    : ThreadingOptions() {
+    *this = ::std::move(from);
+  }
+
+  inline ThreadingOptions& operator=(const ThreadingOptions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ThreadingOptions& operator=(ThreadingOptions&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ThreadingOptions& default_instance() {
+    return *internal_default_instance();
+  }
+  enum OptionalMaxIntraOpParallelismCase {
+    kMaxIntraOpParallelism = 1,
+    OPTIONAL_MAX_INTRA_OP_PARALLELISM_NOT_SET = 0,
+  };
+
+  enum OptionalPrivateThreadpoolSizeCase {
+    kPrivateThreadpoolSize = 2,
+    OPTIONAL_PRIVATE_THREADPOOL_SIZE_NOT_SET = 0,
+  };
+
+  static inline const ThreadingOptions* internal_default_instance() {
+    return reinterpret_cast<const ThreadingOptions*>(
+               &_ThreadingOptions_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    4;
+
+  friend void swap(ThreadingOptions& a, ThreadingOptions& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ThreadingOptions* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ThreadingOptions* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ThreadingOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ThreadingOptions>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ThreadingOptions& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const ThreadingOptions& from) {
+    ThreadingOptions::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ThreadingOptions* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.data.ThreadingOptions";
+  }
+  protected:
+  explicit ThreadingOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kMaxIntraOpParallelismFieldNumber = 1,
+    kPrivateThreadpoolSizeFieldNumber = 2,
+  };
+  // int32 max_intra_op_parallelism = 1;
+  bool has_max_intra_op_parallelism() const;
+  private:
+  bool _internal_has_max_intra_op_parallelism() const;
+  public:
+  void clear_max_intra_op_parallelism();
+  int32_t max_intra_op_parallelism() const;
+  void set_max_intra_op_parallelism(int32_t value);
+  private:
+  int32_t _internal_max_intra_op_parallelism() const;
+  void _internal_set_max_intra_op_parallelism(int32_t value);
+  public:
+
+  // int32 private_threadpool_size = 2;
+  bool has_private_threadpool_size() const;
+  private:
+  bool _internal_has_private_threadpool_size() const;
+  public:
+  void clear_private_threadpool_size();
+  int32_t private_threadpool_size() const;
+  void set_private_threadpool_size(int32_t value);
+  private:
+  int32_t _internal_private_threadpool_size() const;
+  void _internal_set_private_threadpool_size(int32_t value);
+  public:
+
+  void clear_optional_max_intra_op_parallelism();
+  OptionalMaxIntraOpParallelismCase optional_max_intra_op_parallelism_case() const;
+  void clear_optional_private_threadpool_size();
+  OptionalPrivateThreadpoolSizeCase optional_private_threadpool_size_case() const;
+  // @@protoc_insertion_point(class_scope:tensorflow.data.ThreadingOptions)
+ private:
+  class _Internal;
+  void set_has_max_intra_op_parallelism();
+  void set_has_private_threadpool_size();
+
+  inline bool has_optional_max_intra_op_parallelism() const;
+  inline void clear_has_optional_max_intra_op_parallelism();
+
+  inline bool has_optional_private_threadpool_size() const;
+  inline void clear_has_optional_private_threadpool_size();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    union OptionalMaxIntraOpParallelismUnion {
+      constexpr OptionalMaxIntraOpParallelismUnion() : _constinit_{} {}
+        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+      int32_t max_intra_op_parallelism_;
+    } optional_max_intra_op_parallelism_;
+    union OptionalPrivateThreadpoolSizeUnion {
+      constexpr OptionalPrivateThreadpoolSizeUnion() : _constinit_{} {}
+        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+      int32_t private_threadpool_size_;
+    } optional_private_threadpool_size_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    uint32_t _oneof_case_[2];
+
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fdataset_5foptions_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Options final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.data.Options) */ {
+ public:
+  inline Options() : Options(nullptr) {}
+  ~Options() override;
+  explicit PROTOBUF_CONSTEXPR Options(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Options(const Options& from);
+  Options(Options&& from) noexcept
+    : Options() {
+    *this = ::std::move(from);
+  }
+
+  inline Options& operator=(const Options& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Options& operator=(Options&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Options& default_instance() {
+    return *internal_default_instance();
+  }
+  enum OptionalDeterministicCase {
+    kDeterministic = 1,
+    OPTIONAL_DETERMINISTIC_NOT_SET = 0,
+  };
+
+  enum OptionalSlackCase {
+    kSlack = 4,
+    OPTIONAL_SLACK_NOT_SET = 0,
+  };
+
+  enum OptionalExternalStatePolicyCase {
+    kExternalStatePolicy = 6,
+    OPTIONAL_EXTERNAL_STATE_POLICY_NOT_SET = 0,
+  };
+
+  enum OptionalSymbolicCheckpointCase {
+    kSymbolicCheckpoint = 8,
+    OPTIONAL_SYMBOLIC_CHECKPOINT_NOT_SET = 0,
+  };
+
+  enum OptionalWarmStartCase {
+    kWarmStart = 9,
+    OPTIONAL_WARM_START_NOT_SET = 0,
+  };
+
+  static inline const Options* internal_default_instance() {
+    return reinterpret_cast<const Options*>(
+               &_Options_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    5;
+
+  friend void swap(Options& a, Options& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Options* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Options* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Options* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Options>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Options& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Options& from) {
+    Options::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Options* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.data.Options";
+  }
+  protected:
+  explicit Options(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDistributeOptionsFieldNumber = 2,
+    kOptimizationOptionsFieldNumber = 3,
+    kThreadingOptionsFieldNumber = 5,
+    kAutotuneOptionsFieldNumber = 7,
+    kDeterministicFieldNumber = 1,
+    kSlackFieldNumber = 4,
+    kExternalStatePolicyFieldNumber = 6,
+    kSymbolicCheckpointFieldNumber = 8,
+    kWarmStartFieldNumber = 9,
+  };
+  // .tensorflow.data.DistributeOptions distribute_options = 2;
+  bool has_distribute_options() const;
+  private:
+  bool _internal_has_distribute_options() const;
+  public:
+  void clear_distribute_options();
+  const ::tensorflow::data::DistributeOptions& distribute_options() const;
+  PROTOBUF_NODISCARD ::tensorflow::data::DistributeOptions* release_distribute_options();
+  ::tensorflow::data::DistributeOptions* mutable_distribute_options();
+  void set_allocated_distribute_options(::tensorflow::data::DistributeOptions* distribute_options);
+  private:
+  const ::tensorflow::data::DistributeOptions& _internal_distribute_options() const;
+  ::tensorflow::data::DistributeOptions* _internal_mutable_distribute_options();
+  public:
+  void unsafe_arena_set_allocated_distribute_options(
+      ::tensorflow::data::DistributeOptions* distribute_options);
+  ::tensorflow::data::DistributeOptions* unsafe_arena_release_distribute_options();
+
+  // .tensorflow.data.OptimizationOptions optimization_options = 3;
+  bool has_optimization_options() const;
+  private:
+  bool _internal_has_optimization_options() const;
+  public:
+  void clear_optimization_options();
+  const ::tensorflow::data::OptimizationOptions& optimization_options() const;
+  PROTOBUF_NODISCARD ::tensorflow::data::OptimizationOptions* release_optimization_options();
+  ::tensorflow::data::OptimizationOptions* mutable_optimization_options();
+  void set_allocated_optimization_options(::tensorflow::data::OptimizationOptions* optimization_options);
+  private:
+  const ::tensorflow::data::OptimizationOptions& _internal_optimization_options() const;
+  ::tensorflow::data::OptimizationOptions* _internal_mutable_optimization_options();
+  public:
+  void unsafe_arena_set_allocated_optimization_options(
+      ::tensorflow::data::OptimizationOptions* optimization_options);
+  ::tensorflow::data::OptimizationOptions* unsafe_arena_release_optimization_options();
+
+  // .tensorflow.data.ThreadingOptions threading_options = 5;
+  bool has_threading_options() const;
+  private:
+  bool _internal_has_threading_options() const;
+  public:
+  void clear_threading_options();
+  const ::tensorflow::data::ThreadingOptions& threading_options() const;
+  PROTOBUF_NODISCARD ::tensorflow::data::ThreadingOptions* release_threading_options();
+  ::tensorflow::data::ThreadingOptions* mutable_threading_options();
+  void set_allocated_threading_options(::tensorflow::data::ThreadingOptions* threading_options);
+  private:
+  const ::tensorflow::data::ThreadingOptions& _internal_threading_options() const;
+  ::tensorflow::data::ThreadingOptions* _internal_mutable_threading_options();
+  public:
+  void unsafe_arena_set_allocated_threading_options(
+      ::tensorflow::data::ThreadingOptions* threading_options);
+  ::tensorflow::data::ThreadingOptions* unsafe_arena_release_threading_options();
+
+  // .tensorflow.data.AutotuneOptions autotune_options = 7;
+  bool has_autotune_options() const;
+  private:
+  bool _internal_has_autotune_options() const;
+  public:
+  void clear_autotune_options();
+  const ::tensorflow::data::AutotuneOptions& autotune_options() const;
+  PROTOBUF_NODISCARD ::tensorflow::data::AutotuneOptions* release_autotune_options();
+  ::tensorflow::data::AutotuneOptions* mutable_autotune_options();
+  void set_allocated_autotune_options(::tensorflow::data::AutotuneOptions* autotune_options);
+  private:
+  const ::tensorflow::data::AutotuneOptions& _internal_autotune_options() const;
+  ::tensorflow::data::AutotuneOptions* _internal_mutable_autotune_options();
+  public:
+  void unsafe_arena_set_allocated_autotune_options(
+      ::tensorflow::data::AutotuneOptions* autotune_options);
+  ::tensorflow::data::AutotuneOptions* unsafe_arena_release_autotune_options();
+
+  // bool deterministic = 1;
+  bool has_deterministic() const;
+  private:
+  bool _internal_has_deterministic() const;
+  public:
+  void clear_deterministic();
+  bool deterministic() const;
+  void set_deterministic(bool value);
+  private:
+  bool _internal_deterministic() const;
+  void _internal_set_deterministic(bool value);
+  public:
+
+  // bool slack = 4;
+  bool has_slack() const;
+  private:
+  bool _internal_has_slack() const;
+  public:
+  void clear_slack();
+  bool slack() const;
+  void set_slack(bool value);
+  private:
+  bool _internal_slack() const;
+  void _internal_set_slack(bool value);
+  public:
+
+  // .tensorflow.data.ExternalStatePolicy external_state_policy = 6;
+  bool has_external_state_policy() const;
+  private:
+  bool _internal_has_external_state_policy() const;
+  public:
+  void clear_external_state_policy();
+  ::tensorflow::data::ExternalStatePolicy external_state_policy() const;
+  void set_external_state_policy(::tensorflow::data::ExternalStatePolicy value);
+  private:
+  ::tensorflow::data::ExternalStatePolicy _internal_external_state_policy() const;
+  void _internal_set_external_state_policy(::tensorflow::data::ExternalStatePolicy value);
+  public:
+
+  // bool symbolic_checkpoint = 8;
+  bool has_symbolic_checkpoint() const;
+  private:
+  bool _internal_has_symbolic_checkpoint() const;
+  public:
+  void clear_symbolic_checkpoint();
+  bool symbolic_checkpoint() const;
+  void set_symbolic_checkpoint(bool value);
+  private:
+  bool _internal_symbolic_checkpoint() const;
+  void _internal_set_symbolic_checkpoint(bool value);
+  public:
+
+  // bool warm_start = 9;
+  bool has_warm_start() const;
+  private:
+  bool _internal_has_warm_start() const;
+  public:
+  void clear_warm_start();
+  bool warm_start() const;
+  void set_warm_start(bool value);
+  private:
+  bool _internal_warm_start() const;
+  void _internal_set_warm_start(bool value);
+  public:
+
+  void clear_optional_deterministic();
+  OptionalDeterministicCase optional_deterministic_case() const;
+  void clear_optional_slack();
+  OptionalSlackCase optional_slack_case() const;
+  void clear_optional_external_state_policy();
+  OptionalExternalStatePolicyCase optional_external_state_policy_case() const;
+  void clear_optional_symbolic_checkpoint();
+  OptionalSymbolicCheckpointCase optional_symbolic_checkpoint_case() const;
+  void clear_optional_warm_start();
+  OptionalWarmStartCase optional_warm_start_case() const;
+  // @@protoc_insertion_point(class_scope:tensorflow.data.Options)
+ private:
+  class _Internal;
+  void set_has_deterministic();
+  void set_has_slack();
+  void set_has_external_state_policy();
+  void set_has_symbolic_checkpoint();
+  void set_has_warm_start();
+
+  inline bool has_optional_deterministic() const;
+  inline void clear_has_optional_deterministic();
+
+  inline bool has_optional_slack() const;
+  inline void clear_has_optional_slack();
+
+  inline bool has_optional_external_state_policy() const;
+  inline void clear_has_optional_external_state_policy();
+
+  inline bool has_optional_symbolic_checkpoint() const;
+  inline void clear_has_optional_symbolic_checkpoint();
+
+  inline bool has_optional_warm_start() const;
+  inline void clear_has_optional_warm_start();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::tensorflow::data::DistributeOptions* distribute_options_;
+    ::tensorflow::data::OptimizationOptions* optimization_options_;
+    ::tensorflow::data::ThreadingOptions* threading_options_;
+    ::tensorflow::data::AutotuneOptions* autotune_options_;
+    union OptionalDeterministicUnion {
+      constexpr OptionalDeterministicUnion() : _constinit_{} {}
+        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+      bool deterministic_;
+    } optional_deterministic_;
+    union OptionalSlackUnion {
+      constexpr OptionalSlackUnion() : _constinit_{} {}
+        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+      bool slack_;
+    } optional_slack_;
+    union OptionalExternalStatePolicyUnion {
+      constexpr OptionalExternalStatePolicyUnion() : _constinit_{} {}
+        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+      int external_state_policy_;
+    } optional_external_state_policy_;
+    union OptionalSymbolicCheckpointUnion {
+      constexpr OptionalSymbolicCheckpointUnion() : _constinit_{} {}
+        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+      bool symbolic_checkpoint_;
+    } optional_symbolic_checkpoint_;
+    union OptionalWarmStartUnion {
+      constexpr OptionalWarmStartUnion() : _constinit_{} {}
+        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+      bool warm_start_;
+    } optional_warm_start_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    uint32_t _oneof_case_[5];
+
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fdataset_5foptions_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// AutotuneOptions
+
+// bool enabled = 1;
+inline bool AutotuneOptions::_internal_has_enabled() const {
+  return optional_enabled_case() == kEnabled;
+}
+inline bool AutotuneOptions::has_enabled() const {
+  return _internal_has_enabled();
+}
+inline void AutotuneOptions::set_has_enabled() {
+  _impl_._oneof_case_[0] = kEnabled;
+}
+inline void AutotuneOptions::clear_enabled() {
+  if (_internal_has_enabled()) {
+    _impl_.optional_enabled_.enabled_ = false;
+    clear_has_optional_enabled();
+  }
+}
+inline bool AutotuneOptions::_internal_enabled() const {
+  if (_internal_has_enabled()) {
+    return _impl_.optional_enabled_.enabled_;
+  }
+  return false;
+}
+inline void AutotuneOptions::_internal_set_enabled(bool value) {
+  if (!_internal_has_enabled()) {
+    clear_optional_enabled();
+    set_has_enabled();
+  }
+  _impl_.optional_enabled_.enabled_ = value;
+}
+inline bool AutotuneOptions::enabled() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.AutotuneOptions.enabled)
+  return _internal_enabled();
+}
+inline void AutotuneOptions::set_enabled(bool value) {
+  _internal_set_enabled(value);
+  // @@protoc_insertion_point(field_set:tensorflow.data.AutotuneOptions.enabled)
+}
+
+// int32 cpu_budget = 2;
+inline bool AutotuneOptions::_internal_has_cpu_budget() const {
+  return optional_cpu_budget_case() == kCpuBudget;
+}
+inline bool AutotuneOptions::has_cpu_budget() const {
+  return _internal_has_cpu_budget();
+}
+inline void AutotuneOptions::set_has_cpu_budget() {
+  _impl_._oneof_case_[1] = kCpuBudget;
+}
+inline void AutotuneOptions::clear_cpu_budget() {
+  if (_internal_has_cpu_budget()) {
+    _impl_.optional_cpu_budget_.cpu_budget_ = 0;
+    clear_has_optional_cpu_budget();
+  }
+}
+inline int32_t AutotuneOptions::_internal_cpu_budget() const {
+  if (_internal_has_cpu_budget()) {
+    return _impl_.optional_cpu_budget_.cpu_budget_;
+  }
+  return 0;
+}
+inline void AutotuneOptions::_internal_set_cpu_budget(int32_t value) {
+  if (!_internal_has_cpu_budget()) {
+    clear_optional_cpu_budget();
+    set_has_cpu_budget();
+  }
+  _impl_.optional_cpu_budget_.cpu_budget_ = value;
+}
+inline int32_t AutotuneOptions::cpu_budget() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.AutotuneOptions.cpu_budget)
+  return _internal_cpu_budget();
+}
+inline void AutotuneOptions::set_cpu_budget(int32_t value) {
+  _internal_set_cpu_budget(value);
+  // @@protoc_insertion_point(field_set:tensorflow.data.AutotuneOptions.cpu_budget)
+}
+
+// int64 ram_budget = 3;
+inline bool AutotuneOptions::_internal_has_ram_budget() const {
+  return optional_ram_budget_case() == kRamBudget;
+}
+inline bool AutotuneOptions::has_ram_budget() const {
+  return _internal_has_ram_budget();
+}
+inline void AutotuneOptions::set_has_ram_budget() {
+  _impl_._oneof_case_[2] = kRamBudget;
+}
+inline void AutotuneOptions::clear_ram_budget() {
+  if (_internal_has_ram_budget()) {
+    _impl_.optional_ram_budget_.ram_budget_ = int64_t{0};
+    clear_has_optional_ram_budget();
+  }
+}
+inline int64_t AutotuneOptions::_internal_ram_budget() const {
+  if (_internal_has_ram_budget()) {
+    return _impl_.optional_ram_budget_.ram_budget_;
+  }
+  return int64_t{0};
+}
+inline void AutotuneOptions::_internal_set_ram_budget(int64_t value) {
+  if (!_internal_has_ram_budget()) {
+    clear_optional_ram_budget();
+    set_has_ram_budget();
+  }
+  _impl_.optional_ram_budget_.ram_budget_ = value;
+}
+inline int64_t AutotuneOptions::ram_budget() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.AutotuneOptions.ram_budget)
+  return _internal_ram_budget();
+}
+inline void AutotuneOptions::set_ram_budget(int64_t value) {
+  _internal_set_ram_budget(value);
+  // @@protoc_insertion_point(field_set:tensorflow.data.AutotuneOptions.ram_budget)
+}
+
+// .tensorflow.data.model.AutotuneAlgorithm autotune_algorithm = 4;
+inline bool AutotuneOptions::_internal_has_autotune_algorithm() const {
+  return optional_autotune_algorithm_case() == kAutotuneAlgorithm;
+}
+inline bool AutotuneOptions::has_autotune_algorithm() const {
+  return _internal_has_autotune_algorithm();
+}
+inline void AutotuneOptions::set_has_autotune_algorithm() {
+  _impl_._oneof_case_[3] = kAutotuneAlgorithm;
+}
+inline void AutotuneOptions::clear_autotune_algorithm() {
+  if (_internal_has_autotune_algorithm()) {
+    _impl_.optional_autotune_algorithm_.autotune_algorithm_ = 0;
+    clear_has_optional_autotune_algorithm();
+  }
+}
+inline ::tensorflow::data::model::AutotuneAlgorithm AutotuneOptions::_internal_autotune_algorithm() const {
+  if (_internal_has_autotune_algorithm()) {
+    return static_cast< ::tensorflow::data::model::AutotuneAlgorithm >(_impl_.optional_autotune_algorithm_.autotune_algorithm_);
+  }
+  return static_cast< ::tensorflow::data::model::AutotuneAlgorithm >(0);
+}
+inline ::tensorflow::data::model::AutotuneAlgorithm AutotuneOptions::autotune_algorithm() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.AutotuneOptions.autotune_algorithm)
+  return _internal_autotune_algorithm();
+}
+inline void AutotuneOptions::_internal_set_autotune_algorithm(::tensorflow::data::model::AutotuneAlgorithm value) {
+  if (!_internal_has_autotune_algorithm()) {
+    clear_optional_autotune_algorithm();
+    set_has_autotune_algorithm();
+  }
+  _impl_.optional_autotune_algorithm_.autotune_algorithm_ = value;
+}
+inline void AutotuneOptions::set_autotune_algorithm(::tensorflow::data::model::AutotuneAlgorithm value) {
+  _internal_set_autotune_algorithm(value);
+  // @@protoc_insertion_point(field_set:tensorflow.data.AutotuneOptions.autotune_algorithm)
+}
+
+inline bool AutotuneOptions::has_optional_enabled() const {
+  return optional_enabled_case() != OPTIONAL_ENABLED_NOT_SET;
+}
+inline void AutotuneOptions::clear_has_optional_enabled() {
+  _impl_._oneof_case_[0] = OPTIONAL_ENABLED_NOT_SET;
+}
+inline bool AutotuneOptions::has_optional_cpu_budget() const {
+  return optional_cpu_budget_case() != OPTIONAL_CPU_BUDGET_NOT_SET;
+}
+inline void AutotuneOptions::clear_has_optional_cpu_budget() {
+  _impl_._oneof_case_[1] = OPTIONAL_CPU_BUDGET_NOT_SET;
+}
+inline bool AutotuneOptions::has_optional_ram_budget() const {
+  return optional_ram_budget_case() != OPTIONAL_RAM_BUDGET_NOT_SET;
+}
+inline void AutotuneOptions::clear_has_optional_ram_budget() {
+  _impl_._oneof_case_[2] = OPTIONAL_RAM_BUDGET_NOT_SET;
+}
+inline bool AutotuneOptions::has_optional_autotune_algorithm() const {
+  return optional_autotune_algorithm_case() != OPTIONAL_AUTOTUNE_ALGORITHM_NOT_SET;
+}
+inline void AutotuneOptions::clear_has_optional_autotune_algorithm() {
+  _impl_._oneof_case_[3] = OPTIONAL_AUTOTUNE_ALGORITHM_NOT_SET;
+}
+inline AutotuneOptions::OptionalEnabledCase AutotuneOptions::optional_enabled_case() const {
+  return AutotuneOptions::OptionalEnabledCase(_impl_._oneof_case_[0]);
+}
+inline AutotuneOptions::OptionalCpuBudgetCase AutotuneOptions::optional_cpu_budget_case() const {
+  return AutotuneOptions::OptionalCpuBudgetCase(_impl_._oneof_case_[1]);
+}
+inline AutotuneOptions::OptionalRamBudgetCase AutotuneOptions::optional_ram_budget_case() const {
+  return AutotuneOptions::OptionalRamBudgetCase(_impl_._oneof_case_[2]);
+}
+inline AutotuneOptions::OptionalAutotuneAlgorithmCase AutotuneOptions::optional_autotune_algorithm_case() const {
+  return AutotuneOptions::OptionalAutotuneAlgorithmCase(_impl_._oneof_case_[3]);
+}
+// -------------------------------------------------------------------
+
+// CardinalityOptions
+
+// .tensorflow.data.CardinalityOptions.ComputeLevel compute_level = 1;
+inline void CardinalityOptions::clear_compute_level() {
+  _impl_.compute_level_ = 0;
+}
+inline ::tensorflow::data::CardinalityOptions_ComputeLevel CardinalityOptions::_internal_compute_level() const {
+  return static_cast< ::tensorflow::data::CardinalityOptions_ComputeLevel >(_impl_.compute_level_);
+}
+inline ::tensorflow::data::CardinalityOptions_ComputeLevel CardinalityOptions::compute_level() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.CardinalityOptions.compute_level)
+  return _internal_compute_level();
+}
+inline void CardinalityOptions::_internal_set_compute_level(::tensorflow::data::CardinalityOptions_ComputeLevel value) {
+  
+  _impl_.compute_level_ = value;
+}
+inline void CardinalityOptions::set_compute_level(::tensorflow::data::CardinalityOptions_ComputeLevel value) {
+  _internal_set_compute_level(value);
+  // @@protoc_insertion_point(field_set:tensorflow.data.CardinalityOptions.compute_level)
+}
+
+// -------------------------------------------------------------------
+
+// DistributeOptions
+
+// .tensorflow.data.AutoShardPolicy auto_shard_policy = 1;
+inline void DistributeOptions::clear_auto_shard_policy() {
+  _impl_.auto_shard_policy_ = 0;
+}
+inline ::tensorflow::data::AutoShardPolicy DistributeOptions::_internal_auto_shard_policy() const {
+  return static_cast< ::tensorflow::data::AutoShardPolicy >(_impl_.auto_shard_policy_);
+}
+inline ::tensorflow::data::AutoShardPolicy DistributeOptions::auto_shard_policy() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.DistributeOptions.auto_shard_policy)
+  return _internal_auto_shard_policy();
+}
+inline void DistributeOptions::_internal_set_auto_shard_policy(::tensorflow::data::AutoShardPolicy value) {
+  
+  _impl_.auto_shard_policy_ = value;
+}
+inline void DistributeOptions::set_auto_shard_policy(::tensorflow::data::AutoShardPolicy value) {
+  _internal_set_auto_shard_policy(value);
+  // @@protoc_insertion_point(field_set:tensorflow.data.DistributeOptions.auto_shard_policy)
+}
+
+// int32 num_devices = 2;
+inline bool DistributeOptions::_internal_has_num_devices() const {
+  return optional_num_devices_case() == kNumDevices;
+}
+inline bool DistributeOptions::has_num_devices() const {
+  return _internal_has_num_devices();
+}
+inline void DistributeOptions::set_has_num_devices() {
+  _impl_._oneof_case_[0] = kNumDevices;
+}
+inline void DistributeOptions::clear_num_devices() {
+  if (_internal_has_num_devices()) {
+    _impl_.optional_num_devices_.num_devices_ = 0;
+    clear_has_optional_num_devices();
+  }
+}
+inline int32_t DistributeOptions::_internal_num_devices() const {
+  if (_internal_has_num_devices()) {
+    return _impl_.optional_num_devices_.num_devices_;
+  }
+  return 0;
+}
+inline void DistributeOptions::_internal_set_num_devices(int32_t value) {
+  if (!_internal_has_num_devices()) {
+    clear_optional_num_devices();
+    set_has_num_devices();
+  }
+  _impl_.optional_num_devices_.num_devices_ = value;
+}
+inline int32_t DistributeOptions::num_devices() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.DistributeOptions.num_devices)
+  return _internal_num_devices();
+}
+inline void DistributeOptions::set_num_devices(int32_t value) {
+  _internal_set_num_devices(value);
+  // @@protoc_insertion_point(field_set:tensorflow.data.DistributeOptions.num_devices)
+}
+
+inline bool DistributeOptions::has_optional_num_devices() const {
+  return optional_num_devices_case() != OPTIONAL_NUM_DEVICES_NOT_SET;
+}
+inline void DistributeOptions::clear_has_optional_num_devices() {
+  _impl_._oneof_case_[0] = OPTIONAL_NUM_DEVICES_NOT_SET;
+}
+inline DistributeOptions::OptionalNumDevicesCase DistributeOptions::optional_num_devices_case() const {
+  return DistributeOptions::OptionalNumDevicesCase(_impl_._oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// OptimizationOptions
+
+// bool apply_default_optimizations = 1;
+inline bool OptimizationOptions::_internal_has_apply_default_optimizations() const {
+  return optional_apply_default_optimizations_case() == kApplyDefaultOptimizations;
+}
+inline bool OptimizationOptions::has_apply_default_optimizations() const {
+  return _internal_has_apply_default_optimizations();
+}
+inline void OptimizationOptions::set_has_apply_default_optimizations() {
+  _impl_._oneof_case_[0] = kApplyDefaultOptimizations;
+}
+inline void OptimizationOptions::clear_apply_default_optimizations() {
+  if (_internal_has_apply_default_optimizations()) {
+    _impl_.optional_apply_default_optimizations_.apply_default_optimizations_ = false;
+    clear_has_optional_apply_default_optimizations();
+  }
+}
+inline bool OptimizationOptions::_internal_apply_default_optimizations() const {
+  if (_internal_has_apply_default_optimizations()) {
+    return _impl_.optional_apply_default_optimizations_.apply_default_optimizations_;
+  }
+  return false;
+}
+inline void OptimizationOptions::_internal_set_apply_default_optimizations(bool value) {
+  if (!_internal_has_apply_default_optimizations()) {
+    clear_optional_apply_default_optimizations();
+    set_has_apply_default_optimizations();
+  }
+  _impl_.optional_apply_default_optimizations_.apply_default_optimizations_ = value;
+}
+inline bool OptimizationOptions::apply_default_optimizations() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.OptimizationOptions.apply_default_optimizations)
+  return _internal_apply_default_optimizations();
+}
+inline void OptimizationOptions::set_apply_default_optimizations(bool value) {
+  _internal_set_apply_default_optimizations(value);
+  // @@protoc_insertion_point(field_set:tensorflow.data.OptimizationOptions.apply_default_optimizations)
+}
+
+// bool filter_fusion = 6;
+inline bool OptimizationOptions::_internal_has_filter_fusion() const {
+  return optional_filter_fusion_case() == kFilterFusion;
+}
+inline bool OptimizationOptions::has_filter_fusion() const {
+  return _internal_has_filter_fusion();
+}
+inline void OptimizationOptions::set_has_filter_fusion() {
+  _impl_._oneof_case_[1] = kFilterFusion;
+}
+inline void OptimizationOptions::clear_filter_fusion() {
+  if (_internal_has_filter_fusion()) {
+    _impl_.optional_filter_fusion_.filter_fusion_ = false;
+    clear_has_optional_filter_fusion();
+  }
+}
+inline bool OptimizationOptions::_internal_filter_fusion() const {
+  if (_internal_has_filter_fusion()) {
+    return _impl_.optional_filter_fusion_.filter_fusion_;
+  }
+  return false;
+}
+inline void OptimizationOptions::_internal_set_filter_fusion(bool value) {
+  if (!_internal_has_filter_fusion()) {
+    clear_optional_filter_fusion();
+    set_has_filter_fusion();
+  }
+  _impl_.optional_filter_fusion_.filter_fusion_ = value;
+}
+inline bool OptimizationOptions::filter_fusion() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.OptimizationOptions.filter_fusion)
+  return _internal_filter_fusion();
+}
+inline void OptimizationOptions::set_filter_fusion(bool value) {
+  _internal_set_filter_fusion(value);
+  // @@protoc_insertion_point(field_set:tensorflow.data.OptimizationOptions.filter_fusion)
+}
+
+// bool map_and_batch_fusion = 9;
+inline bool OptimizationOptions::_internal_has_map_and_batch_fusion() const {
+  return optional_map_and_batch_fusion_case() == kMapAndBatchFusion;
+}
+inline bool OptimizationOptions::has_map_and_batch_fusion() const {
+  return _internal_has_map_and_batch_fusion();
+}
+inline void OptimizationOptions::set_has_map_and_batch_fusion() {
+  _impl_._oneof_case_[2] = kMapAndBatchFusion;
+}
+inline void OptimizationOptions::clear_map_and_batch_fusion() {
+  if (_internal_has_map_and_batch_fusion()) {
+    _impl_.optional_map_and_batch_fusion_.map_and_batch_fusion_ = false;
+    clear_has_optional_map_and_batch_fusion();
+  }
+}
+inline bool OptimizationOptions::_internal_map_and_batch_fusion() const {
+  if (_internal_has_map_and_batch_fusion()) {
+    return _impl_.optional_map_and_batch_fusion_.map_and_batch_fusion_;
+  }
+  return false;
+}
+inline void OptimizationOptions::_internal_set_map_and_batch_fusion(bool value) {
+  if (!_internal_has_map_and_batch_fusion()) {
+    clear_optional_map_and_batch_fusion();
+    set_has_map_and_batch_fusion();
+  }
+  _impl_.optional_map_and_batch_fusion_.map_and_batch_fusion_ = value;
+}
+inline bool OptimizationOptions::map_and_batch_fusion() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.OptimizationOptions.map_and_batch_fusion)
+  return _internal_map_and_batch_fusion();
+}
+inline void OptimizationOptions::set_map_and_batch_fusion(bool value) {
+  _internal_set_map_and_batch_fusion(value);
+  // @@protoc_insertion_point(field_set:tensorflow.data.OptimizationOptions.map_and_batch_fusion)
+}
+
+// bool map_and_filter_fusion = 10;
+inline bool OptimizationOptions::_internal_has_map_and_filter_fusion() const {
+  return optional_map_and_filter_fusion_case() == kMapAndFilterFusion;
+}
+inline bool OptimizationOptions::has_map_and_filter_fusion() const {
+  return _internal_has_map_and_filter_fusion();
+}
+inline void OptimizationOptions::set_has_map_and_filter_fusion() {
+  _impl_._oneof_case_[3] = kMapAndFilterFusion;
+}
+inline void OptimizationOptions::clear_map_and_filter_fusion() {
+  if (_internal_has_map_and_filter_fusion()) {
+    _impl_.optional_map_and_filter_fusion_.map_and_filter_fusion_ = false;
+    clear_has_optional_map_and_filter_fusion();
+  }
+}
+inline bool OptimizationOptions::_internal_map_and_filter_fusion() const {
+  if (_internal_has_map_and_filter_fusion()) {
+    return _impl_.optional_map_and_filter_fusion_.map_and_filter_fusion_;
+  }
+  return false;
+}
+inline void OptimizationOptions::_internal_set_map_and_filter_fusion(bool value) {
+  if (!_internal_has_map_and_filter_fusion()) {
+    clear_optional_map_and_filter_fusion();
+    set_has_map_and_filter_fusion();
+  }
+  _impl_.optional_map_and_filter_fusion_.map_and_filter_fusion_ = value;
+}
+inline bool OptimizationOptions::map_and_filter_fusion() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.OptimizationOptions.map_and_filter_fusion)
+  return _internal_map_and_filter_fusion();
+}
+inline void OptimizationOptions::set_map_and_filter_fusion(bool value) {
+  _internal_set_map_and_filter_fusion(value);
+  // @@protoc_insertion_point(field_set:tensorflow.data.OptimizationOptions.map_and_filter_fusion)
+}
+
+// bool map_fusion = 11;
+inline bool OptimizationOptions::_internal_has_map_fusion() const {
+  return optional_map_fusion_case() == kMapFusion;
+}
+inline bool OptimizationOptions::has_map_fusion() const {
+  return _internal_has_map_fusion();
+}
+inline void OptimizationOptions::set_has_map_fusion() {
+  _impl_._oneof_case_[4] = kMapFusion;
+}
+inline void OptimizationOptions::clear_map_fusion() {
+  if (_internal_has_map_fusion()) {
+    _impl_.optional_map_fusion_.map_fusion_ = false;
+    clear_has_optional_map_fusion();
+  }
+}
+inline bool OptimizationOptions::_internal_map_fusion() const {
+  if (_internal_has_map_fusion()) {
+    return _impl_.optional_map_fusion_.map_fusion_;
+  }
+  return false;
+}
+inline void OptimizationOptions::_internal_set_map_fusion(bool value) {
+  if (!_internal_has_map_fusion()) {
+    clear_optional_map_fusion();
+    set_has_map_fusion();
+  }
+  _impl_.optional_map_fusion_.map_fusion_ = value;
+}
+inline bool OptimizationOptions::map_fusion() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.OptimizationOptions.map_fusion)
+  return _internal_map_fusion();
+}
+inline void OptimizationOptions::set_map_fusion(bool value) {
+  _internal_set_map_fusion(value);
+  // @@protoc_insertion_point(field_set:tensorflow.data.OptimizationOptions.map_fusion)
+}
+
+// bool map_parallelization = 12;
+inline bool OptimizationOptions::_internal_has_map_parallelization() const {
+  return optional_map_parallelization_case() == kMapParallelization;
+}
+inline bool OptimizationOptions::has_map_parallelization() const {
+  return _internal_has_map_parallelization();
+}
+inline void OptimizationOptions::set_has_map_parallelization() {
+  _impl_._oneof_case_[5] = kMapParallelization;
+}
+inline void OptimizationOptions::clear_map_parallelization() {
+  if (_internal_has_map_parallelization()) {
+    _impl_.optional_map_parallelization_.map_parallelization_ = false;
+    clear_has_optional_map_parallelization();
+  }
+}
+inline bool OptimizationOptions::_internal_map_parallelization() const {
+  if (_internal_has_map_parallelization()) {
+    return _impl_.optional_map_parallelization_.map_parallelization_;
+  }
+  return false;
+}
+inline void OptimizationOptions::_internal_set_map_parallelization(bool value) {
+  if (!_internal_has_map_parallelization()) {
+    clear_optional_map_parallelization();
+    set_has_map_parallelization();
+  }
+  _impl_.optional_map_parallelization_.map_parallelization_ = value;
+}
+inline bool OptimizationOptions::map_parallelization() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.OptimizationOptions.map_parallelization)
+  return _internal_map_parallelization();
+}
+inline void OptimizationOptions::set_map_parallelization(bool value) {
+  _internal_set_map_parallelization(value);
+  // @@protoc_insertion_point(field_set:tensorflow.data.OptimizationOptions.map_parallelization)
+}
+
+// bool noop_elimination = 14;
+inline bool OptimizationOptions::_internal_has_noop_elimination() const {
+  return optional_noop_elimination_case() == kNoopElimination;
+}
+inline bool OptimizationOptions::has_noop_elimination() const {
+  return _internal_has_noop_elimination();
+}
+inline void OptimizationOptions::set_has_noop_elimination() {
+  _impl_._oneof_case_[6] = kNoopElimination;
+}
+inline void OptimizationOptions::clear_noop_elimination() {
+  if (_internal_has_noop_elimination()) {
+    _impl_.optional_noop_elimination_.noop_elimination_ = false;
+    clear_has_optional_noop_elimination();
+  }
+}
+inline bool OptimizationOptions::_internal_noop_elimination() const {
+  if (_internal_has_noop_elimination()) {
+    return _impl_.optional_noop_elimination_.noop_elimination_;
+  }
+  return false;
+}
+inline void OptimizationOptions::_internal_set_noop_elimination(bool value) {
+  if (!_internal_has_noop_elimination()) {
+    clear_optional_noop_elimination();
+    set_has_noop_elimination();
+  }
+  _impl_.optional_noop_elimination_.noop_elimination_ = value;
+}
+inline bool OptimizationOptions::noop_elimination() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.OptimizationOptions.noop_elimination)
+  return _internal_noop_elimination();
+}
+inline void OptimizationOptions::set_noop_elimination(bool value) {
+  _internal_set_noop_elimination(value);
+  // @@protoc_insertion_point(field_set:tensorflow.data.OptimizationOptions.noop_elimination)
+}
+
+// bool parallel_batch = 15;
+inline bool OptimizationOptions::_internal_has_parallel_batch() const {
+  return optional_parallel_batch_case() == kParallelBatch;
+}
+inline bool OptimizationOptions::has_parallel_batch() const {
+  return _internal_has_parallel_batch();
+}
+inline void OptimizationOptions::set_has_parallel_batch() {
+  _impl_._oneof_case_[7] = kParallelBatch;
+}
+inline void OptimizationOptions::clear_parallel_batch() {
+  if (_internal_has_parallel_batch()) {
+    _impl_.optional_parallel_batch_.parallel_batch_ = false;
+    clear_has_optional_parallel_batch();
+  }
+}
+inline bool OptimizationOptions::_internal_parallel_batch() const {
+  if (_internal_has_parallel_batch()) {
+    return _impl_.optional_parallel_batch_.parallel_batch_;
+  }
+  return false;
+}
+inline void OptimizationOptions::_internal_set_parallel_batch(bool value) {
+  if (!_internal_has_parallel_batch()) {
+    clear_optional_parallel_batch();
+    set_has_parallel_batch();
+  }
+  _impl_.optional_parallel_batch_.parallel_batch_ = value;
+}
+inline bool OptimizationOptions::parallel_batch() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.OptimizationOptions.parallel_batch)
+  return _internal_parallel_batch();
+}
+inline void OptimizationOptions::set_parallel_batch(bool value) {
+  _internal_set_parallel_batch(value);
+  // @@protoc_insertion_point(field_set:tensorflow.data.OptimizationOptions.parallel_batch)
+}
+
+// bool shuffle_and_repeat_fusion = 17;
+inline bool OptimizationOptions::_internal_has_shuffle_and_repeat_fusion() const {
+  return optional_shuffle_and_repeat_fusion_case() == kShuffleAndRepeatFusion;
+}
+inline bool OptimizationOptions::has_shuffle_and_repeat_fusion() const {
+  return _internal_has_shuffle_and_repeat_fusion();
+}
+inline void OptimizationOptions::set_has_shuffle_and_repeat_fusion() {
+  _impl_._oneof_case_[8] = kShuffleAndRepeatFusion;
+}
+inline void OptimizationOptions::clear_shuffle_and_repeat_fusion() {
+  if (_internal_has_shuffle_and_repeat_fusion()) {
+    _impl_.optional_shuffle_and_repeat_fusion_.shuffle_and_repeat_fusion_ = false;
+    clear_has_optional_shuffle_and_repeat_fusion();
+  }
+}
+inline bool OptimizationOptions::_internal_shuffle_and_repeat_fusion() const {
+  if (_internal_has_shuffle_and_repeat_fusion()) {
+    return _impl_.optional_shuffle_and_repeat_fusion_.shuffle_and_repeat_fusion_;
+  }
+  return false;
+}
+inline void OptimizationOptions::_internal_set_shuffle_and_repeat_fusion(bool value) {
+  if (!_internal_has_shuffle_and_repeat_fusion()) {
+    clear_optional_shuffle_and_repeat_fusion();
+    set_has_shuffle_and_repeat_fusion();
+  }
+  _impl_.optional_shuffle_and_repeat_fusion_.shuffle_and_repeat_fusion_ = value;
+}
+inline bool OptimizationOptions::shuffle_and_repeat_fusion() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.OptimizationOptions.shuffle_and_repeat_fusion)
+  return _internal_shuffle_and_repeat_fusion();
+}
+inline void OptimizationOptions::set_shuffle_and_repeat_fusion(bool value) {
+  _internal_set_shuffle_and_repeat_fusion(value);
+  // @@protoc_insertion_point(field_set:tensorflow.data.OptimizationOptions.shuffle_and_repeat_fusion)
+}
+
+// bool filter_parallelization = 18;
+inline bool OptimizationOptions::_internal_has_filter_parallelization() const {
+  return optional_filter_parallelization_case() == kFilterParallelization;
+}
+inline bool OptimizationOptions::has_filter_parallelization() const {
+  return _internal_has_filter_parallelization();
+}
+inline void OptimizationOptions::set_has_filter_parallelization() {
+  _impl_._oneof_case_[9] = kFilterParallelization;
+}
+inline void OptimizationOptions::clear_filter_parallelization() {
+  if (_internal_has_filter_parallelization()) {
+    _impl_.optional_filter_parallelization_.filter_parallelization_ = false;
+    clear_has_optional_filter_parallelization();
+  }
+}
+inline bool OptimizationOptions::_internal_filter_parallelization() const {
+  if (_internal_has_filter_parallelization()) {
+    return _impl_.optional_filter_parallelization_.filter_parallelization_;
+  }
+  return false;
+}
+inline void OptimizationOptions::_internal_set_filter_parallelization(bool value) {
+  if (!_internal_has_filter_parallelization()) {
+    clear_optional_filter_parallelization();
+    set_has_filter_parallelization();
+  }
+  _impl_.optional_filter_parallelization_.filter_parallelization_ = value;
+}
+inline bool OptimizationOptions::filter_parallelization() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.OptimizationOptions.filter_parallelization)
+  return _internal_filter_parallelization();
+}
+inline void OptimizationOptions::set_filter_parallelization(bool value) {
+  _internal_set_filter_parallelization(value);
+  // @@protoc_insertion_point(field_set:tensorflow.data.OptimizationOptions.filter_parallelization)
+}
+
+// bool inject_prefetch = 19;
+inline bool OptimizationOptions::_internal_has_inject_prefetch() const {
+  return optional_inject_prefetch_case() == kInjectPrefetch;
+}
+inline bool OptimizationOptions::has_inject_prefetch() const {
+  return _internal_has_inject_prefetch();
+}
+inline void OptimizationOptions::set_has_inject_prefetch() {
+  _impl_._oneof_case_[10] = kInjectPrefetch;
+}
+inline void OptimizationOptions::clear_inject_prefetch() {
+  if (_internal_has_inject_prefetch()) {
+    _impl_.optional_inject_prefetch_.inject_prefetch_ = false;
+    clear_has_optional_inject_prefetch();
+  }
+}
+inline bool OptimizationOptions::_internal_inject_prefetch() const {
+  if (_internal_has_inject_prefetch()) {
+    return _impl_.optional_inject_prefetch_.inject_prefetch_;
+  }
+  return false;
+}
+inline void OptimizationOptions::_internal_set_inject_prefetch(bool value) {
+  if (!_internal_has_inject_prefetch()) {
+    clear_optional_inject_prefetch();
+    set_has_inject_prefetch();
+  }
+  _impl_.optional_inject_prefetch_.inject_prefetch_ = value;
+}
+inline bool OptimizationOptions::inject_prefetch() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.OptimizationOptions.inject_prefetch)
+  return _internal_inject_prefetch();
+}
+inline void OptimizationOptions::set_inject_prefetch(bool value) {
+  _internal_set_inject_prefetch(value);
+  // @@protoc_insertion_point(field_set:tensorflow.data.OptimizationOptions.inject_prefetch)
+}
+
+inline bool OptimizationOptions::has_optional_apply_default_optimizations() const {
+  return optional_apply_default_optimizations_case() != OPTIONAL_APPLY_DEFAULT_OPTIMIZATIONS_NOT_SET;
+}
+inline void OptimizationOptions::clear_has_optional_apply_default_optimizations() {
+  _impl_._oneof_case_[0] = OPTIONAL_APPLY_DEFAULT_OPTIMIZATIONS_NOT_SET;
+}
+inline bool OptimizationOptions::has_optional_filter_fusion() const {
+  return optional_filter_fusion_case() != OPTIONAL_FILTER_FUSION_NOT_SET;
+}
+inline void OptimizationOptions::clear_has_optional_filter_fusion() {
+  _impl_._oneof_case_[1] = OPTIONAL_FILTER_FUSION_NOT_SET;
+}
+inline bool OptimizationOptions::has_optional_map_and_batch_fusion() const {
+  return optional_map_and_batch_fusion_case() != OPTIONAL_MAP_AND_BATCH_FUSION_NOT_SET;
+}
+inline void OptimizationOptions::clear_has_optional_map_and_batch_fusion() {
+  _impl_._oneof_case_[2] = OPTIONAL_MAP_AND_BATCH_FUSION_NOT_SET;
+}
+inline bool OptimizationOptions::has_optional_map_and_filter_fusion() const {
+  return optional_map_and_filter_fusion_case() != OPTIONAL_MAP_AND_FILTER_FUSION_NOT_SET;
+}
+inline void OptimizationOptions::clear_has_optional_map_and_filter_fusion() {
+  _impl_._oneof_case_[3] = OPTIONAL_MAP_AND_FILTER_FUSION_NOT_SET;
+}
+inline bool OptimizationOptions::has_optional_map_fusion() const {
+  return optional_map_fusion_case() != OPTIONAL_MAP_FUSION_NOT_SET;
+}
+inline void OptimizationOptions::clear_has_optional_map_fusion() {
+  _impl_._oneof_case_[4] = OPTIONAL_MAP_FUSION_NOT_SET;
+}
+inline bool OptimizationOptions::has_optional_map_parallelization() const {
+  return optional_map_parallelization_case() != OPTIONAL_MAP_PARALLELIZATION_NOT_SET;
+}
+inline void OptimizationOptions::clear_has_optional_map_parallelization() {
+  _impl_._oneof_case_[5] = OPTIONAL_MAP_PARALLELIZATION_NOT_SET;
+}
+inline bool OptimizationOptions::has_optional_noop_elimination() const {
+  return optional_noop_elimination_case() != OPTIONAL_NOOP_ELIMINATION_NOT_SET;
+}
+inline void OptimizationOptions::clear_has_optional_noop_elimination() {
+  _impl_._oneof_case_[6] = OPTIONAL_NOOP_ELIMINATION_NOT_SET;
+}
+inline bool OptimizationOptions::has_optional_parallel_batch() const {
+  return optional_parallel_batch_case() != OPTIONAL_PARALLEL_BATCH_NOT_SET;
+}
+inline void OptimizationOptions::clear_has_optional_parallel_batch() {
+  _impl_._oneof_case_[7] = OPTIONAL_PARALLEL_BATCH_NOT_SET;
+}
+inline bool OptimizationOptions::has_optional_shuffle_and_repeat_fusion() const {
+  return optional_shuffle_and_repeat_fusion_case() != OPTIONAL_SHUFFLE_AND_REPEAT_FUSION_NOT_SET;
+}
+inline void OptimizationOptions::clear_has_optional_shuffle_and_repeat_fusion() {
+  _impl_._oneof_case_[8] = OPTIONAL_SHUFFLE_AND_REPEAT_FUSION_NOT_SET;
+}
+inline bool OptimizationOptions::has_optional_filter_parallelization() const {
+  return optional_filter_parallelization_case() != OPTIONAL_FILTER_PARALLELIZATION_NOT_SET;
+}
+inline void OptimizationOptions::clear_has_optional_filter_parallelization() {
+  _impl_._oneof_case_[9] = OPTIONAL_FILTER_PARALLELIZATION_NOT_SET;
+}
+inline bool OptimizationOptions::has_optional_inject_prefetch() const {
+  return optional_inject_prefetch_case() != OPTIONAL_INJECT_PREFETCH_NOT_SET;
+}
+inline void OptimizationOptions::clear_has_optional_inject_prefetch() {
+  _impl_._oneof_case_[10] = OPTIONAL_INJECT_PREFETCH_NOT_SET;
+}
+inline OptimizationOptions::OptionalApplyDefaultOptimizationsCase OptimizationOptions::optional_apply_default_optimizations_case() const {
+  return OptimizationOptions::OptionalApplyDefaultOptimizationsCase(_impl_._oneof_case_[0]);
+}
+inline OptimizationOptions::OptionalFilterFusionCase OptimizationOptions::optional_filter_fusion_case() const {
+  return OptimizationOptions::OptionalFilterFusionCase(_impl_._oneof_case_[1]);
+}
+inline OptimizationOptions::OptionalMapAndBatchFusionCase OptimizationOptions::optional_map_and_batch_fusion_case() const {
+  return OptimizationOptions::OptionalMapAndBatchFusionCase(_impl_._oneof_case_[2]);
+}
+inline OptimizationOptions::OptionalMapAndFilterFusionCase OptimizationOptions::optional_map_and_filter_fusion_case() const {
+  return OptimizationOptions::OptionalMapAndFilterFusionCase(_impl_._oneof_case_[3]);
+}
+inline OptimizationOptions::OptionalMapFusionCase OptimizationOptions::optional_map_fusion_case() const {
+  return OptimizationOptions::OptionalMapFusionCase(_impl_._oneof_case_[4]);
+}
+inline OptimizationOptions::OptionalMapParallelizationCase OptimizationOptions::optional_map_parallelization_case() const {
+  return OptimizationOptions::OptionalMapParallelizationCase(_impl_._oneof_case_[5]);
+}
+inline OptimizationOptions::OptionalNoopEliminationCase OptimizationOptions::optional_noop_elimination_case() const {
+  return OptimizationOptions::OptionalNoopEliminationCase(_impl_._oneof_case_[6]);
+}
+inline OptimizationOptions::OptionalParallelBatchCase OptimizationOptions::optional_parallel_batch_case() const {
+  return OptimizationOptions::OptionalParallelBatchCase(_impl_._oneof_case_[7]);
+}
+inline OptimizationOptions::OptionalShuffleAndRepeatFusionCase OptimizationOptions::optional_shuffle_and_repeat_fusion_case() const {
+  return OptimizationOptions::OptionalShuffleAndRepeatFusionCase(_impl_._oneof_case_[8]);
+}
+inline OptimizationOptions::OptionalFilterParallelizationCase OptimizationOptions::optional_filter_parallelization_case() const {
+  return OptimizationOptions::OptionalFilterParallelizationCase(_impl_._oneof_case_[9]);
+}
+inline OptimizationOptions::OptionalInjectPrefetchCase OptimizationOptions::optional_inject_prefetch_case() const {
+  return OptimizationOptions::OptionalInjectPrefetchCase(_impl_._oneof_case_[10]);
+}
+// -------------------------------------------------------------------
+
+// ThreadingOptions
+
+// int32 max_intra_op_parallelism = 1;
+inline bool ThreadingOptions::_internal_has_max_intra_op_parallelism() const {
+  return optional_max_intra_op_parallelism_case() == kMaxIntraOpParallelism;
+}
+inline bool ThreadingOptions::has_max_intra_op_parallelism() const {
+  return _internal_has_max_intra_op_parallelism();
+}
+inline void ThreadingOptions::set_has_max_intra_op_parallelism() {
+  _impl_._oneof_case_[0] = kMaxIntraOpParallelism;
+}
+inline void ThreadingOptions::clear_max_intra_op_parallelism() {
+  if (_internal_has_max_intra_op_parallelism()) {
+    _impl_.optional_max_intra_op_parallelism_.max_intra_op_parallelism_ = 0;
+    clear_has_optional_max_intra_op_parallelism();
+  }
+}
+inline int32_t ThreadingOptions::_internal_max_intra_op_parallelism() const {
+  if (_internal_has_max_intra_op_parallelism()) {
+    return _impl_.optional_max_intra_op_parallelism_.max_intra_op_parallelism_;
+  }
+  return 0;
+}
+inline void ThreadingOptions::_internal_set_max_intra_op_parallelism(int32_t value) {
+  if (!_internal_has_max_intra_op_parallelism()) {
+    clear_optional_max_intra_op_parallelism();
+    set_has_max_intra_op_parallelism();
+  }
+  _impl_.optional_max_intra_op_parallelism_.max_intra_op_parallelism_ = value;
+}
+inline int32_t ThreadingOptions::max_intra_op_parallelism() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.ThreadingOptions.max_intra_op_parallelism)
+  return _internal_max_intra_op_parallelism();
+}
+inline void ThreadingOptions::set_max_intra_op_parallelism(int32_t value) {
+  _internal_set_max_intra_op_parallelism(value);
+  // @@protoc_insertion_point(field_set:tensorflow.data.ThreadingOptions.max_intra_op_parallelism)
+}
+
+// int32 private_threadpool_size = 2;
+inline bool ThreadingOptions::_internal_has_private_threadpool_size() const {
+  return optional_private_threadpool_size_case() == kPrivateThreadpoolSize;
+}
+inline bool ThreadingOptions::has_private_threadpool_size() const {
+  return _internal_has_private_threadpool_size();
+}
+inline void ThreadingOptions::set_has_private_threadpool_size() {
+  _impl_._oneof_case_[1] = kPrivateThreadpoolSize;
+}
+inline void ThreadingOptions::clear_private_threadpool_size() {
+  if (_internal_has_private_threadpool_size()) {
+    _impl_.optional_private_threadpool_size_.private_threadpool_size_ = 0;
+    clear_has_optional_private_threadpool_size();
+  }
+}
+inline int32_t ThreadingOptions::_internal_private_threadpool_size() const {
+  if (_internal_has_private_threadpool_size()) {
+    return _impl_.optional_private_threadpool_size_.private_threadpool_size_;
+  }
+  return 0;
+}
+inline void ThreadingOptions::_internal_set_private_threadpool_size(int32_t value) {
+  if (!_internal_has_private_threadpool_size()) {
+    clear_optional_private_threadpool_size();
+    set_has_private_threadpool_size();
+  }
+  _impl_.optional_private_threadpool_size_.private_threadpool_size_ = value;
+}
+inline int32_t ThreadingOptions::private_threadpool_size() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.ThreadingOptions.private_threadpool_size)
+  return _internal_private_threadpool_size();
+}
+inline void ThreadingOptions::set_private_threadpool_size(int32_t value) {
+  _internal_set_private_threadpool_size(value);
+  // @@protoc_insertion_point(field_set:tensorflow.data.ThreadingOptions.private_threadpool_size)
+}
+
+inline bool ThreadingOptions::has_optional_max_intra_op_parallelism() const {
+  return optional_max_intra_op_parallelism_case() != OPTIONAL_MAX_INTRA_OP_PARALLELISM_NOT_SET;
+}
+inline void ThreadingOptions::clear_has_optional_max_intra_op_parallelism() {
+  _impl_._oneof_case_[0] = OPTIONAL_MAX_INTRA_OP_PARALLELISM_NOT_SET;
+}
+inline bool ThreadingOptions::has_optional_private_threadpool_size() const {
+  return optional_private_threadpool_size_case() != OPTIONAL_PRIVATE_THREADPOOL_SIZE_NOT_SET;
+}
+inline void ThreadingOptions::clear_has_optional_private_threadpool_size() {
+  _impl_._oneof_case_[1] = OPTIONAL_PRIVATE_THREADPOOL_SIZE_NOT_SET;
+}
+inline ThreadingOptions::OptionalMaxIntraOpParallelismCase ThreadingOptions::optional_max_intra_op_parallelism_case() const {
+  return ThreadingOptions::OptionalMaxIntraOpParallelismCase(_impl_._oneof_case_[0]);
+}
+inline ThreadingOptions::OptionalPrivateThreadpoolSizeCase ThreadingOptions::optional_private_threadpool_size_case() const {
+  return ThreadingOptions::OptionalPrivateThreadpoolSizeCase(_impl_._oneof_case_[1]);
+}
+// -------------------------------------------------------------------
+
+// Options
+
+// bool deterministic = 1;
+inline bool Options::_internal_has_deterministic() const {
+  return optional_deterministic_case() == kDeterministic;
+}
+inline bool Options::has_deterministic() const {
+  return _internal_has_deterministic();
+}
+inline void Options::set_has_deterministic() {
+  _impl_._oneof_case_[0] = kDeterministic;
+}
+inline void Options::clear_deterministic() {
+  if (_internal_has_deterministic()) {
+    _impl_.optional_deterministic_.deterministic_ = false;
+    clear_has_optional_deterministic();
+  }
+}
+inline bool Options::_internal_deterministic() const {
+  if (_internal_has_deterministic()) {
+    return _impl_.optional_deterministic_.deterministic_;
+  }
+  return false;
+}
+inline void Options::_internal_set_deterministic(bool value) {
+  if (!_internal_has_deterministic()) {
+    clear_optional_deterministic();
+    set_has_deterministic();
+  }
+  _impl_.optional_deterministic_.deterministic_ = value;
+}
+inline bool Options::deterministic() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.Options.deterministic)
+  return _internal_deterministic();
+}
+inline void Options::set_deterministic(bool value) {
+  _internal_set_deterministic(value);
+  // @@protoc_insertion_point(field_set:tensorflow.data.Options.deterministic)
+}
+
+// .tensorflow.data.AutotuneOptions autotune_options = 7;
+inline bool Options::_internal_has_autotune_options() const {
+  return this != internal_default_instance() && _impl_.autotune_options_ != nullptr;
+}
+inline bool Options::has_autotune_options() const {
+  return _internal_has_autotune_options();
+}
+inline void Options::clear_autotune_options() {
+  if (GetArenaForAllocation() == nullptr && _impl_.autotune_options_ != nullptr) {
+    delete _impl_.autotune_options_;
+  }
+  _impl_.autotune_options_ = nullptr;
+}
+inline const ::tensorflow::data::AutotuneOptions& Options::_internal_autotune_options() const {
+  const ::tensorflow::data::AutotuneOptions* p = _impl_.autotune_options_;
+  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::data::AutotuneOptions&>(
+      ::tensorflow::data::_AutotuneOptions_default_instance_);
+}
+inline const ::tensorflow::data::AutotuneOptions& Options::autotune_options() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.Options.autotune_options)
+  return _internal_autotune_options();
+}
+inline void Options::unsafe_arena_set_allocated_autotune_options(
+    ::tensorflow::data::AutotuneOptions* autotune_options) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.autotune_options_);
+  }
+  _impl_.autotune_options_ = autotune_options;
+  if (autotune_options) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.data.Options.autotune_options)
+}
+inline ::tensorflow::data::AutotuneOptions* Options::release_autotune_options() {
+  
+  ::tensorflow::data::AutotuneOptions* temp = _impl_.autotune_options_;
+  _impl_.autotune_options_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::tensorflow::data::AutotuneOptions* Options::unsafe_arena_release_autotune_options() {
+  // @@protoc_insertion_point(field_release:tensorflow.data.Options.autotune_options)
+  
+  ::tensorflow::data::AutotuneOptions* temp = _impl_.autotune_options_;
+  _impl_.autotune_options_ = nullptr;
+  return temp;
+}
+inline ::tensorflow::data::AutotuneOptions* Options::_internal_mutable_autotune_options() {
+  
+  if (_impl_.autotune_options_ == nullptr) {
+    auto* p = CreateMaybeMessage<::tensorflow::data::AutotuneOptions>(GetArenaForAllocation());
+    _impl_.autotune_options_ = p;
+  }
+  return _impl_.autotune_options_;
+}
+inline ::tensorflow::data::AutotuneOptions* Options::mutable_autotune_options() {
+  ::tensorflow::data::AutotuneOptions* _msg = _internal_mutable_autotune_options();
+  // @@protoc_insertion_point(field_mutable:tensorflow.data.Options.autotune_options)
+  return _msg;
+}
+inline void Options::set_allocated_autotune_options(::tensorflow::data::AutotuneOptions* autotune_options) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.autotune_options_;
+  }
+  if (autotune_options) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(autotune_options);
+    if (message_arena != submessage_arena) {
+      autotune_options = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, autotune_options, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.autotune_options_ = autotune_options;
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.data.Options.autotune_options)
+}
+
+// .tensorflow.data.DistributeOptions distribute_options = 2;
+inline bool Options::_internal_has_distribute_options() const {
+  return this != internal_default_instance() && _impl_.distribute_options_ != nullptr;
+}
+inline bool Options::has_distribute_options() const {
+  return _internal_has_distribute_options();
+}
+inline void Options::clear_distribute_options() {
+  if (GetArenaForAllocation() == nullptr && _impl_.distribute_options_ != nullptr) {
+    delete _impl_.distribute_options_;
+  }
+  _impl_.distribute_options_ = nullptr;
+}
+inline const ::tensorflow::data::DistributeOptions& Options::_internal_distribute_options() const {
+  const ::tensorflow::data::DistributeOptions* p = _impl_.distribute_options_;
+  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::data::DistributeOptions&>(
+      ::tensorflow::data::_DistributeOptions_default_instance_);
+}
+inline const ::tensorflow::data::DistributeOptions& Options::distribute_options() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.Options.distribute_options)
+  return _internal_distribute_options();
+}
+inline void Options::unsafe_arena_set_allocated_distribute_options(
+    ::tensorflow::data::DistributeOptions* distribute_options) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.distribute_options_);
+  }
+  _impl_.distribute_options_ = distribute_options;
+  if (distribute_options) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.data.Options.distribute_options)
+}
+inline ::tensorflow::data::DistributeOptions* Options::release_distribute_options() {
+  
+  ::tensorflow::data::DistributeOptions* temp = _impl_.distribute_options_;
+  _impl_.distribute_options_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::tensorflow::data::DistributeOptions* Options::unsafe_arena_release_distribute_options() {
+  // @@protoc_insertion_point(field_release:tensorflow.data.Options.distribute_options)
+  
+  ::tensorflow::data::DistributeOptions* temp = _impl_.distribute_options_;
+  _impl_.distribute_options_ = nullptr;
+  return temp;
+}
+inline ::tensorflow::data::DistributeOptions* Options::_internal_mutable_distribute_options() {
+  
+  if (_impl_.distribute_options_ == nullptr) {
+    auto* p = CreateMaybeMessage<::tensorflow::data::DistributeOptions>(GetArenaForAllocation());
+    _impl_.distribute_options_ = p;
+  }
+  return _impl_.distribute_options_;
+}
+inline ::tensorflow::data::DistributeOptions* Options::mutable_distribute_options() {
+  ::tensorflow::data::DistributeOptions* _msg = _internal_mutable_distribute_options();
+  // @@protoc_insertion_point(field_mutable:tensorflow.data.Options.distribute_options)
+  return _msg;
+}
+inline void Options::set_allocated_distribute_options(::tensorflow::data::DistributeOptions* distribute_options) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.distribute_options_;
+  }
+  if (distribute_options) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(distribute_options);
+    if (message_arena != submessage_arena) {
+      distribute_options = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, distribute_options, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.distribute_options_ = distribute_options;
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.data.Options.distribute_options)
+}
+
+// .tensorflow.data.OptimizationOptions optimization_options = 3;
+inline bool Options::_internal_has_optimization_options() const {
+  return this != internal_default_instance() && _impl_.optimization_options_ != nullptr;
+}
+inline bool Options::has_optimization_options() const {
+  return _internal_has_optimization_options();
+}
+inline void Options::clear_optimization_options() {
+  if (GetArenaForAllocation() == nullptr && _impl_.optimization_options_ != nullptr) {
+    delete _impl_.optimization_options_;
+  }
+  _impl_.optimization_options_ = nullptr;
+}
+inline const ::tensorflow::data::OptimizationOptions& Options::_internal_optimization_options() const {
+  const ::tensorflow::data::OptimizationOptions* p = _impl_.optimization_options_;
+  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::data::OptimizationOptions&>(
+      ::tensorflow::data::_OptimizationOptions_default_instance_);
+}
+inline const ::tensorflow::data::OptimizationOptions& Options::optimization_options() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.Options.optimization_options)
+  return _internal_optimization_options();
+}
+inline void Options::unsafe_arena_set_allocated_optimization_options(
+    ::tensorflow::data::OptimizationOptions* optimization_options) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.optimization_options_);
+  }
+  _impl_.optimization_options_ = optimization_options;
+  if (optimization_options) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.data.Options.optimization_options)
+}
+inline ::tensorflow::data::OptimizationOptions* Options::release_optimization_options() {
+  
+  ::tensorflow::data::OptimizationOptions* temp = _impl_.optimization_options_;
+  _impl_.optimization_options_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::tensorflow::data::OptimizationOptions* Options::unsafe_arena_release_optimization_options() {
+  // @@protoc_insertion_point(field_release:tensorflow.data.Options.optimization_options)
+  
+  ::tensorflow::data::OptimizationOptions* temp = _impl_.optimization_options_;
+  _impl_.optimization_options_ = nullptr;
+  return temp;
+}
+inline ::tensorflow::data::OptimizationOptions* Options::_internal_mutable_optimization_options() {
+  
+  if (_impl_.optimization_options_ == nullptr) {
+    auto* p = CreateMaybeMessage<::tensorflow::data::OptimizationOptions>(GetArenaForAllocation());
+    _impl_.optimization_options_ = p;
+  }
+  return _impl_.optimization_options_;
+}
+inline ::tensorflow::data::OptimizationOptions* Options::mutable_optimization_options() {
+  ::tensorflow::data::OptimizationOptions* _msg = _internal_mutable_optimization_options();
+  // @@protoc_insertion_point(field_mutable:tensorflow.data.Options.optimization_options)
+  return _msg;
+}
+inline void Options::set_allocated_optimization_options(::tensorflow::data::OptimizationOptions* optimization_options) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.optimization_options_;
+  }
+  if (optimization_options) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(optimization_options);
+    if (message_arena != submessage_arena) {
+      optimization_options = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, optimization_options, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.optimization_options_ = optimization_options;
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.data.Options.optimization_options)
+}
+
+// bool slack = 4;
+inline bool Options::_internal_has_slack() const {
+  return optional_slack_case() == kSlack;
+}
+inline bool Options::has_slack() const {
+  return _internal_has_slack();
+}
+inline void Options::set_has_slack() {
+  _impl_._oneof_case_[1] = kSlack;
+}
+inline void Options::clear_slack() {
+  if (_internal_has_slack()) {
+    _impl_.optional_slack_.slack_ = false;
+    clear_has_optional_slack();
+  }
+}
+inline bool Options::_internal_slack() const {
+  if (_internal_has_slack()) {
+    return _impl_.optional_slack_.slack_;
+  }
+  return false;
+}
+inline void Options::_internal_set_slack(bool value) {
+  if (!_internal_has_slack()) {
+    clear_optional_slack();
+    set_has_slack();
+  }
+  _impl_.optional_slack_.slack_ = value;
+}
+inline bool Options::slack() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.Options.slack)
+  return _internal_slack();
+}
+inline void Options::set_slack(bool value) {
+  _internal_set_slack(value);
+  // @@protoc_insertion_point(field_set:tensorflow.data.Options.slack)
+}
+
+// .tensorflow.data.ThreadingOptions threading_options = 5;
+inline bool Options::_internal_has_threading_options() const {
+  return this != internal_default_instance() && _impl_.threading_options_ != nullptr;
+}
+inline bool Options::has_threading_options() const {
+  return _internal_has_threading_options();
+}
+inline void Options::clear_threading_options() {
+  if (GetArenaForAllocation() == nullptr && _impl_.threading_options_ != nullptr) {
+    delete _impl_.threading_options_;
+  }
+  _impl_.threading_options_ = nullptr;
+}
+inline const ::tensorflow::data::ThreadingOptions& Options::_internal_threading_options() const {
+  const ::tensorflow::data::ThreadingOptions* p = _impl_.threading_options_;
+  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::data::ThreadingOptions&>(
+      ::tensorflow::data::_ThreadingOptions_default_instance_);
+}
+inline const ::tensorflow::data::ThreadingOptions& Options::threading_options() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.Options.threading_options)
+  return _internal_threading_options();
+}
+inline void Options::unsafe_arena_set_allocated_threading_options(
+    ::tensorflow::data::ThreadingOptions* threading_options) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.threading_options_);
+  }
+  _impl_.threading_options_ = threading_options;
+  if (threading_options) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.data.Options.threading_options)
+}
+inline ::tensorflow::data::ThreadingOptions* Options::release_threading_options() {
+  
+  ::tensorflow::data::ThreadingOptions* temp = _impl_.threading_options_;
+  _impl_.threading_options_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::tensorflow::data::ThreadingOptions* Options::unsafe_arena_release_threading_options() {
+  // @@protoc_insertion_point(field_release:tensorflow.data.Options.threading_options)
+  
+  ::tensorflow::data::ThreadingOptions* temp = _impl_.threading_options_;
+  _impl_.threading_options_ = nullptr;
+  return temp;
+}
+inline ::tensorflow::data::ThreadingOptions* Options::_internal_mutable_threading_options() {
+  
+  if (_impl_.threading_options_ == nullptr) {
+    auto* p = CreateMaybeMessage<::tensorflow::data::ThreadingOptions>(GetArenaForAllocation());
+    _impl_.threading_options_ = p;
+  }
+  return _impl_.threading_options_;
+}
+inline ::tensorflow::data::ThreadingOptions* Options::mutable_threading_options() {
+  ::tensorflow::data::ThreadingOptions* _msg = _internal_mutable_threading_options();
+  // @@protoc_insertion_point(field_mutable:tensorflow.data.Options.threading_options)
+  return _msg;
+}
+inline void Options::set_allocated_threading_options(::tensorflow::data::ThreadingOptions* threading_options) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.threading_options_;
+  }
+  if (threading_options) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(threading_options);
+    if (message_arena != submessage_arena) {
+      threading_options = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, threading_options, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.threading_options_ = threading_options;
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.data.Options.threading_options)
+}
+
+// .tensorflow.data.ExternalStatePolicy external_state_policy = 6;
+inline bool Options::_internal_has_external_state_policy() const {
+  return optional_external_state_policy_case() == kExternalStatePolicy;
+}
+inline bool Options::has_external_state_policy() const {
+  return _internal_has_external_state_policy();
+}
+inline void Options::set_has_external_state_policy() {
+  _impl_._oneof_case_[2] = kExternalStatePolicy;
+}
+inline void Options::clear_external_state_policy() {
+  if (_internal_has_external_state_policy()) {
+    _impl_.optional_external_state_policy_.external_state_policy_ = 0;
+    clear_has_optional_external_state_policy();
+  }
+}
+inline ::tensorflow::data::ExternalStatePolicy Options::_internal_external_state_policy() const {
+  if (_internal_has_external_state_policy()) {
+    return static_cast< ::tensorflow::data::ExternalStatePolicy >(_impl_.optional_external_state_policy_.external_state_policy_);
+  }
+  return static_cast< ::tensorflow::data::ExternalStatePolicy >(0);
+}
+inline ::tensorflow::data::ExternalStatePolicy Options::external_state_policy() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.Options.external_state_policy)
+  return _internal_external_state_policy();
+}
+inline void Options::_internal_set_external_state_policy(::tensorflow::data::ExternalStatePolicy value) {
+  if (!_internal_has_external_state_policy()) {
+    clear_optional_external_state_policy();
+    set_has_external_state_policy();
+  }
+  _impl_.optional_external_state_policy_.external_state_policy_ = value;
+}
+inline void Options::set_external_state_policy(::tensorflow::data::ExternalStatePolicy value) {
+  _internal_set_external_state_policy(value);
+  // @@protoc_insertion_point(field_set:tensorflow.data.Options.external_state_policy)
+}
+
+// bool symbolic_checkpoint = 8;
+inline bool Options::_internal_has_symbolic_checkpoint() const {
+  return optional_symbolic_checkpoint_case() == kSymbolicCheckpoint;
+}
+inline bool Options::has_symbolic_checkpoint() const {
+  return _internal_has_symbolic_checkpoint();
+}
+inline void Options::set_has_symbolic_checkpoint() {
+  _impl_._oneof_case_[3] = kSymbolicCheckpoint;
+}
+inline void Options::clear_symbolic_checkpoint() {
+  if (_internal_has_symbolic_checkpoint()) {
+    _impl_.optional_symbolic_checkpoint_.symbolic_checkpoint_ = false;
+    clear_has_optional_symbolic_checkpoint();
+  }
+}
+inline bool Options::_internal_symbolic_checkpoint() const {
+  if (_internal_has_symbolic_checkpoint()) {
+    return _impl_.optional_symbolic_checkpoint_.symbolic_checkpoint_;
+  }
+  return false;
+}
+inline void Options::_internal_set_symbolic_checkpoint(bool value) {
+  if (!_internal_has_symbolic_checkpoint()) {
+    clear_optional_symbolic_checkpoint();
+    set_has_symbolic_checkpoint();
+  }
+  _impl_.optional_symbolic_checkpoint_.symbolic_checkpoint_ = value;
+}
+inline bool Options::symbolic_checkpoint() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.Options.symbolic_checkpoint)
+  return _internal_symbolic_checkpoint();
+}
+inline void Options::set_symbolic_checkpoint(bool value) {
+  _internal_set_symbolic_checkpoint(value);
+  // @@protoc_insertion_point(field_set:tensorflow.data.Options.symbolic_checkpoint)
+}
+
+// bool warm_start = 9;
+inline bool Options::_internal_has_warm_start() const {
+  return optional_warm_start_case() == kWarmStart;
+}
+inline bool Options::has_warm_start() const {
+  return _internal_has_warm_start();
+}
+inline void Options::set_has_warm_start() {
+  _impl_._oneof_case_[4] = kWarmStart;
+}
+inline void Options::clear_warm_start() {
+  if (_internal_has_warm_start()) {
+    _impl_.optional_warm_start_.warm_start_ = false;
+    clear_has_optional_warm_start();
+  }
+}
+inline bool Options::_internal_warm_start() const {
+  if (_internal_has_warm_start()) {
+    return _impl_.optional_warm_start_.warm_start_;
+  }
+  return false;
+}
+inline void Options::_internal_set_warm_start(bool value) {
+  if (!_internal_has_warm_start()) {
+    clear_optional_warm_start();
+    set_has_warm_start();
+  }
+  _impl_.optional_warm_start_.warm_start_ = value;
+}
+inline bool Options::warm_start() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.Options.warm_start)
+  return _internal_warm_start();
+}
+inline void Options::set_warm_start(bool value) {
+  _internal_set_warm_start(value);
+  // @@protoc_insertion_point(field_set:tensorflow.data.Options.warm_start)
+}
+
+inline bool Options::has_optional_deterministic() const {
+  return optional_deterministic_case() != OPTIONAL_DETERMINISTIC_NOT_SET;
+}
+inline void Options::clear_has_optional_deterministic() {
+  _impl_._oneof_case_[0] = OPTIONAL_DETERMINISTIC_NOT_SET;
+}
+inline bool Options::has_optional_slack() const {
+  return optional_slack_case() != OPTIONAL_SLACK_NOT_SET;
+}
+inline void Options::clear_has_optional_slack() {
+  _impl_._oneof_case_[1] = OPTIONAL_SLACK_NOT_SET;
+}
+inline bool Options::has_optional_external_state_policy() const {
+  return optional_external_state_policy_case() != OPTIONAL_EXTERNAL_STATE_POLICY_NOT_SET;
+}
+inline void Options::clear_has_optional_external_state_policy() {
+  _impl_._oneof_case_[2] = OPTIONAL_EXTERNAL_STATE_POLICY_NOT_SET;
+}
+inline bool Options::has_optional_symbolic_checkpoint() const {
+  return optional_symbolic_checkpoint_case() != OPTIONAL_SYMBOLIC_CHECKPOINT_NOT_SET;
+}
+inline void Options::clear_has_optional_symbolic_checkpoint() {
+  _impl_._oneof_case_[3] = OPTIONAL_SYMBOLIC_CHECKPOINT_NOT_SET;
+}
+inline bool Options::has_optional_warm_start() const {
+  return optional_warm_start_case() != OPTIONAL_WARM_START_NOT_SET;
+}
+inline void Options::clear_has_optional_warm_start() {
+  _impl_._oneof_case_[4] = OPTIONAL_WARM_START_NOT_SET;
+}
+inline Options::OptionalDeterministicCase Options::optional_deterministic_case() const {
+  return Options::OptionalDeterministicCase(_impl_._oneof_case_[0]);
+}
+inline Options::OptionalSlackCase Options::optional_slack_case() const {
+  return Options::OptionalSlackCase(_impl_._oneof_case_[1]);
+}
+inline Options::OptionalExternalStatePolicyCase Options::optional_external_state_policy_case() const {
+  return Options::OptionalExternalStatePolicyCase(_impl_._oneof_case_[2]);
+}
+inline Options::OptionalSymbolicCheckpointCase Options::optional_symbolic_checkpoint_case() const {
+  return Options::OptionalSymbolicCheckpointCase(_impl_._oneof_case_[3]);
+}
+inline Options::OptionalWarmStartCase Options::optional_warm_start_case() const {
+  return Options::OptionalWarmStartCase(_impl_._oneof_case_[4]);
+}
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace data
+}  // namespace tensorflow
+
+PROTOBUF_NAMESPACE_OPEN
+
+template <> struct is_proto_enum< ::tensorflow::data::CardinalityOptions_ComputeLevel> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::tensorflow::data::CardinalityOptions_ComputeLevel>() {
+  return ::tensorflow::data::CardinalityOptions_ComputeLevel_descriptor();
+}
+template <> struct is_proto_enum< ::tensorflow::data::AutoShardPolicy> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::tensorflow::data::AutoShardPolicy>() {
+  return ::tensorflow::data::AutoShardPolicy_descriptor();
+}
+template <> struct is_proto_enum< ::tensorflow::data::ExternalStatePolicy> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::tensorflow::data::ExternalStatePolicy>() {
+  return ::tensorflow::data::ExternalStatePolicy_descriptor();
+}
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fdataset_5foptions_2eproto
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/dataset_options.proto b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/dataset_options.proto
new file mode 100644
index 0000000000000000000000000000000000000000..d2200407b73f1c3a75897cd2e95b2a6fba9e07b9
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/dataset_options.proto
@@ -0,0 +1,226 @@
+syntax = "proto3";
+
+package tensorflow.data;
+
+import "tensorflow/core/framework/model.proto";
+
+option go_package = "github.com/tensorflow/tensorflow/tensorflow/go/core/framework/dataset_options_go_proto";
+
+// Represents the type of auto-sharding we enable.
+enum AutoShardPolicy {
+  // AUTO: Attempts FILE-based sharding, falling back to DATA-based sharding.
+  AUTO = 0;
+  // FILE: Shards by input files (i.e. each worker will get a set of files to
+  // process). When this option is selected, make sure that there is at least as
+  // many files as workers. If there are fewer input files than workers, a
+  // runtime error will be raised.
+  FILE = 1;
+  // DATA: Shards by elements produced by the dataset. Each worker will process
+  // the whole dataset and discard the portion that is not for itself. Note that
+  // for this mode to correctly partitions the dataset elements, the dataset
+  // needs to produce elements in a deterministic order.
+  DATA = 2;
+  // HINT: Looks for the presence of `shard(SHARD_HINT, ...)` which is treated
+  // as a placeholder to replace with `shard(num_workers, worker_index)`.
+  HINT = 3;
+  // OFF: No sharding will be performed.
+  OFF = -1;
+}
+
+// next: 5
+message AutotuneOptions {
+  // Whether to automatically tune performance knobs.
+  oneof optional_enabled {
+    bool enabled = 1;
+  }
+  // When autotuning is enabled (through autotune), determines the CPU budget to
+  // use. Values greater than the number of schedulable CPU cores are allowed
+  // but may result in CPU contention.
+  oneof optional_cpu_budget {
+    int32 cpu_budget = 2;
+  }
+  // When autotuning is enabled (through autotune), determines the RAM budget to
+  // use. Values greater than the available RAM in bytes may result in OOM. If
+  // 0, defaults to half of the available RAM in bytes.
+  oneof optional_ram_budget {
+    int64 ram_budget = 3;
+  }
+
+  // When autotuning is enabled (through autotune), determines the algorithm to
+  // use. If not explicitly set by user, autotuning will follow HILL_CLIMB
+  // algorithm but has more flexibility to tune parameters more aggressively,
+  // in which case the behavior is implementation specific and may change over
+  // time.
+  oneof optional_autotune_algorithm {
+    model.AutotuneAlgorithm autotune_algorithm = 4;
+  }
+}
+
+// next: 2
+message CardinalityOptions {
+  enum ComputeLevel {
+    CARDINALITY_COMPUTE_UNSPECIFIED = 0;
+    // Cardinality will only be computed if it can be determined in a cheap
+    // manner (ie. without reading from file sources). If the cardinality would
+    // be nontrivial to compute, Cardinality() will return UNKNOWN_CARDINALITY.
+    CARDINALITY_COMPUTE_LOW = 1;
+    // Moderate effort will be made to determine cardinality, such as reading
+    // index data from source files. If significant work is needed to compute
+    // cardinality (e.g. reading entire source file contents or executing user
+    // defined functions), Cardinality() will return UNKNOWN_CARDINALITY.
+    CARDINALITY_COMPUTE_MODERATE = 2;
+  }
+  ComputeLevel compute_level = 1;
+}
+
+// next: 3
+message DistributeOptions {
+  AutoShardPolicy auto_shard_policy = 1;
+  // The number of devices attached to this input pipeline.
+  oneof optional_num_devices {
+    int32 num_devices = 2;
+  }
+}
+
+// next: 21
+message OptimizationOptions {
+  // Whether to apply default graph optimizations. If False, only graph
+  // optimizations that have been explicitly enabled will be applied.
+  oneof optional_apply_default_optimizations {
+    bool apply_default_optimizations = 1;
+  }
+  reserved 2;
+  reserved 3;
+  reserved 4;
+  reserved 5;
+  // Whether to fuse filter transformations.
+  oneof optional_filter_fusion {
+    bool filter_fusion = 6;
+  }
+  // NOTE: field id 7 deleted in June 2021.
+  reserved 7;
+  // NOTE: field id 8 deleted in June 2021.
+  reserved 8;
+  // Whether to fuse map and batch transformations.
+  oneof optional_map_and_batch_fusion {
+    bool map_and_batch_fusion = 9;
+  }
+  // Whether to fuse map and filter transformations.
+  oneof optional_map_and_filter_fusion {
+    bool map_and_filter_fusion = 10;
+  }
+  // Whether to fuse map transformations.
+  oneof optional_map_fusion {
+    bool map_fusion = 11;
+  }
+  // Whether to parallelize stateless map transformations.
+  oneof optional_map_parallelization {
+    bool map_parallelization = 12;
+  }
+
+  // NOTE: field id 13 deleted in June 2021.
+  reserved 13;
+
+  // Whether to eliminate no-op transformations.
+  oneof optional_noop_elimination {
+    bool noop_elimination = 14;
+  }
+  // Whether to parallelize copying of batch elements. This optimization is
+  // highly experimental and can cause performance degradation (e.g. when the
+  // parallelization overhead exceeds the benefits of performing the data copies
+  // in parallel). You should only enable this optimization if a) your input
+  // pipeline is bottlenecked on batching and b) you have validated that this
+  // optimization improves performance.
+  oneof optional_parallel_batch {
+    bool parallel_batch = 15;
+  }
+  // Field id 16 was removed in 06/2021.
+  reserved 16;
+  // Whether to fuse shuffle and repeat transformations.
+  oneof optional_shuffle_and_repeat_fusion {
+    bool shuffle_and_repeat_fusion = 17;
+  }
+  // Whether to parallelize stateless filter transformations.
+  oneof optional_filter_parallelization {
+    bool filter_parallelization = 18;
+  }
+  // Whether to inject 'Prefetch' as the last transformation. Only takes effect
+  // if the last transformation is synchronous; otherwise does nothing.
+  oneof optional_inject_prefetch {
+    bool inject_prefetch = 19;
+  }
+  // NOTE: field id 20 was removed in August 2023.
+  reserved 20;
+}
+
+// next: 3
+message ThreadingOptions {
+  // If set, it overrides the maximum degree of intra-op parallelism.
+  oneof optional_max_intra_op_parallelism {
+    int32 max_intra_op_parallelism = 1;
+  }
+  // If set, the dataset will use a private threadpool of the given size.
+  oneof optional_private_threadpool_size {
+    int32 private_threadpool_size = 2;
+  }
+}
+
+// Represents how to handle external state during serialization.
+enum ExternalStatePolicy {
+  POLICY_WARN = 0;
+  POLICY_IGNORE = 1;
+  POLICY_FAIL = 2;
+}
+
+// Message stored with Dataset objects to control how datasets are processed and
+// optimized.
+//
+// next: 10
+message Options {
+  // Whether the outputs need to be produced in deterministic order.
+  oneof optional_deterministic {
+    bool deterministic = 1;
+  }
+  // The autotune options associated with the dataset.
+  AutotuneOptions autotune_options = 7;
+  // The distribution strategy options associated with the dataset.
+  DistributeOptions distribute_options = 2;
+  // The optimization options associated with the dataset.
+  OptimizationOptions optimization_options = 3;
+  // Whether to introduce 'slack' in the last `prefetch` of the input pipeline,
+  // if it exists. This may reduce CPU contention with accelerator host-side
+  // activity at the start of a step. The slack frequency is determined by the
+  // number of devices attached to this input pipeline.
+  oneof optional_slack {
+    bool slack = 4;
+  }
+  // The threading options associated with the dataset.
+  ThreadingOptions threading_options = 5;
+  // This option can be used to override the default policy for how to handle
+  // external state when serializing a dataset or checkpointing its iterator.
+  // There are three settings available - IGNORE: External state is ignored
+  // without a warning; WARN: External state is ignored and a warning is logged;
+  // FAIL: External state results in an error.
+  oneof optional_external_state_policy {
+    ExternalStatePolicy external_state_policy = 6;
+  }
+  // This option indicates whether to checkpoint input pipeline state
+  // "explicitly", by storing the internal state of iterators for each
+  // tf.data operation, (the default), or "symbolically", by storing metadata
+  // that captures the state of each tf.data operation at the time it processed
+  // the last data seen by tf.data consumer.
+  //
+  // Symbolic checkpoints are expected to be much smaller but not all tf.data
+  // operations are compatible with symbolic checkpointing. In particular,
+  // symbolic checkpointing requires that data is processed in-order and
+  // operations that reorder elements, such as `shuffle()` or non-deterministic
+  // `map()`, are not compatible with symbolic checkpointing.
+  oneof optional_symbolic_checkpoint {
+    bool symbolic_checkpoint = 8;
+  }
+  // Whether to start background threads of asynchronous transformations upon
+  // iterator creation (as opposed to upon first call to `GetNext`).
+  oneof optional_warm_start {
+    bool warm_start = 9;
+  }
+}
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/dataset_stateful_op_allowlist.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/dataset_stateful_op_allowlist.h
new file mode 100644
index 0000000000000000000000000000000000000000..5e8cdd4af32a19dd9ae21a55647b7b4d8bfbd8d0
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/dataset_stateful_op_allowlist.h
@@ -0,0 +1,81 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_DATASET_STATEFUL_OP_ALLOWLIST_H_
+#define TENSORFLOW_CORE_FRAMEWORK_DATASET_STATEFUL_OP_ALLOWLIST_H_
+
+#include <unordered_set>
+#include "tensorflow/core/lib/core/status.h"
+
+namespace tensorflow {
+namespace data {
+// Registry for stateful ops that need to be used in dataset functions.
+// See below macro for usage details.
+class AllowlistedStatefulOpRegistry {
+ public:
+  Status Add(string op_name) {
+    op_names_.insert(std::move(op_name));
+    return OkStatus();
+  }
+
+  Status Remove(string op_name) {
+    op_names_.erase(op_name);
+    return OkStatus();
+  }
+
+  bool Contains(const string& op_name) { return op_names_.count(op_name); }
+
+  static AllowlistedStatefulOpRegistry* Global() {
+    static auto* reg = new AllowlistedStatefulOpRegistry;
+    return reg;
+  }
+
+ private:
+  AllowlistedStatefulOpRegistry() = default;
+  AllowlistedStatefulOpRegistry(AllowlistedStatefulOpRegistry const& copy) =
+      delete;
+  AllowlistedStatefulOpRegistry operator=(
+      AllowlistedStatefulOpRegistry const& copy) = delete;
+
+  std::unordered_set<string> op_names_;
+};
+
+}  // namespace data
+
+// Use this macro to allowlist an op that is marked stateful but needs to be
+// used inside a map_fn in an input pipeline. This is only needed if you wish
+// to be able to checkpoint the state of the input pipeline. We currently
+// do not allow stateful ops to be defined inside of map_fns since it is not
+// possible to save their state.
+// Note that the state of the allowlisted ops inside functions will not be
+// saved during checkpointing, hence this should only be used if the op is
+// marked stateful for reasons like to avoid constant folding during graph
+// optimization but is not stateful.
+// If possible, try to remove the stateful flag on the op first.
+// Example usage:
+//
+//   ALLOW_STATEFUL_OP_FOR_DATASET_FUNCTIONS("LegacyStatefulReader");
+//
+#define ALLOW_STATEFUL_OP_FOR_DATASET_FUNCTIONS(name) \
+  ALLOW_STATEFUL_OP_FOR_DATASET_FUNCTIONS_UNIQ_HELPER(__COUNTER__, name)
+#define ALLOW_STATEFUL_OP_FOR_DATASET_FUNCTIONS_UNIQ_HELPER(ctr, name) \
+  ALLOW_STATEFUL_OP_FOR_DATASET_FUNCTIONS_UNIQ(ctr, name)
+#define ALLOW_STATEFUL_OP_FOR_DATASET_FUNCTIONS_UNIQ(ctr, name)       \
+  static ::tensorflow::Status allowlist_op##ctr TF_ATTRIBUTE_UNUSED = \
+      ::tensorflow::data::AllowlistedStatefulOpRegistry::Global()->Add(name)
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_DATASET_STATEFUL_OP_ALLOWLIST_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/device.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/device.h
new file mode 100644
index 0000000000000000000000000000000000000000..a7d5bb260d536928fbab7f16f053d909e4e0d30e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/device.h
@@ -0,0 +1,218 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// A Device is a something that can perform computations as part of a
+// model.  Devices can be local (runs computation on this machine), or
+// remote (contacts a device local to another machine using an RPC to
+// do the work).  Devices are registered in a DeviceSet, which is also
+// responsible for the Device <-> id mapping.
+//
+// Device names
+// * Every Device should have a unique name with the format:
+//     /job:___/replica:___/task:___/(gpu|cpu):___
+//   An example name would be "/job:train/replica:0/task:3/device:GPU:2".
+// * Task numbers are within the specified replica, so there are as
+//   many "task zeros" as replicas.
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_DEVICE_H_
+#define TENSORFLOW_CORE_FRAMEWORK_DEVICE_H_
+
+#include <memory>
+#include <string>
+
+#include "tensorflow/core/framework/allocator.h"
+#include "tensorflow/core/framework/control_flow.h"
+#include "tensorflow/core/framework/device_attributes.pb.h"
+#include "tensorflow/core/framework/device_base.h"
+#include "tensorflow/core/framework/graph.pb.h"
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/op_segment.h"
+#include "tensorflow/core/framework/resource_mgr.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/graph/graph.h"
+#include "tensorflow/core/graph/types.h"
+#include "tensorflow/core/platform/errors.h"
+#include "tensorflow/core/platform/macros.h"
+#include "tensorflow/core/platform/status.h"
+#include "tensorflow/core/platform/types.h"
+#include "tensorflow/core/util/device_name_utils.h"
+
+namespace tensorflow {
+
+class Device : public DeviceBase {
+ public:
+  // Callback type that takes a Status and returns void.
+  typedef std::function<void(const Status&)> DoneCallback;
+
+  Device(Env* env, const DeviceAttributes& device_attributes);
+  ~Device() override;
+
+  // A compare function that orders devices by their parsed name.
+  static bool LessByParsedName(const Device& a, const Device& b) {
+    return a.parsed_name() < b.parsed_name();
+  }
+
+  // Full name of this device (see top comment).
+  const std::string& name() const override { return device_attributes_.name(); }
+
+  // Parsed name of this device
+  const DeviceNameUtils::ParsedName& parsed_name() const override {
+    return parsed_name_;
+  }
+
+  // Describes what kind of device this is.  This is intended to be
+  // human-readable and not computer-parsed, except that two devices
+  // with the same device_type() are expected to perform similarly
+  // (both from a computation and communication perspective).
+  const std::string& device_type() const {
+    return device_attributes_.device_type();
+  }
+
+  // Returns an aggregation of device attributes.
+  const DeviceAttributes& attributes() const override {
+    return device_attributes_;
+  }
+
+  // Performs the actual compute function.
+  //
+  // Subclasses may override this function if they wish to perform
+  // some initialization before each compute.
+  virtual void Compute(OpKernel* op_kernel, OpKernelContext* context) {
+    op_kernel->Compute(context);
+  }
+
+  // Asynchronous kernel's compute.
+  virtual void ComputeAsync(AsyncOpKernel* op_kernel, OpKernelContext* context,
+                            AsyncOpKernel::DoneCallback done) {
+    op_kernel->ComputeAsync(context, std::move(done));
+  }
+
+  // Blocks until all operations queued on the device at the time of
+  // the call have completed.  Returns any error pending on the device
+  // at completion.
+  virtual Status Sync() = 0;
+
+  // Calls the given callback when all operations queued on the device at the
+  // time of the call have completed. The callback is passed any error pending
+  // on the device at completion.
+  // TODO(b/112409994): Consolidate these two APIs, removing the synchronous
+  // version.
+  virtual void Sync(const DoneCallback& done);
+
+  // On session completion, the executor may call Device::Sync() depending on
+  // flag settings. Override this to return false for devices that don't allow
+  // such calls. Instead, these devices must use other mechanisms (such as
+  // num_deferred_ops) to ensure the device has finished processing necessary
+  // work at session completion. In addition, for these devices, RefreshStatus
+  // must be called at session completion to retrieve execution result status.
+  //
+  // Devices that override this function must also implement RefreshStatus.
+  virtual bool AllowsSyncOnCompletion() const { return true; }
+
+  // This is used in conjunction with AllowsSyncOnCompletion to allow the
+  // executor to get execution result status at session completion.
+  //
+  // For supported devices, this call returns the underlying device stream's
+  // current status in a non-blocking way, without using blocking calls such as
+  // Stream::BlockHostUntilDone or Device::Sync. When applicable, the device
+  // status is also updated with the retrieved stream status.
+  virtual Status RefreshStatus() {
+    return errors::Unimplemented(
+        "RefreshStatus is not supported on this device.");
+  }
+
+  // Optionally modify the device's GraphDef before execution.
+  //
+  // This method should be considered experimental and is supplied to enable
+  // prototyping of TensorFlow device implementations that need to modify
+  // the GraphDef before execution.
+  //
+  // 'graph' supplies the partition of the graph assigned to this
+  // device.
+  virtual Status MaybeRewriteGraph(std::unique_ptr<Graph>* /*graph*/) {
+    return OkStatus();
+  }
+
+  // Sets `out_context` a new DeviceContext* for executing a graph, or nullptr
+  // if the device does not support contexts. Returns an error status if any
+  // error occurred while trying to create a context, otherwise OK.
+  //
+  // The caller takes ownership of one reference on the output DeviceContext*,
+  // and should call Unref().
+  virtual Status TryGetDeviceContext(DeviceContext** out_context) {
+    *out_context = nullptr;
+    return OkStatus();
+  }
+
+  // Returns the op segment of this device.  The caller can reuse op
+  // kernels registered for the same session running on this device.
+  OpSegment* op_segment() { return &op_seg_; }
+
+  // Returns the resource manager associated w/ this device.
+  virtual ResourceMgr* resource_manager() { return rmgr_; }
+
+  // Summarizes the status of this Device, for debugging.
+  std::string DebugString() const { return device_attributes_.DebugString(); }
+
+  // Assembles the parameter components into a complete DeviceAttributes value.
+  static DeviceAttributes BuildDeviceAttributes(
+      const std::string& name, DeviceType device, Bytes memory_limit,
+      const DeviceLocality& locality, const std::string& physical_device_desc);
+
+  static DeviceAttributes BuildDeviceAttributes(
+      const std::string& name, DeviceType device, Bytes memory_limit,
+      const DeviceLocality& locality) {
+    // Pass in an empty string as physical device name.
+    return BuildDeviceAttributes(name, device, memory_limit, locality, "");
+  }
+
+  // Updates `attributes()`, indicating the XLA global ID associated with this
+  // device. This ID is unique across clients in a multi-client setup. For TPUs
+  // this does not happen until the TPU system has been initialized.
+  void set_xla_global_id(int64_t id) override {
+    device_attributes_.set_xla_global_id(id);
+  }
+
+  // Clears the resource manager associated with this device.
+  void ClearResourceMgr() { rmgr_->Clear(); }
+
+  virtual bool IsLocal() const { return true; }
+
+  // Informs if this Device can be used as a caller in RemoteCall operation.
+  virtual bool IsRemoteCallAllowed() const;
+
+ protected:
+  void DeleteResourceMgr() {
+    delete rmgr_;
+    rmgr_ = nullptr;
+  }
+
+ private:
+  DeviceAttributes device_attributes_;
+  DeviceNameUtils::ParsedName parsed_name_;
+
+  // op_seg_ maps session handle and op name to OpKernel objects.
+  OpSegment op_seg_;
+
+  // Resources associated w/ this device. E.g., shared variables, etc.
+  ResourceMgr* rmgr_ = nullptr;
+
+  Device(const Device&) = delete;
+  void operator=(const Device&) = delete;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_DEVICE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/device_attributes.pb.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/device_attributes.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..7400631b4a8f6c496e0033afb43a26ffb03ac8e7
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/device_attributes.pb.h
@@ -0,0 +1,1418 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: tensorflow/core/framework/device_attributes.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fdevice_5fattributes_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fdevice_5fattributes_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3021000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3021009 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_tensorflow_2fcore_2fframework_2fdevice_5fattributes_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_tensorflow_2fcore_2fframework_2fdevice_5fattributes_2eproto {
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_tensorflow_2fcore_2fframework_2fdevice_5fattributes_2eproto;
+namespace tensorflow {
+class DeviceAttributes;
+struct DeviceAttributesDefaultTypeInternal;
+extern DeviceAttributesDefaultTypeInternal _DeviceAttributes_default_instance_;
+class DeviceLocality;
+struct DeviceLocalityDefaultTypeInternal;
+extern DeviceLocalityDefaultTypeInternal _DeviceLocality_default_instance_;
+class InterconnectLink;
+struct InterconnectLinkDefaultTypeInternal;
+extern InterconnectLinkDefaultTypeInternal _InterconnectLink_default_instance_;
+class LocalLinks;
+struct LocalLinksDefaultTypeInternal;
+extern LocalLinksDefaultTypeInternal _LocalLinks_default_instance_;
+}  // namespace tensorflow
+PROTOBUF_NAMESPACE_OPEN
+template<> ::tensorflow::DeviceAttributes* Arena::CreateMaybeMessage<::tensorflow::DeviceAttributes>(Arena*);
+template<> ::tensorflow::DeviceLocality* Arena::CreateMaybeMessage<::tensorflow::DeviceLocality>(Arena*);
+template<> ::tensorflow::InterconnectLink* Arena::CreateMaybeMessage<::tensorflow::InterconnectLink>(Arena*);
+template<> ::tensorflow::LocalLinks* Arena::CreateMaybeMessage<::tensorflow::LocalLinks>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace tensorflow {
+
+// ===================================================================
+
+class InterconnectLink final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.InterconnectLink) */ {
+ public:
+  inline InterconnectLink() : InterconnectLink(nullptr) {}
+  ~InterconnectLink() override;
+  explicit PROTOBUF_CONSTEXPR InterconnectLink(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  InterconnectLink(const InterconnectLink& from);
+  InterconnectLink(InterconnectLink&& from) noexcept
+    : InterconnectLink() {
+    *this = ::std::move(from);
+  }
+
+  inline InterconnectLink& operator=(const InterconnectLink& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline InterconnectLink& operator=(InterconnectLink&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const InterconnectLink& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const InterconnectLink* internal_default_instance() {
+    return reinterpret_cast<const InterconnectLink*>(
+               &_InterconnectLink_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(InterconnectLink& a, InterconnectLink& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(InterconnectLink* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(InterconnectLink* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  InterconnectLink* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<InterconnectLink>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const InterconnectLink& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const InterconnectLink& from) {
+    InterconnectLink::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(InterconnectLink* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.InterconnectLink";
+  }
+  protected:
+  explicit InterconnectLink(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTypeFieldNumber = 2,
+    kDeviceIdFieldNumber = 1,
+    kStrengthFieldNumber = 3,
+  };
+  // string type = 2;
+  void clear_type();
+  const std::string& type() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_type(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_type();
+  PROTOBUF_NODISCARD std::string* release_type();
+  void set_allocated_type(std::string* type);
+  private:
+  const std::string& _internal_type() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_type(const std::string& value);
+  std::string* _internal_mutable_type();
+  public:
+
+  // int32 device_id = 1;
+  void clear_device_id();
+  int32_t device_id() const;
+  void set_device_id(int32_t value);
+  private:
+  int32_t _internal_device_id() const;
+  void _internal_set_device_id(int32_t value);
+  public:
+
+  // int32 strength = 3;
+  void clear_strength();
+  int32_t strength() const;
+  void set_strength(int32_t value);
+  private:
+  int32_t _internal_strength() const;
+  void _internal_set_strength(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.InterconnectLink)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_;
+    int32_t device_id_;
+    int32_t strength_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fdevice_5fattributes_2eproto;
+};
+// -------------------------------------------------------------------
+
+class LocalLinks final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.LocalLinks) */ {
+ public:
+  inline LocalLinks() : LocalLinks(nullptr) {}
+  ~LocalLinks() override;
+  explicit PROTOBUF_CONSTEXPR LocalLinks(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  LocalLinks(const LocalLinks& from);
+  LocalLinks(LocalLinks&& from) noexcept
+    : LocalLinks() {
+    *this = ::std::move(from);
+  }
+
+  inline LocalLinks& operator=(const LocalLinks& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline LocalLinks& operator=(LocalLinks&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const LocalLinks& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const LocalLinks* internal_default_instance() {
+    return reinterpret_cast<const LocalLinks*>(
+               &_LocalLinks_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(LocalLinks& a, LocalLinks& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(LocalLinks* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(LocalLinks* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  LocalLinks* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<LocalLinks>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const LocalLinks& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const LocalLinks& from) {
+    LocalLinks::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(LocalLinks* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.LocalLinks";
+  }
+  protected:
+  explicit LocalLinks(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kLinkFieldNumber = 1,
+  };
+  // repeated .tensorflow.InterconnectLink link = 1;
+  int link_size() const;
+  private:
+  int _internal_link_size() const;
+  public:
+  void clear_link();
+  ::tensorflow::InterconnectLink* mutable_link(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::InterconnectLink >*
+      mutable_link();
+  private:
+  const ::tensorflow::InterconnectLink& _internal_link(int index) const;
+  ::tensorflow::InterconnectLink* _internal_add_link();
+  public:
+  const ::tensorflow::InterconnectLink& link(int index) const;
+  ::tensorflow::InterconnectLink* add_link();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::InterconnectLink >&
+      link() const;
+
+  // @@protoc_insertion_point(class_scope:tensorflow.LocalLinks)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::InterconnectLink > link_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fdevice_5fattributes_2eproto;
+};
+// -------------------------------------------------------------------
+
+class DeviceLocality final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.DeviceLocality) */ {
+ public:
+  inline DeviceLocality() : DeviceLocality(nullptr) {}
+  ~DeviceLocality() override;
+  explicit PROTOBUF_CONSTEXPR DeviceLocality(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DeviceLocality(const DeviceLocality& from);
+  DeviceLocality(DeviceLocality&& from) noexcept
+    : DeviceLocality() {
+    *this = ::std::move(from);
+  }
+
+  inline DeviceLocality& operator=(const DeviceLocality& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DeviceLocality& operator=(DeviceLocality&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const DeviceLocality& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const DeviceLocality* internal_default_instance() {
+    return reinterpret_cast<const DeviceLocality*>(
+               &_DeviceLocality_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(DeviceLocality& a, DeviceLocality& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DeviceLocality* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(DeviceLocality* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  DeviceLocality* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<DeviceLocality>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const DeviceLocality& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const DeviceLocality& from) {
+    DeviceLocality::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(DeviceLocality* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.DeviceLocality";
+  }
+  protected:
+  explicit DeviceLocality(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kLinksFieldNumber = 3,
+    kBusIdFieldNumber = 1,
+    kNumaNodeFieldNumber = 2,
+  };
+  // .tensorflow.LocalLinks links = 3;
+  bool has_links() const;
+  private:
+  bool _internal_has_links() const;
+  public:
+  void clear_links();
+  const ::tensorflow::LocalLinks& links() const;
+  PROTOBUF_NODISCARD ::tensorflow::LocalLinks* release_links();
+  ::tensorflow::LocalLinks* mutable_links();
+  void set_allocated_links(::tensorflow::LocalLinks* links);
+  private:
+  const ::tensorflow::LocalLinks& _internal_links() const;
+  ::tensorflow::LocalLinks* _internal_mutable_links();
+  public:
+  void unsafe_arena_set_allocated_links(
+      ::tensorflow::LocalLinks* links);
+  ::tensorflow::LocalLinks* unsafe_arena_release_links();
+
+  // int32 bus_id = 1;
+  void clear_bus_id();
+  int32_t bus_id() const;
+  void set_bus_id(int32_t value);
+  private:
+  int32_t _internal_bus_id() const;
+  void _internal_set_bus_id(int32_t value);
+  public:
+
+  // int32 numa_node = 2;
+  void clear_numa_node();
+  int32_t numa_node() const;
+  void set_numa_node(int32_t value);
+  private:
+  int32_t _internal_numa_node() const;
+  void _internal_set_numa_node(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.DeviceLocality)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::tensorflow::LocalLinks* links_;
+    int32_t bus_id_;
+    int32_t numa_node_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fdevice_5fattributes_2eproto;
+};
+// -------------------------------------------------------------------
+
+class DeviceAttributes final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.DeviceAttributes) */ {
+ public:
+  inline DeviceAttributes() : DeviceAttributes(nullptr) {}
+  ~DeviceAttributes() override;
+  explicit PROTOBUF_CONSTEXPR DeviceAttributes(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DeviceAttributes(const DeviceAttributes& from);
+  DeviceAttributes(DeviceAttributes&& from) noexcept
+    : DeviceAttributes() {
+    *this = ::std::move(from);
+  }
+
+  inline DeviceAttributes& operator=(const DeviceAttributes& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DeviceAttributes& operator=(DeviceAttributes&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const DeviceAttributes& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const DeviceAttributes* internal_default_instance() {
+    return reinterpret_cast<const DeviceAttributes*>(
+               &_DeviceAttributes_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  friend void swap(DeviceAttributes& a, DeviceAttributes& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DeviceAttributes* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(DeviceAttributes* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  DeviceAttributes* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<DeviceAttributes>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const DeviceAttributes& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const DeviceAttributes& from) {
+    DeviceAttributes::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(DeviceAttributes* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.DeviceAttributes";
+  }
+  protected:
+  explicit DeviceAttributes(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNameFieldNumber = 1,
+    kDeviceTypeFieldNumber = 2,
+    kPhysicalDeviceDescFieldNumber = 7,
+    kLocalityFieldNumber = 5,
+    kMemoryLimitFieldNumber = 4,
+    kIncarnationFieldNumber = 6,
+    kXlaGlobalIdFieldNumber = 8,
+  };
+  // string name = 1;
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // string device_type = 2;
+  void clear_device_type();
+  const std::string& device_type() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_device_type(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_device_type();
+  PROTOBUF_NODISCARD std::string* release_device_type();
+  void set_allocated_device_type(std::string* device_type);
+  private:
+  const std::string& _internal_device_type() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_device_type(const std::string& value);
+  std::string* _internal_mutable_device_type();
+  public:
+
+  // string physical_device_desc = 7;
+  void clear_physical_device_desc();
+  const std::string& physical_device_desc() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_physical_device_desc(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_physical_device_desc();
+  PROTOBUF_NODISCARD std::string* release_physical_device_desc();
+  void set_allocated_physical_device_desc(std::string* physical_device_desc);
+  private:
+  const std::string& _internal_physical_device_desc() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_physical_device_desc(const std::string& value);
+  std::string* _internal_mutable_physical_device_desc();
+  public:
+
+  // .tensorflow.DeviceLocality locality = 5;
+  bool has_locality() const;
+  private:
+  bool _internal_has_locality() const;
+  public:
+  void clear_locality();
+  const ::tensorflow::DeviceLocality& locality() const;
+  PROTOBUF_NODISCARD ::tensorflow::DeviceLocality* release_locality();
+  ::tensorflow::DeviceLocality* mutable_locality();
+  void set_allocated_locality(::tensorflow::DeviceLocality* locality);
+  private:
+  const ::tensorflow::DeviceLocality& _internal_locality() const;
+  ::tensorflow::DeviceLocality* _internal_mutable_locality();
+  public:
+  void unsafe_arena_set_allocated_locality(
+      ::tensorflow::DeviceLocality* locality);
+  ::tensorflow::DeviceLocality* unsafe_arena_release_locality();
+
+  // int64 memory_limit = 4;
+  void clear_memory_limit();
+  int64_t memory_limit() const;
+  void set_memory_limit(int64_t value);
+  private:
+  int64_t _internal_memory_limit() const;
+  void _internal_set_memory_limit(int64_t value);
+  public:
+
+  // fixed64 incarnation = 6;
+  void clear_incarnation();
+  uint64_t incarnation() const;
+  void set_incarnation(uint64_t value);
+  private:
+  uint64_t _internal_incarnation() const;
+  void _internal_set_incarnation(uint64_t value);
+  public:
+
+  // int64 xla_global_id = 8;
+  void clear_xla_global_id();
+  int64_t xla_global_id() const;
+  void set_xla_global_id(int64_t value);
+  private:
+  int64_t _internal_xla_global_id() const;
+  void _internal_set_xla_global_id(int64_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.DeviceAttributes)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_type_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr physical_device_desc_;
+    ::tensorflow::DeviceLocality* locality_;
+    int64_t memory_limit_;
+    uint64_t incarnation_;
+    int64_t xla_global_id_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fdevice_5fattributes_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// InterconnectLink
+
+// int32 device_id = 1;
+inline void InterconnectLink::clear_device_id() {
+  _impl_.device_id_ = 0;
+}
+inline int32_t InterconnectLink::_internal_device_id() const {
+  return _impl_.device_id_;
+}
+inline int32_t InterconnectLink::device_id() const {
+  // @@protoc_insertion_point(field_get:tensorflow.InterconnectLink.device_id)
+  return _internal_device_id();
+}
+inline void InterconnectLink::_internal_set_device_id(int32_t value) {
+  
+  _impl_.device_id_ = value;
+}
+inline void InterconnectLink::set_device_id(int32_t value) {
+  _internal_set_device_id(value);
+  // @@protoc_insertion_point(field_set:tensorflow.InterconnectLink.device_id)
+}
+
+// string type = 2;
+inline void InterconnectLink::clear_type() {
+  _impl_.type_.ClearToEmpty();
+}
+inline const std::string& InterconnectLink::type() const {
+  // @@protoc_insertion_point(field_get:tensorflow.InterconnectLink.type)
+  return _internal_type();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void InterconnectLink::set_type(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.type_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.InterconnectLink.type)
+}
+inline std::string* InterconnectLink::mutable_type() {
+  std::string* _s = _internal_mutable_type();
+  // @@protoc_insertion_point(field_mutable:tensorflow.InterconnectLink.type)
+  return _s;
+}
+inline const std::string& InterconnectLink::_internal_type() const {
+  return _impl_.type_.Get();
+}
+inline void InterconnectLink::_internal_set_type(const std::string& value) {
+  
+  _impl_.type_.Set(value, GetArenaForAllocation());
+}
+inline std::string* InterconnectLink::_internal_mutable_type() {
+  
+  return _impl_.type_.Mutable(GetArenaForAllocation());
+}
+inline std::string* InterconnectLink::release_type() {
+  // @@protoc_insertion_point(field_release:tensorflow.InterconnectLink.type)
+  return _impl_.type_.Release();
+}
+inline void InterconnectLink::set_allocated_type(std::string* type) {
+  if (type != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.type_.SetAllocated(type, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.type_.IsDefault()) {
+    _impl_.type_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.InterconnectLink.type)
+}
+
+// int32 strength = 3;
+inline void InterconnectLink::clear_strength() {
+  _impl_.strength_ = 0;
+}
+inline int32_t InterconnectLink::_internal_strength() const {
+  return _impl_.strength_;
+}
+inline int32_t InterconnectLink::strength() const {
+  // @@protoc_insertion_point(field_get:tensorflow.InterconnectLink.strength)
+  return _internal_strength();
+}
+inline void InterconnectLink::_internal_set_strength(int32_t value) {
+  
+  _impl_.strength_ = value;
+}
+inline void InterconnectLink::set_strength(int32_t value) {
+  _internal_set_strength(value);
+  // @@protoc_insertion_point(field_set:tensorflow.InterconnectLink.strength)
+}
+
+// -------------------------------------------------------------------
+
+// LocalLinks
+
+// repeated .tensorflow.InterconnectLink link = 1;
+inline int LocalLinks::_internal_link_size() const {
+  return _impl_.link_.size();
+}
+inline int LocalLinks::link_size() const {
+  return _internal_link_size();
+}
+inline void LocalLinks::clear_link() {
+  _impl_.link_.Clear();
+}
+inline ::tensorflow::InterconnectLink* LocalLinks::mutable_link(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.LocalLinks.link)
+  return _impl_.link_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::InterconnectLink >*
+LocalLinks::mutable_link() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.LocalLinks.link)
+  return &_impl_.link_;
+}
+inline const ::tensorflow::InterconnectLink& LocalLinks::_internal_link(int index) const {
+  return _impl_.link_.Get(index);
+}
+inline const ::tensorflow::InterconnectLink& LocalLinks::link(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.LocalLinks.link)
+  return _internal_link(index);
+}
+inline ::tensorflow::InterconnectLink* LocalLinks::_internal_add_link() {
+  return _impl_.link_.Add();
+}
+inline ::tensorflow::InterconnectLink* LocalLinks::add_link() {
+  ::tensorflow::InterconnectLink* _add = _internal_add_link();
+  // @@protoc_insertion_point(field_add:tensorflow.LocalLinks.link)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::InterconnectLink >&
+LocalLinks::link() const {
+  // @@protoc_insertion_point(field_list:tensorflow.LocalLinks.link)
+  return _impl_.link_;
+}
+
+// -------------------------------------------------------------------
+
+// DeviceLocality
+
+// int32 bus_id = 1;
+inline void DeviceLocality::clear_bus_id() {
+  _impl_.bus_id_ = 0;
+}
+inline int32_t DeviceLocality::_internal_bus_id() const {
+  return _impl_.bus_id_;
+}
+inline int32_t DeviceLocality::bus_id() const {
+  // @@protoc_insertion_point(field_get:tensorflow.DeviceLocality.bus_id)
+  return _internal_bus_id();
+}
+inline void DeviceLocality::_internal_set_bus_id(int32_t value) {
+  
+  _impl_.bus_id_ = value;
+}
+inline void DeviceLocality::set_bus_id(int32_t value) {
+  _internal_set_bus_id(value);
+  // @@protoc_insertion_point(field_set:tensorflow.DeviceLocality.bus_id)
+}
+
+// int32 numa_node = 2;
+inline void DeviceLocality::clear_numa_node() {
+  _impl_.numa_node_ = 0;
+}
+inline int32_t DeviceLocality::_internal_numa_node() const {
+  return _impl_.numa_node_;
+}
+inline int32_t DeviceLocality::numa_node() const {
+  // @@protoc_insertion_point(field_get:tensorflow.DeviceLocality.numa_node)
+  return _internal_numa_node();
+}
+inline void DeviceLocality::_internal_set_numa_node(int32_t value) {
+  
+  _impl_.numa_node_ = value;
+}
+inline void DeviceLocality::set_numa_node(int32_t value) {
+  _internal_set_numa_node(value);
+  // @@protoc_insertion_point(field_set:tensorflow.DeviceLocality.numa_node)
+}
+
+// .tensorflow.LocalLinks links = 3;
+inline bool DeviceLocality::_internal_has_links() const {
+  return this != internal_default_instance() && _impl_.links_ != nullptr;
+}
+inline bool DeviceLocality::has_links() const {
+  return _internal_has_links();
+}
+inline void DeviceLocality::clear_links() {
+  if (GetArenaForAllocation() == nullptr && _impl_.links_ != nullptr) {
+    delete _impl_.links_;
+  }
+  _impl_.links_ = nullptr;
+}
+inline const ::tensorflow::LocalLinks& DeviceLocality::_internal_links() const {
+  const ::tensorflow::LocalLinks* p = _impl_.links_;
+  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::LocalLinks&>(
+      ::tensorflow::_LocalLinks_default_instance_);
+}
+inline const ::tensorflow::LocalLinks& DeviceLocality::links() const {
+  // @@protoc_insertion_point(field_get:tensorflow.DeviceLocality.links)
+  return _internal_links();
+}
+inline void DeviceLocality::unsafe_arena_set_allocated_links(
+    ::tensorflow::LocalLinks* links) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.links_);
+  }
+  _impl_.links_ = links;
+  if (links) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.DeviceLocality.links)
+}
+inline ::tensorflow::LocalLinks* DeviceLocality::release_links() {
+  
+  ::tensorflow::LocalLinks* temp = _impl_.links_;
+  _impl_.links_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::tensorflow::LocalLinks* DeviceLocality::unsafe_arena_release_links() {
+  // @@protoc_insertion_point(field_release:tensorflow.DeviceLocality.links)
+  
+  ::tensorflow::LocalLinks* temp = _impl_.links_;
+  _impl_.links_ = nullptr;
+  return temp;
+}
+inline ::tensorflow::LocalLinks* DeviceLocality::_internal_mutable_links() {
+  
+  if (_impl_.links_ == nullptr) {
+    auto* p = CreateMaybeMessage<::tensorflow::LocalLinks>(GetArenaForAllocation());
+    _impl_.links_ = p;
+  }
+  return _impl_.links_;
+}
+inline ::tensorflow::LocalLinks* DeviceLocality::mutable_links() {
+  ::tensorflow::LocalLinks* _msg = _internal_mutable_links();
+  // @@protoc_insertion_point(field_mutable:tensorflow.DeviceLocality.links)
+  return _msg;
+}
+inline void DeviceLocality::set_allocated_links(::tensorflow::LocalLinks* links) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.links_;
+  }
+  if (links) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(links);
+    if (message_arena != submessage_arena) {
+      links = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, links, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.links_ = links;
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.DeviceLocality.links)
+}
+
+// -------------------------------------------------------------------
+
+// DeviceAttributes
+
+// string name = 1;
+inline void DeviceAttributes::clear_name() {
+  _impl_.name_.ClearToEmpty();
+}
+inline const std::string& DeviceAttributes::name() const {
+  // @@protoc_insertion_point(field_get:tensorflow.DeviceAttributes.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void DeviceAttributes::set_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.DeviceAttributes.name)
+}
+inline std::string* DeviceAttributes::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:tensorflow.DeviceAttributes.name)
+  return _s;
+}
+inline const std::string& DeviceAttributes::_internal_name() const {
+  return _impl_.name_.Get();
+}
+inline void DeviceAttributes::_internal_set_name(const std::string& value) {
+  
+  _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* DeviceAttributes::_internal_mutable_name() {
+  
+  return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* DeviceAttributes::release_name() {
+  // @@protoc_insertion_point(field_release:tensorflow.DeviceAttributes.name)
+  return _impl_.name_.Release();
+}
+inline void DeviceAttributes::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.DeviceAttributes.name)
+}
+
+// string device_type = 2;
+inline void DeviceAttributes::clear_device_type() {
+  _impl_.device_type_.ClearToEmpty();
+}
+inline const std::string& DeviceAttributes::device_type() const {
+  // @@protoc_insertion_point(field_get:tensorflow.DeviceAttributes.device_type)
+  return _internal_device_type();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void DeviceAttributes::set_device_type(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.device_type_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.DeviceAttributes.device_type)
+}
+inline std::string* DeviceAttributes::mutable_device_type() {
+  std::string* _s = _internal_mutable_device_type();
+  // @@protoc_insertion_point(field_mutable:tensorflow.DeviceAttributes.device_type)
+  return _s;
+}
+inline const std::string& DeviceAttributes::_internal_device_type() const {
+  return _impl_.device_type_.Get();
+}
+inline void DeviceAttributes::_internal_set_device_type(const std::string& value) {
+  
+  _impl_.device_type_.Set(value, GetArenaForAllocation());
+}
+inline std::string* DeviceAttributes::_internal_mutable_device_type() {
+  
+  return _impl_.device_type_.Mutable(GetArenaForAllocation());
+}
+inline std::string* DeviceAttributes::release_device_type() {
+  // @@protoc_insertion_point(field_release:tensorflow.DeviceAttributes.device_type)
+  return _impl_.device_type_.Release();
+}
+inline void DeviceAttributes::set_allocated_device_type(std::string* device_type) {
+  if (device_type != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.device_type_.SetAllocated(device_type, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.device_type_.IsDefault()) {
+    _impl_.device_type_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.DeviceAttributes.device_type)
+}
+
+// int64 memory_limit = 4;
+inline void DeviceAttributes::clear_memory_limit() {
+  _impl_.memory_limit_ = int64_t{0};
+}
+inline int64_t DeviceAttributes::_internal_memory_limit() const {
+  return _impl_.memory_limit_;
+}
+inline int64_t DeviceAttributes::memory_limit() const {
+  // @@protoc_insertion_point(field_get:tensorflow.DeviceAttributes.memory_limit)
+  return _internal_memory_limit();
+}
+inline void DeviceAttributes::_internal_set_memory_limit(int64_t value) {
+  
+  _impl_.memory_limit_ = value;
+}
+inline void DeviceAttributes::set_memory_limit(int64_t value) {
+  _internal_set_memory_limit(value);
+  // @@protoc_insertion_point(field_set:tensorflow.DeviceAttributes.memory_limit)
+}
+
+// .tensorflow.DeviceLocality locality = 5;
+inline bool DeviceAttributes::_internal_has_locality() const {
+  return this != internal_default_instance() && _impl_.locality_ != nullptr;
+}
+inline bool DeviceAttributes::has_locality() const {
+  return _internal_has_locality();
+}
+inline void DeviceAttributes::clear_locality() {
+  if (GetArenaForAllocation() == nullptr && _impl_.locality_ != nullptr) {
+    delete _impl_.locality_;
+  }
+  _impl_.locality_ = nullptr;
+}
+inline const ::tensorflow::DeviceLocality& DeviceAttributes::_internal_locality() const {
+  const ::tensorflow::DeviceLocality* p = _impl_.locality_;
+  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::DeviceLocality&>(
+      ::tensorflow::_DeviceLocality_default_instance_);
+}
+inline const ::tensorflow::DeviceLocality& DeviceAttributes::locality() const {
+  // @@protoc_insertion_point(field_get:tensorflow.DeviceAttributes.locality)
+  return _internal_locality();
+}
+inline void DeviceAttributes::unsafe_arena_set_allocated_locality(
+    ::tensorflow::DeviceLocality* locality) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.locality_);
+  }
+  _impl_.locality_ = locality;
+  if (locality) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.DeviceAttributes.locality)
+}
+inline ::tensorflow::DeviceLocality* DeviceAttributes::release_locality() {
+  
+  ::tensorflow::DeviceLocality* temp = _impl_.locality_;
+  _impl_.locality_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::tensorflow::DeviceLocality* DeviceAttributes::unsafe_arena_release_locality() {
+  // @@protoc_insertion_point(field_release:tensorflow.DeviceAttributes.locality)
+  
+  ::tensorflow::DeviceLocality* temp = _impl_.locality_;
+  _impl_.locality_ = nullptr;
+  return temp;
+}
+inline ::tensorflow::DeviceLocality* DeviceAttributes::_internal_mutable_locality() {
+  
+  if (_impl_.locality_ == nullptr) {
+    auto* p = CreateMaybeMessage<::tensorflow::DeviceLocality>(GetArenaForAllocation());
+    _impl_.locality_ = p;
+  }
+  return _impl_.locality_;
+}
+inline ::tensorflow::DeviceLocality* DeviceAttributes::mutable_locality() {
+  ::tensorflow::DeviceLocality* _msg = _internal_mutable_locality();
+  // @@protoc_insertion_point(field_mutable:tensorflow.DeviceAttributes.locality)
+  return _msg;
+}
+inline void DeviceAttributes::set_allocated_locality(::tensorflow::DeviceLocality* locality) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.locality_;
+  }
+  if (locality) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(locality);
+    if (message_arena != submessage_arena) {
+      locality = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, locality, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.locality_ = locality;
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.DeviceAttributes.locality)
+}
+
+// fixed64 incarnation = 6;
+inline void DeviceAttributes::clear_incarnation() {
+  _impl_.incarnation_ = uint64_t{0u};
+}
+inline uint64_t DeviceAttributes::_internal_incarnation() const {
+  return _impl_.incarnation_;
+}
+inline uint64_t DeviceAttributes::incarnation() const {
+  // @@protoc_insertion_point(field_get:tensorflow.DeviceAttributes.incarnation)
+  return _internal_incarnation();
+}
+inline void DeviceAttributes::_internal_set_incarnation(uint64_t value) {
+  
+  _impl_.incarnation_ = value;
+}
+inline void DeviceAttributes::set_incarnation(uint64_t value) {
+  _internal_set_incarnation(value);
+  // @@protoc_insertion_point(field_set:tensorflow.DeviceAttributes.incarnation)
+}
+
+// string physical_device_desc = 7;
+inline void DeviceAttributes::clear_physical_device_desc() {
+  _impl_.physical_device_desc_.ClearToEmpty();
+}
+inline const std::string& DeviceAttributes::physical_device_desc() const {
+  // @@protoc_insertion_point(field_get:tensorflow.DeviceAttributes.physical_device_desc)
+  return _internal_physical_device_desc();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void DeviceAttributes::set_physical_device_desc(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.physical_device_desc_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.DeviceAttributes.physical_device_desc)
+}
+inline std::string* DeviceAttributes::mutable_physical_device_desc() {
+  std::string* _s = _internal_mutable_physical_device_desc();
+  // @@protoc_insertion_point(field_mutable:tensorflow.DeviceAttributes.physical_device_desc)
+  return _s;
+}
+inline const std::string& DeviceAttributes::_internal_physical_device_desc() const {
+  return _impl_.physical_device_desc_.Get();
+}
+inline void DeviceAttributes::_internal_set_physical_device_desc(const std::string& value) {
+  
+  _impl_.physical_device_desc_.Set(value, GetArenaForAllocation());
+}
+inline std::string* DeviceAttributes::_internal_mutable_physical_device_desc() {
+  
+  return _impl_.physical_device_desc_.Mutable(GetArenaForAllocation());
+}
+inline std::string* DeviceAttributes::release_physical_device_desc() {
+  // @@protoc_insertion_point(field_release:tensorflow.DeviceAttributes.physical_device_desc)
+  return _impl_.physical_device_desc_.Release();
+}
+inline void DeviceAttributes::set_allocated_physical_device_desc(std::string* physical_device_desc) {
+  if (physical_device_desc != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.physical_device_desc_.SetAllocated(physical_device_desc, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.physical_device_desc_.IsDefault()) {
+    _impl_.physical_device_desc_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.DeviceAttributes.physical_device_desc)
+}
+
+// int64 xla_global_id = 8;
+inline void DeviceAttributes::clear_xla_global_id() {
+  _impl_.xla_global_id_ = int64_t{0};
+}
+inline int64_t DeviceAttributes::_internal_xla_global_id() const {
+  return _impl_.xla_global_id_;
+}
+inline int64_t DeviceAttributes::xla_global_id() const {
+  // @@protoc_insertion_point(field_get:tensorflow.DeviceAttributes.xla_global_id)
+  return _internal_xla_global_id();
+}
+inline void DeviceAttributes::_internal_set_xla_global_id(int64_t value) {
+  
+  _impl_.xla_global_id_ = value;
+}
+inline void DeviceAttributes::set_xla_global_id(int64_t value) {
+  _internal_set_xla_global_id(value);
+  // @@protoc_insertion_point(field_set:tensorflow.DeviceAttributes.xla_global_id)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace tensorflow
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fdevice_5fattributes_2eproto
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/device_attributes.proto b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/device_attributes.proto
new file mode 100644
index 0000000000000000000000000000000000000000..5f568e255f4683902737fa07aa5f5b619d3d4606
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/device_attributes.proto
@@ -0,0 +1,58 @@
+syntax = "proto3";
+
+package tensorflow;
+
+option cc_enable_arenas = true;
+option java_outer_classname = "DeviceAttributesProtos";
+option java_multiple_files = true;
+option java_package = "org.tensorflow.framework";
+option go_package = "github.com/tensorflow/tensorflow/tensorflow/go/core/framework/device_attributes_go_proto";
+
+message InterconnectLink {
+  int32 device_id = 1;
+  string type = 2;
+  int32 strength = 3;
+}
+
+message LocalLinks {
+  repeated InterconnectLink link = 1;
+}
+
+message DeviceLocality {
+  // Optional bus locality of device.  Default value of 0 means
+  // no specific locality.  Specific localities are indexed from 1.
+  int32 bus_id = 1;
+
+  // Optional NUMA locality of device.
+  int32 numa_node = 2;
+
+  // Optional local interconnect links to other devices.
+  LocalLinks links = 3;
+}
+
+message DeviceAttributes {
+  // Fully specified name of the device within a cluster.
+  string name = 1;
+
+  // String representation of device_type.
+  string device_type = 2;
+
+  // Memory capacity of device in bytes.
+  int64 memory_limit = 4;
+
+  // Platform-specific data about device that may be useful
+  // for supporting efficient data transfers.
+  DeviceLocality locality = 5;
+
+  // A device is assigned a global unique number each time it is
+  // initialized. "incarnation" should never be 0.
+  fixed64 incarnation = 6;
+
+  // String representation of the physical device that this device maps to.
+  string physical_device_desc = 7;
+
+  // A physical device ID for use in XLA DeviceAssignments, unique across
+  // clients in a multi-client setup. Set to -1 if unavailable, non-negative
+  // otherwise.
+  int64 xla_global_id = 8;
+}
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/device_base.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/device_base.h
new file mode 100644
index 0000000000000000000000000000000000000000..ada04e0f8f284c7dba99fb8c74da3988d2345fe3
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/device_base.h
@@ -0,0 +1,308 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_DEVICE_BASE_H_
+#define TENSORFLOW_CORE_FRAMEWORK_DEVICE_BASE_H_
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "absl/base/macros.h"
+#include "absl/strings/string_view.h"
+#include "tensorflow/core/framework/device_attributes.pb.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/lib/core/errors.h"
+#include "tensorflow/core/lib/core/refcount.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/lib/core/stringpiece.h"
+#include "tensorflow/core/platform/logging.h"
+#include "tensorflow/core/platform/threadpool.h"
+#include "tensorflow/core/util/device_name_utils.h"
+
+namespace Eigen {
+struct ThreadPoolDevice;
+}  // end namespace Eigen
+
+namespace stream_executor {
+class Stream;
+}  // namespace stream_executor
+
+namespace tsl {
+class Env;
+namespace thread {
+class ThreadPool;
+}  // namespace thread
+}  // namespace tsl
+namespace tensorflow {
+
+class Device;
+class DeviceAttributes;
+class EventMgr;
+class OpKernelContext;
+class ResourceMgr;
+class ScopedAllocatorMgr;
+class TensorProto;
+
+// A wrapper for an Eigen Gpu Device that includes per-op state. The
+// class is defined even for non-GPU devices since the
+// OpKernelContext::Params structure wants to fill it in.
+class PerOpGpuDevice {
+ public:
+  virtual ~PerOpGpuDevice() {}
+  virtual const Eigen::GpuDevice& device() const = 0;
+};
+
+// A class that devices can subclass to pass around
+// Device-specific context to OpKernels.
+class DeviceContext : public core::RefCounted {
+ public:
+  ~DeviceContext() override {}
+  virtual stream_executor::Stream* stream() const { return nullptr; }
+  virtual void MaintainLifetimeOnStream(const Tensor* t,
+                                        stream_executor::Stream* stream) const {
+  }
+
+  // "cpu_tensor" is a tensor on a CPU. Copies "cpu_tensor" into
+  // "device_tensor" which is on a non-CPU device "device". "device_tensor"
+  // must be allocated to be of the same size as "cpu_tensor".
+  virtual void CopyCPUTensorToDevice(const Tensor* cpu_tensor, Device* device,
+                                     Tensor* device_tensor, StatusCallback done,
+                                     bool sync_dst_compute = true) const {
+    done(errors::Internal("Unrecognized device type in CPU-to-device Copy"));
+  }
+
+  // Same as CopyCPUTensorToDevice, but in a synchronous way.
+  Status CopyCPUTensorToDeviceSync(const Tensor* cpu_tensor, Device* device,
+                                   Tensor* device_tensor) const;
+
+  // Copies a tensor in this device.
+  virtual void CopyTensorInSameDevice(const Tensor* input_tensor,
+                                      Device* device, Tensor* output_tensor,
+                                      StatusCallback done) const {
+    done(errors::Unimplemented("Copy in same device not implemented."));
+  }
+
+  // "device_tensor" is a tensor on a non-CPU device.  Copies
+  // device_tensor into "cpu_tensor".  "cpu_tensor" must be allocated
+  // to be of the same size as "device_tensor".
+  virtual void CopyDeviceTensorToCPU(const Tensor* device_tensor,
+                                     StringPiece tensor_name, Device* device,
+                                     Tensor* cpu_tensor, StatusCallback done) {
+    done(errors::Internal("Unrecognized device type in device-to-CPU Copy"));
+  }
+
+  // Same as `CopyDeviceTensorToCPU`, but blocks until the copy is done.
+  Status CopyDeviceTensorToCPUSync(const Tensor* device_tensor,
+                                   StringPiece tensor_name, Device* device,
+                                   Tensor* cpu_tensor);
+
+  // If possible, wait for all events on *stream to complete then execute func.
+  // A non-OK Status is returned otherwise.  The stream argument should be the
+  // one provided by AcceleratorDeviceInfo.  This function is not applicable to
+  // devices that don't provide such a value.
+  virtual Status ThenExecute(Device* device, stream_executor::Stream* stream,
+                             std::function<void()> func) {
+    return errors::Internal("ThenExecute not supported by device");
+  }
+
+  // check if device is a pluggable device
+  virtual bool IsPluggableDevice() { return false; }
+
+  // Returns the pinned host memory allocator for the device.
+  virtual Allocator* host_memory_allocator() const { return nullptr; }
+};
+
+class DeviceBase {
+ public:
+  explicit DeviceBase(tsl::Env* env) : env_(env) {}
+  virtual ~DeviceBase();
+
+  tsl::Env* env() const { return env_; }
+
+  struct CpuWorkerThreads {
+    int num_threads = 0;
+    tsl::thread::ThreadPool* workers = nullptr;
+  };
+
+  // Does not take ownership.
+  void set_tensorflow_cpu_worker_threads(CpuWorkerThreads* t) {
+    cpu_worker_threads_ = t;
+  }
+
+  virtual const CpuWorkerThreads* tensorflow_cpu_worker_threads() const {
+    CHECK(cpu_worker_threads_ != nullptr);
+    return cpu_worker_threads_;
+  }
+
+  // "stream" is used in special circumstances (such as the
+  // constructors of Ops) where there is no available OpKernelContext.
+  // "default_context" is used by OpKernelContext whenever a device does not
+  // supply a DeviceContext for an op in TryGetDeviceContext() (e.g. when only
+  // using a single stream.)
+  // "event_mgr" is used to delay deallocation of temporary GPU buffers.
+  // TODO(pbar) Work out how to move this out of DeviceBase.
+  struct AcceleratorDeviceInfo {
+    // Make sure all the defaults are NULL, so we can spot missing assignments.
+    stream_executor::Stream* stream = nullptr;
+    DeviceContext* default_context = nullptr;
+    DeviceContext* pjrt_context = nullptr;
+    bool use_pjrt_tensor_buffer = false;
+    EventMgr* event_mgr = nullptr;
+    int gpu_id = -1;
+  };
+
+  // Does not take ownership.
+  void set_tensorflow_accelerator_device_info(
+      AcceleratorDeviceInfo* device_info) {
+    accelerator_device_info_ = device_info;
+  }
+
+  virtual const AcceleratorDeviceInfo* tensorflow_accelerator_device_info()
+      const {
+    return accelerator_device_info_;
+  }
+
+  // The preferred thread pool for this device. If it is nullptr, the system
+  // automatically assigns a thread pool for execution.
+  virtual tsl::thread::ThreadPool* tensorflow_device_thread_pool() {
+    return device_thread_pool_;
+  }
+
+  // Does not take ownership.
+  void set_eigen_cpu_device(Eigen::ThreadPoolDevice* d);
+
+  // Return the Allocator implementation to use based on the allocator
+  // attributes requested.  See allocator.h for more details.
+  virtual Allocator* GetAllocator(AllocatorAttributes /*attr*/) {
+    LOG(FATAL) << "GetAllocator() is not implemented.";
+    return nullptr;
+  }
+
+  // This method is provided for backwards compatibility, and will be removed
+  // in a future release.
+  ABSL_DEPRECATED("Use `this->GetAllocator()` or `this->GetScopedAllocator()`.")
+  Allocator* GetStepAllocator(AllocatorAttributes attr, ResourceMgr*) {
+    return GetAllocator(attr);
+  }
+
+  // Return an Allocator prepared for use in particular places by graph
+  // optimization
+  virtual Allocator* GetScopedAllocator(AllocatorAttributes attr,
+                                        int64_t step_id) {
+    LOG(FATAL) << "Device does not implement GetScopedAllocator()";
+    return nullptr;
+  }
+
+  virtual ScopedAllocatorMgr* GetScopedAllocatorMgr() const { return nullptr; }
+
+  virtual bool has_eigen_cpu_device() const {
+    return !eigen_cpu_devices_.empty();
+  }
+
+  virtual const Eigen::ThreadPoolDevice* eigen_cpu_device();
+
+  // Caller owns the return value. The OpKernelContext calls this even
+  // for devices that do not implement an eigen_gpu_device. Overridden
+  // by GPU devices to return a derived type.
+  virtual PerOpGpuDevice* MakeGpuDevice() { return nullptr; }
+
+  virtual DeviceBase* UnderlyingDevice() { return this; }
+  virtual const DeviceBase* UnderlyingDevice() const { return this; }
+
+  // This is overridden by GPU devices to reinitialize the derived
+  // type returned by MakeGpuDevice.
+  virtual Status ReinitializeGpuDevice(OpKernelContext* /*context*/,
+                                       PerOpGpuDevice* /*device*/,
+                                       DeviceContext* /*dc*/,
+                                       Allocator* /*allocator*/) {
+    return OkStatus();
+  }
+
+  // Unimplemented by default
+  virtual const DeviceAttributes& attributes() const;
+  virtual int NumaNode() const { return attributes().locality().numa_node(); }
+  virtual const std::string& name() const;
+  virtual const DeviceNameUtils::ParsedName& parsed_name() const;
+
+  // Updates `attributes()`, indicating the XLA global ID associated with this
+  // device. This ID is unique across clients in a multi-client setup. For TPUs
+  // this does not happen until the TPU system has been initialized.
+  //
+  // Implemented in Device.
+  virtual void set_xla_global_id(int64_t id) {}
+
+  // Materializes the given TensorProto into 'tensor' stored in Device
+  // memory.  Most devices will want to override this.
+  //
+  // TODO(vrv): We should be able to put this function into
+  // OpKernelContext and handle the copies from device memory via send
+  // and receive nodes, instead of requiring that each device handle
+  // the copies here as well as in copy ops.
+  virtual Status MakeTensorFromProto(const TensorProto& tensor_proto,
+                                     const AllocatorAttributes alloc_attrs,
+                                     Tensor* tensor) {
+    return errors::Internal("Device does not implement MakeTensorFromProto()");
+  }
+
+  // Some devices (i.e. GPUs) may free device memory prior to its actual use
+  // being completed on the assumption that subsequent allocations can only be
+  // used serially with respect to pending uses.  If this function returns a
+  // non-zero value it is the value of a device-specific counter such that any
+  // device memory tagged with an earlier freed-at count is really unencumbered
+  // by pending uses.  For this to be useful the device memory allocator must
+  // be tagging deallocated memory chunks using the same counter.
+  virtual uint64 SafeAllocFrontier(uint64 old_value) { return 0; }
+
+  // Copies `input_tensor` to `output_tensor`, where both tensors are on this
+  // device. This function assumes that `output_tensor` has already been
+  // allocated with a buffer that is large enough to hold `input_tensor`'s data.
+  // Calls `done` from a device-specific thread after copy is finished, which
+  // may be the same as calling thread.
+  //
+  // NOTE(ayushd): This function is for TensorFlow internal use only.  Deep copy
+  // is discouraged and should not be used in OpKernels.
+  virtual void CopyTensorInSameDevice(const Tensor* input_tensor,
+                                      Tensor* output_tensor,
+                                      const DeviceContext* device_context,
+                                      StatusCallback done) {
+    done(errors::Internal("Device ", name(), " does not implement ",
+                          "CopyTensorInSameDevice"));
+  }
+
+ protected:
+  // Does not take ownership.
+  void set_tensorflow_device_thread_pool(tsl::thread::ThreadPool* thread_pool) {
+    device_thread_pool_ = thread_pool;
+  }
+
+ private:
+  tsl::Env* const env_;
+  CpuWorkerThreads* cpu_worker_threads_ = nullptr;
+  // Set by GPUs as well as by TPU devices.
+  AcceleratorDeviceInfo* accelerator_device_info_ = nullptr;
+  tsl::thread::ThreadPool* device_thread_pool_ = nullptr;
+  std::vector<Eigen::ThreadPoolDevice*> eigen_cpu_devices_;
+};
+
+// Methods to create and check for Symbolic execution devices.
+// Such devices are mostly used for TF-XLA bridge. TF should not treat these as
+// normal devices.
+void AddSymbolicExecutionDevice(absl::string_view device_name);
+bool IsSymbolicExecutionDevice(absl::string_view device_name);
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_DEVICE_BASE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/device_factory.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/device_factory.h
new file mode 100644
index 0000000000000000000000000000000000000000..c238aebf475bd29b50a96e1aff2119f6d9f014fb
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/device_factory.h
@@ -0,0 +1,172 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_DEVICE_FACTORY_H_
+#define TENSORFLOW_CORE_FRAMEWORK_DEVICE_FACTORY_H_
+
+#include <string>
+#include <vector>
+
+#include "absl/base/attributes.h"
+#include "tensorflow/core/platform/status.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+
+class Device;
+struct SessionOptions;
+
+class DeviceFactory {
+ public:
+  virtual ~DeviceFactory() {}
+  static void Register(const std::string& device_type,
+                       std::unique_ptr<DeviceFactory> factory, int priority,
+                       bool is_pluggable_device);
+  ABSL_DEPRECATED("Use the `Register` function above instead")
+  static void Register(const std::string& device_type, DeviceFactory* factory,
+                       int priority, bool is_pluggable_device) {
+    Register(device_type, std::unique_ptr<DeviceFactory>(factory), priority,
+             is_pluggable_device);
+  }
+  static DeviceFactory* GetFactory(const std::string& device_type);
+
+  // Append to "*devices" CPU devices.
+  static Status AddCpuDevices(const SessionOptions& options,
+                              const std::string& name_prefix,
+                              std::vector<std::unique_ptr<Device>>* devices);
+
+  // Append to "*devices" all suitable devices, respecting
+  // any device type specific properties/counts listed in "options".
+  //
+  // CPU devices are added first.
+  static Status AddDevices(const SessionOptions& options,
+                           const std::string& name_prefix,
+                           std::vector<std::unique_ptr<Device>>* devices);
+
+  // Helper for tests.  Create a single device of type "type".  The
+  // returned device is always numbered zero, so if creating multiple
+  // devices of the same type, supply distinct name_prefix arguments.
+  static std::unique_ptr<Device> NewDevice(const string& type,
+                                           const SessionOptions& options,
+                                           const string& name_prefix);
+
+  // Iterate through all device factories and build a list of all of the
+  // possible physical devices.
+  //
+  // CPU is are added first.
+  static Status ListAllPhysicalDevices(std::vector<string>* devices);
+
+  // Iterate through all device factories and build a list of all of the
+  // possible pluggable physical devices.
+  static Status ListPluggablePhysicalDevices(std::vector<string>* devices);
+
+  // Get details for a specific device among all device factories.
+  // 'device_index' indexes into devices from ListAllPhysicalDevices.
+  static Status GetAnyDeviceDetails(
+      int device_index, std::unordered_map<string, string>* details);
+
+  // For a specific device factory list all possible physical devices.
+  virtual Status ListPhysicalDevices(std::vector<string>* devices) = 0;
+
+  // Get details for a specific device for a specific factory. Subclasses
+  // can store arbitrary device information in the map. 'device_index' indexes
+  // into devices from ListPhysicalDevices.
+  virtual Status GetDeviceDetails(int device_index,
+                                  std::unordered_map<string, string>* details) {
+    return OkStatus();
+  }
+
+  // Most clients should call AddDevices() instead.
+  virtual Status CreateDevices(
+      const SessionOptions& options, const std::string& name_prefix,
+      std::vector<std::unique_ptr<Device>>* devices) = 0;
+
+  // Return the device priority number for a "device_type" string.
+  //
+  // Higher number implies higher priority.
+  //
+  // In standard TensorFlow distributions, GPU device types are
+  // preferred over CPU, and by default, custom devices that don't set
+  // a custom priority during registration will be prioritized lower
+  // than CPU.  Custom devices that want a higher priority can set the
+  // 'priority' field when registering their device to something
+  // higher than the packaged devices.  See calls to
+  // REGISTER_LOCAL_DEVICE_FACTORY to see the existing priorities used
+  // for built-in devices.
+  static int32 DevicePriority(const std::string& device_type);
+
+  // Returns true if 'device_type' is registered from plugin. Returns false if
+  // 'device_type' is a first-party device.
+  static bool IsPluggableDevice(const std::string& device_type);
+};
+
+namespace dfactory {
+
+template <class Factory>
+class Registrar {
+ public:
+  // Multiple registrations for the same device type with different priorities
+  // are allowed.  Priorities are used in two different ways:
+  //
+  // 1) When choosing which factory (that is, which device
+  //    implementation) to use for a specific 'device_type', the
+  //    factory registered with the highest priority will be chosen.
+  //    For example, if there are two registrations:
+  //
+  //      Registrar<CPUFactory1>("CPU", 125);
+  //      Registrar<CPUFactory2>("CPU", 150);
+  //
+  //    then CPUFactory2 will be chosen when
+  //    DeviceFactory::GetFactory("CPU") is called.
+  //
+  // 2) When choosing which 'device_type' is preferred over other
+  //    DeviceTypes in a DeviceSet, the ordering is determined
+  //    by the 'priority' set during registration.  For example, if there
+  //    are two registrations:
+  //
+  //      Registrar<CPUFactory>("CPU", 100);
+  //      Registrar<GPUFactory>("GPU", 200);
+  //
+  //    then DeviceType("GPU") will be prioritized higher than
+  //    DeviceType("CPU").
+  //
+  // The default priority values for built-in devices is:
+  // GPU: 210
+  // GPUCompatibleCPU: 70
+  // ThreadPoolDevice: 60
+  // Default: 50
+  explicit Registrar(const std::string& device_type, int priority = 50) {
+    DeviceFactory::Register(device_type, std::make_unique<Factory>(), priority,
+                            /*is_pluggable_device*/ false);
+  }
+};
+
+}  // namespace dfactory
+
+#define REGISTER_LOCAL_DEVICE_FACTORY(device_type, device_factory, ...) \
+  INTERNAL_REGISTER_LOCAL_DEVICE_FACTORY(device_type, device_factory,   \
+                                         __COUNTER__, ##__VA_ARGS__)
+
+#define INTERNAL_REGISTER_LOCAL_DEVICE_FACTORY(device_type, device_factory, \
+                                               ctr, ...)                    \
+  static ::tensorflow::dfactory::Registrar<device_factory>                  \
+  INTERNAL_REGISTER_LOCAL_DEVICE_FACTORY_NAME(ctr)(device_type, ##__VA_ARGS__)
+
+// __COUNTER__ must go through another macro to be properly expanded
+#define INTERNAL_REGISTER_LOCAL_DEVICE_FACTORY_NAME(ctr) ___##ctr##__object_
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_DEVICE_FACTORY_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/full_type.pb.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/full_type.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..2ccc5310fc2bd660dafb5747f482d5ec8c84743f
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/full_type.pb.h
@@ -0,0 +1,553 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: tensorflow/core/framework/full_type.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2ffull_5ftype_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2ffull_5ftype_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3021000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3021009 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_tensorflow_2fcore_2fframework_2ffull_5ftype_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_tensorflow_2fcore_2fframework_2ffull_5ftype_2eproto {
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_tensorflow_2fcore_2fframework_2ffull_5ftype_2eproto;
+namespace tensorflow {
+class FullTypeDef;
+struct FullTypeDefDefaultTypeInternal;
+extern FullTypeDefDefaultTypeInternal _FullTypeDef_default_instance_;
+}  // namespace tensorflow
+PROTOBUF_NAMESPACE_OPEN
+template<> ::tensorflow::FullTypeDef* Arena::CreateMaybeMessage<::tensorflow::FullTypeDef>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace tensorflow {
+
+enum FullTypeId : int {
+  TFT_UNSET = 0,
+  TFT_VAR = 1,
+  TFT_ANY = 2,
+  TFT_PRODUCT = 3,
+  TFT_NAMED = 4,
+  TFT_FOR_EACH = 20,
+  TFT_CALLABLE = 100,
+  TFT_TENSOR = 1000,
+  TFT_ARRAY = 1001,
+  TFT_OPTIONAL = 1002,
+  TFT_LITERAL = 1003,
+  TFT_ENCODED = 1004,
+  TFT_SHAPE_TENSOR = 1005,
+  TFT_BOOL = 200,
+  TFT_UINT8 = 201,
+  TFT_UINT16 = 202,
+  TFT_UINT32 = 203,
+  TFT_UINT64 = 204,
+  TFT_INT8 = 205,
+  TFT_INT16 = 206,
+  TFT_INT32 = 207,
+  TFT_INT64 = 208,
+  TFT_HALF = 209,
+  TFT_FLOAT = 210,
+  TFT_DOUBLE = 211,
+  TFT_BFLOAT16 = 215,
+  TFT_COMPLEX64 = 212,
+  TFT_COMPLEX128 = 213,
+  TFT_STRING = 214,
+  TFT_DATASET = 10102,
+  TFT_RAGGED = 10103,
+  TFT_ITERATOR = 10104,
+  TFT_MUTEX_LOCK = 10202,
+  TFT_LEGACY_VARIANT = 10203,
+  FullTypeId_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
+  FullTypeId_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
+};
+bool FullTypeId_IsValid(int value);
+constexpr FullTypeId FullTypeId_MIN = TFT_UNSET;
+constexpr FullTypeId FullTypeId_MAX = TFT_LEGACY_VARIANT;
+constexpr int FullTypeId_ARRAYSIZE = FullTypeId_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FullTypeId_descriptor();
+template<typename T>
+inline const std::string& FullTypeId_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, FullTypeId>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function FullTypeId_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    FullTypeId_descriptor(), enum_t_value);
+}
+inline bool FullTypeId_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FullTypeId* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<FullTypeId>(
+    FullTypeId_descriptor(), name, value);
+}
+// ===================================================================
+
+class FullTypeDef final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.FullTypeDef) */ {
+ public:
+  inline FullTypeDef() : FullTypeDef(nullptr) {}
+  ~FullTypeDef() override;
+  explicit PROTOBUF_CONSTEXPR FullTypeDef(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  FullTypeDef(const FullTypeDef& from);
+  FullTypeDef(FullTypeDef&& from) noexcept
+    : FullTypeDef() {
+    *this = ::std::move(from);
+  }
+
+  inline FullTypeDef& operator=(const FullTypeDef& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline FullTypeDef& operator=(FullTypeDef&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const FullTypeDef& default_instance() {
+    return *internal_default_instance();
+  }
+  enum AttrCase {
+    kS = 3,
+    kI = 4,
+    ATTR_NOT_SET = 0,
+  };
+
+  static inline const FullTypeDef* internal_default_instance() {
+    return reinterpret_cast<const FullTypeDef*>(
+               &_FullTypeDef_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(FullTypeDef& a, FullTypeDef& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(FullTypeDef* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(FullTypeDef* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  FullTypeDef* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<FullTypeDef>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const FullTypeDef& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const FullTypeDef& from) {
+    FullTypeDef::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(FullTypeDef* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.FullTypeDef";
+  }
+  protected:
+  explicit FullTypeDef(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kArgsFieldNumber = 2,
+    kTypeIdFieldNumber = 1,
+    kSFieldNumber = 3,
+    kIFieldNumber = 4,
+  };
+  // repeated .tensorflow.FullTypeDef args = 2;
+  int args_size() const;
+  private:
+  int _internal_args_size() const;
+  public:
+  void clear_args();
+  ::tensorflow::FullTypeDef* mutable_args(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::FullTypeDef >*
+      mutable_args();
+  private:
+  const ::tensorflow::FullTypeDef& _internal_args(int index) const;
+  ::tensorflow::FullTypeDef* _internal_add_args();
+  public:
+  const ::tensorflow::FullTypeDef& args(int index) const;
+  ::tensorflow::FullTypeDef* add_args();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::FullTypeDef >&
+      args() const;
+
+  // .tensorflow.FullTypeId type_id = 1;
+  void clear_type_id();
+  ::tensorflow::FullTypeId type_id() const;
+  void set_type_id(::tensorflow::FullTypeId value);
+  private:
+  ::tensorflow::FullTypeId _internal_type_id() const;
+  void _internal_set_type_id(::tensorflow::FullTypeId value);
+  public:
+
+  // string s = 3;
+  bool has_s() const;
+  private:
+  bool _internal_has_s() const;
+  public:
+  void clear_s();
+  const std::string& s() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_s(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_s();
+  PROTOBUF_NODISCARD std::string* release_s();
+  void set_allocated_s(std::string* s);
+  private:
+  const std::string& _internal_s() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_s(const std::string& value);
+  std::string* _internal_mutable_s();
+  public:
+
+  // int64 i = 4;
+  bool has_i() const;
+  private:
+  bool _internal_has_i() const;
+  public:
+  void clear_i();
+  int64_t i() const;
+  void set_i(int64_t value);
+  private:
+  int64_t _internal_i() const;
+  void _internal_set_i(int64_t value);
+  public:
+
+  void clear_attr();
+  AttrCase attr_case() const;
+  // @@protoc_insertion_point(class_scope:tensorflow.FullTypeDef)
+ private:
+  class _Internal;
+  void set_has_s();
+  void set_has_i();
+
+  inline bool has_attr() const;
+  inline void clear_has_attr();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::FullTypeDef > args_;
+    int type_id_;
+    union AttrUnion {
+      constexpr AttrUnion() : _constinit_{} {}
+        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr s_;
+      int64_t i_;
+    } attr_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    uint32_t _oneof_case_[1];
+
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2ffull_5ftype_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// FullTypeDef
+
+// .tensorflow.FullTypeId type_id = 1;
+inline void FullTypeDef::clear_type_id() {
+  _impl_.type_id_ = 0;
+}
+inline ::tensorflow::FullTypeId FullTypeDef::_internal_type_id() const {
+  return static_cast< ::tensorflow::FullTypeId >(_impl_.type_id_);
+}
+inline ::tensorflow::FullTypeId FullTypeDef::type_id() const {
+  // @@protoc_insertion_point(field_get:tensorflow.FullTypeDef.type_id)
+  return _internal_type_id();
+}
+inline void FullTypeDef::_internal_set_type_id(::tensorflow::FullTypeId value) {
+  
+  _impl_.type_id_ = value;
+}
+inline void FullTypeDef::set_type_id(::tensorflow::FullTypeId value) {
+  _internal_set_type_id(value);
+  // @@protoc_insertion_point(field_set:tensorflow.FullTypeDef.type_id)
+}
+
+// repeated .tensorflow.FullTypeDef args = 2;
+inline int FullTypeDef::_internal_args_size() const {
+  return _impl_.args_.size();
+}
+inline int FullTypeDef::args_size() const {
+  return _internal_args_size();
+}
+inline void FullTypeDef::clear_args() {
+  _impl_.args_.Clear();
+}
+inline ::tensorflow::FullTypeDef* FullTypeDef::mutable_args(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.FullTypeDef.args)
+  return _impl_.args_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::FullTypeDef >*
+FullTypeDef::mutable_args() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.FullTypeDef.args)
+  return &_impl_.args_;
+}
+inline const ::tensorflow::FullTypeDef& FullTypeDef::_internal_args(int index) const {
+  return _impl_.args_.Get(index);
+}
+inline const ::tensorflow::FullTypeDef& FullTypeDef::args(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.FullTypeDef.args)
+  return _internal_args(index);
+}
+inline ::tensorflow::FullTypeDef* FullTypeDef::_internal_add_args() {
+  return _impl_.args_.Add();
+}
+inline ::tensorflow::FullTypeDef* FullTypeDef::add_args() {
+  ::tensorflow::FullTypeDef* _add = _internal_add_args();
+  // @@protoc_insertion_point(field_add:tensorflow.FullTypeDef.args)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::FullTypeDef >&
+FullTypeDef::args() const {
+  // @@protoc_insertion_point(field_list:tensorflow.FullTypeDef.args)
+  return _impl_.args_;
+}
+
+// string s = 3;
+inline bool FullTypeDef::_internal_has_s() const {
+  return attr_case() == kS;
+}
+inline bool FullTypeDef::has_s() const {
+  return _internal_has_s();
+}
+inline void FullTypeDef::set_has_s() {
+  _impl_._oneof_case_[0] = kS;
+}
+inline void FullTypeDef::clear_s() {
+  if (_internal_has_s()) {
+    _impl_.attr_.s_.Destroy();
+    clear_has_attr();
+  }
+}
+inline const std::string& FullTypeDef::s() const {
+  // @@protoc_insertion_point(field_get:tensorflow.FullTypeDef.s)
+  return _internal_s();
+}
+template <typename ArgT0, typename... ArgT>
+inline void FullTypeDef::set_s(ArgT0&& arg0, ArgT... args) {
+  if (!_internal_has_s()) {
+    clear_attr();
+    set_has_s();
+    _impl_.attr_.s_.InitDefault();
+  }
+  _impl_.attr_.s_.Set( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.FullTypeDef.s)
+}
+inline std::string* FullTypeDef::mutable_s() {
+  std::string* _s = _internal_mutable_s();
+  // @@protoc_insertion_point(field_mutable:tensorflow.FullTypeDef.s)
+  return _s;
+}
+inline const std::string& FullTypeDef::_internal_s() const {
+  if (_internal_has_s()) {
+    return _impl_.attr_.s_.Get();
+  }
+  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void FullTypeDef::_internal_set_s(const std::string& value) {
+  if (!_internal_has_s()) {
+    clear_attr();
+    set_has_s();
+    _impl_.attr_.s_.InitDefault();
+  }
+  _impl_.attr_.s_.Set(value, GetArenaForAllocation());
+}
+inline std::string* FullTypeDef::_internal_mutable_s() {
+  if (!_internal_has_s()) {
+    clear_attr();
+    set_has_s();
+    _impl_.attr_.s_.InitDefault();
+  }
+  return _impl_.attr_.s_.Mutable(      GetArenaForAllocation());
+}
+inline std::string* FullTypeDef::release_s() {
+  // @@protoc_insertion_point(field_release:tensorflow.FullTypeDef.s)
+  if (_internal_has_s()) {
+    clear_has_attr();
+    return _impl_.attr_.s_.Release();
+  } else {
+    return nullptr;
+  }
+}
+inline void FullTypeDef::set_allocated_s(std::string* s) {
+  if (has_attr()) {
+    clear_attr();
+  }
+  if (s != nullptr) {
+    set_has_s();
+    _impl_.attr_.s_.InitAllocated(s, GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.FullTypeDef.s)
+}
+
+// int64 i = 4;
+inline bool FullTypeDef::_internal_has_i() const {
+  return attr_case() == kI;
+}
+inline bool FullTypeDef::has_i() const {
+  return _internal_has_i();
+}
+inline void FullTypeDef::set_has_i() {
+  _impl_._oneof_case_[0] = kI;
+}
+inline void FullTypeDef::clear_i() {
+  if (_internal_has_i()) {
+    _impl_.attr_.i_ = int64_t{0};
+    clear_has_attr();
+  }
+}
+inline int64_t FullTypeDef::_internal_i() const {
+  if (_internal_has_i()) {
+    return _impl_.attr_.i_;
+  }
+  return int64_t{0};
+}
+inline void FullTypeDef::_internal_set_i(int64_t value) {
+  if (!_internal_has_i()) {
+    clear_attr();
+    set_has_i();
+  }
+  _impl_.attr_.i_ = value;
+}
+inline int64_t FullTypeDef::i() const {
+  // @@protoc_insertion_point(field_get:tensorflow.FullTypeDef.i)
+  return _internal_i();
+}
+inline void FullTypeDef::set_i(int64_t value) {
+  _internal_set_i(value);
+  // @@protoc_insertion_point(field_set:tensorflow.FullTypeDef.i)
+}
+
+inline bool FullTypeDef::has_attr() const {
+  return attr_case() != ATTR_NOT_SET;
+}
+inline void FullTypeDef::clear_has_attr() {
+  _impl_._oneof_case_[0] = ATTR_NOT_SET;
+}
+inline FullTypeDef::AttrCase FullTypeDef::attr_case() const {
+  return FullTypeDef::AttrCase(_impl_._oneof_case_[0]);
+}
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace tensorflow
+
+PROTOBUF_NAMESPACE_OPEN
+
+template <> struct is_proto_enum< ::tensorflow::FullTypeId> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::tensorflow::FullTypeId>() {
+  return ::tensorflow::FullTypeId_descriptor();
+}
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2ffull_5ftype_2eproto
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/full_type.proto b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/full_type.proto
new file mode 100644
index 0000000000000000000000000000000000000000..19e8da5ab718063fdec499166ab8dc0986f4df37
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/full_type.proto
@@ -0,0 +1,310 @@
+syntax = "proto3";
+
+package tensorflow;
+
+option cc_enable_arenas = true;
+option java_outer_classname = "FullTypeProtos";
+option java_multiple_files = true;
+option java_package = "org.tensorflow.framework";
+option go_package = "github.com/tensorflow/tensorflow/tensorflow/go/core/framework/full_type_go_proto";
+
+// LINT.IfChange
+// Experimental. Represents the complete type information of a TensorFlow value.
+enum FullTypeId {
+  // The default represents an uninitialized values.
+  TFT_UNSET = 0;
+
+  // Type symbols. Used to construct more complex type expressions like
+  // algebraic data types.
+
+  // Type variables may serve as placeholder for any other type ID in type
+  // templates.
+  //
+  // Examples:
+  //   TFT_DATASET[TFT_VAR["T"]] is a Dataset returning a type indicated by "T".
+  //   TFT_TENSOR[TFT_VAR["T"]] is a Tensor of n element type indicated by "T".
+  //   TFT_TENSOR[TFT_VAR["T"]], TFT_TENSOR[TFT_VAR["T"]] are two tensors of
+  //     identical element types.
+  //   TFT_TENSOR[TFT_VAR["P"]], TFT_TENSOR[TFT_VAR["Q"]] are two tensors of
+  //     independent element types.
+  //
+  TFT_VAR = 1;
+
+  // Wildcard type. Describes a parameter of unknown type. In TensorFlow, that
+  // can mean either a "Top" type (accepts any type), or a dynamically typed
+  // object whose type is unknown in context.
+  // Important: "unknown" does not necessarily mean undeterminable!
+  TFT_ANY = 2;
+
+  // The algebraic product type. This is an algebraic type that may be used just
+  // for logical grouping. Not to confused with TFT_TUPLE which describes a
+  // concrete object of several elements.
+  //
+  // Example:
+  //   TFT_DATASET[TFT_PRODUCT[TFT_TENSOR[TFT_INT32], TFT_TENSOR[TFT_FLOAT64]]]
+  //     is a Dataset producing two tensors, an integer one and a float one.
+  //
+  TFT_PRODUCT = 3;
+
+  // Represents a named field, with the name stored in the attribute.
+  //
+  // Parametrization:
+  //   TFT_NAMED[<type>]{<name>}
+  //   * <type> is the type of the field
+  //   * <name> is the field name, as string (thpugh can theoretically be an int
+  //     as well)
+  //
+  // Example:
+  //   TFT_RECORD[
+  //     TFT_NAMED[TFT_TENSOR[TFT_INT32]]{'foo'},
+  //     TFT_NAMED[TFT_TENSOR[TFT_FLOAT32]]{'bar'},
+  //   ]
+  //     is a structure with two fields, an int tensor "foo" and a float tensor
+  //     "bar".
+  TFT_NAMED = 4;
+
+  // Template definition. Expands the variables by repeating a template as
+  // arguments of container.
+  //
+  // Parametrization:
+  //   TFT_FOR_EACH[<container_type>, <template>, <expansions>]
+  //   * <container_type> is the type of the container that the template will be
+  //     expanded into
+  //   * <template> is any type definition that potentially contains type
+  //     variables
+  //   * <expansions> is a TFT_VAR and may include more types in the future
+  //
+  // Example:
+  //   TFT_FOR_EACH[
+  //         TFT_PRODUCT,
+  //         TFT_TENSOR[TFT_VAR["t"]],
+  //         TFT_VAR["t"]
+  //     ]
+  //     will substitute a T = TFT_INT32 to TFT_PRODUCT[TFT_TENSOR[TFT_INT32]]
+  //     and a T = (TFT_INT32, TFT_INT64) to
+  //     TFT_PRODUCT[TFT_TENSOR[TFT_INT32], TFT_TENSOR[TFT_INT64]].
+  TFT_FOR_EACH = 20;
+
+  // Callable types describe functions and ops.
+  //
+  // Parametrization:
+  //   TFT_CALLABLE[<arg type>, <return type>]
+  //   * <arg type> is the type of the arguments; TFT_PRODUCT represents
+  //   multiple
+  //     arguments.
+  //   * <return type> is the return type; TFT_PRODUCT represents multiple
+  //     return values (that means that callables returning multiple things
+  //     don't necessarily return a single tuple).
+  //
+  // Example:
+  //   TFT_CALLABLE[
+  //     TFT_ANY,
+  //     TFT_PRODUCT[TFT_TENSOR[TFT_INT32], TFT_TENSOR[TFT_FLOAT64]],
+  //   ]
+  //     is a callable with unspecified (for now) input arguments, and
+  //     two return values of type tensor.
+  //
+  TFT_CALLABLE = 100;
+
+  // Concrete type IDs, representing "proper" data types that can describe
+  // runtime TensorFlow objects.
+
+  // The usual Tensor. This is a parametric type.
+  //
+  // Parametrization:
+  //   TFT_TENSOR[<element type>, <shape type>]
+  //   * <element type> is currently limited to one of the element types
+  //     defined below.
+  //   * <shape type> is not yet defined, and may only be TFT_UNKNOWN for now.
+  //
+  // A TFT_SHAPE type will be defined in the future.
+  //
+  // Example:
+  //   TFT_TENSOR[TFT_INT32, TFT_UNKNOWN]
+  //     is a Tensor of int32 element type and unknown shape.
+  //
+  // TODO(mdan): Define TFT_SHAPE and add more examples.
+  TFT_TENSOR = 1000;
+
+  // Array (or tensorflow::TensorList in the variant type registry).
+  // Note: this is not to be confused with the deprecated `TensorArray*` ops
+  // which are not supported by FullType.
+  // This type represents a random-access list whose elements can be
+  // described by a single type. Although immutable, Array is expected to
+  // support efficient mutation semantics (i.e. element update) in the
+  // user-facing API.
+  // The element type may be generic or even TFT_ANY for a heterogenous list.
+  //
+  // Parametrization:
+  //   TFT_ARRAY[<element type>]
+  //   * <element type> may be any concrete type.
+  //
+  // Examples:
+  //   TFT_ARRAY[TFT_TENSOR[TFT_INT32]] is a TensorArray holding int32 Tensors
+  //     of any shape.
+  //   TFT_ARRAY[TFT_TENSOR[TFT_UNKNOWN]] is a TensorArray holding Tensors of
+  //     mixed element types.
+  //   TFT_ARRAY[TFT_UNKNOWN] is a TensorArray holding any element type.
+  //   TFT_ARRAY[] is equivalent to TFT_ARRAY[TFT_UNKNOWN].
+  //   TFT_ARRAY[TFT_ARRAY[]] is an array or arrays (of unknown types).
+  TFT_ARRAY = 1001;
+
+  // Optional (or tensorflow::OptionalVariant in the variant type registry).
+  // This type represents a value that may either hold an element of a single
+  // specified type, or nothing at all.
+  //
+  // Parametrization:
+  //   TFT_OPTIONAL[<element type>]
+  //   * <element type> may be any concrete type.
+  //
+  // Examples:
+  //   TFT_OPTIONAL[TFT_TENSOR[TFT_INT32]] is an Optional holding an int32
+  //     Tensor of any shape.
+  TFT_OPTIONAL = 1002;
+
+  // Literal types describe compile-time constant values.
+  // Literal types may also participate in dependent types.
+  //
+  // Parametrization:
+  //   TFT_LITERAL[<value type>]{<value>}
+  //   * <value type> may be any concrete type compatible that can hold <value>
+  //   * <value> is the type's attribute, and holds the actual literal value
+  //
+  // Examples:
+  //   TFT_LITERAL[TFT_INT32]{1} is the compile-time constant 1.
+  TFT_LITERAL = 1003;
+
+  // Encoding types describe a value of a certain type, encoded as a different
+  // type.
+  //
+  // Parametrization:
+  //   TFT_ENCODED[<encoded type>, <encoding type>]
+  //   * <encoded type> may be any type
+  //   * <encoding type> may be any type
+  //
+  // Examples:
+  //   TFT_ENCODING[TFT_INT32, TFT_STRING] is an integer encoded as string.
+  TFT_ENCODED = 1004;
+
+  // The type of "shape tensors" where the runtime value is the shape of
+  // some tensor(s), i.e. the output of tf.shape.
+  // Shape tensors have special, host-only placement, in contrast to
+  // TFT_TENSOR[TFT_INT32] which is the type of a normal numeric tensor
+  // with no special placement.
+  //
+  // Examples:
+  //   TFT_SHAPE_TENSOR[TFT_INT32] is the most common
+  //   TFT_SHAPE_TENSOR[TFT_INT64] is also allowed
+  TFT_SHAPE_TENSOR = 1005;
+
+  // Type attributes. These always appear in the parametrization of a type,
+  // never alone. For example, there is no such thing as a "bool" TensorFlow
+  // object (for now).
+
+  // The bool element type.
+  // TODO(mdan): Quantized types, legacy representations (e.g. ref)
+  TFT_BOOL = 200;
+  // Integer element types.
+  TFT_UINT8 = 201;
+  TFT_UINT16 = 202;
+  TFT_UINT32 = 203;
+  TFT_UINT64 = 204;
+  TFT_INT8 = 205;
+  TFT_INT16 = 206;
+  TFT_INT32 = 207;
+  TFT_INT64 = 208;
+  // Floating-point element types.
+  TFT_HALF = 209;
+  TFT_FLOAT = 210;
+  TFT_DOUBLE = 211;
+  TFT_BFLOAT16 = 215;
+  // Complex element types.
+  // TODO(mdan): Represent as TFT_COMPLEX[TFT_DOUBLE] instead?
+  TFT_COMPLEX64 = 212;
+  TFT_COMPLEX128 = 213;
+  // The string element type.
+  TFT_STRING = 214;
+
+  // Other types that we don't know yet whether they will become part of the
+  // core type system or be consisdered third-party (and consequently moved to
+  // user-defined type mechanisms). Presently, they are effectively in the core
+  // type system, because key compilation passes like Placer account for their
+  // existence.
+
+  // Datasets created by tf.data ops and APIs. Datasets have generator/iterable
+  // semantics, that is, one can construct an iterator from them. Like
+  // Array, they are considered to return elements that can be described
+  // by a single type. Unlike Array, they do not support random access or
+  // mutation, and can potentially produce an infinite number of elements.
+  // A datasets can produce logical structures (e.g. multiple elements). This
+  // is expressed using TFT_PRODUCT.
+  //
+  //
+  // Parametrization: TFT_DATASET[<element type>].
+  //   * <element type> may be a concrete type or a type symbol. It represents
+  //     the data type of the elements produced by the dataset.
+  //
+  // Examples:
+  //   TFT_DATSET[TFT_TENSOR[TFT_INT32]] is a Dataset producing single int32
+  //     Tensors of unknown shape.
+  //   TFT_DATSET[TFT_PRODUCT[TFT_TENSOR[TFT_INT32], TFT_TENSOR[TFT_FLOAT32]] is
+  //     a Dataset producing pairs of Tensors, one integer and one float.
+  // Note: The high ID number is to prepare for the eventuality that Datasets
+  // will be supported by user types in the future.
+  TFT_DATASET = 10102;
+
+  // A ragged tensor created by tf.ragged ops and APIs.
+  //
+  // Parametrization: TFT_RAGGED[<element_type>].
+  TFT_RAGGED = 10103;
+
+  // Iterators created by tf.data ops and APIs. Very similar to Datasets, except
+  // they are mutable.
+  //
+  //
+  // Parametrization: TFT_ITERATOR[<element type>].
+  //   * <element type> may be a concrete type or a type symbol. It represents
+  //     the data type of the elements produced by the dataset.
+  TFT_ITERATOR = 10104;
+
+  // A mutex lock tensor, produced by tf.raw_ops.MutexLock.
+  // Unlike strict execution models, where ownership of a lock is denoted by
+  // "running after the lock has been acquired", in non-strict mode, lock
+  // ownership is in the true sense: "the op argument representing the lock is
+  // available".
+  // Mutex locks are the dynamic counterpart of control dependencies.
+  // TODO(mdan): Properly document this thing.
+  //
+  // Parametrization: TFT_MUTEX_LOCK[].
+  TFT_MUTEX_LOCK = 10202;
+
+  // The equivalent of a Tensor with DT_VARIANT dtype, kept here to simplify
+  // translation. This type should not normally appear after type inference.
+  // Note that LEGACY_VARIANT != ANY: TENSOR[INT32] is a subtype of ANY, but is
+  // not a subtype of LEGACY_VARIANT.
+  TFT_LEGACY_VARIANT = 10203;
+}
+
+// Highly experimental and very likely to change.
+// This encoding uses tags instead of dedicated messages for regularity. In
+// particular the encoding imposes no restrictions on what the parameters of any
+// type should be, which in particular needs to be true for type symbols.
+message FullTypeDef {
+  // The principal type represented by this object. This may be a concrete type
+  // (Tensor, Dataset) a type variable (used for dependent types) a type
+  // symbol (Any, Union). See FullTypeId for details.
+  FullTypeId type_id = 1;
+
+  repeated FullTypeDef args = 2;
+
+  // Literal values of this type object, if the type admits one.
+  // For example, a type variable admits a string attribute - its name.
+  // Shape-related types may admit int attributes - their static shape values.
+  // Fields for more data types to be added as needed.
+  oneof attr {
+    string s = 3;
+    int64 i = 4;
+    // TODO(mdan): list/tensor, map? Need to reconcile with TFT_RECORD, etc.
+  }
+}
+// LINT.ThenChange(../ir/types/attributes.td)
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/full_type_inference_util.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/full_type_inference_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..3117613bcd130ff0003de27cd4352d1afc1251c9
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/full_type_inference_util.h
@@ -0,0 +1,159 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_FULL_TYPE_INFERENCE_UTIL_H_
+#define TENSORFLOW_CORE_FRAMEWORK_FULL_TYPE_INFERENCE_UTIL_H_
+
+#include <functional>
+#include <string>
+#include <vector>
+
+#include "tensorflow/core/framework/full_type.pb.h"
+#include "tensorflow/core/framework/op_def_builder.h"
+#include "tensorflow/core/platform/statusor.h"
+
+namespace tensorflow {
+
+namespace full_type {
+
+// TODO(mdan): Specific helpers won't get too far. Use a parser instead.
+
+// Helpers that allow shorthand expression for the more common kinds of type
+// inference functions.
+// TODO(mdan): Break into separate header if it grows.
+// Note: The information contained in these functions is also expressed to some
+// extent by opdef attributes of the kind "input: T, output T". But in that
+// context, T has strong DType semantics (i.e. T is DT_VARIANT for most
+// interesting cases). The logic here extends to the op's FullType, so it's best
+// to keep them separate, even though it leads to some redundancy. The
+// same can be said about the shape inference function.
+
+// Note: Unlike type constructors, which describe op definitions, type inference
+// functions are meant to modify the type information of specific nodes (i.e.
+// NodeDef proto).
+
+// Helper for a no-op type inference function that indicates type inference
+// should never alter the node's existing type.
+// This is the same as not defining a type inference function at all, but
+// explicitly communicates that intent.
+TypeInferenceFn KeepExisting();
+
+// A helper for a type inference function that indicates a single output that
+// is a tensor of type t. This is the equivalent of a type construtor since it
+// does not depend on inputs. This can be used with Tuple.
+TypeInferenceFn Tensor(FullTypeId t);
+
+// Helper for a type inference function which has the same type as the i'th
+// input.
+// The n arg allows multiple outputs, e.g. (T -> Product[T, T]).
+// TODO(mdan): Drop defaults for readability if more non-(0, 1) cases appear.
+// TODO(mdan): Rename to just Replicate.
+TypeInferenceFn ReplicateInput(int i = 0, int n = 1);
+
+// Helper for a type inference function which has the same type as a variadic
+// number of inputs, e.g. (T, T -> Product[T]), (T, T, T -> Product[T]), etc.
+// Infers the meet of the input types, in the sense of type meets (see
+// https://en.wikipedia.org/wiki/Join_and_meet). This implementation is
+// simplified to require the two inputs are a subtype of another.
+TypeInferenceFn Merge();
+
+// Helper for ops with semantics of encoding an input, that is,
+// `T -> Encoded[T, <t>]`, where <t> is the encoded type.
+TypeInferenceFn Encode(FullTypeId t, int i);
+
+// Helper for ops with semantics of encoding an input, that is,
+// `Encoded[T, <t>] -> T`, where <t> is the encoded type.
+TypeInferenceFn Decode(FullTypeId t, int i);
+
+// Helper for the type inference counterpart of Unary, that is (U ->
+// PRODUCT[<t>[U]]), where <t> is parameterized by this factory, and U is the
+// type of the input specified by element_idx.
+// Note: when we migrate to a more formal type definition of an op, these two
+// functions will naturally merge.
+TypeInferenceFn UnaryContainerCreate(FullTypeId t, int element_idx);
+
+// Helper for ops with semantics of adding an element to a container (<t>[T]),
+// that is (<t>[U], V -> PRODUCT[<t>[Union[U, V]]]), where <t> is parameterized
+// by this factory, U is the type of the input specified by container_idx, and V
+// is the type of the input specified by element_idx. The homogeneous arg allows
+// for constraints which guarantee that U and V must have a subtyping
+// relationship, case in which either V or U is selected, whichever is the
+// supertype.
+TypeInferenceFn UnaryContainerAdd(FullTypeId t, int container_idx,
+                                  int element_idx, bool homogeneous);
+
+// Helper for ops with semantics of unstacking multiple inputs into a container
+// `<t>[T1, ..., Tn]`, that is `T1, ..., Tn -> <t>[PRODUCT[U1, ..., Un]]`
+// where Ui is obtained from an "unstack" mapping T -> U. Both <t> and the
+// "unstack" mapping are parameterized by this factory.
+// Note that when the "unstack" function is the identity function, this becomes
+// equivalent to ContainerCreate.
+TypeInferenceFn MultiaryUnstack(
+    FullTypeId t, std::function<FullTypeDef(const FullTypeDef&)> unstack);
+
+// Helper for ops with semantics of applying some transformation to the
+// elements of a container:
+// `<t>[PRODUCT[T1, ..., Tn]] -> <t>[PRODUCT[U1, ..., Un]]`,
+// where Ui is obtained by applying a map T -> U. Both <t> and the "map"
+// function are parameterized by this factory. See BatchTensor and ShardTensor
+// for examples of "map".
+TypeInferenceFn ContainerMap(
+    FullTypeId t, int input_idx,
+    std::function<FullTypeDef(const FullTypeDef&)> map);
+
+// Helper for ops with semantics of repacking some element from a container to
+// another `<t> -> <u>`, in a covariant way, that is, `<t>[T] -> <u>[T]`. <t>
+// and <u> are parameterized by this factory. The input type is specified by
+// element_idx.
+TypeInferenceFn MapCovariant(FullTypeId t, FullTypeId u, int input_idx);
+
+// Helper for ops with semantics of calling a function. The function is
+// specified indirectly, as the name of an attribute that holds the actual
+// function name.
+TypeInferenceFn FunctionCall(const string& func_attr_name);
+
+// Compose the type of a function by concatenating the outputs of multiple
+// type inference functions. If func_list is {type inference function 1, type
+// inference function 2} which return PRODUCT[T1], PRODUCT[T2] resprectively,
+// the result is PRODUCT[T1, T2], This supports the Merge op that has an index
+// output in addition to the result of the Merge type inference function.
+TypeInferenceFn Tuple(const std::vector<TypeInferenceFn>& func_list);
+
+// Auxiliary constructs to help creation of type inference functions.
+// TODO(mdan): define these as type inference functions as well.
+
+// Mapping function representing the type function for unstacking of
+// Tensor (or Tensor-like) types. Note that this is a helper to use with
+// other type inference functions; it's not a function itself.
+// TODO(mdan): Replace with a trait, when available.
+FullTypeDef UnstackTensor(const FullTypeDef& t);
+
+// Mapping function representing the type function for an op that changes the
+// batch size of dataset. Note that this is a helper to use with other type
+// inference functions; it's not a function itself.
+// TODO(mdan): Replace with a trait, when available.
+FullTypeDef BatchTensor(const FullTypeDef& t);
+
+// Mapping function representing the type function for an op that creates a
+// fixed (given) number of tensors of a size calculated based on the input. Note
+// that this is a helper to use with other type inference functions; it's not a
+// function itself.
+// TODO(mdan): Replace with a trait, when available.
+FullTypeDef ShardTensor(const FullTypeDef& t);
+}  // namespace full_type
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_FULL_TYPE_INFERENCE_UTIL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/full_type_util.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/full_type_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..27d10e81d8d99074a8be057d91ae2672ee1a5bf8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/full_type_util.h
@@ -0,0 +1,130 @@
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_FULL_TYPE_UTIL_H_
+#define TENSORFLOW_CORE_FRAMEWORK_FULL_TYPE_UTIL_H_
+
+#include <functional>
+#include <string>
+
+#include "tensorflow/core/framework/full_type.pb.h"
+#include "tensorflow/core/framework/node_def.pb.h"
+#include "tensorflow/core/framework/node_def_util.h"
+#include "tensorflow/core/framework/op_def.pb.h"
+#include "tensorflow/core/framework/op_def_builder.h"
+#include "tensorflow/core/platform/statusor.h"
+
+namespace tensorflow {
+
+namespace full_type {
+
+// TODO(mdan): Specific helpers won't get too far. Use a parser instead.
+// TODO(mdan): Move constructors into a separate file.
+
+// Helpers that allow shorthand expression for the more common kinds of type
+// constructors.
+// Note: The arity below refers to the number of arguments of parametric types,
+// not to the number of return values from a particular op.
+// Note: Type constructors are meant to create static type definitions in the
+// op definition (i.e. the OpDef proto).
+
+// Helper for a no-op type constructor that indicates that the node's type
+// should be set by external means (typically by the user).
+OpTypeConstructor NoOp();
+
+// Helper for a trivial type constructor that indicates a node has no
+// outputs (that is, its output type is an empty TFT_PRODUCT).
+OpTypeConstructor NoOutputs();
+
+// Helper for a type constructor of <t>[] (with no parameters).
+OpTypeConstructor Nullary(FullTypeId t);
+
+// Helper for a type constructor of <t>[FT_VAR[<var_name>]].
+OpTypeConstructor Unary(FullTypeId t, const string& var_name);
+
+// Helper for a type constructor of <t>[FT_ANY].
+OpTypeConstructor UnaryGeneric(FullTypeId t);
+
+// Helper for a type constructor of <t>[FT_TENSOR[<dtype>]].
+OpTypeConstructor UnaryTensorContainer(FullTypeId t, FullTypeId dtype);
+
+// Helper for a type constructor of <t>[FT_VAR[<var_name>]].
+OpTypeConstructor UnaryTensorContainer(FullTypeId t, const string& var_name);
+
+// Helper for a type constructor of
+// <t>[FT_FOR_EACH[
+//     FT_PRODUCT,
+//     FT_TENSOR[FT_VAR[<var_name>]],
+//     FT_VAR[<var_name>]].
+// Multi-valued type variables will expand the template (see full_type.proto).
+OpTypeConstructor VariadicTensorContainer(FullTypeId t, const string& var_name);
+
+// Type specialization and inference logic. This function narrows the type
+// specified in an op definition. Such types are usually generic and dependent
+// on input types. This function resolves the output types based on the input
+// types specified in a given node def.
+Status SpecializeType(const AttrSlice& attrs, const OpDef& op_def,
+                      FullTypeDef& target);
+
+const FullTypeDef& GetArgDefaultUnset(const FullTypeDef& t, int i);
+const FullTypeDef& GetArgDefaultAny(const FullTypeDef& t, int i);
+
+bool IsEqual(const FullTypeDef& lhs, const FullTypeDef& rhs);
+
+bool IsSubtype(const FullTypeDef& lhs, const FullTypeDef& rhs,
+               bool covariant = true);
+
+uint64_t Hash(const FullTypeDef& arg);
+
+// Determine if the given fulltype is a host memory type.
+// While it is prefered that Placer (placer.cc and colocation_graph.cc) make
+// all host memory type placement decisions, any decision made elsewhere
+// should use this function (e.g. instead of assuming that all variants never
+// contain host memory types).
+inline bool IsHostMemoryType(const FullTypeDef& t) {
+  switch (t.type_id()) {
+    case TFT_TENSOR:
+      return IsHostMemoryType(full_type::GetArgDefaultAny(t, 0));
+    case TFT_ARRAY:
+      return IsHostMemoryType(full_type::GetArgDefaultAny(t, 0));
+    case TFT_DATASET:
+      return true;
+    case TFT_MUTEX_LOCK:
+      return true;
+    case TFT_RAGGED:
+      return IsHostMemoryType(full_type::GetArgDefaultAny(t, 0));
+    case TFT_STRING:
+      return true;
+    case TFT_ITERATOR:
+      return IsHostMemoryType(full_type::GetArgDefaultAny(t, 0));
+    case TFT_OPTIONAL:
+      return IsHostMemoryType(full_type::GetArgDefaultAny(t, 0));
+    case TFT_PRODUCT:
+      for (int i = 0; i < t.args_size(); i++) {
+        if (IsHostMemoryType(full_type::GetArgDefaultAny(t, i))) {
+          return true;
+        }
+      }
+      return false;
+    default:
+      return false;
+  }
+}
+
+}  // namespace full_type
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_FULL_TYPE_UTIL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/function.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/function.h
new file mode 100644
index 0000000000000000000000000000000000000000..6502a413298de8dd6bb8221615c72cad4ed402b2
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/function.h
@@ -0,0 +1,1213 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_FUNCTION_H_
+#define TENSORFLOW_CORE_FRAMEWORK_FUNCTION_H_
+
+#include <memory>
+#include <unordered_map>
+#include <vector>
+
+// clang-format off
+// Required for IS_MOBILE_PLATFORM
+#include "tensorflow/core/framework/graph_debug_info.pb.h"
+#include "tensorflow/core/framework/op_def_builder.h"
+#include "tensorflow/core/platform/platform.h"
+// clang-format on
+
+#include "absl/container/flat_hash_map.h"
+#include "absl/types/optional.h"
+#include "absl/types/variant.h"
+#include "tensorflow/core/framework/attr_value.pb.h"
+#include "tensorflow/core/framework/attr_value_util.h"
+#include "tensorflow/core/framework/cancellation.h"
+#include "tensorflow/core/framework/function.pb.h"
+#include "tensorflow/core/framework/node_def_util.h"
+#include "tensorflow/core/framework/op.h"
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/optimized_function_graph.pb.h"
+#include "tensorflow/core/framework/registration/registration.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/graph/graph_debug_info_builder.h"
+#include "tensorflow/core/platform/env.h"
+#include "tensorflow/core/platform/macros.h"
+#include "tensorflow/core/platform/mutex.h"
+#include "tensorflow/core/platform/protobuf.h"
+#include "tensorflow/core/platform/random.h"
+#include "tensorflow/core/platform/stack_frame.h"
+#include "tensorflow/core/platform/threadpool_interface.h"
+#include "tensorflow/core/protobuf/config.pb.h"
+#include "tsl/protobuf/error_codes.pb.h"
+#if !defined(IS_MOBILE_PLATFORM)
+#include "tensorflow/core/protobuf/remote_tensor_handle.pb.h"
+#endif  // IS_MOBILE_PLATFORM
+
+namespace tensorflow {
+
+class CollectiveExecutor;
+class DeviceSet;
+class Graph;
+class GraphDef;
+class OpKernel;
+class ProcessFunctionLibraryRuntime;
+class ResourceMgr;
+class Rendezvous;
+class ScopedStepContainer;
+class StepStatsCollectorInterface;
+class Node;
+
+// FunctionDefHelper::Create is a convenient helper to construct a
+// FunctionDef proto.
+// E.g.,
+//   FunctionDef my_func = FunctionDefHelper::Create(
+//     "my_func_name",
+//     {"x:T", "y:T" /* one string per argument */},
+//     {"z:T" /* one string per return value */},
+//     {"T: {float, double}" /* one string per attribute  */},
+//     {
+//        {{"o"}, "Mul", {"x", "y"}, {{"T", "$T"}}}
+//        /* one entry per function node */
+//     },
+//     /* Mapping between function returns and function node outputs. */
+//     {{"z", "o:z"}});
+//
+// For the old Function::Node approach, use FunctionDefHelper::Define()
+// E.g.,
+//   FunctionDef my_func = FunctionDefHelper::Define(
+//     "my_func_name",
+//     {"x:T", "y:T" /* one string per argument */},
+//     {"z:T" /* one string per return value */},
+//     {"T: {float, double}" /* one string per attribute  */},
+//     {
+//        {{"z"}, "Mul", {"x", "y"}, {{"T", "$T"}}}
+//        /* one entry per function node */
+//     });
+class FunctionDefHelper {
+ public:
+  // AttrValueWrapper has copy constructors for the type T so that
+  // it's easy to construct a simple AttrValue proto.
+  //
+  // If T is a string type (const char*, string, or StringPiece), and
+  // it starts with "$", we construct a AttrValue of "placeholder".
+  //
+  // E.g.,
+  //   std::<string, AttrValueWrapper> x = {"T", "$T"}
+  // is a named attr value placeholder.
+  struct AttrValueWrapper {
+    AttrValue proto;
+
+    AttrValueWrapper() {}
+
+    template <typename T>
+    AttrValueWrapper(T val) {  // NOLINT(runtime/explicit)
+      SetAttrValue(val, &proto);
+    }
+
+   private:
+    void InitFromString(StringPiece val);
+  };
+
+  // Constructs an AttrValue.func given the "name" and "attrs".
+  static AttrValueWrapper FunctionRef(
+      const std::string& name,
+      gtl::ArraySlice<std::pair<string, AttrValueWrapper>> attrs);
+  static AttrValueWrapper FunctionRef(const std::string& name) {
+    return FunctionRef(name, {});
+  }
+
+  // Node is used to construct FunctionDef.Node using initialization
+  // lists. E.g.,
+  //  Node n = {{"z"}, "Mul", {"x", "y"}, {{"T", "$T"}}};  // z = x * y
+  //
+  // If the op has no inputs, then name is be specified.
+  //  Node n = {{}, "AssignVariable", {"resource", "val"}, {{"dtype",
+  //  "DT_FLOAT"},
+  //            {"update0"}, "CPU:0", "update1"}}
+  struct Node {
+    // When constructing a NodeDef, the first entry in ret is used as
+    // the node name, the remaining values are ignored.
+    std::vector<string> ret;
+    std::string op;
+    std::vector<string> arg;
+    std::vector<std::pair<string, AttrValueWrapper>> attr;
+    std::vector<string> dep;
+    std::string device;
+
+    // Required if the op has zero outputs. Otherwise, ret[0] used as name if
+    // name is left empty.
+    std::string name;
+
+    std::string GetName() const {
+      if (!name.empty()) return name;
+      CHECK(!ret.empty());
+      return ret[0];
+    }
+    std::vector<string> original_node_names;
+    std::vector<string> original_func_names;
+
+    NodeDef ToNodeDef() const;
+  };
+
+  // Creates a FunctionDef from the given parameters. Node inputs must use
+  // function encoding (node_name:output_name[:output_index]).
+  // - `ret_def` holds a mapping from the function output names from `out_def`
+  //   to the node outputs from `node_def`.
+  // - `control_ret_def` holds a mapping from the function control
+  //   output names to the nodes from `node_def`.
+  static FunctionDef Create(
+      const std::string& function_name, gtl::ArraySlice<string> in_def,
+      gtl::ArraySlice<string> out_def, gtl::ArraySlice<string> attr_def,
+      gtl::ArraySlice<Node> node_def,
+      gtl::ArraySlice<std::pair<string, string>> ret_def,
+      gtl::ArraySlice<std::pair<string, string>> control_ret_def);
+
+  // Creates a FunctionDef from the given parameters. Node inputs must use
+  // function encoding (node_name:output_name[:output_index]).
+  // - `ret_def` holds a mapping from the function output names from `out_def`
+  //   to the node outputs from `node_def`.
+  static FunctionDef Create(const std::string& function_name,
+                            gtl::ArraySlice<string> in_def,
+                            gtl::ArraySlice<string> out_def,
+                            gtl::ArraySlice<string> attr_def,
+                            gtl::ArraySlice<Node> node_def,
+                            gtl::ArraySlice<std::pair<string, string>> ret_def);
+
+  // TODO(josh11b): Get rid of these and transition to the one above.
+  static FunctionDef Define(const std::string& function_name,
+                            gtl::ArraySlice<string> arg_def,
+                            gtl::ArraySlice<string> ret_def,
+                            gtl::ArraySlice<string> attr_def,
+                            gtl::ArraySlice<Node> node_def);
+
+  // Defines an anonymous function. I.e., its name is not relevant.
+  static FunctionDef Define(gtl::ArraySlice<string> arg_def,
+                            gtl::ArraySlice<string> ret_def,
+                            gtl::ArraySlice<string> attr_def,
+                            gtl::ArraySlice<Node> node_def);
+
+  // Helpers to construct a constant scalar.
+  template <typename T>
+  static Node Const(const std::string& name, const T& val) {
+    Node n = {{name}, "Const"};
+    const DataType dtype = DataTypeToEnum<T>::value;
+    n.attr.push_back({"dtype", dtype});
+    Tensor t(dtype, TensorShape({}));
+    t.scalar<T>()() = val;
+    n.attr.push_back({"value", t});
+    return n;
+  }
+
+  template <typename T>
+  static Node Const(const std::string& name, gtl::ArraySlice<T> vals) {
+    Node n = {{name}, "Const"};
+    const DataType dtype = DataTypeToEnum<T>::value;
+    n.attr.push_back({"dtype", dtype});
+    int64_t num = vals.size();
+    Tensor t(dtype, TensorShape({num}));
+    for (size_t i = 0; i < vals.size(); ++i) {
+      t.flat<T>()(i) = vals[i];
+    }
+    n.attr.push_back({"value", t});
+    return n;
+  }
+};
+
+template <>
+inline FunctionDefHelper::AttrValueWrapper::AttrValueWrapper(const char* val) {
+  InitFromString(val);
+}
+
+template <>
+inline FunctionDefHelper::AttrValueWrapper::AttrValueWrapper(
+    const std::string& val) {
+  InitFromString(val);
+}
+
+template <>
+inline FunctionDefHelper::AttrValueWrapper::AttrValueWrapper(StringPiece val) {
+  InitFromString(val);
+}
+
+// Instantiate a function.
+//
+// "fdef" encodes a TF function with some attrs in fdef.signature.attr
+// containing placeholders.  InstantiateFunction binds these
+// placeholders and produces an instantiated function encoded in
+// "result.gdef". The value to substitute a placeholder is given by
+// "attr_values", which is a map from a placeholder name to an attr
+// value.
+//
+// InstantiateFunction calls "get_function" to find signatures of other
+// functions and primitive ops.
+
+// GetFunctionSignature(func name, opdef) returns OK if the func name is found
+// and opdef is filled with a pointer to the corresponding signature
+// (a OpDef proto). Otherwise, returns an error.
+typedef std::function<Status(const string&, const OpDef**)>
+    GetFunctionSignature;
+
+struct InstantiationResult {
+  DataTypeVector arg_types;
+  DataTypeVector ret_types;
+  std::vector<NodeDef> nodes;
+};
+Status InstantiateFunction(const FunctionDef& fdef, AttrSlice attr_values,
+                           GetFunctionSignature get_function,
+                           InstantiationResult* result);
+
+// Returns a debug string for a function definition.
+//
+// The returned text is multiple-line. It is intended to be
+// human-readable rather than being friendly to parsers. It is _NOT_
+// intended to be the canonical string representation of "func_def".
+// Particularly, it may not include all information presented in
+// "func_def" (e.g., comments, description of the function arguments,
+// etc.)
+std::string DebugString(const FunctionDef& func_def);
+std::string DebugString(const GraphDef& instantiated_func_def);
+std::string DebugString(gtl::ArraySlice<NodeDef> instantiated_func_nodes);
+
+// Returns a debug string for a top level graph (the main program and
+// its supporting functions defined in its library).
+std::string DebugStringWhole(const GraphDef& gdef);
+
+// Returns true if f1 == f2. Compares all fields, including descriptions. Order
+// of NodeDefs doesn't matter.
+bool FunctionDefsEqual(const FunctionDef& f1, const FunctionDef& f2);
+
+// Return a hash of `fdef` that is consistent with FunctionDefsEqual method.
+// In other words, if two fdefs compare equal, their hash values will be the
+// same.
+uint64 FunctionDefHash(const FunctionDef& fdef);
+
+class CallFrameInterface {
+ public:
+  virtual ~CallFrameInterface() {}
+
+  virtual size_t num_args() const = 0;
+  virtual size_t num_retvals() const = 0;
+
+  virtual Status GetArg(int index, const Tensor** val) = 0;
+
+  // Optimized implementation of `GetArg()` that allows the caller to take
+  // ownership of the tensor. This method may only be called once per
+  // value of `index` and `CallFrameInterface` instance.
+  //
+  // REQUIRES: `this->CanConsumeArg(index) == true`.
+  virtual void ConsumeArg(int index, Tensor* val) {
+    LOG(ERROR) << "This `CallFrameInterface` implementation does not support "
+                  "consuming arguments.";
+  }
+  virtual bool CanConsumeArg(int index) const { return false; }
+
+  virtual Status SetRetval(int index, const Tensor& val) = 0;
+};
+
+// Represents a function call frame. I.e., the data structure used to
+// pass arguments to a function and retrieve its results.
+//
+// Runtime must arrange accesses to one FunctionCallFrame s.t.
+//   1. SetArgs() happens before any GetArg();
+//   2. GetRetvals happens after all SetRetval();
+class FunctionCallFrame : public CallFrameInterface {
+ public:
+  FunctionCallFrame(DataTypeSlice arg_types, DataTypeSlice ret_types);
+  ~FunctionCallFrame() override;
+
+  // Caller methods.
+  Status SetArgs(gtl::ArraySlice<Tensor> args);
+  Status GetRetvals(std::vector<Tensor>* rets) const;
+
+  // Moves the return values from the frame to rets. If allow_dead_tensors is
+  // false it will fail if any of the retvals do not have a value.
+  Status ConsumeRetvals(std::vector<Tensor>* rets, bool allow_dead_tensors);
+
+  size_t num_args() const override { return arg_types_.size(); }
+  size_t num_retvals() const override { return ret_types_.size(); }
+
+  // Callee methods.
+  Status GetArg(int index, const Tensor** val) override;
+  Status SetRetval(int index, const Tensor& val) override;
+
+ private:
+  DataTypeVector arg_types_;
+  DataTypeVector ret_types_;
+  gtl::InlinedVector<Tensor, 4> args_;
+  struct Retval {
+    bool has_val = false;
+    Tensor val;
+  };
+  gtl::InlinedVector<Retval, 4> rets_;
+
+  FunctionCallFrame(const FunctionCallFrame&) = delete;
+  void operator=(const FunctionCallFrame&) = delete;
+};
+
+// Map of function names to StackTracesMaps.
+using FunctionDefLibraryStackTraces =
+    absl::flat_hash_map<std::string, StackTracesMap>;
+
+// Holds Function information that can be shared in multiple places.
+// FunctionRecord must be explicitly finalized before being saved in
+// FunctionLibraryDefinition or any other place that expects immutability.
+class FunctionRecord : public core::RefCounted {
+ public:
+  FunctionRecord(const FunctionDef& fdef, const StackTracesMap& stack_traces,
+                 bool finalized);
+  FunctionRecord(FunctionDef&& fdef, StackTracesMap&& stack_traces,
+                 bool finalized);
+
+  // Mark FunctionRecord as finalized (disable mutation).
+  void finalize();
+
+  // Get a mutable reference to the FunctionDef owned by the record.
+  // Will fail if record is finalized.
+  StatusOr<FunctionDef*> mutable_fdef();
+
+  // Get an immutable access to FunctionRecord properties.
+  const FunctionDef& fdef() const;
+  const StackTracesMap& stack_traces() const;
+  const OpRegistrationData& op_registration_data() const;
+  const bool finalized() const;
+
+ private:
+  bool finalized_ = false;
+
+  FunctionDef fdef_;
+  const StackTracesMap stack_traces_;
+  const OpRegistrationData op_registration_data_;
+};
+
+// Helper to maintain a map between function names in a given
+// FunctionDefLibrary and function definitions.
+//
+// This class is thread-safe.
+class FunctionLibraryDefinition : public OpRegistryInterface {
+ public:
+  // Ops created for function arguments bear the name given by `kArgOp`; those
+  // created for return values bear the name given by `kRetOp`.
+  static constexpr const char* const kArgOp = "_Arg";
+  static constexpr const char* const kDeviceArgOp = "_DeviceArg";
+  static constexpr const char* const kRetOp = "_Retval";
+  static constexpr const char* const kDeviceRetOp = "_DeviceRetval";
+  static constexpr const char* const kIntsOnDeviceAttr =
+      "experimental_ints_on_device";
+  static constexpr const char* const kSharedRendezvousAttr =
+      "shared_rendezvous";
+
+  static constexpr const char* const kGradientOp = "SymbolicGradient";
+  static constexpr const char* const kFuncAttr = "f";
+
+  // Note: This constructor grabs `lib_def`'s lock in shared mode.
+  FunctionLibraryDefinition(const FunctionLibraryDefinition& lib_def);
+  FunctionLibraryDefinition(const OpRegistryInterface* default_registry,
+                            const FunctionDefLibrary& lib_def = {});
+  ~FunctionLibraryDefinition() override;
+
+  FunctionLibraryDefinition& operator=(const FunctionLibraryDefinition&) =
+      delete;
+  FunctionLibraryDefinition& operator=(FunctionLibraryDefinition&& other);
+
+  // Returns True if the library contains `func`, False otherwise.
+  bool Contains(const std::string& func) const TF_LOCKS_EXCLUDED(mu_);
+
+  // Returns nullptr if "func" is not defined in "lib_def". Otherwise,
+  // returns its definition proto.
+  //
+  // NB: This function returns a borrowed pointer, which can be invalidated by a
+  // subsequent call to `ReplaceFunction()` with the given name.
+  const FunctionDef* Find(const std::string& func) const TF_LOCKS_EXCLUDED(mu_);
+
+  // Returns nullptr if "func" is not defined in "lib_def". Otherwise,
+  // returns a strong reference pointer to the FunctionRecord in the library.
+  core::RefCountPtr<FunctionRecord> FindRecord(const std::string& func) const
+      TF_LOCKS_EXCLUDED(mu_);
+
+  // Adds function definition 'fdef' to this function library.
+  // Returns status 'ok' on success, or error otherwise. This is a no-op if
+  // 'fdef' already exists in this function library.
+  // If 'fdef' is successfully added to the library, it will be accessible
+  // from 'LookUp' and included in the proto returned by 'ToProto'.
+  // This operation is atomic.
+  //
+  // Associates `graph` with a function `func_name`. Lifetime assumption:
+  // `graph` has to outlive all instantiated graphs.
+  Status AddFunctionDef(const FunctionDef& fdef,
+                        const StackTracesMap& stack_traces = {})
+      TF_LOCKS_EXCLUDED(mu_);
+
+  // Adds gradient definition 'grad' to this function library.
+  // This is a no-op if 'grad' already exists in this function library.
+  // If 'grad' is successfully added, it will be accessible via 'FindGradient'
+  // and included in the proto returned by 'ToProto'.
+  // This operation is atomic.
+  Status AddGradientDef(const GradientDef& grad) TF_LOCKS_EXCLUDED(mu_);
+
+  // Replaces the function corresponding to `func` with `fdef`. Returns
+  // a non-OK status if "func" was not found in the library, OK otherwise.
+  // Please be careful when replacing function: make sure all previous pointers
+  // returned by `Find()` are no longer in use.
+  Status ReplaceFunction(const std::string& func, const FunctionDef& fdef,
+                         const StackTracesMap& stack_traces = {})
+      TF_LOCKS_EXCLUDED(mu_);
+
+  // Replaces the gradient corresponding to `grad.function_name()`. Returns
+  // a non-OK status if "grad.function_name()" was not found in the library, OK
+  // otherwise.
+  Status ReplaceGradient(const GradientDef& grad) TF_LOCKS_EXCLUDED(mu_);
+
+  // Removes the function corresponding to 'func'. Returns a non-OK status if
+  // 'func' was not found in the library, OK otherwise.
+  // Please be careful when removing function: make sure there are no other
+  // nodes using the function, and all previous pointers returned by `Find()`
+  // are no longer in use.
+  Status RemoveFunction(const std::string& func) TF_LOCKS_EXCLUDED(mu_);
+
+  // Removes all the functions and gradient functions.
+  void Clear() TF_LOCKS_EXCLUDED(mu_);
+
+  // Adds the functions and gradients in 'other' to this function library.
+  // Duplicate functions and gradients are ignored.
+  // This operation is atomic.
+  Status AddLibrary(const FunctionLibraryDefinition& other)
+      TF_LOCKS_EXCLUDED(mu_);
+  Status AddLibrary(FunctionLibraryDefinition&& other) TF_LOCKS_EXCLUDED(mu_);
+
+  // Adds the functions and gradients in 'lib_def' to this function library.
+  // Duplicate functions and gradients are ignored. This overload adds the
+  // functions with no stack traces. This operation is atomic.
+  Status AddLibrary(const FunctionDefLibrary& lib_def) TF_LOCKS_EXCLUDED(mu_);
+  Status AddLibrary(FunctionDefLibrary&& lib_def) TF_LOCKS_EXCLUDED(mu_);
+
+  // Adds the functions and gradients in 'lib_def' to this function library.
+  // Duplicate functions and gradients are ignored.
+  // This operation is atomic.
+  Status AddLibrary(const FunctionDefLibrary& lib_def,
+                    const FunctionDefLibraryStackTraces& library_traces)
+      TF_LOCKS_EXCLUDED(mu_);
+  Status AddLibrary(FunctionDefLibrary&& lib_def,
+                    const FunctionDefLibraryStackTraces& library_traces)
+      TF_LOCKS_EXCLUDED(mu_);
+
+  // If the gradient function for 'func' is specified explicitly in
+  // the library, returns the gradient function name.  Otherwise,
+  // returns an empty string.
+  std::string FindGradient(const std::string& func) const
+      TF_LOCKS_EXCLUDED(mu_);
+
+  // OpRegistryInterface method. Useful for constructing a Graph.
+  //
+  // If "op" is defined in the library, returns its signature.
+  // Otherwise, assume "op" is a primitive op and returns its op
+  // signature and shape inference function.
+  //
+  // NB: This function outputs a borrowed pointer, which can be invalidated by a
+  // subsequent call to `ReplaceFunction()` with the given name.
+  Status LookUp(const std::string& op_type_name,
+                const OpRegistrationData** op_reg_data) const override
+      TF_LOCKS_EXCLUDED(mu_);
+
+  // Generates new function name with the specified prefix that is unique
+  // across this library.
+  std::string UniqueFunctionName(StringPiece prefix) const
+      TF_LOCKS_EXCLUDED(mu_);
+
+  // Given a node def 'ndef', inspects attributes of the callee
+  // function to derive the attribute 'value' for 'attr'. Returns OK
+  // iff the attribute is given by the function's definition.
+  // TODO(irving): Remove; keep only the const Node& version.
+  template <typename T>
+  Status GetAttr(const NodeDef& ndef, const std::string& attr, T* value) const;
+
+  // Given a node, inspects attributes of the callee function to derive the
+  // attribute 'value' for 'attr'. Returns OK iff the attribute is given by the
+  // function's definition.
+  template <typename T>
+  Status GetAttr(const Node& node, const std::string& attr, T* value) const;
+
+  // Returns a proto representation of the state of this function library.
+  FunctionDefLibrary ToProto() const TF_LOCKS_EXCLUDED(mu_);
+
+  size_t num_functions() const TF_LOCKS_EXCLUDED(mu_) {
+    tf_shared_lock l(mu_);
+    return records_.size();
+  }
+
+  // Returns all the function names in the FunctionLibraryDefinition.
+  std::vector<string> ListFunctionNames() const TF_LOCKS_EXCLUDED(mu_);
+
+  const OpRegistryInterface* default_registry() const {
+    return default_registry_;
+  }
+  void set_default_registry(const OpRegistryInterface* registry) {
+    default_registry_ = registry;
+  }
+
+  // Returns a copy of `*this` with only the subset of functions that are
+  // reachable from the nodes of `graph` or `func`.
+  FunctionLibraryDefinition ReachableDefinitions(const GraphDef& graph) const;
+  FunctionLibraryDefinition ReachableDefinitions(const FunctionDef& func) const;
+
+  // Copies the function named `func` from `other` to this
+  // FunctionLibraryDefinition.
+  // REQUIRES: `this->default_registry() == other.default_registry()`.
+  // Returns OK on success, or error otherwise. This is a no-op if a function
+  // name `func` already exists in this function library, and has the same
+  // implementation as in `other`. If the implementations conflict, an invalid
+  // argument error is returned.
+  Status CopyFunctionDefFrom(const std::string& name,
+                             const FunctionLibraryDefinition& other);
+
+  // Returns graph with debug stack traces for the given function, or `nullptr`
+  // if none found.
+  const StackTracesMap* GetStackTraces(const std::string& func_name) const {
+    core::RefCountPtr<FunctionRecord> entry = FindRecord(func_name);
+    if (entry.get() != nullptr) {
+      return &entry->stack_traces();
+    }
+    return nullptr;
+  }
+
+  // Adds or updates an OptimizedFunctionGraph. Key is `function_name`.
+  void AddOptimizedFunctionGraph(const std::string& function_name,
+                                 const OptimizedFunctionGraph& graph)
+      TF_LOCKS_EXCLUDED(mu_) {
+    mutex_lock l(mu_);
+    optimized_function_graph_map_.emplace(function_name, graph);
+  }
+
+  // Look up for OptimizedFunctionGraph given `function_name`. Returns nullptr
+  // if not found.
+  OptimizedFunctionGraph* FindOptimizedFunctionGraph(
+      const std::string& function_name) const TF_LOCKS_EXCLUDED(mu_) {
+    tf_shared_lock l(mu_);
+    if (auto it = optimized_function_graph_map_.find(function_name);
+        it != optimized_function_graph_map_.end()) {
+      return &(it->second);
+    }
+    return nullptr;
+  }
+
+ private:
+  core::RefCountPtr<FunctionRecord> FindHelper(const string& func) const
+      TF_SHARED_LOCKS_REQUIRED(mu_);
+  std::string FindGradientHelper(const std::string& func) const
+      TF_SHARED_LOCKS_REQUIRED(mu_);
+
+  Status AddHelper(FunctionRecord* registration, bool* added)
+      TF_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+
+  // Same as AddFunctionDef/AddGradientDef except these methods set
+  // `added` to true if the `fdef`/`grad` were actually added to this.
+  Status AddFunctionDefHelper(FunctionDef&& fdef, StackTracesMap&& stack_traces,
+                              bool* added) TF_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+  Status AddGradientDefHelper(const GradientDef& grad, bool* added)
+      TF_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+
+  // Helper function for GetAttr. Returns the FunctionDef* to get the
+  // attr from.
+  const FunctionDef* GetAttrImpl(const NodeDef& ndef) const
+      TF_LOCKS_EXCLUDED(mu_);
+
+  // Remove all functions in `funcs` and all gradients of functions in
+  // `funcs_with_grads` from this library.
+  Status Remove(const std::vector<string>& funcs,
+                const std::vector<string>& funcs_with_grads)
+      TF_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+
+  // Remove `func` from the library. Returns non-OK Status unless `func` is in
+  // the library. This should only be called when there is a guarantee that the
+  // function being removed hasn't been retrieved with `Find`.
+  Status RemoveFunctionHelper(const std::string& func)
+      TF_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+
+  // Remove gradient of function `func` from the library. Returns non-OK Status
+  // unless `func` has a gradient.
+  Status RemoveGradient(const std::string& func)
+      TF_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+
+  mutable mutex mu_;
+  const OpRegistryInterface* default_registry_;
+  gtl::FlatMap<string, FunctionRecord*> records_ TF_GUARDED_BY(mu_);
+  gtl::FlatMap<string, string> func_grad_ TF_GUARDED_BY(mu_);
+  // Maps from function name to optimized function graph.
+  gtl::FlatMap<string, OptimizedFunctionGraph> optimized_function_graph_map_
+      TF_GUARDED_BY(mu_);
+};
+
+// Forward declare. Defined in common_runtime/function.h
+struct FunctionBody;
+
+// Forward declare. Defined in common_runtime/device.h
+class Device;
+// Forward declare. Defined in common_runtime/device_mgr.h
+class DeviceMgr;
+
+// Index of an _Arg node.
+struct FunctionArgIndex {
+  explicit FunctionArgIndex(const int index) : index(index) {}
+  FunctionArgIndex(const int index, const int sub_index)
+      : index(index), sub_index(sub_index) {}
+
+  // The value of the attribute "Index" of the _Arg node.
+  int index;
+  // Set only when the _Arg node represents multiple arguments (e.g. an _Arg
+  // node is replicated to multiple devices/subgraphs). Use sub-index to
+  // distinguish arguments with the same index.
+  int sub_index = -1;
+};
+
+class FunctionLibraryRuntime : public core::WeakRefCounted {
+ public:
+  virtual ~FunctionLibraryRuntime() {}
+
+  // Instantiate a function with the given "attrs".
+  //
+  // Returns OK and fills in "handle" if the instantiation succeeds.
+  // Otherwise returns an error and "handle" is undefined.
+  struct InstantiateOptions {
+    // The canonical device name of the device on which the function
+    // should be instantiated. If empty, the function will be
+    // instantiated on the local device.
+    std::string target;
+
+    // Should the function be instantiated as a multi-device function?
+    bool is_multi_device_function = false;
+
+    // If true, graph passes will be skipped when instantiating the function
+    // since they have already run on the main function side.
+    bool is_component_function = false;
+
+    // For multi-device functions, a vector of canonical device names for
+    // function's inputs. The device of resource inputs must be the device
+    // backing the resource, not the CPU device backing the resource handle.
+    // Must have the same length as number of inputs to the function.
+    std::vector<string> input_devices;
+
+    // For multi-device functions, a vector of canonical device names for
+    // function's outputs.
+    //
+    // (a) If specified (must have the same length as number of outputs):
+    //
+    // Specified devices will be assigned to Retval nodes inserted into the
+    // function body graph in place of function outputs. It is allowed to
+    // specify output device as empty string, in this case Retval device
+    // assignment will be inferred later when function graph will be placed
+    // before partitioning (this is required for resource outputs). Placer will
+    // respect colocation constraints.
+    //
+    // (b) If not specified:
+    //
+    // Function runtime will infer Retval device by following input edges, until
+    // it will reach a node with a device specification. This device
+    // specification must identify a unique device, i.e. a general specification
+    // like "job:foo" matching multiple devices will result in an error.
+    //
+    // IMPORTANT: Resource outputs
+    //
+    // Multi device functions might return resources on a devices different from
+    // the function call device. If output device is not specified for the
+    // resource output, and node producing that resource is a function call,
+    // runtime will leave device specification empty and will rely on Placer to
+    // infer correct device.
+    std::vector<string> output_devices;
+
+    // If set, it indicates the original output indices of a component function.
+    absl::optional<std::vector<int>> ret_indices = absl::nullopt;
+
+    // Maps from a CompositeDevice name to a list of underlying physical
+    // devices.
+    absl::flat_hash_map<string, const std::vector<string>*> composite_devices;
+
+    // This interface is EXPERIMENTAL and subject to change.
+    //
+    // For multi-device functions, a mapping from _Arg node index to type and
+    // shape for input resources.
+    // REQUIRES: if input_resource_dtypes_and_shapes.count(i) > 0 then i-th
+    // argument type must be DT_RESOURCE.
+    std::unordered_map<int, DtypeAndPartialTensorShape>
+        input_resource_dtypes_and_shapes;
+
+    // This interface is EXPERIMENTAL and subject to change.
+    //
+    // If non-null, the runtime will use `lib_def` to resolve function(s) named
+    // in `function_name` and `attrs`. Otherwise, the runtime will use its
+    // internal library.
+    //
+    // NOTE(mrry): If provided, all functions defined in `lib_def` must be
+    // self-contained, and cannot refer to functions defined in other libraries.
+    const FunctionLibraryDefinition* lib_def = nullptr;
+
+    // This interface is EXPERIMENTAL and subject to change.
+    //
+    // If non-empty, the runtime will use `state_handle` to identify
+    // cached state related the instantiated function. Two functions
+    // of the same name and attrs, instantiated with the same
+    // `state_handle` will have the same handle and share the same
+    // state (in stateful kernels); and two functions with different
+    // values for `state_handle` will have independent state.
+    std::string state_handle;
+
+    // This interface is EXPERIMENTAL and subject to change.
+    //
+    // Instantiates the function using an executor of the given type. If empty,
+    // the default TensorFlow executor will be used.
+    std::string executor_type;
+
+    // If true, the runtime will attempt to create kernels for the function at
+    // instantiation time, rather than on the first run. This can be used to
+    // surface errors earlier.
+    bool create_kernels_eagerly = false;
+
+    // This interface is EXPERIMENTAL and subject to change.
+    //
+    // Instantiates the function with the provided config_proto.
+    ConfigProto config_proto;
+
+    // If provided, this optimization function will be invoked before
+    // the placer for multi-device functions.
+    std::function<Status(std::vector<string> /*ret_node_names*/,
+                         std::vector<string> /*keep_node_names*/,
+                         FunctionLibraryDefinition*, const DeviceSet&,
+                         Device* /*cpu_device*/, std::unique_ptr<Graph>*)>
+        optimize_graph_fn;
+
+    // If set, partitioned functions will be added to `graph_collector`.
+    // `graph_collector` must be alive during the call to Instantiate.
+    GraphCollector* graph_collector = nullptr;
+
+    // Indicates whether the multi-device function backend should default the
+    // placement of ops without request device to `target`.
+    bool default_device_to_target = true;
+
+    // If true, the optimized Graph will be stored so that
+    // `FunctionLibraryRuntime::DebugString(handle)` contains the optimized
+    // Graph. Otherwise, the unoptimized function Graph will be returned.
+    bool include_optimized_graph_in_debug_string = false;
+
+    // If true, the function library runtime cache the function instantiation.
+    bool use_function_cache = false;
+
+    // This interface is EXPERIMENTAL and subject to change.
+    //
+    // If True, allow optimizations which should be targeted at a limited
+    // set of small functions.  For example, running kernels synchronously can
+    // be faster under some conditions.
+    bool allow_small_function_optimizations = false;
+
+    // This interface is EXPERIMENTAL and subject to change.
+    //
+    // If True, allow graphs containing control flow nodes to be run on the
+    // single threaded executor.
+    bool allow_control_flow_sync_execution = false;
+
+    // TODO(b/176491312): Remove this if shape inference on import flag is
+    // removed. If True, allows mlir roundtrip to run shape inference on import.
+    bool shape_inference_on_tfe_dialect_import = true;
+
+    // Force int32 _Arg and _Retvals nodes to be left on device instead of
+    // pinning to host.
+    //
+    // Note that we do not pin int32 nodes to host for subgraphs running in
+    // TPU/XLA devices. So this is mainly used to handle the case of multi-CPU
+    // and GPU (non-XLA) graphs.
+    bool int_args_and_retvals_on_device = false;
+
+    // This interface is EXPERIMENTAL and subject to change.
+    //
+    // Instantiates the function for XLA compilation on device_type. If empty,
+    // function is not compiled.
+    std::string xla_compile_device_type;
+
+    // This interface is EXPERIMENTAL and subject to change.
+    //
+    // Instantiates the function enabling soft placement or outside compilation.
+    bool allow_soft_placement = false;
+  };
+  typedef uint64 Handle;
+  virtual Status Instantiate(const std::string& function_name, AttrSlice attrs,
+                             const InstantiateOptions& options,
+                             Handle* handle) = 0;
+  Status Instantiate(const std::string& function_name, AttrSlice attrs,
+                     Handle* handle) {
+    auto opts = absl::make_unique<InstantiateOptions>();
+    return Instantiate(function_name, attrs, *opts, handle);
+  }
+
+  // Releases state associated with the handle.
+  virtual Status ReleaseHandle(Handle handle) = 0;
+
+  // Returns the function body for the instantiated function given its
+  // handle 'h'. Returns nullptr if "h" is not found.
+  //
+  // *this keeps the ownership of the returned object, which remains alive
+  // as long as *this.
+  virtual const FunctionBody* GetFunctionBody(Handle h) = 0;
+
+  // Returns the return types for the function identified by handle `h`.
+  virtual Status GetRetTypes(Handle h, DataTypeVector* ret_types) = 0;
+
+  // Asynchronously invokes the instantiated function identified by
+  // "handle".
+  //
+  // If function execution succeeds, "done" is called with OK and
+  // "*rets" is filled with the function's return values. Otherwise,
+  // "done" is called with an error status.
+  //
+  // Does not take ownership of "rets".
+  // In the cross-process scenario, runner isn't used for making the Async
+  // RPC calls.
+  struct Options {
+    Options() {}
+    explicit Options(const int64_t step_id) : step_id(step_id) {}
+
+    // Choose a step ID that is guaranteed not to clash with any
+    // Session-generated step ID. DirectSession only generates
+    // non-negative step IDs (contiguous, starting from 0), and
+    // MasterSession generates 56-bit random step IDs whose MSB is
+    // always 0, so a negative random step ID should suffice.
+    const int64_t step_id = -std::abs(static_cast<int64_t>(random::New64()));
+
+    // op_id of the function running in eager mode. Set when we want to copy
+    // remote outputs lazily. All components of a remote multi-device function
+    // should use the same op_id, in order to correctly map remote output
+    // tensors to the remote TensorHandles in the default device.
+    absl::optional<int64_t> op_id = absl::nullopt;
+
+    // Not owned. Caller makes sure that the rendezvous outlives this Options.
+    RendezvousInterface* rendezvous = nullptr;
+    CancellationManager* cancellation_manager = nullptr;
+    CollectiveExecutor* collective_executor = nullptr;
+    ScopedStepContainer* step_container = nullptr;
+    StepStatsCollectorInterface* stats_collector = nullptr;
+    tsl::CoordinationServiceAgent* coordination_service_agent = nullptr;
+
+    absl::optional<ManagedStackTrace> stack_trace = absl::nullopt;
+
+    std::function<void(std::function<void()>)>* runner = nullptr;
+
+    // Parameters for remote function execution.
+    bool remote_execution = false;
+    std::string source_device = "";  // Fully specified device name.
+
+    // Allocator attributes specifying where the args are / rets should be put.
+    // These should either be {} or match the length of args / retvals. If {},
+    // the default allocator attributes will be assumed for all args / retvals.
+    std::vector<AllocatorAttributes> args_alloc_attrs;
+    std::vector<AllocatorAttributes> rets_alloc_attrs;
+
+    // If true, we create a new IntraProcessRendezvous, else use the existing
+    // one.
+    bool create_rendezvous = false;
+
+    // If True, allow returning dead tensors.
+    bool allow_dead_tensors = false;
+
+    // If True, hint that all kernels should be treated as "inexpensive", and
+    // hence executed on the scheduling thread.
+    bool run_all_kernels_inline = false;
+
+    // If not null, use this thread pool for intra op scheduling.
+    thread::ThreadPoolInterface* user_intra_op_threadpool = nullptr;
+
+    // Returns a human readable representation of this.
+    std::string DebugString() const;
+  };
+  typedef std::function<void(const Status&)> DoneCallback;
+  virtual void Run(const Options& opts, Handle handle,
+                   gtl::ArraySlice<Tensor> args, std::vector<Tensor>* rets,
+                   DoneCallback done) = 0;
+  virtual void Run(const Options& opts, Handle handle,
+                   CallFrameInterface* call_frame, DoneCallback done) = 0;
+
+  virtual Status RunSync(Options opts, Handle handle,
+                         gtl::ArraySlice<Tensor> args,
+                         std::vector<Tensor>* rets) = 0;
+  virtual Status RunSync(Options opts, Handle handle,
+                         CallFrameInterface* call_frame) = 0;
+
+  // Creates a "kernel" for the given NodeProperties "props".
+  //
+  // If succeeds, returns OK and the caller takes the ownership of the
+  // returned "*kernel". Otherwise, returns an error.
+  virtual Status CreateKernel(
+      const std::shared_ptr<const NodeProperties>& props,
+      OpKernel** kernel) = 0;
+
+  // Returns true iff the function named `function_name` is stateful.
+  //
+  // NOTE(mrry): This method assumes that the runtime is associated with a
+  // default function library, and looks up `function_name` in that library.
+  // It does not support overriding the function library.
+  virtual bool IsStateful(const std::string& function_name) const = 0;
+
+  // Returns the device on which the function executes.
+  virtual Device* device() = 0;
+  virtual const Device* device() const = 0;
+
+  // Returns the default runner in which the ops should be launched. If the
+  // device on which the function executes has a private thread pool, return
+  // runner on the device local thread pool.
+  virtual std::function<void(std::function<void()>)>* runner() = 0;
+
+  // Get the DeviceMgr from which the device was obtained.
+  virtual const DeviceMgr* device_mgr() const = 0;
+
+  // Returns the function library definition that backs this runtime.
+  //
+  // NOTE(mrry): The returned library definition is the default function library
+  // for this runtime. The caller may override the function library used by the
+  // runtime to instantiate functions, which will not be reflected in the return
+  // value of this function.
+  virtual const FunctionLibraryDefinition* GetFunctionLibraryDefinition()
+      const = 0;
+
+  // Returns the environment on which the function executes.
+  virtual Env* env() = 0;
+
+  // Returns the ConfigProto passed to the session used to create the function.
+  virtual const ConfigProto* const config_proto() = 0;
+
+  // Returns a debug string showing the definition of the function of
+  // 'handle'.
+  virtual std::string DebugString(Handle handle) = 0;
+
+  // Returns the graph version number.
+  virtual int graph_def_version() const = 0;
+
+  typedef uint64 LocalHandle;
+
+  // Creates a copy of ProcessFunctionLibraryRuntime (transferring ownership to
+  // the caller), FunctionLibraryRuntime (owned by the returned
+  // ProcessFunctionLibraryRuntime), FunctionLibraryDefinition (transferring
+  // ownership to the caller). Note that both the ProcessFunctionLibraryRuntime
+  // and FunctionLibraryRuntime borrow a pointer to the
+  // FunctionLibraryDefinition and so the FunctionLibraryDefinition should
+  // outlive both.
+  //
+  // The `skip_flib_def` argument controls whether the method should clone the
+  // FunctionLibraryDefinition (default behavior) or return an empty function
+  // library. The latter is used by tf.data, which manages
+  // FunctionLibraryDefinitions for its functions independently (and passes
+  // these into the FunctionLibraryRuntime through an overlay), to avoid linear
+  // runtime w.r.t. to number of functions in the current function library.
+  virtual Status Clone(std::unique_ptr<FunctionLibraryDefinition>* out_lib_def,
+                       std::unique_ptr<ProcessFunctionLibraryRuntime>* out_pflr,
+                       FunctionLibraryRuntime** out_flr,
+                       bool skip_flib_def = false) = 0;
+
+  // Returns the name of the executor class (in the sense of
+  // `ExecutorFactory::GetFactory()`) that will be used based on the given
+  // dynamic `options` and static `attrs`. If none is specified, this method
+  // will return an empty string, which leaves the decision up to the runtime.
+  static std::string ExecutorType(const InstantiateOptions& options,
+                                  AttrSlice attrs);
+};
+
+// Returns the device of the `arg_index`-th function input. Update
+// `composite_devices` if the input device is a composite device.
+std::string GetFunctionResourceInputDevice(
+    const Tensor& input, const int arg_index, const FunctionDef& function_def,
+    absl::flat_hash_map<string, std::vector<string>>* composite_devices);
+
+// Returns a canonicalized string for the instantiation of the function of the
+// given "name", attributes "attrs", and "options".
+//
+// The returned string is guaranteed to be stable within one address space. But
+// it may be change as the implementation evolves. Therefore, it should not be
+// persisted or compared across address spaces.
+std::string Canonicalize(
+    const std::string& funcname, AttrSlice attrs,
+    const FunctionLibraryRuntime::InstantiateOptions& options);
+std::string Canonicalize(const std::string& funcname, AttrSlice attrs);
+
+const FunctionLibraryRuntime::Handle kInvalidHandle = -1;
+const FunctionLibraryRuntime::LocalHandle kInvalidLocalHandle = -1;
+
+class CustomKernelCreator {
+ public:
+  virtual ~CustomKernelCreator() {}
+
+  // Given a NodeDef 'node_def' and the function library runtime 'flr',
+  // validate if the class supports creating such a kernel.
+  virtual bool CanCreateKernel(
+      const FunctionLibraryRuntime& flr,
+      const std::shared_ptr<const NodeProperties>& props) const = 0;
+
+  // Given a supported NodeDef, returns a kernel that computes the node.
+  virtual Status CreateKernel(
+      FunctionLibraryRuntime* flr,
+      const std::shared_ptr<const NodeProperties>& props,
+      std::unique_ptr<OpKernel>* kernel) const = 0;
+};
+
+typedef
+#if !defined(IS_MOBILE_PLATFORM)
+    absl::variant<Tensor, eager::RemoteTensorHandle*>
+        FunctionArg;
+#else
+    absl::variant<Tensor>
+        FunctionArg;
+#endif
+
+// Either a local tensor or the shape of a remote tensor.
+typedef absl::variant<Tensor, TensorShape> FunctionRet;
+
+// Used to instantiate and run functions in a distributed system.
+class DistributedFunctionLibraryRuntime {
+ public:
+  virtual ~DistributedFunctionLibraryRuntime() {}
+
+  // Instantiate a function on a remote target specified in `options.target`, by
+  // sending the name and definition of the function to the remote worker. The
+  // local `handle` is filled for the instantiated function data and can be used
+  // for subsequent run function calls on the remote target.
+  virtual void Instantiate(
+      const std::string& function_name,
+      const FunctionLibraryDefinition& lib_def, AttrSlice attrs,
+      const FunctionLibraryRuntime::InstantiateOptions& options,
+      FunctionLibraryRuntime::LocalHandle* handle,
+      FunctionLibraryRuntime::DoneCallback done) = 0;
+
+  // Run an instantiated remote function (specified by `handle`) with a list of
+  // input Tensors in `args` and get its output Tensors in `rets`. The input
+  // tensor data will be sent with the function execution request, and must be
+  // available on the current caller side.
+  // opts.runner isn't used for execution.
+  virtual void Run(const FunctionLibraryRuntime::Options& opts,
+                   FunctionLibraryRuntime::LocalHandle handle,
+                   gtl::ArraySlice<Tensor> args, std::vector<Tensor>* rets,
+                   FunctionLibraryRuntime::DoneCallback done) = 0;
+
+  // Run an instantiated remote function (specified by `handle`) with a list of
+  // input Tensors or RemoteTensorHandles as `args` and get its output Tensors
+  // or TensorShapes in `rets`. When using RemoteTensorHandles as function
+  // inputs or TensorShapes as outputs, the corresponding tensor data will be
+  // resolved on the remote worker, so it is not required to be locally
+  // available on the caller side. Using RemoteTensorHandle inputs is not
+  // supported in TensorFlow v1 runtime.
+  virtual void Run(const FunctionLibraryRuntime::Options& opts,
+                   FunctionLibraryRuntime::LocalHandle handle,
+                   gtl::ArraySlice<FunctionArg> args,
+                   std::vector<FunctionRet>* rets,
+                   FunctionLibraryRuntime::DoneCallback done) = 0;
+
+  // Clean up a previously instantiated function on remote worker.
+  virtual void CleanUp(uint64 step_id,
+                       FunctionLibraryRuntime::LocalHandle handle,
+                       FunctionLibraryRuntime::DoneCallback done) = 0;
+
+  // DeviceMgr with *all* available devices (i.e., local and remote).
+  virtual DeviceMgr* remote_device_mgr() const = 0;
+};
+
+// Extracts the actual type from "attr_values" based on its definition
+// "arg_def".
+//
+// If "arg_def" is a N*T type, *is_type_list is set to false, and
+// *dtypes is set to be a vector of size N and each element is T.
+//
+// If "arg_def" is a list(type), *is_type_list is set to true, and
+// *dtypes is set to be a vector of types specified in attrs for
+// arg_def.
+//
+// Otherwise (arg_def is a simple type T), *is_type_list is set to
+// false, and *dtypes is set to a single element vector, whose only
+// element is T.
+Status ArgNumType(AttrSlice attrs, const OpDef::ArgDef& arg_def,
+                  bool* is_type_list, DataTypeVector* dtypes);
+
+// To register a gradient function for a builtin op, one should use
+//   REGISTER_OP_GRADIENT(<op_name>, <c++ grad factory>);
+//
+// Typically, the c++ grad factory is a plan function that can be
+// converted into ::tensorflow::gradient::Creator, which is
+//   std::function<Status(const AttrSlice&, FunctionDef*)>.
+//
+// A ::tensorflow::gradient::Creator should populate in FunctionDef* with a
+// definition of a brain function which compute the gradient for the
+// <op_name> when the <op_name> is instantiated with the given attrs.
+//
+// E.g.,
+//
+// Status MatMulGrad(const AttrSlice& attrs, FunctionDef* g) {
+//   bool transpose_a;
+//   TF_RETURN_IF_ERROR(attrs.Get("transpose_a", &transpose_a));
+//   bool transpose_b;
+//   TF_RETURN_IF_ERROR(attrs.Get("transpose_b", &transpose_b));
+//   DataType dtype;
+//   TF_RETURN_IF_ERROR(attrs.Get("dtype", &dtype));
+//   if (!transpose_a && !transpose_b) {
+//     *g = FunctionDefHelper::Define(
+//       "MatMulGrad",
+//       {"x:T ", "y:T", "dz:T"},    // Inputs to this function
+//       {"dx:T", "dy:T"},           // Outputs from this function
+//       {"T: {float, double}"},     // Attributes needed by this function
+//       {
+//         {{"x_t"}, "Transpose", {"x"}, {{"T", "$T"}}},
+//         {{"y_t"}, "Transpose", {"y"}, {{"T", "$T"}}},
+//         {{"dx"}, "MatMul", {"dz", "y_t"}, {{"T", "$T"}}},
+//         {{"dy"}, "MatMul", {"x_", "dz"}, {{"T", "$T"}}},
+//       });
+//   } else {
+//     ... ...
+//   }
+//   return OkStatus();
+// }
+//
+// NOTE: $T is substituted with the type variable "T" when the
+// gradient function MatMul is instantiated.
+//
+// TODO(zhifengc): Better documentation somewhere.
+
+// Macros to define a gradient function factory for a primitive
+// operation.
+#define REGISTER_OP_GRADIENT(name, fn) \
+  REGISTER_OP_GRADIENT_UNIQ_HELPER(__COUNTER__, name, fn)
+
+#define REGISTER_OP_NO_GRADIENT(name) \
+  REGISTER_OP_GRADIENT_UNIQ_HELPER(__COUNTER__, name, nullptr)
+
+#define REGISTER_OP_GRADIENT_UNIQ_HELPER(ctr, name, fn) \
+  REGISTER_OP_GRADIENT_UNIQ(ctr, name, fn)
+
+#define REGISTER_OP_GRADIENT_UNIQ(ctr, name, fn)      \
+  static bool unused_grad_##ctr TF_ATTRIBUTE_UNUSED = \
+      SHOULD_REGISTER_OP_GRADIENT &&                  \
+      ::tensorflow::gradient::RegisterOp(name, fn)
+
+namespace gradient {
+// Register a gradient creator for the "op".
+typedef std::function<Status(const AttrSlice& attrs, FunctionDef*)> Creator;
+bool RegisterOp(const std::string& op, Creator func);
+
+// Returns OK the gradient creator for the "op" is found (may be
+// nullptr if REGISTER_OP_NO_GRADIENT is used.
+Status GetOpGradientCreator(const std::string& op, Creator* creator);
+};  // namespace gradient
+
+// Declare explicit instantiations of GetAttr
+#define GET_ATTR(T)                                          \
+  extern template Status FunctionLibraryDefinition::GetAttr( \
+      const Node&, const string&, T*) const;                 \
+  extern template Status FunctionLibraryDefinition::GetAttr( \
+      const NodeDef&, const string&, T*) const;
+GET_ATTR(string)
+GET_ATTR(bool)
+#undef GET_ATTR
+
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_FUNCTION_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/function.pb.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/function.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..a2d8599f9dfbd6eac2a9a1134266f8d636f23762
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/function.pb.h
@@ -0,0 +1,1933 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: tensorflow/core/framework/function.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2ffunction_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2ffunction_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3021000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3021009 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/map.h>  // IWYU pragma: export
+#include <google/protobuf/map_entry.h>
+#include <google/protobuf/map_field_inl.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "tensorflow/core/framework/attr_value.pb.h"
+#include "tensorflow/core/framework/node_def.pb.h"
+#include "tensorflow/core/framework/op_def.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_tensorflow_2fcore_2fframework_2ffunction_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_tensorflow_2fcore_2fframework_2ffunction_2eproto {
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_tensorflow_2fcore_2fframework_2ffunction_2eproto;
+namespace tensorflow {
+class FunctionDef;
+struct FunctionDefDefaultTypeInternal;
+extern FunctionDefDefaultTypeInternal _FunctionDef_default_instance_;
+class FunctionDefLibrary;
+struct FunctionDefLibraryDefaultTypeInternal;
+extern FunctionDefLibraryDefaultTypeInternal _FunctionDefLibrary_default_instance_;
+class FunctionDef_ArgAttrEntry_DoNotUse;
+struct FunctionDef_ArgAttrEntry_DoNotUseDefaultTypeInternal;
+extern FunctionDef_ArgAttrEntry_DoNotUseDefaultTypeInternal _FunctionDef_ArgAttrEntry_DoNotUse_default_instance_;
+class FunctionDef_ArgAttrs;
+struct FunctionDef_ArgAttrsDefaultTypeInternal;
+extern FunctionDef_ArgAttrsDefaultTypeInternal _FunctionDef_ArgAttrs_default_instance_;
+class FunctionDef_ArgAttrs_AttrEntry_DoNotUse;
+struct FunctionDef_ArgAttrs_AttrEntry_DoNotUseDefaultTypeInternal;
+extern FunctionDef_ArgAttrs_AttrEntry_DoNotUseDefaultTypeInternal _FunctionDef_ArgAttrs_AttrEntry_DoNotUse_default_instance_;
+class FunctionDef_AttrEntry_DoNotUse;
+struct FunctionDef_AttrEntry_DoNotUseDefaultTypeInternal;
+extern FunctionDef_AttrEntry_DoNotUseDefaultTypeInternal _FunctionDef_AttrEntry_DoNotUse_default_instance_;
+class FunctionDef_ControlRetEntry_DoNotUse;
+struct FunctionDef_ControlRetEntry_DoNotUseDefaultTypeInternal;
+extern FunctionDef_ControlRetEntry_DoNotUseDefaultTypeInternal _FunctionDef_ControlRetEntry_DoNotUse_default_instance_;
+class FunctionDef_ResourceArgUniqueIdEntry_DoNotUse;
+struct FunctionDef_ResourceArgUniqueIdEntry_DoNotUseDefaultTypeInternal;
+extern FunctionDef_ResourceArgUniqueIdEntry_DoNotUseDefaultTypeInternal _FunctionDef_ResourceArgUniqueIdEntry_DoNotUse_default_instance_;
+class FunctionDef_RetEntry_DoNotUse;
+struct FunctionDef_RetEntry_DoNotUseDefaultTypeInternal;
+extern FunctionDef_RetEntry_DoNotUseDefaultTypeInternal _FunctionDef_RetEntry_DoNotUse_default_instance_;
+class GradientDef;
+struct GradientDefDefaultTypeInternal;
+extern GradientDefDefaultTypeInternal _GradientDef_default_instance_;
+class RegisteredGradient;
+struct RegisteredGradientDefaultTypeInternal;
+extern RegisteredGradientDefaultTypeInternal _RegisteredGradient_default_instance_;
+}  // namespace tensorflow
+PROTOBUF_NAMESPACE_OPEN
+template<> ::tensorflow::FunctionDef* Arena::CreateMaybeMessage<::tensorflow::FunctionDef>(Arena*);
+template<> ::tensorflow::FunctionDefLibrary* Arena::CreateMaybeMessage<::tensorflow::FunctionDefLibrary>(Arena*);
+template<> ::tensorflow::FunctionDef_ArgAttrEntry_DoNotUse* Arena::CreateMaybeMessage<::tensorflow::FunctionDef_ArgAttrEntry_DoNotUse>(Arena*);
+template<> ::tensorflow::FunctionDef_ArgAttrs* Arena::CreateMaybeMessage<::tensorflow::FunctionDef_ArgAttrs>(Arena*);
+template<> ::tensorflow::FunctionDef_ArgAttrs_AttrEntry_DoNotUse* Arena::CreateMaybeMessage<::tensorflow::FunctionDef_ArgAttrs_AttrEntry_DoNotUse>(Arena*);
+template<> ::tensorflow::FunctionDef_AttrEntry_DoNotUse* Arena::CreateMaybeMessage<::tensorflow::FunctionDef_AttrEntry_DoNotUse>(Arena*);
+template<> ::tensorflow::FunctionDef_ControlRetEntry_DoNotUse* Arena::CreateMaybeMessage<::tensorflow::FunctionDef_ControlRetEntry_DoNotUse>(Arena*);
+template<> ::tensorflow::FunctionDef_ResourceArgUniqueIdEntry_DoNotUse* Arena::CreateMaybeMessage<::tensorflow::FunctionDef_ResourceArgUniqueIdEntry_DoNotUse>(Arena*);
+template<> ::tensorflow::FunctionDef_RetEntry_DoNotUse* Arena::CreateMaybeMessage<::tensorflow::FunctionDef_RetEntry_DoNotUse>(Arena*);
+template<> ::tensorflow::GradientDef* Arena::CreateMaybeMessage<::tensorflow::GradientDef>(Arena*);
+template<> ::tensorflow::RegisteredGradient* Arena::CreateMaybeMessage<::tensorflow::RegisteredGradient>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace tensorflow {
+
+// ===================================================================
+
+class FunctionDefLibrary final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.FunctionDefLibrary) */ {
+ public:
+  inline FunctionDefLibrary() : FunctionDefLibrary(nullptr) {}
+  ~FunctionDefLibrary() override;
+  explicit PROTOBUF_CONSTEXPR FunctionDefLibrary(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  FunctionDefLibrary(const FunctionDefLibrary& from);
+  FunctionDefLibrary(FunctionDefLibrary&& from) noexcept
+    : FunctionDefLibrary() {
+    *this = ::std::move(from);
+  }
+
+  inline FunctionDefLibrary& operator=(const FunctionDefLibrary& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline FunctionDefLibrary& operator=(FunctionDefLibrary&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const FunctionDefLibrary& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const FunctionDefLibrary* internal_default_instance() {
+    return reinterpret_cast<const FunctionDefLibrary*>(
+               &_FunctionDefLibrary_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(FunctionDefLibrary& a, FunctionDefLibrary& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(FunctionDefLibrary* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(FunctionDefLibrary* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  FunctionDefLibrary* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<FunctionDefLibrary>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const FunctionDefLibrary& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const FunctionDefLibrary& from) {
+    FunctionDefLibrary::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(FunctionDefLibrary* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.FunctionDefLibrary";
+  }
+  protected:
+  explicit FunctionDefLibrary(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kFunctionFieldNumber = 1,
+    kGradientFieldNumber = 2,
+    kRegisteredGradientsFieldNumber = 3,
+  };
+  // repeated .tensorflow.FunctionDef function = 1;
+  int function_size() const;
+  private:
+  int _internal_function_size() const;
+  public:
+  void clear_function();
+  ::tensorflow::FunctionDef* mutable_function(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::FunctionDef >*
+      mutable_function();
+  private:
+  const ::tensorflow::FunctionDef& _internal_function(int index) const;
+  ::tensorflow::FunctionDef* _internal_add_function();
+  public:
+  const ::tensorflow::FunctionDef& function(int index) const;
+  ::tensorflow::FunctionDef* add_function();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::FunctionDef >&
+      function() const;
+
+  // repeated .tensorflow.GradientDef gradient = 2;
+  int gradient_size() const;
+  private:
+  int _internal_gradient_size() const;
+  public:
+  void clear_gradient();
+  ::tensorflow::GradientDef* mutable_gradient(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::GradientDef >*
+      mutable_gradient();
+  private:
+  const ::tensorflow::GradientDef& _internal_gradient(int index) const;
+  ::tensorflow::GradientDef* _internal_add_gradient();
+  public:
+  const ::tensorflow::GradientDef& gradient(int index) const;
+  ::tensorflow::GradientDef* add_gradient();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::GradientDef >&
+      gradient() const;
+
+  // repeated .tensorflow.RegisteredGradient registered_gradients = 3;
+  int registered_gradients_size() const;
+  private:
+  int _internal_registered_gradients_size() const;
+  public:
+  void clear_registered_gradients();
+  ::tensorflow::RegisteredGradient* mutable_registered_gradients(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::RegisteredGradient >*
+      mutable_registered_gradients();
+  private:
+  const ::tensorflow::RegisteredGradient& _internal_registered_gradients(int index) const;
+  ::tensorflow::RegisteredGradient* _internal_add_registered_gradients();
+  public:
+  const ::tensorflow::RegisteredGradient& registered_gradients(int index) const;
+  ::tensorflow::RegisteredGradient* add_registered_gradients();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::RegisteredGradient >&
+      registered_gradients() const;
+
+  // @@protoc_insertion_point(class_scope:tensorflow.FunctionDefLibrary)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::FunctionDef > function_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::GradientDef > gradient_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::RegisteredGradient > registered_gradients_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2ffunction_2eproto;
+};
+// -------------------------------------------------------------------
+
+class FunctionDef_AttrEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<FunctionDef_AttrEntry_DoNotUse, 
+    std::string, ::tensorflow::AttrValue,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> {
+public:
+  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<FunctionDef_AttrEntry_DoNotUse, 
+    std::string, ::tensorflow::AttrValue,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
+  FunctionDef_AttrEntry_DoNotUse();
+  explicit PROTOBUF_CONSTEXPR FunctionDef_AttrEntry_DoNotUse(
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+  explicit FunctionDef_AttrEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  void MergeFrom(const FunctionDef_AttrEntry_DoNotUse& other);
+  static const FunctionDef_AttrEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const FunctionDef_AttrEntry_DoNotUse*>(&_FunctionDef_AttrEntry_DoNotUse_default_instance_); }
+  static bool ValidateKey(std::string* s) {
+    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "tensorflow.FunctionDef.AttrEntry.key");
+ }
+  static bool ValidateValue(void*) { return true; }
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2ffunction_2eproto;
+};
+
+// -------------------------------------------------------------------
+
+class FunctionDef_ArgAttrs_AttrEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<FunctionDef_ArgAttrs_AttrEntry_DoNotUse, 
+    std::string, ::tensorflow::AttrValue,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> {
+public:
+  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<FunctionDef_ArgAttrs_AttrEntry_DoNotUse, 
+    std::string, ::tensorflow::AttrValue,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
+  FunctionDef_ArgAttrs_AttrEntry_DoNotUse();
+  explicit PROTOBUF_CONSTEXPR FunctionDef_ArgAttrs_AttrEntry_DoNotUse(
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+  explicit FunctionDef_ArgAttrs_AttrEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  void MergeFrom(const FunctionDef_ArgAttrs_AttrEntry_DoNotUse& other);
+  static const FunctionDef_ArgAttrs_AttrEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const FunctionDef_ArgAttrs_AttrEntry_DoNotUse*>(&_FunctionDef_ArgAttrs_AttrEntry_DoNotUse_default_instance_); }
+  static bool ValidateKey(std::string* s) {
+    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "tensorflow.FunctionDef.ArgAttrs.AttrEntry.key");
+ }
+  static bool ValidateValue(void*) { return true; }
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2ffunction_2eproto;
+};
+
+// -------------------------------------------------------------------
+
+class FunctionDef_ArgAttrs final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.FunctionDef.ArgAttrs) */ {
+ public:
+  inline FunctionDef_ArgAttrs() : FunctionDef_ArgAttrs(nullptr) {}
+  ~FunctionDef_ArgAttrs() override;
+  explicit PROTOBUF_CONSTEXPR FunctionDef_ArgAttrs(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  FunctionDef_ArgAttrs(const FunctionDef_ArgAttrs& from);
+  FunctionDef_ArgAttrs(FunctionDef_ArgAttrs&& from) noexcept
+    : FunctionDef_ArgAttrs() {
+    *this = ::std::move(from);
+  }
+
+  inline FunctionDef_ArgAttrs& operator=(const FunctionDef_ArgAttrs& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline FunctionDef_ArgAttrs& operator=(FunctionDef_ArgAttrs&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const FunctionDef_ArgAttrs& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const FunctionDef_ArgAttrs* internal_default_instance() {
+    return reinterpret_cast<const FunctionDef_ArgAttrs*>(
+               &_FunctionDef_ArgAttrs_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  friend void swap(FunctionDef_ArgAttrs& a, FunctionDef_ArgAttrs& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(FunctionDef_ArgAttrs* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(FunctionDef_ArgAttrs* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  FunctionDef_ArgAttrs* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<FunctionDef_ArgAttrs>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const FunctionDef_ArgAttrs& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const FunctionDef_ArgAttrs& from) {
+    FunctionDef_ArgAttrs::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(FunctionDef_ArgAttrs* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.FunctionDef.ArgAttrs";
+  }
+  protected:
+  explicit FunctionDef_ArgAttrs(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kAttrFieldNumber = 1,
+  };
+  // map<string, .tensorflow.AttrValue> attr = 1;
+  int attr_size() const;
+  private:
+  int _internal_attr_size() const;
+  public:
+  void clear_attr();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::AttrValue >&
+      _internal_attr() const;
+  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::AttrValue >*
+      _internal_mutable_attr();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::AttrValue >&
+      attr() const;
+  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::AttrValue >*
+      mutable_attr();
+
+  // @@protoc_insertion_point(class_scope:tensorflow.FunctionDef.ArgAttrs)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::MapField<
+        FunctionDef_ArgAttrs_AttrEntry_DoNotUse,
+        std::string, ::tensorflow::AttrValue,
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> attr_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2ffunction_2eproto;
+};
+// -------------------------------------------------------------------
+
+class FunctionDef_ArgAttrEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<FunctionDef_ArgAttrEntry_DoNotUse, 
+    uint32_t, ::tensorflow::FunctionDef_ArgAttrs,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> {
+public:
+  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<FunctionDef_ArgAttrEntry_DoNotUse, 
+    uint32_t, ::tensorflow::FunctionDef_ArgAttrs,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
+  FunctionDef_ArgAttrEntry_DoNotUse();
+  explicit PROTOBUF_CONSTEXPR FunctionDef_ArgAttrEntry_DoNotUse(
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+  explicit FunctionDef_ArgAttrEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  void MergeFrom(const FunctionDef_ArgAttrEntry_DoNotUse& other);
+  static const FunctionDef_ArgAttrEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const FunctionDef_ArgAttrEntry_DoNotUse*>(&_FunctionDef_ArgAttrEntry_DoNotUse_default_instance_); }
+  static bool ValidateKey(void*) { return true; }
+  static bool ValidateValue(void*) { return true; }
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2ffunction_2eproto;
+};
+
+// -------------------------------------------------------------------
+
+class FunctionDef_ResourceArgUniqueIdEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<FunctionDef_ResourceArgUniqueIdEntry_DoNotUse, 
+    uint32_t, uint32_t,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32> {
+public:
+  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<FunctionDef_ResourceArgUniqueIdEntry_DoNotUse, 
+    uint32_t, uint32_t,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32> SuperType;
+  FunctionDef_ResourceArgUniqueIdEntry_DoNotUse();
+  explicit PROTOBUF_CONSTEXPR FunctionDef_ResourceArgUniqueIdEntry_DoNotUse(
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+  explicit FunctionDef_ResourceArgUniqueIdEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  void MergeFrom(const FunctionDef_ResourceArgUniqueIdEntry_DoNotUse& other);
+  static const FunctionDef_ResourceArgUniqueIdEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const FunctionDef_ResourceArgUniqueIdEntry_DoNotUse*>(&_FunctionDef_ResourceArgUniqueIdEntry_DoNotUse_default_instance_); }
+  static bool ValidateKey(void*) { return true; }
+  static bool ValidateValue(void*) { return true; }
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2ffunction_2eproto;
+};
+
+// -------------------------------------------------------------------
+
+class FunctionDef_RetEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<FunctionDef_RetEntry_DoNotUse, 
+    std::string, std::string,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING> {
+public:
+  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<FunctionDef_RetEntry_DoNotUse, 
+    std::string, std::string,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING> SuperType;
+  FunctionDef_RetEntry_DoNotUse();
+  explicit PROTOBUF_CONSTEXPR FunctionDef_RetEntry_DoNotUse(
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+  explicit FunctionDef_RetEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  void MergeFrom(const FunctionDef_RetEntry_DoNotUse& other);
+  static const FunctionDef_RetEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const FunctionDef_RetEntry_DoNotUse*>(&_FunctionDef_RetEntry_DoNotUse_default_instance_); }
+  static bool ValidateKey(std::string* s) {
+    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "tensorflow.FunctionDef.RetEntry.key");
+ }
+  static bool ValidateValue(std::string* s) {
+    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "tensorflow.FunctionDef.RetEntry.value");
+ }
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2ffunction_2eproto;
+};
+
+// -------------------------------------------------------------------
+
+class FunctionDef_ControlRetEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<FunctionDef_ControlRetEntry_DoNotUse, 
+    std::string, std::string,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING> {
+public:
+  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<FunctionDef_ControlRetEntry_DoNotUse, 
+    std::string, std::string,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING> SuperType;
+  FunctionDef_ControlRetEntry_DoNotUse();
+  explicit PROTOBUF_CONSTEXPR FunctionDef_ControlRetEntry_DoNotUse(
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+  explicit FunctionDef_ControlRetEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  void MergeFrom(const FunctionDef_ControlRetEntry_DoNotUse& other);
+  static const FunctionDef_ControlRetEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const FunctionDef_ControlRetEntry_DoNotUse*>(&_FunctionDef_ControlRetEntry_DoNotUse_default_instance_); }
+  static bool ValidateKey(std::string* s) {
+    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "tensorflow.FunctionDef.ControlRetEntry.key");
+ }
+  static bool ValidateValue(std::string* s) {
+    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "tensorflow.FunctionDef.ControlRetEntry.value");
+ }
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2ffunction_2eproto;
+};
+
+// -------------------------------------------------------------------
+
+class FunctionDef final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.FunctionDef) */ {
+ public:
+  inline FunctionDef() : FunctionDef(nullptr) {}
+  ~FunctionDef() override;
+  explicit PROTOBUF_CONSTEXPR FunctionDef(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  FunctionDef(const FunctionDef& from);
+  FunctionDef(FunctionDef&& from) noexcept
+    : FunctionDef() {
+    *this = ::std::move(from);
+  }
+
+  inline FunctionDef& operator=(const FunctionDef& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline FunctionDef& operator=(FunctionDef&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const FunctionDef& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const FunctionDef* internal_default_instance() {
+    return reinterpret_cast<const FunctionDef*>(
+               &_FunctionDef_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    8;
+
+  friend void swap(FunctionDef& a, FunctionDef& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(FunctionDef* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(FunctionDef* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  FunctionDef* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<FunctionDef>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const FunctionDef& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const FunctionDef& from) {
+    FunctionDef::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(FunctionDef* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.FunctionDef";
+  }
+  protected:
+  explicit FunctionDef(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef FunctionDef_ArgAttrs ArgAttrs;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNodeDefFieldNumber = 3,
+    kRetFieldNumber = 4,
+    kAttrFieldNumber = 5,
+    kControlRetFieldNumber = 6,
+    kArgAttrFieldNumber = 7,
+    kResourceArgUniqueIdFieldNumber = 8,
+    kSignatureFieldNumber = 1,
+  };
+  // repeated .tensorflow.NodeDef node_def = 3;
+  int node_def_size() const;
+  private:
+  int _internal_node_def_size() const;
+  public:
+  void clear_node_def();
+  ::tensorflow::NodeDef* mutable_node_def(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::NodeDef >*
+      mutable_node_def();
+  private:
+  const ::tensorflow::NodeDef& _internal_node_def(int index) const;
+  ::tensorflow::NodeDef* _internal_add_node_def();
+  public:
+  const ::tensorflow::NodeDef& node_def(int index) const;
+  ::tensorflow::NodeDef* add_node_def();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::NodeDef >&
+      node_def() const;
+
+  // map<string, string> ret = 4;
+  int ret_size() const;
+  private:
+  int _internal_ret_size() const;
+  public:
+  void clear_ret();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
+      _internal_ret() const;
+  ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
+      _internal_mutable_ret();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
+      ret() const;
+  ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
+      mutable_ret();
+
+  // map<string, .tensorflow.AttrValue> attr = 5;
+  int attr_size() const;
+  private:
+  int _internal_attr_size() const;
+  public:
+  void clear_attr();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::AttrValue >&
+      _internal_attr() const;
+  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::AttrValue >*
+      _internal_mutable_attr();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::AttrValue >&
+      attr() const;
+  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::AttrValue >*
+      mutable_attr();
+
+  // map<string, string> control_ret = 6;
+  int control_ret_size() const;
+  private:
+  int _internal_control_ret_size() const;
+  public:
+  void clear_control_ret();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
+      _internal_control_ret() const;
+  ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
+      _internal_mutable_control_ret();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
+      control_ret() const;
+  ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
+      mutable_control_ret();
+
+  // map<uint32, .tensorflow.FunctionDef.ArgAttrs> arg_attr = 7;
+  int arg_attr_size() const;
+  private:
+  int _internal_arg_attr_size() const;
+  public:
+  void clear_arg_attr();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::Map< uint32_t, ::tensorflow::FunctionDef_ArgAttrs >&
+      _internal_arg_attr() const;
+  ::PROTOBUF_NAMESPACE_ID::Map< uint32_t, ::tensorflow::FunctionDef_ArgAttrs >*
+      _internal_mutable_arg_attr();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::Map< uint32_t, ::tensorflow::FunctionDef_ArgAttrs >&
+      arg_attr() const;
+  ::PROTOBUF_NAMESPACE_ID::Map< uint32_t, ::tensorflow::FunctionDef_ArgAttrs >*
+      mutable_arg_attr();
+
+  // map<uint32, uint32> resource_arg_unique_id = 8;
+  int resource_arg_unique_id_size() const;
+  private:
+  int _internal_resource_arg_unique_id_size() const;
+  public:
+  void clear_resource_arg_unique_id();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::Map< uint32_t, uint32_t >&
+      _internal_resource_arg_unique_id() const;
+  ::PROTOBUF_NAMESPACE_ID::Map< uint32_t, uint32_t >*
+      _internal_mutable_resource_arg_unique_id();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::Map< uint32_t, uint32_t >&
+      resource_arg_unique_id() const;
+  ::PROTOBUF_NAMESPACE_ID::Map< uint32_t, uint32_t >*
+      mutable_resource_arg_unique_id();
+
+  // .tensorflow.OpDef signature = 1;
+  bool has_signature() const;
+  private:
+  bool _internal_has_signature() const;
+  public:
+  void clear_signature();
+  const ::tensorflow::OpDef& signature() const;
+  PROTOBUF_NODISCARD ::tensorflow::OpDef* release_signature();
+  ::tensorflow::OpDef* mutable_signature();
+  void set_allocated_signature(::tensorflow::OpDef* signature);
+  private:
+  const ::tensorflow::OpDef& _internal_signature() const;
+  ::tensorflow::OpDef* _internal_mutable_signature();
+  public:
+  void unsafe_arena_set_allocated_signature(
+      ::tensorflow::OpDef* signature);
+  ::tensorflow::OpDef* unsafe_arena_release_signature();
+
+  // @@protoc_insertion_point(class_scope:tensorflow.FunctionDef)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::NodeDef > node_def_;
+    ::PROTOBUF_NAMESPACE_ID::internal::MapField<
+        FunctionDef_RetEntry_DoNotUse,
+        std::string, std::string,
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING> ret_;
+    ::PROTOBUF_NAMESPACE_ID::internal::MapField<
+        FunctionDef_AttrEntry_DoNotUse,
+        std::string, ::tensorflow::AttrValue,
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> attr_;
+    ::PROTOBUF_NAMESPACE_ID::internal::MapField<
+        FunctionDef_ControlRetEntry_DoNotUse,
+        std::string, std::string,
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING> control_ret_;
+    ::PROTOBUF_NAMESPACE_ID::internal::MapField<
+        FunctionDef_ArgAttrEntry_DoNotUse,
+        uint32_t, ::tensorflow::FunctionDef_ArgAttrs,
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32,
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> arg_attr_;
+    ::PROTOBUF_NAMESPACE_ID::internal::MapField<
+        FunctionDef_ResourceArgUniqueIdEntry_DoNotUse,
+        uint32_t, uint32_t,
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32,
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32> resource_arg_unique_id_;
+    ::tensorflow::OpDef* signature_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2ffunction_2eproto;
+};
+// -------------------------------------------------------------------
+
+class GradientDef final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.GradientDef) */ {
+ public:
+  inline GradientDef() : GradientDef(nullptr) {}
+  ~GradientDef() override;
+  explicit PROTOBUF_CONSTEXPR GradientDef(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  GradientDef(const GradientDef& from);
+  GradientDef(GradientDef&& from) noexcept
+    : GradientDef() {
+    *this = ::std::move(from);
+  }
+
+  inline GradientDef& operator=(const GradientDef& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline GradientDef& operator=(GradientDef&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const GradientDef& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const GradientDef* internal_default_instance() {
+    return reinterpret_cast<const GradientDef*>(
+               &_GradientDef_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    9;
+
+  friend void swap(GradientDef& a, GradientDef& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(GradientDef* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(GradientDef* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  GradientDef* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<GradientDef>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const GradientDef& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const GradientDef& from) {
+    GradientDef::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(GradientDef* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.GradientDef";
+  }
+  protected:
+  explicit GradientDef(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kFunctionNameFieldNumber = 1,
+    kGradientFuncFieldNumber = 2,
+  };
+  // string function_name = 1;
+  void clear_function_name();
+  const std::string& function_name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_function_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_function_name();
+  PROTOBUF_NODISCARD std::string* release_function_name();
+  void set_allocated_function_name(std::string* function_name);
+  private:
+  const std::string& _internal_function_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_function_name(const std::string& value);
+  std::string* _internal_mutable_function_name();
+  public:
+
+  // string gradient_func = 2;
+  void clear_gradient_func();
+  const std::string& gradient_func() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_gradient_func(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_gradient_func();
+  PROTOBUF_NODISCARD std::string* release_gradient_func();
+  void set_allocated_gradient_func(std::string* gradient_func);
+  private:
+  const std::string& _internal_gradient_func() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_gradient_func(const std::string& value);
+  std::string* _internal_mutable_gradient_func();
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.GradientDef)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr function_name_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr gradient_func_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2ffunction_2eproto;
+};
+// -------------------------------------------------------------------
+
+class RegisteredGradient final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.RegisteredGradient) */ {
+ public:
+  inline RegisteredGradient() : RegisteredGradient(nullptr) {}
+  ~RegisteredGradient() override;
+  explicit PROTOBUF_CONSTEXPR RegisteredGradient(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  RegisteredGradient(const RegisteredGradient& from);
+  RegisteredGradient(RegisteredGradient&& from) noexcept
+    : RegisteredGradient() {
+    *this = ::std::move(from);
+  }
+
+  inline RegisteredGradient& operator=(const RegisteredGradient& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline RegisteredGradient& operator=(RegisteredGradient&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const RegisteredGradient& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const RegisteredGradient* internal_default_instance() {
+    return reinterpret_cast<const RegisteredGradient*>(
+               &_RegisteredGradient_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    10;
+
+  friend void swap(RegisteredGradient& a, RegisteredGradient& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(RegisteredGradient* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(RegisteredGradient* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  RegisteredGradient* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<RegisteredGradient>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const RegisteredGradient& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const RegisteredGradient& from) {
+    RegisteredGradient::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(RegisteredGradient* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.RegisteredGradient";
+  }
+  protected:
+  explicit RegisteredGradient(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kGradientFuncFieldNumber = 1,
+    kRegisteredOpTypeFieldNumber = 2,
+  };
+  // string gradient_func = 1;
+  void clear_gradient_func();
+  const std::string& gradient_func() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_gradient_func(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_gradient_func();
+  PROTOBUF_NODISCARD std::string* release_gradient_func();
+  void set_allocated_gradient_func(std::string* gradient_func);
+  private:
+  const std::string& _internal_gradient_func() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_gradient_func(const std::string& value);
+  std::string* _internal_mutable_gradient_func();
+  public:
+
+  // string registered_op_type = 2;
+  void clear_registered_op_type();
+  const std::string& registered_op_type() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_registered_op_type(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_registered_op_type();
+  PROTOBUF_NODISCARD std::string* release_registered_op_type();
+  void set_allocated_registered_op_type(std::string* registered_op_type);
+  private:
+  const std::string& _internal_registered_op_type() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_registered_op_type(const std::string& value);
+  std::string* _internal_mutable_registered_op_type();
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.RegisteredGradient)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr gradient_func_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr registered_op_type_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2ffunction_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// FunctionDefLibrary
+
+// repeated .tensorflow.FunctionDef function = 1;
+inline int FunctionDefLibrary::_internal_function_size() const {
+  return _impl_.function_.size();
+}
+inline int FunctionDefLibrary::function_size() const {
+  return _internal_function_size();
+}
+inline void FunctionDefLibrary::clear_function() {
+  _impl_.function_.Clear();
+}
+inline ::tensorflow::FunctionDef* FunctionDefLibrary::mutable_function(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.FunctionDefLibrary.function)
+  return _impl_.function_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::FunctionDef >*
+FunctionDefLibrary::mutable_function() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.FunctionDefLibrary.function)
+  return &_impl_.function_;
+}
+inline const ::tensorflow::FunctionDef& FunctionDefLibrary::_internal_function(int index) const {
+  return _impl_.function_.Get(index);
+}
+inline const ::tensorflow::FunctionDef& FunctionDefLibrary::function(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.FunctionDefLibrary.function)
+  return _internal_function(index);
+}
+inline ::tensorflow::FunctionDef* FunctionDefLibrary::_internal_add_function() {
+  return _impl_.function_.Add();
+}
+inline ::tensorflow::FunctionDef* FunctionDefLibrary::add_function() {
+  ::tensorflow::FunctionDef* _add = _internal_add_function();
+  // @@protoc_insertion_point(field_add:tensorflow.FunctionDefLibrary.function)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::FunctionDef >&
+FunctionDefLibrary::function() const {
+  // @@protoc_insertion_point(field_list:tensorflow.FunctionDefLibrary.function)
+  return _impl_.function_;
+}
+
+// repeated .tensorflow.GradientDef gradient = 2;
+inline int FunctionDefLibrary::_internal_gradient_size() const {
+  return _impl_.gradient_.size();
+}
+inline int FunctionDefLibrary::gradient_size() const {
+  return _internal_gradient_size();
+}
+inline void FunctionDefLibrary::clear_gradient() {
+  _impl_.gradient_.Clear();
+}
+inline ::tensorflow::GradientDef* FunctionDefLibrary::mutable_gradient(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.FunctionDefLibrary.gradient)
+  return _impl_.gradient_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::GradientDef >*
+FunctionDefLibrary::mutable_gradient() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.FunctionDefLibrary.gradient)
+  return &_impl_.gradient_;
+}
+inline const ::tensorflow::GradientDef& FunctionDefLibrary::_internal_gradient(int index) const {
+  return _impl_.gradient_.Get(index);
+}
+inline const ::tensorflow::GradientDef& FunctionDefLibrary::gradient(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.FunctionDefLibrary.gradient)
+  return _internal_gradient(index);
+}
+inline ::tensorflow::GradientDef* FunctionDefLibrary::_internal_add_gradient() {
+  return _impl_.gradient_.Add();
+}
+inline ::tensorflow::GradientDef* FunctionDefLibrary::add_gradient() {
+  ::tensorflow::GradientDef* _add = _internal_add_gradient();
+  // @@protoc_insertion_point(field_add:tensorflow.FunctionDefLibrary.gradient)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::GradientDef >&
+FunctionDefLibrary::gradient() const {
+  // @@protoc_insertion_point(field_list:tensorflow.FunctionDefLibrary.gradient)
+  return _impl_.gradient_;
+}
+
+// repeated .tensorflow.RegisteredGradient registered_gradients = 3;
+inline int FunctionDefLibrary::_internal_registered_gradients_size() const {
+  return _impl_.registered_gradients_.size();
+}
+inline int FunctionDefLibrary::registered_gradients_size() const {
+  return _internal_registered_gradients_size();
+}
+inline void FunctionDefLibrary::clear_registered_gradients() {
+  _impl_.registered_gradients_.Clear();
+}
+inline ::tensorflow::RegisteredGradient* FunctionDefLibrary::mutable_registered_gradients(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.FunctionDefLibrary.registered_gradients)
+  return _impl_.registered_gradients_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::RegisteredGradient >*
+FunctionDefLibrary::mutable_registered_gradients() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.FunctionDefLibrary.registered_gradients)
+  return &_impl_.registered_gradients_;
+}
+inline const ::tensorflow::RegisteredGradient& FunctionDefLibrary::_internal_registered_gradients(int index) const {
+  return _impl_.registered_gradients_.Get(index);
+}
+inline const ::tensorflow::RegisteredGradient& FunctionDefLibrary::registered_gradients(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.FunctionDefLibrary.registered_gradients)
+  return _internal_registered_gradients(index);
+}
+inline ::tensorflow::RegisteredGradient* FunctionDefLibrary::_internal_add_registered_gradients() {
+  return _impl_.registered_gradients_.Add();
+}
+inline ::tensorflow::RegisteredGradient* FunctionDefLibrary::add_registered_gradients() {
+  ::tensorflow::RegisteredGradient* _add = _internal_add_registered_gradients();
+  // @@protoc_insertion_point(field_add:tensorflow.FunctionDefLibrary.registered_gradients)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::RegisteredGradient >&
+FunctionDefLibrary::registered_gradients() const {
+  // @@protoc_insertion_point(field_list:tensorflow.FunctionDefLibrary.registered_gradients)
+  return _impl_.registered_gradients_;
+}
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// FunctionDef_ArgAttrs
+
+// map<string, .tensorflow.AttrValue> attr = 1;
+inline int FunctionDef_ArgAttrs::_internal_attr_size() const {
+  return _impl_.attr_.size();
+}
+inline int FunctionDef_ArgAttrs::attr_size() const {
+  return _internal_attr_size();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::AttrValue >&
+FunctionDef_ArgAttrs::_internal_attr() const {
+  return _impl_.attr_.GetMap();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::AttrValue >&
+FunctionDef_ArgAttrs::attr() const {
+  // @@protoc_insertion_point(field_map:tensorflow.FunctionDef.ArgAttrs.attr)
+  return _internal_attr();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::AttrValue >*
+FunctionDef_ArgAttrs::_internal_mutable_attr() {
+  return _impl_.attr_.MutableMap();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::AttrValue >*
+FunctionDef_ArgAttrs::mutable_attr() {
+  // @@protoc_insertion_point(field_mutable_map:tensorflow.FunctionDef.ArgAttrs.attr)
+  return _internal_mutable_attr();
+}
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// FunctionDef
+
+// .tensorflow.OpDef signature = 1;
+inline bool FunctionDef::_internal_has_signature() const {
+  return this != internal_default_instance() && _impl_.signature_ != nullptr;
+}
+inline bool FunctionDef::has_signature() const {
+  return _internal_has_signature();
+}
+inline const ::tensorflow::OpDef& FunctionDef::_internal_signature() const {
+  const ::tensorflow::OpDef* p = _impl_.signature_;
+  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::OpDef&>(
+      ::tensorflow::_OpDef_default_instance_);
+}
+inline const ::tensorflow::OpDef& FunctionDef::signature() const {
+  // @@protoc_insertion_point(field_get:tensorflow.FunctionDef.signature)
+  return _internal_signature();
+}
+inline void FunctionDef::unsafe_arena_set_allocated_signature(
+    ::tensorflow::OpDef* signature) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.signature_);
+  }
+  _impl_.signature_ = signature;
+  if (signature) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.FunctionDef.signature)
+}
+inline ::tensorflow::OpDef* FunctionDef::release_signature() {
+  
+  ::tensorflow::OpDef* temp = _impl_.signature_;
+  _impl_.signature_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::tensorflow::OpDef* FunctionDef::unsafe_arena_release_signature() {
+  // @@protoc_insertion_point(field_release:tensorflow.FunctionDef.signature)
+  
+  ::tensorflow::OpDef* temp = _impl_.signature_;
+  _impl_.signature_ = nullptr;
+  return temp;
+}
+inline ::tensorflow::OpDef* FunctionDef::_internal_mutable_signature() {
+  
+  if (_impl_.signature_ == nullptr) {
+    auto* p = CreateMaybeMessage<::tensorflow::OpDef>(GetArenaForAllocation());
+    _impl_.signature_ = p;
+  }
+  return _impl_.signature_;
+}
+inline ::tensorflow::OpDef* FunctionDef::mutable_signature() {
+  ::tensorflow::OpDef* _msg = _internal_mutable_signature();
+  // @@protoc_insertion_point(field_mutable:tensorflow.FunctionDef.signature)
+  return _msg;
+}
+inline void FunctionDef::set_allocated_signature(::tensorflow::OpDef* signature) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.signature_);
+  }
+  if (signature) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(signature));
+    if (message_arena != submessage_arena) {
+      signature = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, signature, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.signature_ = signature;
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.FunctionDef.signature)
+}
+
+// map<string, .tensorflow.AttrValue> attr = 5;
+inline int FunctionDef::_internal_attr_size() const {
+  return _impl_.attr_.size();
+}
+inline int FunctionDef::attr_size() const {
+  return _internal_attr_size();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::AttrValue >&
+FunctionDef::_internal_attr() const {
+  return _impl_.attr_.GetMap();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::AttrValue >&
+FunctionDef::attr() const {
+  // @@protoc_insertion_point(field_map:tensorflow.FunctionDef.attr)
+  return _internal_attr();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::AttrValue >*
+FunctionDef::_internal_mutable_attr() {
+  return _impl_.attr_.MutableMap();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::AttrValue >*
+FunctionDef::mutable_attr() {
+  // @@protoc_insertion_point(field_mutable_map:tensorflow.FunctionDef.attr)
+  return _internal_mutable_attr();
+}
+
+// map<uint32, .tensorflow.FunctionDef.ArgAttrs> arg_attr = 7;
+inline int FunctionDef::_internal_arg_attr_size() const {
+  return _impl_.arg_attr_.size();
+}
+inline int FunctionDef::arg_attr_size() const {
+  return _internal_arg_attr_size();
+}
+inline void FunctionDef::clear_arg_attr() {
+  _impl_.arg_attr_.Clear();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< uint32_t, ::tensorflow::FunctionDef_ArgAttrs >&
+FunctionDef::_internal_arg_attr() const {
+  return _impl_.arg_attr_.GetMap();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< uint32_t, ::tensorflow::FunctionDef_ArgAttrs >&
+FunctionDef::arg_attr() const {
+  // @@protoc_insertion_point(field_map:tensorflow.FunctionDef.arg_attr)
+  return _internal_arg_attr();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< uint32_t, ::tensorflow::FunctionDef_ArgAttrs >*
+FunctionDef::_internal_mutable_arg_attr() {
+  return _impl_.arg_attr_.MutableMap();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< uint32_t, ::tensorflow::FunctionDef_ArgAttrs >*
+FunctionDef::mutable_arg_attr() {
+  // @@protoc_insertion_point(field_mutable_map:tensorflow.FunctionDef.arg_attr)
+  return _internal_mutable_arg_attr();
+}
+
+// map<uint32, uint32> resource_arg_unique_id = 8;
+inline int FunctionDef::_internal_resource_arg_unique_id_size() const {
+  return _impl_.resource_arg_unique_id_.size();
+}
+inline int FunctionDef::resource_arg_unique_id_size() const {
+  return _internal_resource_arg_unique_id_size();
+}
+inline void FunctionDef::clear_resource_arg_unique_id() {
+  _impl_.resource_arg_unique_id_.Clear();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< uint32_t, uint32_t >&
+FunctionDef::_internal_resource_arg_unique_id() const {
+  return _impl_.resource_arg_unique_id_.GetMap();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< uint32_t, uint32_t >&
+FunctionDef::resource_arg_unique_id() const {
+  // @@protoc_insertion_point(field_map:tensorflow.FunctionDef.resource_arg_unique_id)
+  return _internal_resource_arg_unique_id();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< uint32_t, uint32_t >*
+FunctionDef::_internal_mutable_resource_arg_unique_id() {
+  return _impl_.resource_arg_unique_id_.MutableMap();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< uint32_t, uint32_t >*
+FunctionDef::mutable_resource_arg_unique_id() {
+  // @@protoc_insertion_point(field_mutable_map:tensorflow.FunctionDef.resource_arg_unique_id)
+  return _internal_mutable_resource_arg_unique_id();
+}
+
+// repeated .tensorflow.NodeDef node_def = 3;
+inline int FunctionDef::_internal_node_def_size() const {
+  return _impl_.node_def_.size();
+}
+inline int FunctionDef::node_def_size() const {
+  return _internal_node_def_size();
+}
+inline ::tensorflow::NodeDef* FunctionDef::mutable_node_def(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.FunctionDef.node_def)
+  return _impl_.node_def_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::NodeDef >*
+FunctionDef::mutable_node_def() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.FunctionDef.node_def)
+  return &_impl_.node_def_;
+}
+inline const ::tensorflow::NodeDef& FunctionDef::_internal_node_def(int index) const {
+  return _impl_.node_def_.Get(index);
+}
+inline const ::tensorflow::NodeDef& FunctionDef::node_def(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.FunctionDef.node_def)
+  return _internal_node_def(index);
+}
+inline ::tensorflow::NodeDef* FunctionDef::_internal_add_node_def() {
+  return _impl_.node_def_.Add();
+}
+inline ::tensorflow::NodeDef* FunctionDef::add_node_def() {
+  ::tensorflow::NodeDef* _add = _internal_add_node_def();
+  // @@protoc_insertion_point(field_add:tensorflow.FunctionDef.node_def)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::NodeDef >&
+FunctionDef::node_def() const {
+  // @@protoc_insertion_point(field_list:tensorflow.FunctionDef.node_def)
+  return _impl_.node_def_;
+}
+
+// map<string, string> ret = 4;
+inline int FunctionDef::_internal_ret_size() const {
+  return _impl_.ret_.size();
+}
+inline int FunctionDef::ret_size() const {
+  return _internal_ret_size();
+}
+inline void FunctionDef::clear_ret() {
+  _impl_.ret_.Clear();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
+FunctionDef::_internal_ret() const {
+  return _impl_.ret_.GetMap();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
+FunctionDef::ret() const {
+  // @@protoc_insertion_point(field_map:tensorflow.FunctionDef.ret)
+  return _internal_ret();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
+FunctionDef::_internal_mutable_ret() {
+  return _impl_.ret_.MutableMap();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
+FunctionDef::mutable_ret() {
+  // @@protoc_insertion_point(field_mutable_map:tensorflow.FunctionDef.ret)
+  return _internal_mutable_ret();
+}
+
+// map<string, string> control_ret = 6;
+inline int FunctionDef::_internal_control_ret_size() const {
+  return _impl_.control_ret_.size();
+}
+inline int FunctionDef::control_ret_size() const {
+  return _internal_control_ret_size();
+}
+inline void FunctionDef::clear_control_ret() {
+  _impl_.control_ret_.Clear();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
+FunctionDef::_internal_control_ret() const {
+  return _impl_.control_ret_.GetMap();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
+FunctionDef::control_ret() const {
+  // @@protoc_insertion_point(field_map:tensorflow.FunctionDef.control_ret)
+  return _internal_control_ret();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
+FunctionDef::_internal_mutable_control_ret() {
+  return _impl_.control_ret_.MutableMap();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
+FunctionDef::mutable_control_ret() {
+  // @@protoc_insertion_point(field_mutable_map:tensorflow.FunctionDef.control_ret)
+  return _internal_mutable_control_ret();
+}
+
+// -------------------------------------------------------------------
+
+// GradientDef
+
+// string function_name = 1;
+inline void GradientDef::clear_function_name() {
+  _impl_.function_name_.ClearToEmpty();
+}
+inline const std::string& GradientDef::function_name() const {
+  // @@protoc_insertion_point(field_get:tensorflow.GradientDef.function_name)
+  return _internal_function_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void GradientDef::set_function_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.function_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.GradientDef.function_name)
+}
+inline std::string* GradientDef::mutable_function_name() {
+  std::string* _s = _internal_mutable_function_name();
+  // @@protoc_insertion_point(field_mutable:tensorflow.GradientDef.function_name)
+  return _s;
+}
+inline const std::string& GradientDef::_internal_function_name() const {
+  return _impl_.function_name_.Get();
+}
+inline void GradientDef::_internal_set_function_name(const std::string& value) {
+  
+  _impl_.function_name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* GradientDef::_internal_mutable_function_name() {
+  
+  return _impl_.function_name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* GradientDef::release_function_name() {
+  // @@protoc_insertion_point(field_release:tensorflow.GradientDef.function_name)
+  return _impl_.function_name_.Release();
+}
+inline void GradientDef::set_allocated_function_name(std::string* function_name) {
+  if (function_name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.function_name_.SetAllocated(function_name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.function_name_.IsDefault()) {
+    _impl_.function_name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.GradientDef.function_name)
+}
+
+// string gradient_func = 2;
+inline void GradientDef::clear_gradient_func() {
+  _impl_.gradient_func_.ClearToEmpty();
+}
+inline const std::string& GradientDef::gradient_func() const {
+  // @@protoc_insertion_point(field_get:tensorflow.GradientDef.gradient_func)
+  return _internal_gradient_func();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void GradientDef::set_gradient_func(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.gradient_func_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.GradientDef.gradient_func)
+}
+inline std::string* GradientDef::mutable_gradient_func() {
+  std::string* _s = _internal_mutable_gradient_func();
+  // @@protoc_insertion_point(field_mutable:tensorflow.GradientDef.gradient_func)
+  return _s;
+}
+inline const std::string& GradientDef::_internal_gradient_func() const {
+  return _impl_.gradient_func_.Get();
+}
+inline void GradientDef::_internal_set_gradient_func(const std::string& value) {
+  
+  _impl_.gradient_func_.Set(value, GetArenaForAllocation());
+}
+inline std::string* GradientDef::_internal_mutable_gradient_func() {
+  
+  return _impl_.gradient_func_.Mutable(GetArenaForAllocation());
+}
+inline std::string* GradientDef::release_gradient_func() {
+  // @@protoc_insertion_point(field_release:tensorflow.GradientDef.gradient_func)
+  return _impl_.gradient_func_.Release();
+}
+inline void GradientDef::set_allocated_gradient_func(std::string* gradient_func) {
+  if (gradient_func != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.gradient_func_.SetAllocated(gradient_func, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.gradient_func_.IsDefault()) {
+    _impl_.gradient_func_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.GradientDef.gradient_func)
+}
+
+// -------------------------------------------------------------------
+
+// RegisteredGradient
+
+// string gradient_func = 1;
+inline void RegisteredGradient::clear_gradient_func() {
+  _impl_.gradient_func_.ClearToEmpty();
+}
+inline const std::string& RegisteredGradient::gradient_func() const {
+  // @@protoc_insertion_point(field_get:tensorflow.RegisteredGradient.gradient_func)
+  return _internal_gradient_func();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void RegisteredGradient::set_gradient_func(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.gradient_func_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.RegisteredGradient.gradient_func)
+}
+inline std::string* RegisteredGradient::mutable_gradient_func() {
+  std::string* _s = _internal_mutable_gradient_func();
+  // @@protoc_insertion_point(field_mutable:tensorflow.RegisteredGradient.gradient_func)
+  return _s;
+}
+inline const std::string& RegisteredGradient::_internal_gradient_func() const {
+  return _impl_.gradient_func_.Get();
+}
+inline void RegisteredGradient::_internal_set_gradient_func(const std::string& value) {
+  
+  _impl_.gradient_func_.Set(value, GetArenaForAllocation());
+}
+inline std::string* RegisteredGradient::_internal_mutable_gradient_func() {
+  
+  return _impl_.gradient_func_.Mutable(GetArenaForAllocation());
+}
+inline std::string* RegisteredGradient::release_gradient_func() {
+  // @@protoc_insertion_point(field_release:tensorflow.RegisteredGradient.gradient_func)
+  return _impl_.gradient_func_.Release();
+}
+inline void RegisteredGradient::set_allocated_gradient_func(std::string* gradient_func) {
+  if (gradient_func != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.gradient_func_.SetAllocated(gradient_func, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.gradient_func_.IsDefault()) {
+    _impl_.gradient_func_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.RegisteredGradient.gradient_func)
+}
+
+// string registered_op_type = 2;
+inline void RegisteredGradient::clear_registered_op_type() {
+  _impl_.registered_op_type_.ClearToEmpty();
+}
+inline const std::string& RegisteredGradient::registered_op_type() const {
+  // @@protoc_insertion_point(field_get:tensorflow.RegisteredGradient.registered_op_type)
+  return _internal_registered_op_type();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void RegisteredGradient::set_registered_op_type(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.registered_op_type_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.RegisteredGradient.registered_op_type)
+}
+inline std::string* RegisteredGradient::mutable_registered_op_type() {
+  std::string* _s = _internal_mutable_registered_op_type();
+  // @@protoc_insertion_point(field_mutable:tensorflow.RegisteredGradient.registered_op_type)
+  return _s;
+}
+inline const std::string& RegisteredGradient::_internal_registered_op_type() const {
+  return _impl_.registered_op_type_.Get();
+}
+inline void RegisteredGradient::_internal_set_registered_op_type(const std::string& value) {
+  
+  _impl_.registered_op_type_.Set(value, GetArenaForAllocation());
+}
+inline std::string* RegisteredGradient::_internal_mutable_registered_op_type() {
+  
+  return _impl_.registered_op_type_.Mutable(GetArenaForAllocation());
+}
+inline std::string* RegisteredGradient::release_registered_op_type() {
+  // @@protoc_insertion_point(field_release:tensorflow.RegisteredGradient.registered_op_type)
+  return _impl_.registered_op_type_.Release();
+}
+inline void RegisteredGradient::set_allocated_registered_op_type(std::string* registered_op_type) {
+  if (registered_op_type != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.registered_op_type_.SetAllocated(registered_op_type, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.registered_op_type_.IsDefault()) {
+    _impl_.registered_op_type_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.RegisteredGradient.registered_op_type)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace tensorflow
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2ffunction_2eproto
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/function.proto b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/function.proto
new file mode 100644
index 0000000000000000000000000000000000000000..6e59df71825363c4c67db1fd16b57555f8bebf5d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/function.proto
@@ -0,0 +1,136 @@
+syntax = "proto3";
+
+package tensorflow;
+
+import "tensorflow/core/framework/attr_value.proto";
+import "tensorflow/core/framework/node_def.proto";
+import "tensorflow/core/framework/op_def.proto";
+
+option cc_enable_arenas = true;
+option java_outer_classname = "FunctionProtos";
+option java_multiple_files = true;
+option java_package = "org.tensorflow.framework";
+option go_package = "github.com/tensorflow/tensorflow/tensorflow/go/core/framework/function_go_proto";
+
+// A library is a set of named functions.
+message FunctionDefLibrary {
+  repeated FunctionDef function = 1;
+  repeated GradientDef gradient = 2;
+  repeated RegisteredGradient registered_gradients = 3;
+}
+
+// A function can be instantiated when the runtime can bind every attr
+// with a value. When a GraphDef has a call to a function, it must
+// have binding for every attr defined in the signature.
+//
+// TODO(zhifengc):
+//   * device spec, etc.
+message FunctionDef {
+  // The definition of the function's name, arguments, return values,
+  // attrs etc.
+  OpDef signature = 1;
+
+  // Attributes specific to this function definition.
+  map<string, AttrValue> attr = 5;
+
+  // Attributes for function arguments. These attributes are the same set of
+  // valid attributes as to _Arg nodes.
+  message ArgAttrs {
+    map<string, AttrValue> attr = 1;
+  }
+  map<uint32, ArgAttrs> arg_attr = 7;
+
+  // Unique IDs for each resource argument, used to track aliasing resources. If
+  // Argument A and Argument B alias each other, then
+  // resource_arg_unique_ids[A.index] == resource_arg_unique_ids[B.index].
+  //
+  // If this field is empty, none of the arguments could alias; otherwise, every
+  // resource argument should have an entry in this field.
+  //
+  // When instantiated, the unique IDs will be attached to the _Arg nodes'
+  // "_resource_arg_unique_id" attribute.
+  map<uint32, uint32> resource_arg_unique_id = 8;
+
+  // NOTE: field id 2 deleted on Jan 11, 2017, GraphDef version 21.
+  reserved 2;
+
+  // In both of the following fields, there is the need to specify an
+  // output that is used as either the input to another node (in
+  // `node_def`) or as a return value of the function (in `ret`).
+  // Unlike the NodeDefs in GraphDef, we need to be able to specify a
+  // list in some cases (instead of just single outputs).  Also, we
+  // need to be able to deal with lists of unknown length (so the
+  // output index may not be known at function definition time).  So
+  // we use the following format instead:
+  // * "fun_in" where "fun_in" is the name of a function input arg in
+  //   the `signature` field above.  This represents that input, whether
+  //   it is a single tensor or a list.
+  // * "fun_in:0" gives the first element of a function input arg (a
+  //   non-list input is considered a list of length 1 for these
+  //   purposes).
+  // * "node:out" where "node" is the name of a node in `node_def` and
+  //   "out" is the name one of its op's output arguments (the name
+  //   comes from the OpDef of the node's op). This represents that
+  //   node's output, whether it is a single tensor or a list.
+  //   Note: We enforce that an op's output arguments are never
+  //   renamed in the backwards-compatibility test.
+  // * "node:out:0" gives the first element of a node output arg (a
+  //   non-list output is considered a list of length 1 for these
+  //   purposes).
+  //
+  // NOT CURRENTLY SUPPORTED (but may be in the future):
+  // * "node:out:-1" gives last element in a node output list
+  // * "node:out:1:" gives a list with all but the first element in a
+  //   node output list
+  // * "node:out::-1" gives a list with all but the last element in a
+  //   node output list
+
+  // The body of the function.  Unlike the NodeDefs in a GraphDef, attrs
+  // may have values of type `placeholder` and the `input` field uses
+  // the "output" format above.
+
+  // By convention, "op" in node_def is resolved by consulting with a
+  // user-defined library first. If not resolved, "func" is assumed to
+  // be a builtin op.
+  repeated NodeDef node_def = 3;
+
+  // A mapping from the output arg names from `signature` to the
+  // outputs from `node_def` that should be returned by the function.
+  map<string, string> ret = 4;
+
+  // A mapping from control output names from `signature` to node names in
+  // `node_def` which should be control outputs of this function.
+  map<string, string> control_ret = 6;
+}
+
+// GradientDef defines the gradient function of a function defined in
+// a function library.
+//
+// A gradient function g (specified by gradient_func) for a function f
+// (specified by function_name) must follow the following:
+//
+// The function 'f' must be a numerical function which takes N inputs
+// and produces M outputs. Its gradient function 'g', which is a
+// function taking N + M inputs and produces N outputs.
+//
+// I.e. if we have
+//    (y1, y2, ..., y_M) = f(x1, x2, ..., x_N),
+// then, g is
+//    (dL/dx1, dL/dx2, ..., dL/dx_N) = g(x1, x2, ..., x_N,
+//                                      dL/dy1, dL/dy2, ..., dL/dy_M),
+// where L is a scalar-value function of (x1, x2, ..., xN) (e.g., the
+// loss function). dL/dx_i is the partial derivative of L with respect
+// to x_i.
+message GradientDef {
+  string function_name = 1;  // The function name.
+  string gradient_func = 2;  // The gradient function's name.
+}
+
+// RegisteredGradient stores a gradient function that is registered in the
+// gradients library and used in the ops of a function in the function library.
+// Unlike GradientDef, these gradients are identified by op type, and not
+// directly linked to any function.
+message RegisteredGradient {
+  string gradient_func = 1;       // The gradient function's name.
+  string registered_op_type = 2;  // The gradient function's registered op type.
+}
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/function_handle_cache.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/function_handle_cache.h
new file mode 100644
index 0000000000000000000000000000000000000000..41c73e29bba815c8dbeec9ae40625169c01880a5
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/function_handle_cache.h
@@ -0,0 +1,55 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_FRAMEWORK_FUNCTION_HANDLE_CACHE_H_
+#define TENSORFLOW_CORE_FRAMEWORK_FUNCTION_HANDLE_CACHE_H_
+
+#include <string>
+
+#include "tensorflow/core/framework/function.h"
+
+namespace tensorflow {
+
+// Thread-safe data structure for caching function instantiations.
+class FunctionHandleCache {
+ public:
+  explicit FunctionHandleCache(FunctionLibraryRuntime* lib);
+
+  ~FunctionHandleCache();
+
+  // Looks up the function to be instantiated in the cache first. If present,
+  // returns handle from there. Otherwise, instantiates a new function
+  // and stores handle in the cache.
+  //
+  // The cache retains the ownership of the handle. In particular, the caller
+  // should not invoke `ReleaseHandle`.
+  Status Instantiate(const string& function_name, AttrSlice attrs,
+                     FunctionLibraryRuntime::InstantiateOptions options,
+                     FunctionLibraryRuntime::Handle* handle);
+
+  // Releases all the handles in the cache, clearing out the state for all
+  // functions involved.
+  Status Clear();
+
+ private:
+  mutex mu_;
+  FunctionLibraryRuntime* lib_ = nullptr;  // not owned
+  const string state_handle_;
+  std::unordered_map<string, FunctionLibraryRuntime::Handle> handles_
+      TF_GUARDED_BY(mu_);
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_FUNCTION_HANDLE_CACHE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/graph.pb.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/graph.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..34fcb36b0a904bff2fcc6cba0f14a9b506bfd550
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/graph.pb.h
@@ -0,0 +1,623 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: tensorflow/core/framework/graph.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fgraph_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fgraph_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3021000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3021009 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+#include "tensorflow/core/framework/function.pb.h"
+#include "tensorflow/core/framework/graph_debug_info.pb.h"
+#include "tensorflow/core/framework/node_def.pb.h"
+#include "tensorflow/core/framework/versions.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_tensorflow_2fcore_2fframework_2fgraph_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_tensorflow_2fcore_2fframework_2fgraph_2eproto {
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_tensorflow_2fcore_2fframework_2fgraph_2eproto;
+namespace tensorflow {
+class GraphDef;
+struct GraphDefDefaultTypeInternal;
+extern GraphDefDefaultTypeInternal _GraphDef_default_instance_;
+}  // namespace tensorflow
+PROTOBUF_NAMESPACE_OPEN
+template<> ::tensorflow::GraphDef* Arena::CreateMaybeMessage<::tensorflow::GraphDef>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace tensorflow {
+
+// ===================================================================
+
+class GraphDef final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.GraphDef) */ {
+ public:
+  inline GraphDef() : GraphDef(nullptr) {}
+  ~GraphDef() override;
+  explicit PROTOBUF_CONSTEXPR GraphDef(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  GraphDef(const GraphDef& from);
+  GraphDef(GraphDef&& from) noexcept
+    : GraphDef() {
+    *this = ::std::move(from);
+  }
+
+  inline GraphDef& operator=(const GraphDef& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline GraphDef& operator=(GraphDef&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const GraphDef& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const GraphDef* internal_default_instance() {
+    return reinterpret_cast<const GraphDef*>(
+               &_GraphDef_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(GraphDef& a, GraphDef& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(GraphDef* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(GraphDef* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  GraphDef* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<GraphDef>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const GraphDef& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const GraphDef& from) {
+    GraphDef::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(GraphDef* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.GraphDef";
+  }
+  protected:
+  explicit GraphDef(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNodeFieldNumber = 1,
+    kLibraryFieldNumber = 2,
+    kVersionsFieldNumber = 4,
+    kDebugInfoFieldNumber = 5,
+    kVersionFieldNumber = 3,
+  };
+  // repeated .tensorflow.NodeDef node = 1;
+  int node_size() const;
+  private:
+  int _internal_node_size() const;
+  public:
+  void clear_node();
+  ::tensorflow::NodeDef* mutable_node(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::NodeDef >*
+      mutable_node();
+  private:
+  const ::tensorflow::NodeDef& _internal_node(int index) const;
+  ::tensorflow::NodeDef* _internal_add_node();
+  public:
+  const ::tensorflow::NodeDef& node(int index) const;
+  ::tensorflow::NodeDef* add_node();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::NodeDef >&
+      node() const;
+
+  // .tensorflow.FunctionDefLibrary library = 2;
+  bool has_library() const;
+  private:
+  bool _internal_has_library() const;
+  public:
+  void clear_library();
+  const ::tensorflow::FunctionDefLibrary& library() const;
+  PROTOBUF_NODISCARD ::tensorflow::FunctionDefLibrary* release_library();
+  ::tensorflow::FunctionDefLibrary* mutable_library();
+  void set_allocated_library(::tensorflow::FunctionDefLibrary* library);
+  private:
+  const ::tensorflow::FunctionDefLibrary& _internal_library() const;
+  ::tensorflow::FunctionDefLibrary* _internal_mutable_library();
+  public:
+  void unsafe_arena_set_allocated_library(
+      ::tensorflow::FunctionDefLibrary* library);
+  ::tensorflow::FunctionDefLibrary* unsafe_arena_release_library();
+
+  // .tensorflow.VersionDef versions = 4;
+  bool has_versions() const;
+  private:
+  bool _internal_has_versions() const;
+  public:
+  void clear_versions();
+  const ::tensorflow::VersionDef& versions() const;
+  PROTOBUF_NODISCARD ::tensorflow::VersionDef* release_versions();
+  ::tensorflow::VersionDef* mutable_versions();
+  void set_allocated_versions(::tensorflow::VersionDef* versions);
+  private:
+  const ::tensorflow::VersionDef& _internal_versions() const;
+  ::tensorflow::VersionDef* _internal_mutable_versions();
+  public:
+  void unsafe_arena_set_allocated_versions(
+      ::tensorflow::VersionDef* versions);
+  ::tensorflow::VersionDef* unsafe_arena_release_versions();
+
+  // .tensorflow.GraphDebugInfo debug_info = 5;
+  bool has_debug_info() const;
+  private:
+  bool _internal_has_debug_info() const;
+  public:
+  void clear_debug_info();
+  const ::tensorflow::GraphDebugInfo& debug_info() const;
+  PROTOBUF_NODISCARD ::tensorflow::GraphDebugInfo* release_debug_info();
+  ::tensorflow::GraphDebugInfo* mutable_debug_info();
+  void set_allocated_debug_info(::tensorflow::GraphDebugInfo* debug_info);
+  private:
+  const ::tensorflow::GraphDebugInfo& _internal_debug_info() const;
+  ::tensorflow::GraphDebugInfo* _internal_mutable_debug_info();
+  public:
+  void unsafe_arena_set_allocated_debug_info(
+      ::tensorflow::GraphDebugInfo* debug_info);
+  ::tensorflow::GraphDebugInfo* unsafe_arena_release_debug_info();
+
+  // int32 version = 3 [deprecated = true];
+  PROTOBUF_DEPRECATED void clear_version();
+  PROTOBUF_DEPRECATED int32_t version() const;
+  PROTOBUF_DEPRECATED void set_version(int32_t value);
+  private:
+  int32_t _internal_version() const;
+  void _internal_set_version(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.GraphDef)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::NodeDef > node_;
+    ::tensorflow::FunctionDefLibrary* library_;
+    ::tensorflow::VersionDef* versions_;
+    ::tensorflow::GraphDebugInfo* debug_info_;
+    int32_t version_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fgraph_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// GraphDef
+
+// repeated .tensorflow.NodeDef node = 1;
+inline int GraphDef::_internal_node_size() const {
+  return _impl_.node_.size();
+}
+inline int GraphDef::node_size() const {
+  return _internal_node_size();
+}
+inline ::tensorflow::NodeDef* GraphDef::mutable_node(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.GraphDef.node)
+  return _impl_.node_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::NodeDef >*
+GraphDef::mutable_node() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.GraphDef.node)
+  return &_impl_.node_;
+}
+inline const ::tensorflow::NodeDef& GraphDef::_internal_node(int index) const {
+  return _impl_.node_.Get(index);
+}
+inline const ::tensorflow::NodeDef& GraphDef::node(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.GraphDef.node)
+  return _internal_node(index);
+}
+inline ::tensorflow::NodeDef* GraphDef::_internal_add_node() {
+  return _impl_.node_.Add();
+}
+inline ::tensorflow::NodeDef* GraphDef::add_node() {
+  ::tensorflow::NodeDef* _add = _internal_add_node();
+  // @@protoc_insertion_point(field_add:tensorflow.GraphDef.node)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::NodeDef >&
+GraphDef::node() const {
+  // @@protoc_insertion_point(field_list:tensorflow.GraphDef.node)
+  return _impl_.node_;
+}
+
+// .tensorflow.VersionDef versions = 4;
+inline bool GraphDef::_internal_has_versions() const {
+  return this != internal_default_instance() && _impl_.versions_ != nullptr;
+}
+inline bool GraphDef::has_versions() const {
+  return _internal_has_versions();
+}
+inline const ::tensorflow::VersionDef& GraphDef::_internal_versions() const {
+  const ::tensorflow::VersionDef* p = _impl_.versions_;
+  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::VersionDef&>(
+      ::tensorflow::_VersionDef_default_instance_);
+}
+inline const ::tensorflow::VersionDef& GraphDef::versions() const {
+  // @@protoc_insertion_point(field_get:tensorflow.GraphDef.versions)
+  return _internal_versions();
+}
+inline void GraphDef::unsafe_arena_set_allocated_versions(
+    ::tensorflow::VersionDef* versions) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.versions_);
+  }
+  _impl_.versions_ = versions;
+  if (versions) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.GraphDef.versions)
+}
+inline ::tensorflow::VersionDef* GraphDef::release_versions() {
+  
+  ::tensorflow::VersionDef* temp = _impl_.versions_;
+  _impl_.versions_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::tensorflow::VersionDef* GraphDef::unsafe_arena_release_versions() {
+  // @@protoc_insertion_point(field_release:tensorflow.GraphDef.versions)
+  
+  ::tensorflow::VersionDef* temp = _impl_.versions_;
+  _impl_.versions_ = nullptr;
+  return temp;
+}
+inline ::tensorflow::VersionDef* GraphDef::_internal_mutable_versions() {
+  
+  if (_impl_.versions_ == nullptr) {
+    auto* p = CreateMaybeMessage<::tensorflow::VersionDef>(GetArenaForAllocation());
+    _impl_.versions_ = p;
+  }
+  return _impl_.versions_;
+}
+inline ::tensorflow::VersionDef* GraphDef::mutable_versions() {
+  ::tensorflow::VersionDef* _msg = _internal_mutable_versions();
+  // @@protoc_insertion_point(field_mutable:tensorflow.GraphDef.versions)
+  return _msg;
+}
+inline void GraphDef::set_allocated_versions(::tensorflow::VersionDef* versions) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.versions_);
+  }
+  if (versions) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(versions));
+    if (message_arena != submessage_arena) {
+      versions = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, versions, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.versions_ = versions;
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.GraphDef.versions)
+}
+
+// int32 version = 3 [deprecated = true];
+inline void GraphDef::clear_version() {
+  _impl_.version_ = 0;
+}
+inline int32_t GraphDef::_internal_version() const {
+  return _impl_.version_;
+}
+inline int32_t GraphDef::version() const {
+  // @@protoc_insertion_point(field_get:tensorflow.GraphDef.version)
+  return _internal_version();
+}
+inline void GraphDef::_internal_set_version(int32_t value) {
+  
+  _impl_.version_ = value;
+}
+inline void GraphDef::set_version(int32_t value) {
+  _internal_set_version(value);
+  // @@protoc_insertion_point(field_set:tensorflow.GraphDef.version)
+}
+
+// .tensorflow.FunctionDefLibrary library = 2;
+inline bool GraphDef::_internal_has_library() const {
+  return this != internal_default_instance() && _impl_.library_ != nullptr;
+}
+inline bool GraphDef::has_library() const {
+  return _internal_has_library();
+}
+inline const ::tensorflow::FunctionDefLibrary& GraphDef::_internal_library() const {
+  const ::tensorflow::FunctionDefLibrary* p = _impl_.library_;
+  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::FunctionDefLibrary&>(
+      ::tensorflow::_FunctionDefLibrary_default_instance_);
+}
+inline const ::tensorflow::FunctionDefLibrary& GraphDef::library() const {
+  // @@protoc_insertion_point(field_get:tensorflow.GraphDef.library)
+  return _internal_library();
+}
+inline void GraphDef::unsafe_arena_set_allocated_library(
+    ::tensorflow::FunctionDefLibrary* library) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.library_);
+  }
+  _impl_.library_ = library;
+  if (library) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.GraphDef.library)
+}
+inline ::tensorflow::FunctionDefLibrary* GraphDef::release_library() {
+  
+  ::tensorflow::FunctionDefLibrary* temp = _impl_.library_;
+  _impl_.library_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::tensorflow::FunctionDefLibrary* GraphDef::unsafe_arena_release_library() {
+  // @@protoc_insertion_point(field_release:tensorflow.GraphDef.library)
+  
+  ::tensorflow::FunctionDefLibrary* temp = _impl_.library_;
+  _impl_.library_ = nullptr;
+  return temp;
+}
+inline ::tensorflow::FunctionDefLibrary* GraphDef::_internal_mutable_library() {
+  
+  if (_impl_.library_ == nullptr) {
+    auto* p = CreateMaybeMessage<::tensorflow::FunctionDefLibrary>(GetArenaForAllocation());
+    _impl_.library_ = p;
+  }
+  return _impl_.library_;
+}
+inline ::tensorflow::FunctionDefLibrary* GraphDef::mutable_library() {
+  ::tensorflow::FunctionDefLibrary* _msg = _internal_mutable_library();
+  // @@protoc_insertion_point(field_mutable:tensorflow.GraphDef.library)
+  return _msg;
+}
+inline void GraphDef::set_allocated_library(::tensorflow::FunctionDefLibrary* library) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.library_);
+  }
+  if (library) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(library));
+    if (message_arena != submessage_arena) {
+      library = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, library, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.library_ = library;
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.GraphDef.library)
+}
+
+// .tensorflow.GraphDebugInfo debug_info = 5;
+inline bool GraphDef::_internal_has_debug_info() const {
+  return this != internal_default_instance() && _impl_.debug_info_ != nullptr;
+}
+inline bool GraphDef::has_debug_info() const {
+  return _internal_has_debug_info();
+}
+inline const ::tensorflow::GraphDebugInfo& GraphDef::_internal_debug_info() const {
+  const ::tensorflow::GraphDebugInfo* p = _impl_.debug_info_;
+  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::GraphDebugInfo&>(
+      ::tensorflow::_GraphDebugInfo_default_instance_);
+}
+inline const ::tensorflow::GraphDebugInfo& GraphDef::debug_info() const {
+  // @@protoc_insertion_point(field_get:tensorflow.GraphDef.debug_info)
+  return _internal_debug_info();
+}
+inline void GraphDef::unsafe_arena_set_allocated_debug_info(
+    ::tensorflow::GraphDebugInfo* debug_info) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.debug_info_);
+  }
+  _impl_.debug_info_ = debug_info;
+  if (debug_info) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.GraphDef.debug_info)
+}
+inline ::tensorflow::GraphDebugInfo* GraphDef::release_debug_info() {
+  
+  ::tensorflow::GraphDebugInfo* temp = _impl_.debug_info_;
+  _impl_.debug_info_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::tensorflow::GraphDebugInfo* GraphDef::unsafe_arena_release_debug_info() {
+  // @@protoc_insertion_point(field_release:tensorflow.GraphDef.debug_info)
+  
+  ::tensorflow::GraphDebugInfo* temp = _impl_.debug_info_;
+  _impl_.debug_info_ = nullptr;
+  return temp;
+}
+inline ::tensorflow::GraphDebugInfo* GraphDef::_internal_mutable_debug_info() {
+  
+  if (_impl_.debug_info_ == nullptr) {
+    auto* p = CreateMaybeMessage<::tensorflow::GraphDebugInfo>(GetArenaForAllocation());
+    _impl_.debug_info_ = p;
+  }
+  return _impl_.debug_info_;
+}
+inline ::tensorflow::GraphDebugInfo* GraphDef::mutable_debug_info() {
+  ::tensorflow::GraphDebugInfo* _msg = _internal_mutable_debug_info();
+  // @@protoc_insertion_point(field_mutable:tensorflow.GraphDef.debug_info)
+  return _msg;
+}
+inline void GraphDef::set_allocated_debug_info(::tensorflow::GraphDebugInfo* debug_info) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.debug_info_);
+  }
+  if (debug_info) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(debug_info));
+    if (message_arena != submessage_arena) {
+      debug_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, debug_info, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.debug_info_ = debug_info;
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.GraphDef.debug_info)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace tensorflow
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fgraph_2eproto
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/graph.proto b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/graph.proto
new file mode 100644
index 0000000000000000000000000000000000000000..8523f13ab20452eab3893c4c80a60b2bf50f9c41
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/graph.proto
@@ -0,0 +1,60 @@
+syntax = "proto3";
+
+package tensorflow;
+
+import "tensorflow/core/framework/function.proto";
+import "tensorflow/core/framework/graph_debug_info.proto";
+import "tensorflow/core/framework/node_def.proto";
+import "tensorflow/core/framework/versions.proto";
+
+option cc_enable_arenas = true;
+option java_outer_classname = "GraphProtos";
+option java_multiple_files = true;
+option java_package = "org.tensorflow.framework";
+option go_package = "github.com/tensorflow/tensorflow/tensorflow/go/core/framework/graph_go_proto";
+
+// Represents the graph of operations
+message GraphDef {
+  repeated NodeDef node = 1;
+
+  // Compatibility versions of the graph.  See core/public/version.h for version
+  // history.  The GraphDef version is distinct from the TensorFlow version, and
+  // each release of TensorFlow will support a range of GraphDef versions.
+  VersionDef versions = 4;
+
+  // Deprecated single version field; use versions above instead.  Since all
+  // GraphDef changes before "versions" was introduced were forward
+  // compatible, this field is entirely ignored.
+  int32 version = 3 [deprecated = true];
+
+  // "library" provides user-defined functions.
+  //
+  // Naming:
+  //   * library.function.name are in a flat namespace.
+  //     NOTE: We may need to change it to be hierarchical to support
+  //     different orgs. E.g.,
+  //     { "/google/nn", { ... }},
+  //     { "/google/vision", { ... }}
+  //     { "/org_foo/module_bar", { ... }}
+  //     map<string, FunctionDefLib> named_lib;
+  //   * If node[i].op is the name of one function in "library",
+  //     node[i] is deemed as a function call. Otherwise, node[i].op
+  //     must be a primitive operation supported by the runtime.
+  //
+  //
+  // Function call semantics:
+  //
+  //   * The callee may start execution as soon as some of its inputs
+  //     are ready. The caller may want to use Tuple() mechanism to
+  //     ensure all inputs are ready in the same time.
+  //
+  //   * The consumer of return values may start executing as soon as
+  //     the return values the consumer depends on are ready.  The
+  //     consumer may want to use Tuple() mechanism to ensure the
+  //     consumer does not start until all return values of the callee
+  //     function are ready.
+  FunctionDefLibrary library = 2;
+
+  // Stack traces for the nodes in this graph.
+  GraphDebugInfo debug_info = 5;
+}
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/graph_debug_info.pb.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/graph_debug_info.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..5ace82c1767efbf5620909576082c460db4e7aa1
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/graph_debug_info.pb.h
@@ -0,0 +1,1429 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: tensorflow/core/framework/graph_debug_info.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fgraph_5fdebug_5finfo_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fgraph_5fdebug_5finfo_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3021000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3021009 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/map.h>  // IWYU pragma: export
+#include <google/protobuf/map_entry.h>
+#include <google/protobuf/map_field_inl.h>
+#include <google/protobuf/unknown_field_set.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_tensorflow_2fcore_2fframework_2fgraph_5fdebug_5finfo_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_tensorflow_2fcore_2fframework_2fgraph_5fdebug_5finfo_2eproto {
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_tensorflow_2fcore_2fframework_2fgraph_5fdebug_5finfo_2eproto;
+namespace tensorflow {
+class GraphDebugInfo;
+struct GraphDebugInfoDefaultTypeInternal;
+extern GraphDebugInfoDefaultTypeInternal _GraphDebugInfo_default_instance_;
+class GraphDebugInfo_FileLineCol;
+struct GraphDebugInfo_FileLineColDefaultTypeInternal;
+extern GraphDebugInfo_FileLineColDefaultTypeInternal _GraphDebugInfo_FileLineCol_default_instance_;
+class GraphDebugInfo_FramesByIdEntry_DoNotUse;
+struct GraphDebugInfo_FramesByIdEntry_DoNotUseDefaultTypeInternal;
+extern GraphDebugInfo_FramesByIdEntry_DoNotUseDefaultTypeInternal _GraphDebugInfo_FramesByIdEntry_DoNotUse_default_instance_;
+class GraphDebugInfo_NameToTraceIdEntry_DoNotUse;
+struct GraphDebugInfo_NameToTraceIdEntry_DoNotUseDefaultTypeInternal;
+extern GraphDebugInfo_NameToTraceIdEntry_DoNotUseDefaultTypeInternal _GraphDebugInfo_NameToTraceIdEntry_DoNotUse_default_instance_;
+class GraphDebugInfo_StackTrace;
+struct GraphDebugInfo_StackTraceDefaultTypeInternal;
+extern GraphDebugInfo_StackTraceDefaultTypeInternal _GraphDebugInfo_StackTrace_default_instance_;
+class GraphDebugInfo_TracesByIdEntry_DoNotUse;
+struct GraphDebugInfo_TracesByIdEntry_DoNotUseDefaultTypeInternal;
+extern GraphDebugInfo_TracesByIdEntry_DoNotUseDefaultTypeInternal _GraphDebugInfo_TracesByIdEntry_DoNotUse_default_instance_;
+class GraphDebugInfo_TracesEntry_DoNotUse;
+struct GraphDebugInfo_TracesEntry_DoNotUseDefaultTypeInternal;
+extern GraphDebugInfo_TracesEntry_DoNotUseDefaultTypeInternal _GraphDebugInfo_TracesEntry_DoNotUse_default_instance_;
+}  // namespace tensorflow
+PROTOBUF_NAMESPACE_OPEN
+template<> ::tensorflow::GraphDebugInfo* Arena::CreateMaybeMessage<::tensorflow::GraphDebugInfo>(Arena*);
+template<> ::tensorflow::GraphDebugInfo_FileLineCol* Arena::CreateMaybeMessage<::tensorflow::GraphDebugInfo_FileLineCol>(Arena*);
+template<> ::tensorflow::GraphDebugInfo_FramesByIdEntry_DoNotUse* Arena::CreateMaybeMessage<::tensorflow::GraphDebugInfo_FramesByIdEntry_DoNotUse>(Arena*);
+template<> ::tensorflow::GraphDebugInfo_NameToTraceIdEntry_DoNotUse* Arena::CreateMaybeMessage<::tensorflow::GraphDebugInfo_NameToTraceIdEntry_DoNotUse>(Arena*);
+template<> ::tensorflow::GraphDebugInfo_StackTrace* Arena::CreateMaybeMessage<::tensorflow::GraphDebugInfo_StackTrace>(Arena*);
+template<> ::tensorflow::GraphDebugInfo_TracesByIdEntry_DoNotUse* Arena::CreateMaybeMessage<::tensorflow::GraphDebugInfo_TracesByIdEntry_DoNotUse>(Arena*);
+template<> ::tensorflow::GraphDebugInfo_TracesEntry_DoNotUse* Arena::CreateMaybeMessage<::tensorflow::GraphDebugInfo_TracesEntry_DoNotUse>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace tensorflow {
+
+// ===================================================================
+
+class GraphDebugInfo_FileLineCol final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.GraphDebugInfo.FileLineCol) */ {
+ public:
+  inline GraphDebugInfo_FileLineCol() : GraphDebugInfo_FileLineCol(nullptr) {}
+  ~GraphDebugInfo_FileLineCol() override;
+  explicit PROTOBUF_CONSTEXPR GraphDebugInfo_FileLineCol(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  GraphDebugInfo_FileLineCol(const GraphDebugInfo_FileLineCol& from);
+  GraphDebugInfo_FileLineCol(GraphDebugInfo_FileLineCol&& from) noexcept
+    : GraphDebugInfo_FileLineCol() {
+    *this = ::std::move(from);
+  }
+
+  inline GraphDebugInfo_FileLineCol& operator=(const GraphDebugInfo_FileLineCol& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline GraphDebugInfo_FileLineCol& operator=(GraphDebugInfo_FileLineCol&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const GraphDebugInfo_FileLineCol& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const GraphDebugInfo_FileLineCol* internal_default_instance() {
+    return reinterpret_cast<const GraphDebugInfo_FileLineCol*>(
+               &_GraphDebugInfo_FileLineCol_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(GraphDebugInfo_FileLineCol& a, GraphDebugInfo_FileLineCol& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(GraphDebugInfo_FileLineCol* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(GraphDebugInfo_FileLineCol* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  GraphDebugInfo_FileLineCol* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<GraphDebugInfo_FileLineCol>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const GraphDebugInfo_FileLineCol& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const GraphDebugInfo_FileLineCol& from) {
+    GraphDebugInfo_FileLineCol::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(GraphDebugInfo_FileLineCol* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.GraphDebugInfo.FileLineCol";
+  }
+  protected:
+  explicit GraphDebugInfo_FileLineCol(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kFuncFieldNumber = 4,
+    kCodeFieldNumber = 5,
+    kFileIndexFieldNumber = 1,
+    kLineFieldNumber = 2,
+    kColFieldNumber = 3,
+  };
+  // optional string func = 4;
+  bool has_func() const;
+  private:
+  bool _internal_has_func() const;
+  public:
+  void clear_func();
+  const std::string& func() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_func(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_func();
+  PROTOBUF_NODISCARD std::string* release_func();
+  void set_allocated_func(std::string* func);
+  private:
+  const std::string& _internal_func() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_func(const std::string& value);
+  std::string* _internal_mutable_func();
+  public:
+
+  // optional string code = 5;
+  bool has_code() const;
+  private:
+  bool _internal_has_code() const;
+  public:
+  void clear_code();
+  const std::string& code() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_code(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_code();
+  PROTOBUF_NODISCARD std::string* release_code();
+  void set_allocated_code(std::string* code);
+  private:
+  const std::string& _internal_code() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_code(const std::string& value);
+  std::string* _internal_mutable_code();
+  public:
+
+  // optional int32 file_index = 1;
+  bool has_file_index() const;
+  private:
+  bool _internal_has_file_index() const;
+  public:
+  void clear_file_index();
+  int32_t file_index() const;
+  void set_file_index(int32_t value);
+  private:
+  int32_t _internal_file_index() const;
+  void _internal_set_file_index(int32_t value);
+  public:
+
+  // optional int32 line = 2;
+  bool has_line() const;
+  private:
+  bool _internal_has_line() const;
+  public:
+  void clear_line();
+  int32_t line() const;
+  void set_line(int32_t value);
+  private:
+  int32_t _internal_line() const;
+  void _internal_set_line(int32_t value);
+  public:
+
+  // optional int32 col = 3;
+  bool has_col() const;
+  private:
+  bool _internal_has_col() const;
+  public:
+  void clear_col();
+  int32_t col() const;
+  void set_col(int32_t value);
+  private:
+  int32_t _internal_col() const;
+  void _internal_set_col(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.GraphDebugInfo.FileLineCol)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr func_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr code_;
+    int32_t file_index_;
+    int32_t line_;
+    int32_t col_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fgraph_5fdebug_5finfo_2eproto;
+};
+// -------------------------------------------------------------------
+
+class GraphDebugInfo_StackTrace final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.GraphDebugInfo.StackTrace) */ {
+ public:
+  inline GraphDebugInfo_StackTrace() : GraphDebugInfo_StackTrace(nullptr) {}
+  ~GraphDebugInfo_StackTrace() override;
+  explicit PROTOBUF_CONSTEXPR GraphDebugInfo_StackTrace(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  GraphDebugInfo_StackTrace(const GraphDebugInfo_StackTrace& from);
+  GraphDebugInfo_StackTrace(GraphDebugInfo_StackTrace&& from) noexcept
+    : GraphDebugInfo_StackTrace() {
+    *this = ::std::move(from);
+  }
+
+  inline GraphDebugInfo_StackTrace& operator=(const GraphDebugInfo_StackTrace& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline GraphDebugInfo_StackTrace& operator=(GraphDebugInfo_StackTrace&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const GraphDebugInfo_StackTrace& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const GraphDebugInfo_StackTrace* internal_default_instance() {
+    return reinterpret_cast<const GraphDebugInfo_StackTrace*>(
+               &_GraphDebugInfo_StackTrace_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(GraphDebugInfo_StackTrace& a, GraphDebugInfo_StackTrace& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(GraphDebugInfo_StackTrace* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(GraphDebugInfo_StackTrace* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  GraphDebugInfo_StackTrace* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<GraphDebugInfo_StackTrace>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const GraphDebugInfo_StackTrace& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const GraphDebugInfo_StackTrace& from) {
+    GraphDebugInfo_StackTrace::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(GraphDebugInfo_StackTrace* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.GraphDebugInfo.StackTrace";
+  }
+  protected:
+  explicit GraphDebugInfo_StackTrace(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kFileLineColsFieldNumber = 1,
+    kFrameIdFieldNumber = 2,
+  };
+  // repeated .tensorflow.GraphDebugInfo.FileLineCol file_line_cols = 1;
+  int file_line_cols_size() const;
+  private:
+  int _internal_file_line_cols_size() const;
+  public:
+  void clear_file_line_cols();
+  ::tensorflow::GraphDebugInfo_FileLineCol* mutable_file_line_cols(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::GraphDebugInfo_FileLineCol >*
+      mutable_file_line_cols();
+  private:
+  const ::tensorflow::GraphDebugInfo_FileLineCol& _internal_file_line_cols(int index) const;
+  ::tensorflow::GraphDebugInfo_FileLineCol* _internal_add_file_line_cols();
+  public:
+  const ::tensorflow::GraphDebugInfo_FileLineCol& file_line_cols(int index) const;
+  ::tensorflow::GraphDebugInfo_FileLineCol* add_file_line_cols();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::GraphDebugInfo_FileLineCol >&
+      file_line_cols() const;
+
+  // repeated fixed64 frame_id = 2 [packed = true];
+  int frame_id_size() const;
+  private:
+  int _internal_frame_id_size() const;
+  public:
+  void clear_frame_id();
+  private:
+  uint64_t _internal_frame_id(int index) const;
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
+      _internal_frame_id() const;
+  void _internal_add_frame_id(uint64_t value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
+      _internal_mutable_frame_id();
+  public:
+  uint64_t frame_id(int index) const;
+  void set_frame_id(int index, uint64_t value);
+  void add_frame_id(uint64_t value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
+      frame_id() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
+      mutable_frame_id();
+
+  // @@protoc_insertion_point(class_scope:tensorflow.GraphDebugInfo.StackTrace)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::GraphDebugInfo_FileLineCol > file_line_cols_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t > frame_id_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fgraph_5fdebug_5finfo_2eproto;
+};
+// -------------------------------------------------------------------
+
+class GraphDebugInfo_FramesByIdEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<GraphDebugInfo_FramesByIdEntry_DoNotUse, 
+    uint64_t, ::tensorflow::GraphDebugInfo_FileLineCol,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FIXED64,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> {
+public:
+  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<GraphDebugInfo_FramesByIdEntry_DoNotUse, 
+    uint64_t, ::tensorflow::GraphDebugInfo_FileLineCol,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FIXED64,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
+  GraphDebugInfo_FramesByIdEntry_DoNotUse();
+  explicit PROTOBUF_CONSTEXPR GraphDebugInfo_FramesByIdEntry_DoNotUse(
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+  explicit GraphDebugInfo_FramesByIdEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  void MergeFrom(const GraphDebugInfo_FramesByIdEntry_DoNotUse& other);
+  static const GraphDebugInfo_FramesByIdEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const GraphDebugInfo_FramesByIdEntry_DoNotUse*>(&_GraphDebugInfo_FramesByIdEntry_DoNotUse_default_instance_); }
+  static bool ValidateKey(void*) { return true; }
+  static bool ValidateValue(void*) { return true; }
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fgraph_5fdebug_5finfo_2eproto;
+};
+
+// -------------------------------------------------------------------
+
+class GraphDebugInfo_TracesByIdEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<GraphDebugInfo_TracesByIdEntry_DoNotUse, 
+    uint64_t, ::tensorflow::GraphDebugInfo_StackTrace,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FIXED64,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> {
+public:
+  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<GraphDebugInfo_TracesByIdEntry_DoNotUse, 
+    uint64_t, ::tensorflow::GraphDebugInfo_StackTrace,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FIXED64,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
+  GraphDebugInfo_TracesByIdEntry_DoNotUse();
+  explicit PROTOBUF_CONSTEXPR GraphDebugInfo_TracesByIdEntry_DoNotUse(
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+  explicit GraphDebugInfo_TracesByIdEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  void MergeFrom(const GraphDebugInfo_TracesByIdEntry_DoNotUse& other);
+  static const GraphDebugInfo_TracesByIdEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const GraphDebugInfo_TracesByIdEntry_DoNotUse*>(&_GraphDebugInfo_TracesByIdEntry_DoNotUse_default_instance_); }
+  static bool ValidateKey(void*) { return true; }
+  static bool ValidateValue(void*) { return true; }
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fgraph_5fdebug_5finfo_2eproto;
+};
+
+// -------------------------------------------------------------------
+
+class GraphDebugInfo_TracesEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<GraphDebugInfo_TracesEntry_DoNotUse, 
+    std::string, ::tensorflow::GraphDebugInfo_StackTrace,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> {
+public:
+  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<GraphDebugInfo_TracesEntry_DoNotUse, 
+    std::string, ::tensorflow::GraphDebugInfo_StackTrace,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
+  GraphDebugInfo_TracesEntry_DoNotUse();
+  explicit PROTOBUF_CONSTEXPR GraphDebugInfo_TracesEntry_DoNotUse(
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+  explicit GraphDebugInfo_TracesEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  void MergeFrom(const GraphDebugInfo_TracesEntry_DoNotUse& other);
+  static const GraphDebugInfo_TracesEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const GraphDebugInfo_TracesEntry_DoNotUse*>(&_GraphDebugInfo_TracesEntry_DoNotUse_default_instance_); }
+  static bool ValidateKey(std::string* s) {
+#ifndef NDEBUG
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+       s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "tensorflow.GraphDebugInfo.TracesEntry.key");
+#else
+    (void) s;
+#endif
+    return true;
+ }
+  static bool ValidateValue(void*) { return true; }
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fgraph_5fdebug_5finfo_2eproto;
+};
+
+// -------------------------------------------------------------------
+
+class GraphDebugInfo_NameToTraceIdEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<GraphDebugInfo_NameToTraceIdEntry_DoNotUse, 
+    std::string, uint64_t,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FIXED64> {
+public:
+  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<GraphDebugInfo_NameToTraceIdEntry_DoNotUse, 
+    std::string, uint64_t,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FIXED64> SuperType;
+  GraphDebugInfo_NameToTraceIdEntry_DoNotUse();
+  explicit PROTOBUF_CONSTEXPR GraphDebugInfo_NameToTraceIdEntry_DoNotUse(
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+  explicit GraphDebugInfo_NameToTraceIdEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  void MergeFrom(const GraphDebugInfo_NameToTraceIdEntry_DoNotUse& other);
+  static const GraphDebugInfo_NameToTraceIdEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const GraphDebugInfo_NameToTraceIdEntry_DoNotUse*>(&_GraphDebugInfo_NameToTraceIdEntry_DoNotUse_default_instance_); }
+  static bool ValidateKey(std::string* s) {
+#ifndef NDEBUG
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+       s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "tensorflow.GraphDebugInfo.NameToTraceIdEntry.key");
+#else
+    (void) s;
+#endif
+    return true;
+ }
+  static bool ValidateValue(void*) { return true; }
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fgraph_5fdebug_5finfo_2eproto;
+};
+
+// -------------------------------------------------------------------
+
+class GraphDebugInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.GraphDebugInfo) */ {
+ public:
+  inline GraphDebugInfo() : GraphDebugInfo(nullptr) {}
+  ~GraphDebugInfo() override;
+  explicit PROTOBUF_CONSTEXPR GraphDebugInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  GraphDebugInfo(const GraphDebugInfo& from);
+  GraphDebugInfo(GraphDebugInfo&& from) noexcept
+    : GraphDebugInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline GraphDebugInfo& operator=(const GraphDebugInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline GraphDebugInfo& operator=(GraphDebugInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const GraphDebugInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const GraphDebugInfo* internal_default_instance() {
+    return reinterpret_cast<const GraphDebugInfo*>(
+               &_GraphDebugInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    6;
+
+  friend void swap(GraphDebugInfo& a, GraphDebugInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(GraphDebugInfo* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(GraphDebugInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  GraphDebugInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<GraphDebugInfo>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const GraphDebugInfo& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const GraphDebugInfo& from) {
+    GraphDebugInfo::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(GraphDebugInfo* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.GraphDebugInfo";
+  }
+  protected:
+  explicit GraphDebugInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef GraphDebugInfo_FileLineCol FileLineCol;
+  typedef GraphDebugInfo_StackTrace StackTrace;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kFilesFieldNumber = 1,
+    kTracesFieldNumber = 2,
+    kFramesByIdFieldNumber = 4,
+    kNameToTraceIdFieldNumber = 5,
+    kTracesByIdFieldNumber = 6,
+  };
+  // repeated string files = 1;
+  int files_size() const;
+  private:
+  int _internal_files_size() const;
+  public:
+  void clear_files();
+  const std::string& files(int index) const;
+  std::string* mutable_files(int index);
+  void set_files(int index, const std::string& value);
+  void set_files(int index, std::string&& value);
+  void set_files(int index, const char* value);
+  void set_files(int index, const char* value, size_t size);
+  std::string* add_files();
+  void add_files(const std::string& value);
+  void add_files(std::string&& value);
+  void add_files(const char* value);
+  void add_files(const char* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& files() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_files();
+  private:
+  const std::string& _internal_files(int index) const;
+  std::string* _internal_add_files();
+  public:
+
+  // map<string, .tensorflow.GraphDebugInfo.StackTrace> traces = 2;
+  int traces_size() const;
+  private:
+  int _internal_traces_size() const;
+  public:
+  void clear_traces();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::GraphDebugInfo_StackTrace >&
+      _internal_traces() const;
+  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::GraphDebugInfo_StackTrace >*
+      _internal_mutable_traces();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::GraphDebugInfo_StackTrace >&
+      traces() const;
+  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::GraphDebugInfo_StackTrace >*
+      mutable_traces();
+
+  // map<fixed64, .tensorflow.GraphDebugInfo.FileLineCol> frames_by_id = 4;
+  int frames_by_id_size() const;
+  private:
+  int _internal_frames_by_id_size() const;
+  public:
+  void clear_frames_by_id();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::Map< uint64_t, ::tensorflow::GraphDebugInfo_FileLineCol >&
+      _internal_frames_by_id() const;
+  ::PROTOBUF_NAMESPACE_ID::Map< uint64_t, ::tensorflow::GraphDebugInfo_FileLineCol >*
+      _internal_mutable_frames_by_id();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::Map< uint64_t, ::tensorflow::GraphDebugInfo_FileLineCol >&
+      frames_by_id() const;
+  ::PROTOBUF_NAMESPACE_ID::Map< uint64_t, ::tensorflow::GraphDebugInfo_FileLineCol >*
+      mutable_frames_by_id();
+
+  // map<string, fixed64> name_to_trace_id = 5;
+  int name_to_trace_id_size() const;
+  private:
+  int _internal_name_to_trace_id_size() const;
+  public:
+  void clear_name_to_trace_id();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, uint64_t >&
+      _internal_name_to_trace_id() const;
+  ::PROTOBUF_NAMESPACE_ID::Map< std::string, uint64_t >*
+      _internal_mutable_name_to_trace_id();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, uint64_t >&
+      name_to_trace_id() const;
+  ::PROTOBUF_NAMESPACE_ID::Map< std::string, uint64_t >*
+      mutable_name_to_trace_id();
+
+  // map<fixed64, .tensorflow.GraphDebugInfo.StackTrace> traces_by_id = 6;
+  int traces_by_id_size() const;
+  private:
+  int _internal_traces_by_id_size() const;
+  public:
+  void clear_traces_by_id();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::Map< uint64_t, ::tensorflow::GraphDebugInfo_StackTrace >&
+      _internal_traces_by_id() const;
+  ::PROTOBUF_NAMESPACE_ID::Map< uint64_t, ::tensorflow::GraphDebugInfo_StackTrace >*
+      _internal_mutable_traces_by_id();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::Map< uint64_t, ::tensorflow::GraphDebugInfo_StackTrace >&
+      traces_by_id() const;
+  ::PROTOBUF_NAMESPACE_ID::Map< uint64_t, ::tensorflow::GraphDebugInfo_StackTrace >*
+      mutable_traces_by_id();
+
+  // @@protoc_insertion_point(class_scope:tensorflow.GraphDebugInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> files_;
+    ::PROTOBUF_NAMESPACE_ID::internal::MapField<
+        GraphDebugInfo_TracesEntry_DoNotUse,
+        std::string, ::tensorflow::GraphDebugInfo_StackTrace,
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> traces_;
+    ::PROTOBUF_NAMESPACE_ID::internal::MapField<
+        GraphDebugInfo_FramesByIdEntry_DoNotUse,
+        uint64_t, ::tensorflow::GraphDebugInfo_FileLineCol,
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FIXED64,
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> frames_by_id_;
+    ::PROTOBUF_NAMESPACE_ID::internal::MapField<
+        GraphDebugInfo_NameToTraceIdEntry_DoNotUse,
+        std::string, uint64_t,
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FIXED64> name_to_trace_id_;
+    ::PROTOBUF_NAMESPACE_ID::internal::MapField<
+        GraphDebugInfo_TracesByIdEntry_DoNotUse,
+        uint64_t, ::tensorflow::GraphDebugInfo_StackTrace,
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FIXED64,
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> traces_by_id_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fgraph_5fdebug_5finfo_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// GraphDebugInfo_FileLineCol
+
+// optional int32 file_index = 1;
+inline bool GraphDebugInfo_FileLineCol::_internal_has_file_index() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool GraphDebugInfo_FileLineCol::has_file_index() const {
+  return _internal_has_file_index();
+}
+inline void GraphDebugInfo_FileLineCol::clear_file_index() {
+  _impl_.file_index_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline int32_t GraphDebugInfo_FileLineCol::_internal_file_index() const {
+  return _impl_.file_index_;
+}
+inline int32_t GraphDebugInfo_FileLineCol::file_index() const {
+  // @@protoc_insertion_point(field_get:tensorflow.GraphDebugInfo.FileLineCol.file_index)
+  return _internal_file_index();
+}
+inline void GraphDebugInfo_FileLineCol::_internal_set_file_index(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.file_index_ = value;
+}
+inline void GraphDebugInfo_FileLineCol::set_file_index(int32_t value) {
+  _internal_set_file_index(value);
+  // @@protoc_insertion_point(field_set:tensorflow.GraphDebugInfo.FileLineCol.file_index)
+}
+
+// optional int32 line = 2;
+inline bool GraphDebugInfo_FileLineCol::_internal_has_line() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool GraphDebugInfo_FileLineCol::has_line() const {
+  return _internal_has_line();
+}
+inline void GraphDebugInfo_FileLineCol::clear_line() {
+  _impl_.line_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline int32_t GraphDebugInfo_FileLineCol::_internal_line() const {
+  return _impl_.line_;
+}
+inline int32_t GraphDebugInfo_FileLineCol::line() const {
+  // @@protoc_insertion_point(field_get:tensorflow.GraphDebugInfo.FileLineCol.line)
+  return _internal_line();
+}
+inline void GraphDebugInfo_FileLineCol::_internal_set_line(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.line_ = value;
+}
+inline void GraphDebugInfo_FileLineCol::set_line(int32_t value) {
+  _internal_set_line(value);
+  // @@protoc_insertion_point(field_set:tensorflow.GraphDebugInfo.FileLineCol.line)
+}
+
+// optional int32 col = 3;
+inline bool GraphDebugInfo_FileLineCol::_internal_has_col() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool GraphDebugInfo_FileLineCol::has_col() const {
+  return _internal_has_col();
+}
+inline void GraphDebugInfo_FileLineCol::clear_col() {
+  _impl_.col_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline int32_t GraphDebugInfo_FileLineCol::_internal_col() const {
+  return _impl_.col_;
+}
+inline int32_t GraphDebugInfo_FileLineCol::col() const {
+  // @@protoc_insertion_point(field_get:tensorflow.GraphDebugInfo.FileLineCol.col)
+  return _internal_col();
+}
+inline void GraphDebugInfo_FileLineCol::_internal_set_col(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.col_ = value;
+}
+inline void GraphDebugInfo_FileLineCol::set_col(int32_t value) {
+  _internal_set_col(value);
+  // @@protoc_insertion_point(field_set:tensorflow.GraphDebugInfo.FileLineCol.col)
+}
+
+// optional string func = 4;
+inline bool GraphDebugInfo_FileLineCol::_internal_has_func() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool GraphDebugInfo_FileLineCol::has_func() const {
+  return _internal_has_func();
+}
+inline void GraphDebugInfo_FileLineCol::clear_func() {
+  _impl_.func_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& GraphDebugInfo_FileLineCol::func() const {
+  // @@protoc_insertion_point(field_get:tensorflow.GraphDebugInfo.FileLineCol.func)
+  return _internal_func();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void GraphDebugInfo_FileLineCol::set_func(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.func_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.GraphDebugInfo.FileLineCol.func)
+}
+inline std::string* GraphDebugInfo_FileLineCol::mutable_func() {
+  std::string* _s = _internal_mutable_func();
+  // @@protoc_insertion_point(field_mutable:tensorflow.GraphDebugInfo.FileLineCol.func)
+  return _s;
+}
+inline const std::string& GraphDebugInfo_FileLineCol::_internal_func() const {
+  return _impl_.func_.Get();
+}
+inline void GraphDebugInfo_FileLineCol::_internal_set_func(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.func_.Set(value, GetArenaForAllocation());
+}
+inline std::string* GraphDebugInfo_FileLineCol::_internal_mutable_func() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.func_.Mutable(GetArenaForAllocation());
+}
+inline std::string* GraphDebugInfo_FileLineCol::release_func() {
+  // @@protoc_insertion_point(field_release:tensorflow.GraphDebugInfo.FileLineCol.func)
+  if (!_internal_has_func()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.func_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.func_.IsDefault()) {
+    _impl_.func_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void GraphDebugInfo_FileLineCol::set_allocated_func(std::string* func) {
+  if (func != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.func_.SetAllocated(func, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.func_.IsDefault()) {
+    _impl_.func_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.GraphDebugInfo.FileLineCol.func)
+}
+
+// optional string code = 5;
+inline bool GraphDebugInfo_FileLineCol::_internal_has_code() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool GraphDebugInfo_FileLineCol::has_code() const {
+  return _internal_has_code();
+}
+inline void GraphDebugInfo_FileLineCol::clear_code() {
+  _impl_.code_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& GraphDebugInfo_FileLineCol::code() const {
+  // @@protoc_insertion_point(field_get:tensorflow.GraphDebugInfo.FileLineCol.code)
+  return _internal_code();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void GraphDebugInfo_FileLineCol::set_code(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.code_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.GraphDebugInfo.FileLineCol.code)
+}
+inline std::string* GraphDebugInfo_FileLineCol::mutable_code() {
+  std::string* _s = _internal_mutable_code();
+  // @@protoc_insertion_point(field_mutable:tensorflow.GraphDebugInfo.FileLineCol.code)
+  return _s;
+}
+inline const std::string& GraphDebugInfo_FileLineCol::_internal_code() const {
+  return _impl_.code_.Get();
+}
+inline void GraphDebugInfo_FileLineCol::_internal_set_code(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.code_.Set(value, GetArenaForAllocation());
+}
+inline std::string* GraphDebugInfo_FileLineCol::_internal_mutable_code() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.code_.Mutable(GetArenaForAllocation());
+}
+inline std::string* GraphDebugInfo_FileLineCol::release_code() {
+  // @@protoc_insertion_point(field_release:tensorflow.GraphDebugInfo.FileLineCol.code)
+  if (!_internal_has_code()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.code_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.code_.IsDefault()) {
+    _impl_.code_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void GraphDebugInfo_FileLineCol::set_allocated_code(std::string* code) {
+  if (code != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.code_.SetAllocated(code, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.code_.IsDefault()) {
+    _impl_.code_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.GraphDebugInfo.FileLineCol.code)
+}
+
+// -------------------------------------------------------------------
+
+// GraphDebugInfo_StackTrace
+
+// repeated .tensorflow.GraphDebugInfo.FileLineCol file_line_cols = 1;
+inline int GraphDebugInfo_StackTrace::_internal_file_line_cols_size() const {
+  return _impl_.file_line_cols_.size();
+}
+inline int GraphDebugInfo_StackTrace::file_line_cols_size() const {
+  return _internal_file_line_cols_size();
+}
+inline void GraphDebugInfo_StackTrace::clear_file_line_cols() {
+  _impl_.file_line_cols_.Clear();
+}
+inline ::tensorflow::GraphDebugInfo_FileLineCol* GraphDebugInfo_StackTrace::mutable_file_line_cols(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.GraphDebugInfo.StackTrace.file_line_cols)
+  return _impl_.file_line_cols_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::GraphDebugInfo_FileLineCol >*
+GraphDebugInfo_StackTrace::mutable_file_line_cols() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.GraphDebugInfo.StackTrace.file_line_cols)
+  return &_impl_.file_line_cols_;
+}
+inline const ::tensorflow::GraphDebugInfo_FileLineCol& GraphDebugInfo_StackTrace::_internal_file_line_cols(int index) const {
+  return _impl_.file_line_cols_.Get(index);
+}
+inline const ::tensorflow::GraphDebugInfo_FileLineCol& GraphDebugInfo_StackTrace::file_line_cols(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.GraphDebugInfo.StackTrace.file_line_cols)
+  return _internal_file_line_cols(index);
+}
+inline ::tensorflow::GraphDebugInfo_FileLineCol* GraphDebugInfo_StackTrace::_internal_add_file_line_cols() {
+  return _impl_.file_line_cols_.Add();
+}
+inline ::tensorflow::GraphDebugInfo_FileLineCol* GraphDebugInfo_StackTrace::add_file_line_cols() {
+  ::tensorflow::GraphDebugInfo_FileLineCol* _add = _internal_add_file_line_cols();
+  // @@protoc_insertion_point(field_add:tensorflow.GraphDebugInfo.StackTrace.file_line_cols)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::GraphDebugInfo_FileLineCol >&
+GraphDebugInfo_StackTrace::file_line_cols() const {
+  // @@protoc_insertion_point(field_list:tensorflow.GraphDebugInfo.StackTrace.file_line_cols)
+  return _impl_.file_line_cols_;
+}
+
+// repeated fixed64 frame_id = 2 [packed = true];
+inline int GraphDebugInfo_StackTrace::_internal_frame_id_size() const {
+  return _impl_.frame_id_.size();
+}
+inline int GraphDebugInfo_StackTrace::frame_id_size() const {
+  return _internal_frame_id_size();
+}
+inline void GraphDebugInfo_StackTrace::clear_frame_id() {
+  _impl_.frame_id_.Clear();
+}
+inline uint64_t GraphDebugInfo_StackTrace::_internal_frame_id(int index) const {
+  return _impl_.frame_id_.Get(index);
+}
+inline uint64_t GraphDebugInfo_StackTrace::frame_id(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.GraphDebugInfo.StackTrace.frame_id)
+  return _internal_frame_id(index);
+}
+inline void GraphDebugInfo_StackTrace::set_frame_id(int index, uint64_t value) {
+  _impl_.frame_id_.Set(index, value);
+  // @@protoc_insertion_point(field_set:tensorflow.GraphDebugInfo.StackTrace.frame_id)
+}
+inline void GraphDebugInfo_StackTrace::_internal_add_frame_id(uint64_t value) {
+  _impl_.frame_id_.Add(value);
+}
+inline void GraphDebugInfo_StackTrace::add_frame_id(uint64_t value) {
+  _internal_add_frame_id(value);
+  // @@protoc_insertion_point(field_add:tensorflow.GraphDebugInfo.StackTrace.frame_id)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
+GraphDebugInfo_StackTrace::_internal_frame_id() const {
+  return _impl_.frame_id_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
+GraphDebugInfo_StackTrace::frame_id() const {
+  // @@protoc_insertion_point(field_list:tensorflow.GraphDebugInfo.StackTrace.frame_id)
+  return _internal_frame_id();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
+GraphDebugInfo_StackTrace::_internal_mutable_frame_id() {
+  return &_impl_.frame_id_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
+GraphDebugInfo_StackTrace::mutable_frame_id() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.GraphDebugInfo.StackTrace.frame_id)
+  return _internal_mutable_frame_id();
+}
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// GraphDebugInfo
+
+// repeated string files = 1;
+inline int GraphDebugInfo::_internal_files_size() const {
+  return _impl_.files_.size();
+}
+inline int GraphDebugInfo::files_size() const {
+  return _internal_files_size();
+}
+inline void GraphDebugInfo::clear_files() {
+  _impl_.files_.Clear();
+}
+inline std::string* GraphDebugInfo::add_files() {
+  std::string* _s = _internal_add_files();
+  // @@protoc_insertion_point(field_add_mutable:tensorflow.GraphDebugInfo.files)
+  return _s;
+}
+inline const std::string& GraphDebugInfo::_internal_files(int index) const {
+  return _impl_.files_.Get(index);
+}
+inline const std::string& GraphDebugInfo::files(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.GraphDebugInfo.files)
+  return _internal_files(index);
+}
+inline std::string* GraphDebugInfo::mutable_files(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.GraphDebugInfo.files)
+  return _impl_.files_.Mutable(index);
+}
+inline void GraphDebugInfo::set_files(int index, const std::string& value) {
+  _impl_.files_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:tensorflow.GraphDebugInfo.files)
+}
+inline void GraphDebugInfo::set_files(int index, std::string&& value) {
+  _impl_.files_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:tensorflow.GraphDebugInfo.files)
+}
+inline void GraphDebugInfo::set_files(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.files_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:tensorflow.GraphDebugInfo.files)
+}
+inline void GraphDebugInfo::set_files(int index, const char* value, size_t size) {
+  _impl_.files_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:tensorflow.GraphDebugInfo.files)
+}
+inline std::string* GraphDebugInfo::_internal_add_files() {
+  return _impl_.files_.Add();
+}
+inline void GraphDebugInfo::add_files(const std::string& value) {
+  _impl_.files_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:tensorflow.GraphDebugInfo.files)
+}
+inline void GraphDebugInfo::add_files(std::string&& value) {
+  _impl_.files_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:tensorflow.GraphDebugInfo.files)
+}
+inline void GraphDebugInfo::add_files(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.files_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:tensorflow.GraphDebugInfo.files)
+}
+inline void GraphDebugInfo::add_files(const char* value, size_t size) {
+  _impl_.files_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:tensorflow.GraphDebugInfo.files)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+GraphDebugInfo::files() const {
+  // @@protoc_insertion_point(field_list:tensorflow.GraphDebugInfo.files)
+  return _impl_.files_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+GraphDebugInfo::mutable_files() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.GraphDebugInfo.files)
+  return &_impl_.files_;
+}
+
+// map<fixed64, .tensorflow.GraphDebugInfo.FileLineCol> frames_by_id = 4;
+inline int GraphDebugInfo::_internal_frames_by_id_size() const {
+  return _impl_.frames_by_id_.size();
+}
+inline int GraphDebugInfo::frames_by_id_size() const {
+  return _internal_frames_by_id_size();
+}
+inline void GraphDebugInfo::clear_frames_by_id() {
+  _impl_.frames_by_id_.Clear();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< uint64_t, ::tensorflow::GraphDebugInfo_FileLineCol >&
+GraphDebugInfo::_internal_frames_by_id() const {
+  return _impl_.frames_by_id_.GetMap();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< uint64_t, ::tensorflow::GraphDebugInfo_FileLineCol >&
+GraphDebugInfo::frames_by_id() const {
+  // @@protoc_insertion_point(field_map:tensorflow.GraphDebugInfo.frames_by_id)
+  return _internal_frames_by_id();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< uint64_t, ::tensorflow::GraphDebugInfo_FileLineCol >*
+GraphDebugInfo::_internal_mutable_frames_by_id() {
+  return _impl_.frames_by_id_.MutableMap();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< uint64_t, ::tensorflow::GraphDebugInfo_FileLineCol >*
+GraphDebugInfo::mutable_frames_by_id() {
+  // @@protoc_insertion_point(field_mutable_map:tensorflow.GraphDebugInfo.frames_by_id)
+  return _internal_mutable_frames_by_id();
+}
+
+// map<fixed64, .tensorflow.GraphDebugInfo.StackTrace> traces_by_id = 6;
+inline int GraphDebugInfo::_internal_traces_by_id_size() const {
+  return _impl_.traces_by_id_.size();
+}
+inline int GraphDebugInfo::traces_by_id_size() const {
+  return _internal_traces_by_id_size();
+}
+inline void GraphDebugInfo::clear_traces_by_id() {
+  _impl_.traces_by_id_.Clear();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< uint64_t, ::tensorflow::GraphDebugInfo_StackTrace >&
+GraphDebugInfo::_internal_traces_by_id() const {
+  return _impl_.traces_by_id_.GetMap();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< uint64_t, ::tensorflow::GraphDebugInfo_StackTrace >&
+GraphDebugInfo::traces_by_id() const {
+  // @@protoc_insertion_point(field_map:tensorflow.GraphDebugInfo.traces_by_id)
+  return _internal_traces_by_id();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< uint64_t, ::tensorflow::GraphDebugInfo_StackTrace >*
+GraphDebugInfo::_internal_mutable_traces_by_id() {
+  return _impl_.traces_by_id_.MutableMap();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< uint64_t, ::tensorflow::GraphDebugInfo_StackTrace >*
+GraphDebugInfo::mutable_traces_by_id() {
+  // @@protoc_insertion_point(field_mutable_map:tensorflow.GraphDebugInfo.traces_by_id)
+  return _internal_mutable_traces_by_id();
+}
+
+// map<string, .tensorflow.GraphDebugInfo.StackTrace> traces = 2;
+inline int GraphDebugInfo::_internal_traces_size() const {
+  return _impl_.traces_.size();
+}
+inline int GraphDebugInfo::traces_size() const {
+  return _internal_traces_size();
+}
+inline void GraphDebugInfo::clear_traces() {
+  _impl_.traces_.Clear();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::GraphDebugInfo_StackTrace >&
+GraphDebugInfo::_internal_traces() const {
+  return _impl_.traces_.GetMap();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::GraphDebugInfo_StackTrace >&
+GraphDebugInfo::traces() const {
+  // @@protoc_insertion_point(field_map:tensorflow.GraphDebugInfo.traces)
+  return _internal_traces();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::GraphDebugInfo_StackTrace >*
+GraphDebugInfo::_internal_mutable_traces() {
+  return _impl_.traces_.MutableMap();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::GraphDebugInfo_StackTrace >*
+GraphDebugInfo::mutable_traces() {
+  // @@protoc_insertion_point(field_mutable_map:tensorflow.GraphDebugInfo.traces)
+  return _internal_mutable_traces();
+}
+
+// map<string, fixed64> name_to_trace_id = 5;
+inline int GraphDebugInfo::_internal_name_to_trace_id_size() const {
+  return _impl_.name_to_trace_id_.size();
+}
+inline int GraphDebugInfo::name_to_trace_id_size() const {
+  return _internal_name_to_trace_id_size();
+}
+inline void GraphDebugInfo::clear_name_to_trace_id() {
+  _impl_.name_to_trace_id_.Clear();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, uint64_t >&
+GraphDebugInfo::_internal_name_to_trace_id() const {
+  return _impl_.name_to_trace_id_.GetMap();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, uint64_t >&
+GraphDebugInfo::name_to_trace_id() const {
+  // @@protoc_insertion_point(field_map:tensorflow.GraphDebugInfo.name_to_trace_id)
+  return _internal_name_to_trace_id();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, uint64_t >*
+GraphDebugInfo::_internal_mutable_name_to_trace_id() {
+  return _impl_.name_to_trace_id_.MutableMap();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, uint64_t >*
+GraphDebugInfo::mutable_name_to_trace_id() {
+  // @@protoc_insertion_point(field_mutable_map:tensorflow.GraphDebugInfo.name_to_trace_id)
+  return _internal_mutable_name_to_trace_id();
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace tensorflow
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fgraph_5fdebug_5finfo_2eproto
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/graph_debug_info.proto b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/graph_debug_info.proto
new file mode 100644
index 0000000000000000000000000000000000000000..9a493445dba60b58041e01de8baf21e6621fdbb3
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/graph_debug_info.proto
@@ -0,0 +1,61 @@
+syntax = "proto2";
+
+package tensorflow;
+
+option cc_enable_arenas = true;
+option java_outer_classname = "GraphDebugInfoProtos";
+option java_multiple_files = true;
+option java_package = "org.tensorflow.framework";
+option go_package = "github.com/tensorflow/tensorflow/tensorflow/go/core/protobuf/for_core_protos_go_proto";
+
+message GraphDebugInfo {
+  // This represents a file/line location in the source code.
+  message FileLineCol {
+    // File name index, which can be used to retrieve the file name string from
+    // `files`. The value should be between 0 and (len(files)-1)
+    optional int32 file_index = 1;
+
+    // Line number in the file.
+    optional int32 line = 2;
+
+    // Col number in the file line.
+    optional int32 col = 3;
+
+    // Name of function contains the file line.
+    optional string func = 4;
+
+    // Source code contained in this file line.
+    optional string code = 5;
+  }
+
+  // This represents a stack trace which is a ordered list of `FileLineCol`.
+  message StackTrace {
+    repeated FileLineCol file_line_cols = 1;  // Deprecated.
+    repeated fixed64 frame_id = 2 [packed = true];
+  }
+
+  // This stores all the source code file names and can be indexed by the
+  // `file_index`.
+  repeated string files = 1;
+
+  // Stack traces and frames are uniqueified during construction. These maps
+  // index from the unique id for a frame/trace to the value.
+  map<fixed64, FileLineCol> frames_by_id = 4;
+  map<fixed64, StackTrace> traces_by_id = 6;
+
+  map<string, StackTrace> traces = 2;  // Deprecated.
+
+  // This maps a node name to a trace id contained in `traces_by_id`.
+  //
+  // The map key is a mangling of the containing function and op name with
+  // syntax:
+  //   op.name '@' func_name
+  // For ops in the top-level graph, the func_name is the empty string and hence
+  // the `@` may be ommitted.
+  // Note that op names are restricted to a small number of characters which
+  // exclude '@', making it impossible to collide keys of this form. Function
+  // names accept a much wider set of characters.
+  // It would be preferable to avoid mangling and use a tuple key of (op.name,
+  // func_name), but this is not supported with protocol buffers.
+  map<string, fixed64> name_to_trace_id = 5;
+}
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/graph_def_util.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/graph_def_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..9ebe610bdca2957623b4794714d31b1d52abfffb
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/graph_def_util.h
@@ -0,0 +1,135 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_GRAPH_DEF_UTIL_H_
+#define TENSORFLOW_CORE_FRAMEWORK_GRAPH_DEF_UTIL_H_
+
+#include <set>
+
+#include "tensorflow/core/framework/op.h"
+#include "tensorflow/core/lib/core/status.h"
+
+namespace tensorflow {
+
+// Forward declare proto so that it's symbols can be removed from .so exports
+class GraphDef;
+class NodeDef;
+
+// Produce a human-readable version of a GraphDef that is more concise
+// than a text-format proto.
+string SummarizeGraphDef(const GraphDef& graph_def);
+
+// Validates the syntax of a GraphDef provided externally.
+//
+// The following is an EBNF-style syntax for GraphDef objects. Note that
+// Node objects are actually specified as tensorflow::NodeDef protocol buffers,
+// which contain many other fields that are not (currently) validated.
+//
+// Graph        = Node *
+// Node         = NodeName, Inputs
+// Inputs       = ( DataInput * ), ( ControlInput * )
+// DataInput    = NodeName, ( ":", [1-9], [0-9] * ) ?
+// ControlInput = "^", NodeName
+// NodeName     = [A-Za-z0-9.], [A-Za-z0-9_./] *
+Status ValidateExternalGraphDefSyntax(const GraphDef& graph_def);
+
+// Adds default attributes to NodeDefs in 'graph_def' starting
+// from the 'node_offset' node in 'graph_def'.
+//
+// Default attributes are defined by 'op_registry'.
+//
+// Returns OK on success, an error if 'graph_def' has a NodeDef
+// that cannot be found in 'op_registry'.
+//
+// REQUIRES: 'graph_def' and 'op_registry' are not nullptr.
+Status AddDefaultAttrsToGraphDef(GraphDef* graph_def,
+                                 const OpRegistryInterface& op_registry,
+                                 int node_offset);
+
+// Same as above, except for the fact that it skips nodes that aren't found in
+// op_registry if skip_unknown_ops is true.
+Status AddDefaultAttrsToGraphDef(GraphDef* graph_def,
+                                 const OpRegistryInterface& op_registry,
+                                 int node_offset, bool skip_unknown_ops);
+
+// Remove attrs from 'graph_def' that have the default value according
+// to 'producer_op_registry', but don't exist according to
+// 'consumer_op_registry'. This can allow 'graph_def' to run on the
+// consumer even if consumer was built at an earlier CL (before an
+// attr with a default was added). Note that this will not affect
+// attrs with non-default values, so you must run a
+// ValidateGraphDef...() function to see if the result is in fact
+// compatible. If not nullptr, the op/attr pairs that were removed
+// are added to '*op_attr_removed'.
+//
+// Expected usage, for a producer that wants to prepare a graph for
+// a consumer:
+// // For each consumer, update 'graph_def':
+//   OpListOpRegistry consumer_op_registry(consumer_server_op_list);
+//   std::unordered_set<std::pair<string, string>> op_attr_removed;
+//   TF_RETURN_IF_ERROR(RemoveNewDefaultAttrsFromGraphDef(
+//       &graph_def, consumer_op_registry, *OpRegistry::Global(),
+//       &op_attr_removed));
+// // Validate that each consumer can understand the resulting 'graph_def'
+//   TF_RETURN_IF_ERROR(graph::ValidateGraphDefAgainstOpRegistry(
+//       graph_def, consumer_op_registry));
+// // Consumer can use 'graph_def', and 'op_attr_removed' summarizes
+// // what changes had to be made to 'graph_def' for it to work.
+//
+// Expected usage, for a consumer that has a graph and a
+// (optionally-stripped) op_list from a producer (say from a call to
+// StrippedOpListForGraph(), or in the MetaGraphDef):
+//   OpListOpRegistry producer_op_registry(producer_stripped_op_list);
+//   TF_RETURN_IF_ERROR(RemoveNewDefaultAttrsFromGraphDef(
+//       &graph_def, *OpRegistry::Global(), producer_op_registry, nullptr));
+Status RemoveNewDefaultAttrsFromGraphDef(
+    GraphDef* graph_def, const OpRegistryInterface& consumer_op_registry,
+    const OpRegistryInterface& producer_op_registry,
+    std::set<std::pair<string, string>>* op_attr_removed);
+
+// Goes over the `nodes` and removes attributes that are set to their
+// default values according to op_registry.
+// If some node's definition is not found in the `op_registry`, this node is
+// simply skipped. In most cases, these nodes would be function calls.
+// If a stricter behavior is desired, one can add FunctionLibraryDefinition
+// argument to check for functions and their attributes.
+// This is obvious from signature, but as a warning, if `nodes` contain
+// nodes calling functions, e.g. PartitionCallOp or FunctionalIf, this
+// function does not "recurse" into them.
+void StripDefaultAttributes(const OpRegistryInterface& op_registry,
+                            protobuf::RepeatedPtrField<NodeDef>* nodes);
+
+// Two functions that collect the ops used by a graph.
+//
+// This returns the ops used as a set of strings.
+void OpsUsedByGraph(const GraphDef& graph_def,
+                    std::set<string>* ops_used_in_graph);
+
+// This function computes the stripped_op_list field of MetaGraphDef
+// and similar protos.  The op_registry should contain the ops used to
+// produce graph_def.  The resulting stripped_op_list can be
+// communicated from the producer to the consumer, which can use
+// RemoveNewDefaultAttrsFromGraphDef() to improve forwards compatibility
+// (using an OpListOpRegistry as indicated in the example above).
+//
+// Most users will pass *OpRegistry::Global() for op_registry to strip against
+// the list of ops registered in this process.
+Status StrippedOpListForGraph(const GraphDef& graph_def,
+                              const OpRegistryInterface& op_registry,
+                              OpList* stripped_op_list);
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_GRAPH_DEF_UTIL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/graph_to_functiondef.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/graph_to_functiondef.h
new file mode 100644
index 0000000000000000000000000000000000000000..83e56caed774f89e22307164257048074f943b75
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/graph_to_functiondef.h
@@ -0,0 +1,72 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_GRAPH_TO_FUNCTIONDEF_H_
+#define TENSORFLOW_CORE_FRAMEWORK_GRAPH_TO_FUNCTIONDEF_H_
+
+#include <string>
+#include <vector>
+
+#include "tensorflow/core/framework/function.pb.h"
+#include "tensorflow/core/graph/graph.h"
+#include "tensorflow/core/lib/core/status.h"
+
+namespace tensorflow {
+
+// Graph to FunctionDef conversion. This code is closely modeled on the Python
+// function graph_to_function_def(), which is located in
+// tensorflow/python/framework/graph_to_function_def.py.
+Status GraphToFunctionDef(const Graph& fn_body, const string& fn_name,
+                          bool append_hash_to_fn_name,
+                          bool set_stateful_from_nodes,
+                          bool copy_placeholder_attrs_from_nodes,
+                          const std::vector<const Node*>& body_nodes,
+                          const std::vector<OutputTensor>& inputs,
+                          const std::vector<OutputTensor>& outputs,
+                          const std::vector<string>& output_names,
+                          const std::vector<const Node*>& control_outputs,
+                          const std::vector<string>& control_output_names,
+                          const char* description, FunctionDef* fdef);
+
+// Converts 'graph' to a FunctionDef 'fdef', with name 'name':
+//
+// (1) 'node->IsArg()' nodes converted to function inputs.
+// (2) 'node->IsRetval()' nodes converted to function output.
+// (3) 'control_ret' returns an optional with a control output name, that will
+//     be added to the function `control_ret` map (see FunctionDef) and
+//     `control_output` in Op definition (see OpDef). Control output name must
+//     be unique for all control output nodes.
+Status GraphToFunctionDef(
+    const Graph& graph, const string& name,
+    const std::function<absl::optional<string>(const Node*)>& control_ret,
+    FunctionDef* fdef);
+
+Status GraphToFunctionDef(const Graph& graph, const string& name,
+                          FunctionDef* fdef);
+
+Status GraphToFunctionDef(const Graph& graph, const string& name,
+                          const std::vector<std::string>& output_names,
+                          FunctionDef* fdef);
+
+Status GetGraphAndArgRets(
+    const string& function_name, AttrSlice attrs, const FunctionDef* fdef,
+    const FunctionLibraryDefinition* lib_def, std::unique_ptr<Graph>* graph,
+    std::vector<Node*>* arg_nodes, std::vector<Node*>* ret_nodes,
+    std::vector<string>* ret_node_names, DataTypeVector* ret_types,
+    std::vector<string>* control_ret_node_names);
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_GRAPH_TO_FUNCTIONDEF_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/graph_transfer_info.pb.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/graph_transfer_info.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..426592dd8fc120096cd546bad7316bbed5c01b16
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/graph_transfer_info.pb.h
@@ -0,0 +1,2850 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: tensorflow/core/framework/graph_transfer_info.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fgraph_5ftransfer_5finfo_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fgraph_5ftransfer_5finfo_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3021000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3021009 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "tensorflow/core/framework/types.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_tensorflow_2fcore_2fframework_2fgraph_5ftransfer_5finfo_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_tensorflow_2fcore_2fframework_2fgraph_5ftransfer_5finfo_2eproto {
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_tensorflow_2fcore_2fframework_2fgraph_5ftransfer_5finfo_2eproto;
+namespace tensorflow {
+class GraphTransferConstNodeInfo;
+struct GraphTransferConstNodeInfoDefaultTypeInternal;
+extern GraphTransferConstNodeInfoDefaultTypeInternal _GraphTransferConstNodeInfo_default_instance_;
+class GraphTransferGraphInputNodeInfo;
+struct GraphTransferGraphInputNodeInfoDefaultTypeInternal;
+extern GraphTransferGraphInputNodeInfoDefaultTypeInternal _GraphTransferGraphInputNodeInfo_default_instance_;
+class GraphTransferGraphOutputNodeInfo;
+struct GraphTransferGraphOutputNodeInfoDefaultTypeInternal;
+extern GraphTransferGraphOutputNodeInfoDefaultTypeInternal _GraphTransferGraphOutputNodeInfo_default_instance_;
+class GraphTransferInfo;
+struct GraphTransferInfoDefaultTypeInternal;
+extern GraphTransferInfoDefaultTypeInternal _GraphTransferInfo_default_instance_;
+class GraphTransferNodeInfo;
+struct GraphTransferNodeInfoDefaultTypeInternal;
+extern GraphTransferNodeInfoDefaultTypeInternal _GraphTransferNodeInfo_default_instance_;
+class GraphTransferNodeInput;
+struct GraphTransferNodeInputDefaultTypeInternal;
+extern GraphTransferNodeInputDefaultTypeInternal _GraphTransferNodeInput_default_instance_;
+class GraphTransferNodeInputInfo;
+struct GraphTransferNodeInputInfoDefaultTypeInternal;
+extern GraphTransferNodeInputInfoDefaultTypeInternal _GraphTransferNodeInputInfo_default_instance_;
+class GraphTransferNodeOutputInfo;
+struct GraphTransferNodeOutputInfoDefaultTypeInternal;
+extern GraphTransferNodeOutputInfoDefaultTypeInternal _GraphTransferNodeOutputInfo_default_instance_;
+}  // namespace tensorflow
+PROTOBUF_NAMESPACE_OPEN
+template<> ::tensorflow::GraphTransferConstNodeInfo* Arena::CreateMaybeMessage<::tensorflow::GraphTransferConstNodeInfo>(Arena*);
+template<> ::tensorflow::GraphTransferGraphInputNodeInfo* Arena::CreateMaybeMessage<::tensorflow::GraphTransferGraphInputNodeInfo>(Arena*);
+template<> ::tensorflow::GraphTransferGraphOutputNodeInfo* Arena::CreateMaybeMessage<::tensorflow::GraphTransferGraphOutputNodeInfo>(Arena*);
+template<> ::tensorflow::GraphTransferInfo* Arena::CreateMaybeMessage<::tensorflow::GraphTransferInfo>(Arena*);
+template<> ::tensorflow::GraphTransferNodeInfo* Arena::CreateMaybeMessage<::tensorflow::GraphTransferNodeInfo>(Arena*);
+template<> ::tensorflow::GraphTransferNodeInput* Arena::CreateMaybeMessage<::tensorflow::GraphTransferNodeInput>(Arena*);
+template<> ::tensorflow::GraphTransferNodeInputInfo* Arena::CreateMaybeMessage<::tensorflow::GraphTransferNodeInputInfo>(Arena*);
+template<> ::tensorflow::GraphTransferNodeOutputInfo* Arena::CreateMaybeMessage<::tensorflow::GraphTransferNodeOutputInfo>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace tensorflow {
+
+enum GraphTransferInfo_Destination : int {
+  GraphTransferInfo_Destination_NOP = 0,
+  GraphTransferInfo_Destination_HEXAGON = 1,
+  GraphTransferInfo_Destination_GraphTransferInfo_Destination_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
+  GraphTransferInfo_Destination_GraphTransferInfo_Destination_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
+};
+bool GraphTransferInfo_Destination_IsValid(int value);
+constexpr GraphTransferInfo_Destination GraphTransferInfo_Destination_Destination_MIN = GraphTransferInfo_Destination_NOP;
+constexpr GraphTransferInfo_Destination GraphTransferInfo_Destination_Destination_MAX = GraphTransferInfo_Destination_HEXAGON;
+constexpr int GraphTransferInfo_Destination_Destination_ARRAYSIZE = GraphTransferInfo_Destination_Destination_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* GraphTransferInfo_Destination_descriptor();
+template<typename T>
+inline const std::string& GraphTransferInfo_Destination_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, GraphTransferInfo_Destination>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function GraphTransferInfo_Destination_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    GraphTransferInfo_Destination_descriptor(), enum_t_value);
+}
+inline bool GraphTransferInfo_Destination_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, GraphTransferInfo_Destination* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<GraphTransferInfo_Destination>(
+    GraphTransferInfo_Destination_descriptor(), name, value);
+}
+// ===================================================================
+
+class GraphTransferNodeInput final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.GraphTransferNodeInput) */ {
+ public:
+  inline GraphTransferNodeInput() : GraphTransferNodeInput(nullptr) {}
+  ~GraphTransferNodeInput() override;
+  explicit PROTOBUF_CONSTEXPR GraphTransferNodeInput(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  GraphTransferNodeInput(const GraphTransferNodeInput& from);
+  GraphTransferNodeInput(GraphTransferNodeInput&& from) noexcept
+    : GraphTransferNodeInput() {
+    *this = ::std::move(from);
+  }
+
+  inline GraphTransferNodeInput& operator=(const GraphTransferNodeInput& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline GraphTransferNodeInput& operator=(GraphTransferNodeInput&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const GraphTransferNodeInput& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const GraphTransferNodeInput* internal_default_instance() {
+    return reinterpret_cast<const GraphTransferNodeInput*>(
+               &_GraphTransferNodeInput_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(GraphTransferNodeInput& a, GraphTransferNodeInput& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(GraphTransferNodeInput* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(GraphTransferNodeInput* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  GraphTransferNodeInput* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<GraphTransferNodeInput>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const GraphTransferNodeInput& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const GraphTransferNodeInput& from) {
+    GraphTransferNodeInput::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(GraphTransferNodeInput* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.GraphTransferNodeInput";
+  }
+  protected:
+  explicit GraphTransferNodeInput(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNodeIdFieldNumber = 1,
+    kOutputPortFieldNumber = 2,
+  };
+  // int32 node_id = 1;
+  void clear_node_id();
+  int32_t node_id() const;
+  void set_node_id(int32_t value);
+  private:
+  int32_t _internal_node_id() const;
+  void _internal_set_node_id(int32_t value);
+  public:
+
+  // int32 output_port = 2;
+  void clear_output_port();
+  int32_t output_port() const;
+  void set_output_port(int32_t value);
+  private:
+  int32_t _internal_output_port() const;
+  void _internal_set_output_port(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.GraphTransferNodeInput)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    int32_t node_id_;
+    int32_t output_port_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fgraph_5ftransfer_5finfo_2eproto;
+};
+// -------------------------------------------------------------------
+
+class GraphTransferNodeInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.GraphTransferNodeInfo) */ {
+ public:
+  inline GraphTransferNodeInfo() : GraphTransferNodeInfo(nullptr) {}
+  ~GraphTransferNodeInfo() override;
+  explicit PROTOBUF_CONSTEXPR GraphTransferNodeInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  GraphTransferNodeInfo(const GraphTransferNodeInfo& from);
+  GraphTransferNodeInfo(GraphTransferNodeInfo&& from) noexcept
+    : GraphTransferNodeInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline GraphTransferNodeInfo& operator=(const GraphTransferNodeInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline GraphTransferNodeInfo& operator=(GraphTransferNodeInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const GraphTransferNodeInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const GraphTransferNodeInfo* internal_default_instance() {
+    return reinterpret_cast<const GraphTransferNodeInfo*>(
+               &_GraphTransferNodeInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(GraphTransferNodeInfo& a, GraphTransferNodeInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(GraphTransferNodeInfo* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(GraphTransferNodeInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  GraphTransferNodeInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<GraphTransferNodeInfo>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const GraphTransferNodeInfo& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const GraphTransferNodeInfo& from) {
+    GraphTransferNodeInfo::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(GraphTransferNodeInfo* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.GraphTransferNodeInfo";
+  }
+  protected:
+  explicit GraphTransferNodeInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNameFieldNumber = 1,
+    kTypeNameFieldNumber = 3,
+    kNodeIdFieldNumber = 2,
+    kSocOpIdFieldNumber = 4,
+    kPaddingIdFieldNumber = 5,
+    kInputCountFieldNumber = 6,
+    kOutputCountFieldNumber = 7,
+  };
+  // string name = 1;
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // string type_name = 3;
+  void clear_type_name();
+  const std::string& type_name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_type_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_type_name();
+  PROTOBUF_NODISCARD std::string* release_type_name();
+  void set_allocated_type_name(std::string* type_name);
+  private:
+  const std::string& _internal_type_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_type_name(const std::string& value);
+  std::string* _internal_mutable_type_name();
+  public:
+
+  // int32 node_id = 2;
+  void clear_node_id();
+  int32_t node_id() const;
+  void set_node_id(int32_t value);
+  private:
+  int32_t _internal_node_id() const;
+  void _internal_set_node_id(int32_t value);
+  public:
+
+  // int32 soc_op_id = 4;
+  void clear_soc_op_id();
+  int32_t soc_op_id() const;
+  void set_soc_op_id(int32_t value);
+  private:
+  int32_t _internal_soc_op_id() const;
+  void _internal_set_soc_op_id(int32_t value);
+  public:
+
+  // int32 padding_id = 5;
+  void clear_padding_id();
+  int32_t padding_id() const;
+  void set_padding_id(int32_t value);
+  private:
+  int32_t _internal_padding_id() const;
+  void _internal_set_padding_id(int32_t value);
+  public:
+
+  // int32 input_count = 6;
+  void clear_input_count();
+  int32_t input_count() const;
+  void set_input_count(int32_t value);
+  private:
+  int32_t _internal_input_count() const;
+  void _internal_set_input_count(int32_t value);
+  public:
+
+  // int32 output_count = 7;
+  void clear_output_count();
+  int32_t output_count() const;
+  void set_output_count(int32_t value);
+  private:
+  int32_t _internal_output_count() const;
+  void _internal_set_output_count(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.GraphTransferNodeInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_name_;
+    int32_t node_id_;
+    int32_t soc_op_id_;
+    int32_t padding_id_;
+    int32_t input_count_;
+    int32_t output_count_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fgraph_5ftransfer_5finfo_2eproto;
+};
+// -------------------------------------------------------------------
+
+class GraphTransferConstNodeInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.GraphTransferConstNodeInfo) */ {
+ public:
+  inline GraphTransferConstNodeInfo() : GraphTransferConstNodeInfo(nullptr) {}
+  ~GraphTransferConstNodeInfo() override;
+  explicit PROTOBUF_CONSTEXPR GraphTransferConstNodeInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  GraphTransferConstNodeInfo(const GraphTransferConstNodeInfo& from);
+  GraphTransferConstNodeInfo(GraphTransferConstNodeInfo&& from) noexcept
+    : GraphTransferConstNodeInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline GraphTransferConstNodeInfo& operator=(const GraphTransferConstNodeInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline GraphTransferConstNodeInfo& operator=(GraphTransferConstNodeInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const GraphTransferConstNodeInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const GraphTransferConstNodeInfo* internal_default_instance() {
+    return reinterpret_cast<const GraphTransferConstNodeInfo*>(
+               &_GraphTransferConstNodeInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(GraphTransferConstNodeInfo& a, GraphTransferConstNodeInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(GraphTransferConstNodeInfo* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(GraphTransferConstNodeInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  GraphTransferConstNodeInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<GraphTransferConstNodeInfo>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const GraphTransferConstNodeInfo& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const GraphTransferConstNodeInfo& from) {
+    GraphTransferConstNodeInfo::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(GraphTransferConstNodeInfo* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.GraphTransferConstNodeInfo";
+  }
+  protected:
+  explicit GraphTransferConstNodeInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kShapeFieldNumber = 3,
+    kNameFieldNumber = 1,
+    kDataFieldNumber = 4,
+    kNodeIdFieldNumber = 2,
+    kDtypeFieldNumber = 5,
+  };
+  // repeated int64 shape = 3;
+  int shape_size() const;
+  private:
+  int _internal_shape_size() const;
+  public:
+  void clear_shape();
+  private:
+  int64_t _internal_shape(int index) const;
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
+      _internal_shape() const;
+  void _internal_add_shape(int64_t value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
+      _internal_mutable_shape();
+  public:
+  int64_t shape(int index) const;
+  void set_shape(int index, int64_t value);
+  void add_shape(int64_t value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
+      shape() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
+      mutable_shape();
+
+  // string name = 1;
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // bytes data = 4;
+  void clear_data();
+  const std::string& data() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_data(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_data();
+  PROTOBUF_NODISCARD std::string* release_data();
+  void set_allocated_data(std::string* data);
+  private:
+  const std::string& _internal_data() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_data(const std::string& value);
+  std::string* _internal_mutable_data();
+  public:
+
+  // int32 node_id = 2;
+  void clear_node_id();
+  int32_t node_id() const;
+  void set_node_id(int32_t value);
+  private:
+  int32_t _internal_node_id() const;
+  void _internal_set_node_id(int32_t value);
+  public:
+
+  // .tensorflow.DataType dtype = 5;
+  void clear_dtype();
+  ::tensorflow::DataType dtype() const;
+  void set_dtype(::tensorflow::DataType value);
+  private:
+  ::tensorflow::DataType _internal_dtype() const;
+  void _internal_set_dtype(::tensorflow::DataType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.GraphTransferConstNodeInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > shape_;
+    mutable std::atomic<int> _shape_cached_byte_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr data_;
+    int32_t node_id_;
+    int dtype_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fgraph_5ftransfer_5finfo_2eproto;
+};
+// -------------------------------------------------------------------
+
+class GraphTransferNodeInputInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.GraphTransferNodeInputInfo) */ {
+ public:
+  inline GraphTransferNodeInputInfo() : GraphTransferNodeInputInfo(nullptr) {}
+  ~GraphTransferNodeInputInfo() override;
+  explicit PROTOBUF_CONSTEXPR GraphTransferNodeInputInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  GraphTransferNodeInputInfo(const GraphTransferNodeInputInfo& from);
+  GraphTransferNodeInputInfo(GraphTransferNodeInputInfo&& from) noexcept
+    : GraphTransferNodeInputInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline GraphTransferNodeInputInfo& operator=(const GraphTransferNodeInputInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline GraphTransferNodeInputInfo& operator=(GraphTransferNodeInputInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const GraphTransferNodeInputInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const GraphTransferNodeInputInfo* internal_default_instance() {
+    return reinterpret_cast<const GraphTransferNodeInputInfo*>(
+               &_GraphTransferNodeInputInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  friend void swap(GraphTransferNodeInputInfo& a, GraphTransferNodeInputInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(GraphTransferNodeInputInfo* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(GraphTransferNodeInputInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  GraphTransferNodeInputInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<GraphTransferNodeInputInfo>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const GraphTransferNodeInputInfo& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const GraphTransferNodeInputInfo& from) {
+    GraphTransferNodeInputInfo::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(GraphTransferNodeInputInfo* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.GraphTransferNodeInputInfo";
+  }
+  protected:
+  explicit GraphTransferNodeInputInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNodeInputFieldNumber = 2,
+    kNodeIdFieldNumber = 1,
+  };
+  // repeated .tensorflow.GraphTransferNodeInput node_input = 2;
+  int node_input_size() const;
+  private:
+  int _internal_node_input_size() const;
+  public:
+  void clear_node_input();
+  ::tensorflow::GraphTransferNodeInput* mutable_node_input(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::GraphTransferNodeInput >*
+      mutable_node_input();
+  private:
+  const ::tensorflow::GraphTransferNodeInput& _internal_node_input(int index) const;
+  ::tensorflow::GraphTransferNodeInput* _internal_add_node_input();
+  public:
+  const ::tensorflow::GraphTransferNodeInput& node_input(int index) const;
+  ::tensorflow::GraphTransferNodeInput* add_node_input();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::GraphTransferNodeInput >&
+      node_input() const;
+
+  // int32 node_id = 1;
+  void clear_node_id();
+  int32_t node_id() const;
+  void set_node_id(int32_t value);
+  private:
+  int32_t _internal_node_id() const;
+  void _internal_set_node_id(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.GraphTransferNodeInputInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::GraphTransferNodeInput > node_input_;
+    int32_t node_id_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fgraph_5ftransfer_5finfo_2eproto;
+};
+// -------------------------------------------------------------------
+
+class GraphTransferNodeOutputInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.GraphTransferNodeOutputInfo) */ {
+ public:
+  inline GraphTransferNodeOutputInfo() : GraphTransferNodeOutputInfo(nullptr) {}
+  ~GraphTransferNodeOutputInfo() override;
+  explicit PROTOBUF_CONSTEXPR GraphTransferNodeOutputInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  GraphTransferNodeOutputInfo(const GraphTransferNodeOutputInfo& from);
+  GraphTransferNodeOutputInfo(GraphTransferNodeOutputInfo&& from) noexcept
+    : GraphTransferNodeOutputInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline GraphTransferNodeOutputInfo& operator=(const GraphTransferNodeOutputInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline GraphTransferNodeOutputInfo& operator=(GraphTransferNodeOutputInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const GraphTransferNodeOutputInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const GraphTransferNodeOutputInfo* internal_default_instance() {
+    return reinterpret_cast<const GraphTransferNodeOutputInfo*>(
+               &_GraphTransferNodeOutputInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    4;
+
+  friend void swap(GraphTransferNodeOutputInfo& a, GraphTransferNodeOutputInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(GraphTransferNodeOutputInfo* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(GraphTransferNodeOutputInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  GraphTransferNodeOutputInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<GraphTransferNodeOutputInfo>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const GraphTransferNodeOutputInfo& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const GraphTransferNodeOutputInfo& from) {
+    GraphTransferNodeOutputInfo::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(GraphTransferNodeOutputInfo* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.GraphTransferNodeOutputInfo";
+  }
+  protected:
+  explicit GraphTransferNodeOutputInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kMaxByteSizeFieldNumber = 2,
+    kNodeIdFieldNumber = 1,
+  };
+  // repeated int32 max_byte_size = 2;
+  int max_byte_size_size() const;
+  private:
+  int _internal_max_byte_size_size() const;
+  public:
+  void clear_max_byte_size();
+  private:
+  int32_t _internal_max_byte_size(int index) const;
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+      _internal_max_byte_size() const;
+  void _internal_add_max_byte_size(int32_t value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+      _internal_mutable_max_byte_size();
+  public:
+  int32_t max_byte_size(int index) const;
+  void set_max_byte_size(int index, int32_t value);
+  void add_max_byte_size(int32_t value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+      max_byte_size() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+      mutable_max_byte_size();
+
+  // int32 node_id = 1;
+  void clear_node_id();
+  int32_t node_id() const;
+  void set_node_id(int32_t value);
+  private:
+  int32_t _internal_node_id() const;
+  void _internal_set_node_id(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.GraphTransferNodeOutputInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > max_byte_size_;
+    mutable std::atomic<int> _max_byte_size_cached_byte_size_;
+    int32_t node_id_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fgraph_5ftransfer_5finfo_2eproto;
+};
+// -------------------------------------------------------------------
+
+class GraphTransferGraphInputNodeInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.GraphTransferGraphInputNodeInfo) */ {
+ public:
+  inline GraphTransferGraphInputNodeInfo() : GraphTransferGraphInputNodeInfo(nullptr) {}
+  ~GraphTransferGraphInputNodeInfo() override;
+  explicit PROTOBUF_CONSTEXPR GraphTransferGraphInputNodeInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  GraphTransferGraphInputNodeInfo(const GraphTransferGraphInputNodeInfo& from);
+  GraphTransferGraphInputNodeInfo(GraphTransferGraphInputNodeInfo&& from) noexcept
+    : GraphTransferGraphInputNodeInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline GraphTransferGraphInputNodeInfo& operator=(const GraphTransferGraphInputNodeInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline GraphTransferGraphInputNodeInfo& operator=(GraphTransferGraphInputNodeInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const GraphTransferGraphInputNodeInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const GraphTransferGraphInputNodeInfo* internal_default_instance() {
+    return reinterpret_cast<const GraphTransferGraphInputNodeInfo*>(
+               &_GraphTransferGraphInputNodeInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    5;
+
+  friend void swap(GraphTransferGraphInputNodeInfo& a, GraphTransferGraphInputNodeInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(GraphTransferGraphInputNodeInfo* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(GraphTransferGraphInputNodeInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  GraphTransferGraphInputNodeInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<GraphTransferGraphInputNodeInfo>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const GraphTransferGraphInputNodeInfo& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const GraphTransferGraphInputNodeInfo& from) {
+    GraphTransferGraphInputNodeInfo::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(GraphTransferGraphInputNodeInfo* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.GraphTransferGraphInputNodeInfo";
+  }
+  protected:
+  explicit GraphTransferGraphInputNodeInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kShapeFieldNumber = 2,
+    kNameFieldNumber = 1,
+    kDtypeFieldNumber = 3,
+  };
+  // repeated int64 shape = 2;
+  int shape_size() const;
+  private:
+  int _internal_shape_size() const;
+  public:
+  void clear_shape();
+  private:
+  int64_t _internal_shape(int index) const;
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
+      _internal_shape() const;
+  void _internal_add_shape(int64_t value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
+      _internal_mutable_shape();
+  public:
+  int64_t shape(int index) const;
+  void set_shape(int index, int64_t value);
+  void add_shape(int64_t value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
+      shape() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
+      mutable_shape();
+
+  // string name = 1;
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // .tensorflow.DataType dtype = 3;
+  void clear_dtype();
+  ::tensorflow::DataType dtype() const;
+  void set_dtype(::tensorflow::DataType value);
+  private:
+  ::tensorflow::DataType _internal_dtype() const;
+  void _internal_set_dtype(::tensorflow::DataType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.GraphTransferGraphInputNodeInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > shape_;
+    mutable std::atomic<int> _shape_cached_byte_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+    int dtype_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fgraph_5ftransfer_5finfo_2eproto;
+};
+// -------------------------------------------------------------------
+
+class GraphTransferGraphOutputNodeInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.GraphTransferGraphOutputNodeInfo) */ {
+ public:
+  inline GraphTransferGraphOutputNodeInfo() : GraphTransferGraphOutputNodeInfo(nullptr) {}
+  ~GraphTransferGraphOutputNodeInfo() override;
+  explicit PROTOBUF_CONSTEXPR GraphTransferGraphOutputNodeInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  GraphTransferGraphOutputNodeInfo(const GraphTransferGraphOutputNodeInfo& from);
+  GraphTransferGraphOutputNodeInfo(GraphTransferGraphOutputNodeInfo&& from) noexcept
+    : GraphTransferGraphOutputNodeInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline GraphTransferGraphOutputNodeInfo& operator=(const GraphTransferGraphOutputNodeInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline GraphTransferGraphOutputNodeInfo& operator=(GraphTransferGraphOutputNodeInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const GraphTransferGraphOutputNodeInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const GraphTransferGraphOutputNodeInfo* internal_default_instance() {
+    return reinterpret_cast<const GraphTransferGraphOutputNodeInfo*>(
+               &_GraphTransferGraphOutputNodeInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    6;
+
+  friend void swap(GraphTransferGraphOutputNodeInfo& a, GraphTransferGraphOutputNodeInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(GraphTransferGraphOutputNodeInfo* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(GraphTransferGraphOutputNodeInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  GraphTransferGraphOutputNodeInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<GraphTransferGraphOutputNodeInfo>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const GraphTransferGraphOutputNodeInfo& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const GraphTransferGraphOutputNodeInfo& from) {
+    GraphTransferGraphOutputNodeInfo::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(GraphTransferGraphOutputNodeInfo* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.GraphTransferGraphOutputNodeInfo";
+  }
+  protected:
+  explicit GraphTransferGraphOutputNodeInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kShapeFieldNumber = 2,
+    kNameFieldNumber = 1,
+    kDtypeFieldNumber = 3,
+  };
+  // repeated int64 shape = 2;
+  int shape_size() const;
+  private:
+  int _internal_shape_size() const;
+  public:
+  void clear_shape();
+  private:
+  int64_t _internal_shape(int index) const;
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
+      _internal_shape() const;
+  void _internal_add_shape(int64_t value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
+      _internal_mutable_shape();
+  public:
+  int64_t shape(int index) const;
+  void set_shape(int index, int64_t value);
+  void add_shape(int64_t value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
+      shape() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
+      mutable_shape();
+
+  // string name = 1;
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // .tensorflow.DataType dtype = 3;
+  void clear_dtype();
+  ::tensorflow::DataType dtype() const;
+  void set_dtype(::tensorflow::DataType value);
+  private:
+  ::tensorflow::DataType _internal_dtype() const;
+  void _internal_set_dtype(::tensorflow::DataType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.GraphTransferGraphOutputNodeInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > shape_;
+    mutable std::atomic<int> _shape_cached_byte_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+    int dtype_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fgraph_5ftransfer_5finfo_2eproto;
+};
+// -------------------------------------------------------------------
+
+class GraphTransferInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.GraphTransferInfo) */ {
+ public:
+  inline GraphTransferInfo() : GraphTransferInfo(nullptr) {}
+  ~GraphTransferInfo() override;
+  explicit PROTOBUF_CONSTEXPR GraphTransferInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  GraphTransferInfo(const GraphTransferInfo& from);
+  GraphTransferInfo(GraphTransferInfo&& from) noexcept
+    : GraphTransferInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline GraphTransferInfo& operator=(const GraphTransferInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline GraphTransferInfo& operator=(GraphTransferInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const GraphTransferInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const GraphTransferInfo* internal_default_instance() {
+    return reinterpret_cast<const GraphTransferInfo*>(
+               &_GraphTransferInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    7;
+
+  friend void swap(GraphTransferInfo& a, GraphTransferInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(GraphTransferInfo* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(GraphTransferInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  GraphTransferInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<GraphTransferInfo>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const GraphTransferInfo& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const GraphTransferInfo& from) {
+    GraphTransferInfo::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(GraphTransferInfo* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.GraphTransferInfo";
+  }
+  protected:
+  explicit GraphTransferInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef GraphTransferInfo_Destination Destination;
+  static constexpr Destination NOP =
+    GraphTransferInfo_Destination_NOP;
+  static constexpr Destination HEXAGON =
+    GraphTransferInfo_Destination_HEXAGON;
+  static inline bool Destination_IsValid(int value) {
+    return GraphTransferInfo_Destination_IsValid(value);
+  }
+  static constexpr Destination Destination_MIN =
+    GraphTransferInfo_Destination_Destination_MIN;
+  static constexpr Destination Destination_MAX =
+    GraphTransferInfo_Destination_Destination_MAX;
+  static constexpr int Destination_ARRAYSIZE =
+    GraphTransferInfo_Destination_Destination_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  Destination_descriptor() {
+    return GraphTransferInfo_Destination_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& Destination_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, Destination>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function Destination_Name.");
+    return GraphTransferInfo_Destination_Name(enum_t_value);
+  }
+  static inline bool Destination_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      Destination* value) {
+    return GraphTransferInfo_Destination_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNodeInfoFieldNumber = 1,
+    kConstNodeInfoFieldNumber = 2,
+    kNodeInputInfoFieldNumber = 3,
+    kNodeOutputInfoFieldNumber = 4,
+    kGraphInputNodeInfoFieldNumber = 5,
+    kGraphOutputNodeInfoFieldNumber = 6,
+    kDestinationFieldNumber = 7,
+  };
+  // repeated .tensorflow.GraphTransferNodeInfo node_info = 1;
+  int node_info_size() const;
+  private:
+  int _internal_node_info_size() const;
+  public:
+  void clear_node_info();
+  ::tensorflow::GraphTransferNodeInfo* mutable_node_info(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::GraphTransferNodeInfo >*
+      mutable_node_info();
+  private:
+  const ::tensorflow::GraphTransferNodeInfo& _internal_node_info(int index) const;
+  ::tensorflow::GraphTransferNodeInfo* _internal_add_node_info();
+  public:
+  const ::tensorflow::GraphTransferNodeInfo& node_info(int index) const;
+  ::tensorflow::GraphTransferNodeInfo* add_node_info();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::GraphTransferNodeInfo >&
+      node_info() const;
+
+  // repeated .tensorflow.GraphTransferConstNodeInfo const_node_info = 2;
+  int const_node_info_size() const;
+  private:
+  int _internal_const_node_info_size() const;
+  public:
+  void clear_const_node_info();
+  ::tensorflow::GraphTransferConstNodeInfo* mutable_const_node_info(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::GraphTransferConstNodeInfo >*
+      mutable_const_node_info();
+  private:
+  const ::tensorflow::GraphTransferConstNodeInfo& _internal_const_node_info(int index) const;
+  ::tensorflow::GraphTransferConstNodeInfo* _internal_add_const_node_info();
+  public:
+  const ::tensorflow::GraphTransferConstNodeInfo& const_node_info(int index) const;
+  ::tensorflow::GraphTransferConstNodeInfo* add_const_node_info();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::GraphTransferConstNodeInfo >&
+      const_node_info() const;
+
+  // repeated .tensorflow.GraphTransferNodeInputInfo node_input_info = 3;
+  int node_input_info_size() const;
+  private:
+  int _internal_node_input_info_size() const;
+  public:
+  void clear_node_input_info();
+  ::tensorflow::GraphTransferNodeInputInfo* mutable_node_input_info(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::GraphTransferNodeInputInfo >*
+      mutable_node_input_info();
+  private:
+  const ::tensorflow::GraphTransferNodeInputInfo& _internal_node_input_info(int index) const;
+  ::tensorflow::GraphTransferNodeInputInfo* _internal_add_node_input_info();
+  public:
+  const ::tensorflow::GraphTransferNodeInputInfo& node_input_info(int index) const;
+  ::tensorflow::GraphTransferNodeInputInfo* add_node_input_info();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::GraphTransferNodeInputInfo >&
+      node_input_info() const;
+
+  // repeated .tensorflow.GraphTransferNodeOutputInfo node_output_info = 4;
+  int node_output_info_size() const;
+  private:
+  int _internal_node_output_info_size() const;
+  public:
+  void clear_node_output_info();
+  ::tensorflow::GraphTransferNodeOutputInfo* mutable_node_output_info(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::GraphTransferNodeOutputInfo >*
+      mutable_node_output_info();
+  private:
+  const ::tensorflow::GraphTransferNodeOutputInfo& _internal_node_output_info(int index) const;
+  ::tensorflow::GraphTransferNodeOutputInfo* _internal_add_node_output_info();
+  public:
+  const ::tensorflow::GraphTransferNodeOutputInfo& node_output_info(int index) const;
+  ::tensorflow::GraphTransferNodeOutputInfo* add_node_output_info();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::GraphTransferNodeOutputInfo >&
+      node_output_info() const;
+
+  // repeated .tensorflow.GraphTransferGraphInputNodeInfo graph_input_node_info = 5;
+  int graph_input_node_info_size() const;
+  private:
+  int _internal_graph_input_node_info_size() const;
+  public:
+  void clear_graph_input_node_info();
+  ::tensorflow::GraphTransferGraphInputNodeInfo* mutable_graph_input_node_info(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::GraphTransferGraphInputNodeInfo >*
+      mutable_graph_input_node_info();
+  private:
+  const ::tensorflow::GraphTransferGraphInputNodeInfo& _internal_graph_input_node_info(int index) const;
+  ::tensorflow::GraphTransferGraphInputNodeInfo* _internal_add_graph_input_node_info();
+  public:
+  const ::tensorflow::GraphTransferGraphInputNodeInfo& graph_input_node_info(int index) const;
+  ::tensorflow::GraphTransferGraphInputNodeInfo* add_graph_input_node_info();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::GraphTransferGraphInputNodeInfo >&
+      graph_input_node_info() const;
+
+  // repeated .tensorflow.GraphTransferGraphOutputNodeInfo graph_output_node_info = 6;
+  int graph_output_node_info_size() const;
+  private:
+  int _internal_graph_output_node_info_size() const;
+  public:
+  void clear_graph_output_node_info();
+  ::tensorflow::GraphTransferGraphOutputNodeInfo* mutable_graph_output_node_info(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::GraphTransferGraphOutputNodeInfo >*
+      mutable_graph_output_node_info();
+  private:
+  const ::tensorflow::GraphTransferGraphOutputNodeInfo& _internal_graph_output_node_info(int index) const;
+  ::tensorflow::GraphTransferGraphOutputNodeInfo* _internal_add_graph_output_node_info();
+  public:
+  const ::tensorflow::GraphTransferGraphOutputNodeInfo& graph_output_node_info(int index) const;
+  ::tensorflow::GraphTransferGraphOutputNodeInfo* add_graph_output_node_info();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::GraphTransferGraphOutputNodeInfo >&
+      graph_output_node_info() const;
+
+  // .tensorflow.GraphTransferInfo.Destination destination = 7;
+  void clear_destination();
+  ::tensorflow::GraphTransferInfo_Destination destination() const;
+  void set_destination(::tensorflow::GraphTransferInfo_Destination value);
+  private:
+  ::tensorflow::GraphTransferInfo_Destination _internal_destination() const;
+  void _internal_set_destination(::tensorflow::GraphTransferInfo_Destination value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.GraphTransferInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::GraphTransferNodeInfo > node_info_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::GraphTransferConstNodeInfo > const_node_info_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::GraphTransferNodeInputInfo > node_input_info_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::GraphTransferNodeOutputInfo > node_output_info_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::GraphTransferGraphInputNodeInfo > graph_input_node_info_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::GraphTransferGraphOutputNodeInfo > graph_output_node_info_;
+    int destination_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fgraph_5ftransfer_5finfo_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// GraphTransferNodeInput
+
+// int32 node_id = 1;
+inline void GraphTransferNodeInput::clear_node_id() {
+  _impl_.node_id_ = 0;
+}
+inline int32_t GraphTransferNodeInput::_internal_node_id() const {
+  return _impl_.node_id_;
+}
+inline int32_t GraphTransferNodeInput::node_id() const {
+  // @@protoc_insertion_point(field_get:tensorflow.GraphTransferNodeInput.node_id)
+  return _internal_node_id();
+}
+inline void GraphTransferNodeInput::_internal_set_node_id(int32_t value) {
+  
+  _impl_.node_id_ = value;
+}
+inline void GraphTransferNodeInput::set_node_id(int32_t value) {
+  _internal_set_node_id(value);
+  // @@protoc_insertion_point(field_set:tensorflow.GraphTransferNodeInput.node_id)
+}
+
+// int32 output_port = 2;
+inline void GraphTransferNodeInput::clear_output_port() {
+  _impl_.output_port_ = 0;
+}
+inline int32_t GraphTransferNodeInput::_internal_output_port() const {
+  return _impl_.output_port_;
+}
+inline int32_t GraphTransferNodeInput::output_port() const {
+  // @@protoc_insertion_point(field_get:tensorflow.GraphTransferNodeInput.output_port)
+  return _internal_output_port();
+}
+inline void GraphTransferNodeInput::_internal_set_output_port(int32_t value) {
+  
+  _impl_.output_port_ = value;
+}
+inline void GraphTransferNodeInput::set_output_port(int32_t value) {
+  _internal_set_output_port(value);
+  // @@protoc_insertion_point(field_set:tensorflow.GraphTransferNodeInput.output_port)
+}
+
+// -------------------------------------------------------------------
+
+// GraphTransferNodeInfo
+
+// string name = 1;
+inline void GraphTransferNodeInfo::clear_name() {
+  _impl_.name_.ClearToEmpty();
+}
+inline const std::string& GraphTransferNodeInfo::name() const {
+  // @@protoc_insertion_point(field_get:tensorflow.GraphTransferNodeInfo.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void GraphTransferNodeInfo::set_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.GraphTransferNodeInfo.name)
+}
+inline std::string* GraphTransferNodeInfo::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:tensorflow.GraphTransferNodeInfo.name)
+  return _s;
+}
+inline const std::string& GraphTransferNodeInfo::_internal_name() const {
+  return _impl_.name_.Get();
+}
+inline void GraphTransferNodeInfo::_internal_set_name(const std::string& value) {
+  
+  _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* GraphTransferNodeInfo::_internal_mutable_name() {
+  
+  return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* GraphTransferNodeInfo::release_name() {
+  // @@protoc_insertion_point(field_release:tensorflow.GraphTransferNodeInfo.name)
+  return _impl_.name_.Release();
+}
+inline void GraphTransferNodeInfo::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.GraphTransferNodeInfo.name)
+}
+
+// int32 node_id = 2;
+inline void GraphTransferNodeInfo::clear_node_id() {
+  _impl_.node_id_ = 0;
+}
+inline int32_t GraphTransferNodeInfo::_internal_node_id() const {
+  return _impl_.node_id_;
+}
+inline int32_t GraphTransferNodeInfo::node_id() const {
+  // @@protoc_insertion_point(field_get:tensorflow.GraphTransferNodeInfo.node_id)
+  return _internal_node_id();
+}
+inline void GraphTransferNodeInfo::_internal_set_node_id(int32_t value) {
+  
+  _impl_.node_id_ = value;
+}
+inline void GraphTransferNodeInfo::set_node_id(int32_t value) {
+  _internal_set_node_id(value);
+  // @@protoc_insertion_point(field_set:tensorflow.GraphTransferNodeInfo.node_id)
+}
+
+// string type_name = 3;
+inline void GraphTransferNodeInfo::clear_type_name() {
+  _impl_.type_name_.ClearToEmpty();
+}
+inline const std::string& GraphTransferNodeInfo::type_name() const {
+  // @@protoc_insertion_point(field_get:tensorflow.GraphTransferNodeInfo.type_name)
+  return _internal_type_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void GraphTransferNodeInfo::set_type_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.type_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.GraphTransferNodeInfo.type_name)
+}
+inline std::string* GraphTransferNodeInfo::mutable_type_name() {
+  std::string* _s = _internal_mutable_type_name();
+  // @@protoc_insertion_point(field_mutable:tensorflow.GraphTransferNodeInfo.type_name)
+  return _s;
+}
+inline const std::string& GraphTransferNodeInfo::_internal_type_name() const {
+  return _impl_.type_name_.Get();
+}
+inline void GraphTransferNodeInfo::_internal_set_type_name(const std::string& value) {
+  
+  _impl_.type_name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* GraphTransferNodeInfo::_internal_mutable_type_name() {
+  
+  return _impl_.type_name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* GraphTransferNodeInfo::release_type_name() {
+  // @@protoc_insertion_point(field_release:tensorflow.GraphTransferNodeInfo.type_name)
+  return _impl_.type_name_.Release();
+}
+inline void GraphTransferNodeInfo::set_allocated_type_name(std::string* type_name) {
+  if (type_name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.type_name_.SetAllocated(type_name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.type_name_.IsDefault()) {
+    _impl_.type_name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.GraphTransferNodeInfo.type_name)
+}
+
+// int32 soc_op_id = 4;
+inline void GraphTransferNodeInfo::clear_soc_op_id() {
+  _impl_.soc_op_id_ = 0;
+}
+inline int32_t GraphTransferNodeInfo::_internal_soc_op_id() const {
+  return _impl_.soc_op_id_;
+}
+inline int32_t GraphTransferNodeInfo::soc_op_id() const {
+  // @@protoc_insertion_point(field_get:tensorflow.GraphTransferNodeInfo.soc_op_id)
+  return _internal_soc_op_id();
+}
+inline void GraphTransferNodeInfo::_internal_set_soc_op_id(int32_t value) {
+  
+  _impl_.soc_op_id_ = value;
+}
+inline void GraphTransferNodeInfo::set_soc_op_id(int32_t value) {
+  _internal_set_soc_op_id(value);
+  // @@protoc_insertion_point(field_set:tensorflow.GraphTransferNodeInfo.soc_op_id)
+}
+
+// int32 padding_id = 5;
+inline void GraphTransferNodeInfo::clear_padding_id() {
+  _impl_.padding_id_ = 0;
+}
+inline int32_t GraphTransferNodeInfo::_internal_padding_id() const {
+  return _impl_.padding_id_;
+}
+inline int32_t GraphTransferNodeInfo::padding_id() const {
+  // @@protoc_insertion_point(field_get:tensorflow.GraphTransferNodeInfo.padding_id)
+  return _internal_padding_id();
+}
+inline void GraphTransferNodeInfo::_internal_set_padding_id(int32_t value) {
+  
+  _impl_.padding_id_ = value;
+}
+inline void GraphTransferNodeInfo::set_padding_id(int32_t value) {
+  _internal_set_padding_id(value);
+  // @@protoc_insertion_point(field_set:tensorflow.GraphTransferNodeInfo.padding_id)
+}
+
+// int32 input_count = 6;
+inline void GraphTransferNodeInfo::clear_input_count() {
+  _impl_.input_count_ = 0;
+}
+inline int32_t GraphTransferNodeInfo::_internal_input_count() const {
+  return _impl_.input_count_;
+}
+inline int32_t GraphTransferNodeInfo::input_count() const {
+  // @@protoc_insertion_point(field_get:tensorflow.GraphTransferNodeInfo.input_count)
+  return _internal_input_count();
+}
+inline void GraphTransferNodeInfo::_internal_set_input_count(int32_t value) {
+  
+  _impl_.input_count_ = value;
+}
+inline void GraphTransferNodeInfo::set_input_count(int32_t value) {
+  _internal_set_input_count(value);
+  // @@protoc_insertion_point(field_set:tensorflow.GraphTransferNodeInfo.input_count)
+}
+
+// int32 output_count = 7;
+inline void GraphTransferNodeInfo::clear_output_count() {
+  _impl_.output_count_ = 0;
+}
+inline int32_t GraphTransferNodeInfo::_internal_output_count() const {
+  return _impl_.output_count_;
+}
+inline int32_t GraphTransferNodeInfo::output_count() const {
+  // @@protoc_insertion_point(field_get:tensorflow.GraphTransferNodeInfo.output_count)
+  return _internal_output_count();
+}
+inline void GraphTransferNodeInfo::_internal_set_output_count(int32_t value) {
+  
+  _impl_.output_count_ = value;
+}
+inline void GraphTransferNodeInfo::set_output_count(int32_t value) {
+  _internal_set_output_count(value);
+  // @@protoc_insertion_point(field_set:tensorflow.GraphTransferNodeInfo.output_count)
+}
+
+// -------------------------------------------------------------------
+
+// GraphTransferConstNodeInfo
+
+// string name = 1;
+inline void GraphTransferConstNodeInfo::clear_name() {
+  _impl_.name_.ClearToEmpty();
+}
+inline const std::string& GraphTransferConstNodeInfo::name() const {
+  // @@protoc_insertion_point(field_get:tensorflow.GraphTransferConstNodeInfo.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void GraphTransferConstNodeInfo::set_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.GraphTransferConstNodeInfo.name)
+}
+inline std::string* GraphTransferConstNodeInfo::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:tensorflow.GraphTransferConstNodeInfo.name)
+  return _s;
+}
+inline const std::string& GraphTransferConstNodeInfo::_internal_name() const {
+  return _impl_.name_.Get();
+}
+inline void GraphTransferConstNodeInfo::_internal_set_name(const std::string& value) {
+  
+  _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* GraphTransferConstNodeInfo::_internal_mutable_name() {
+  
+  return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* GraphTransferConstNodeInfo::release_name() {
+  // @@protoc_insertion_point(field_release:tensorflow.GraphTransferConstNodeInfo.name)
+  return _impl_.name_.Release();
+}
+inline void GraphTransferConstNodeInfo::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.GraphTransferConstNodeInfo.name)
+}
+
+// int32 node_id = 2;
+inline void GraphTransferConstNodeInfo::clear_node_id() {
+  _impl_.node_id_ = 0;
+}
+inline int32_t GraphTransferConstNodeInfo::_internal_node_id() const {
+  return _impl_.node_id_;
+}
+inline int32_t GraphTransferConstNodeInfo::node_id() const {
+  // @@protoc_insertion_point(field_get:tensorflow.GraphTransferConstNodeInfo.node_id)
+  return _internal_node_id();
+}
+inline void GraphTransferConstNodeInfo::_internal_set_node_id(int32_t value) {
+  
+  _impl_.node_id_ = value;
+}
+inline void GraphTransferConstNodeInfo::set_node_id(int32_t value) {
+  _internal_set_node_id(value);
+  // @@protoc_insertion_point(field_set:tensorflow.GraphTransferConstNodeInfo.node_id)
+}
+
+// repeated int64 shape = 3;
+inline int GraphTransferConstNodeInfo::_internal_shape_size() const {
+  return _impl_.shape_.size();
+}
+inline int GraphTransferConstNodeInfo::shape_size() const {
+  return _internal_shape_size();
+}
+inline void GraphTransferConstNodeInfo::clear_shape() {
+  _impl_.shape_.Clear();
+}
+inline int64_t GraphTransferConstNodeInfo::_internal_shape(int index) const {
+  return _impl_.shape_.Get(index);
+}
+inline int64_t GraphTransferConstNodeInfo::shape(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.GraphTransferConstNodeInfo.shape)
+  return _internal_shape(index);
+}
+inline void GraphTransferConstNodeInfo::set_shape(int index, int64_t value) {
+  _impl_.shape_.Set(index, value);
+  // @@protoc_insertion_point(field_set:tensorflow.GraphTransferConstNodeInfo.shape)
+}
+inline void GraphTransferConstNodeInfo::_internal_add_shape(int64_t value) {
+  _impl_.shape_.Add(value);
+}
+inline void GraphTransferConstNodeInfo::add_shape(int64_t value) {
+  _internal_add_shape(value);
+  // @@protoc_insertion_point(field_add:tensorflow.GraphTransferConstNodeInfo.shape)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
+GraphTransferConstNodeInfo::_internal_shape() const {
+  return _impl_.shape_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
+GraphTransferConstNodeInfo::shape() const {
+  // @@protoc_insertion_point(field_list:tensorflow.GraphTransferConstNodeInfo.shape)
+  return _internal_shape();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
+GraphTransferConstNodeInfo::_internal_mutable_shape() {
+  return &_impl_.shape_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
+GraphTransferConstNodeInfo::mutable_shape() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.GraphTransferConstNodeInfo.shape)
+  return _internal_mutable_shape();
+}
+
+// bytes data = 4;
+inline void GraphTransferConstNodeInfo::clear_data() {
+  _impl_.data_.ClearToEmpty();
+}
+inline const std::string& GraphTransferConstNodeInfo::data() const {
+  // @@protoc_insertion_point(field_get:tensorflow.GraphTransferConstNodeInfo.data)
+  return _internal_data();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void GraphTransferConstNodeInfo::set_data(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.data_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.GraphTransferConstNodeInfo.data)
+}
+inline std::string* GraphTransferConstNodeInfo::mutable_data() {
+  std::string* _s = _internal_mutable_data();
+  // @@protoc_insertion_point(field_mutable:tensorflow.GraphTransferConstNodeInfo.data)
+  return _s;
+}
+inline const std::string& GraphTransferConstNodeInfo::_internal_data() const {
+  return _impl_.data_.Get();
+}
+inline void GraphTransferConstNodeInfo::_internal_set_data(const std::string& value) {
+  
+  _impl_.data_.Set(value, GetArenaForAllocation());
+}
+inline std::string* GraphTransferConstNodeInfo::_internal_mutable_data() {
+  
+  return _impl_.data_.Mutable(GetArenaForAllocation());
+}
+inline std::string* GraphTransferConstNodeInfo::release_data() {
+  // @@protoc_insertion_point(field_release:tensorflow.GraphTransferConstNodeInfo.data)
+  return _impl_.data_.Release();
+}
+inline void GraphTransferConstNodeInfo::set_allocated_data(std::string* data) {
+  if (data != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.data_.SetAllocated(data, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.data_.IsDefault()) {
+    _impl_.data_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.GraphTransferConstNodeInfo.data)
+}
+
+// .tensorflow.DataType dtype = 5;
+inline void GraphTransferConstNodeInfo::clear_dtype() {
+  _impl_.dtype_ = 0;
+}
+inline ::tensorflow::DataType GraphTransferConstNodeInfo::_internal_dtype() const {
+  return static_cast< ::tensorflow::DataType >(_impl_.dtype_);
+}
+inline ::tensorflow::DataType GraphTransferConstNodeInfo::dtype() const {
+  // @@protoc_insertion_point(field_get:tensorflow.GraphTransferConstNodeInfo.dtype)
+  return _internal_dtype();
+}
+inline void GraphTransferConstNodeInfo::_internal_set_dtype(::tensorflow::DataType value) {
+  
+  _impl_.dtype_ = value;
+}
+inline void GraphTransferConstNodeInfo::set_dtype(::tensorflow::DataType value) {
+  _internal_set_dtype(value);
+  // @@protoc_insertion_point(field_set:tensorflow.GraphTransferConstNodeInfo.dtype)
+}
+
+// -------------------------------------------------------------------
+
+// GraphTransferNodeInputInfo
+
+// int32 node_id = 1;
+inline void GraphTransferNodeInputInfo::clear_node_id() {
+  _impl_.node_id_ = 0;
+}
+inline int32_t GraphTransferNodeInputInfo::_internal_node_id() const {
+  return _impl_.node_id_;
+}
+inline int32_t GraphTransferNodeInputInfo::node_id() const {
+  // @@protoc_insertion_point(field_get:tensorflow.GraphTransferNodeInputInfo.node_id)
+  return _internal_node_id();
+}
+inline void GraphTransferNodeInputInfo::_internal_set_node_id(int32_t value) {
+  
+  _impl_.node_id_ = value;
+}
+inline void GraphTransferNodeInputInfo::set_node_id(int32_t value) {
+  _internal_set_node_id(value);
+  // @@protoc_insertion_point(field_set:tensorflow.GraphTransferNodeInputInfo.node_id)
+}
+
+// repeated .tensorflow.GraphTransferNodeInput node_input = 2;
+inline int GraphTransferNodeInputInfo::_internal_node_input_size() const {
+  return _impl_.node_input_.size();
+}
+inline int GraphTransferNodeInputInfo::node_input_size() const {
+  return _internal_node_input_size();
+}
+inline void GraphTransferNodeInputInfo::clear_node_input() {
+  _impl_.node_input_.Clear();
+}
+inline ::tensorflow::GraphTransferNodeInput* GraphTransferNodeInputInfo::mutable_node_input(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.GraphTransferNodeInputInfo.node_input)
+  return _impl_.node_input_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::GraphTransferNodeInput >*
+GraphTransferNodeInputInfo::mutable_node_input() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.GraphTransferNodeInputInfo.node_input)
+  return &_impl_.node_input_;
+}
+inline const ::tensorflow::GraphTransferNodeInput& GraphTransferNodeInputInfo::_internal_node_input(int index) const {
+  return _impl_.node_input_.Get(index);
+}
+inline const ::tensorflow::GraphTransferNodeInput& GraphTransferNodeInputInfo::node_input(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.GraphTransferNodeInputInfo.node_input)
+  return _internal_node_input(index);
+}
+inline ::tensorflow::GraphTransferNodeInput* GraphTransferNodeInputInfo::_internal_add_node_input() {
+  return _impl_.node_input_.Add();
+}
+inline ::tensorflow::GraphTransferNodeInput* GraphTransferNodeInputInfo::add_node_input() {
+  ::tensorflow::GraphTransferNodeInput* _add = _internal_add_node_input();
+  // @@protoc_insertion_point(field_add:tensorflow.GraphTransferNodeInputInfo.node_input)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::GraphTransferNodeInput >&
+GraphTransferNodeInputInfo::node_input() const {
+  // @@protoc_insertion_point(field_list:tensorflow.GraphTransferNodeInputInfo.node_input)
+  return _impl_.node_input_;
+}
+
+// -------------------------------------------------------------------
+
+// GraphTransferNodeOutputInfo
+
+// int32 node_id = 1;
+inline void GraphTransferNodeOutputInfo::clear_node_id() {
+  _impl_.node_id_ = 0;
+}
+inline int32_t GraphTransferNodeOutputInfo::_internal_node_id() const {
+  return _impl_.node_id_;
+}
+inline int32_t GraphTransferNodeOutputInfo::node_id() const {
+  // @@protoc_insertion_point(field_get:tensorflow.GraphTransferNodeOutputInfo.node_id)
+  return _internal_node_id();
+}
+inline void GraphTransferNodeOutputInfo::_internal_set_node_id(int32_t value) {
+  
+  _impl_.node_id_ = value;
+}
+inline void GraphTransferNodeOutputInfo::set_node_id(int32_t value) {
+  _internal_set_node_id(value);
+  // @@protoc_insertion_point(field_set:tensorflow.GraphTransferNodeOutputInfo.node_id)
+}
+
+// repeated int32 max_byte_size = 2;
+inline int GraphTransferNodeOutputInfo::_internal_max_byte_size_size() const {
+  return _impl_.max_byte_size_.size();
+}
+inline int GraphTransferNodeOutputInfo::max_byte_size_size() const {
+  return _internal_max_byte_size_size();
+}
+inline void GraphTransferNodeOutputInfo::clear_max_byte_size() {
+  _impl_.max_byte_size_.Clear();
+}
+inline int32_t GraphTransferNodeOutputInfo::_internal_max_byte_size(int index) const {
+  return _impl_.max_byte_size_.Get(index);
+}
+inline int32_t GraphTransferNodeOutputInfo::max_byte_size(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.GraphTransferNodeOutputInfo.max_byte_size)
+  return _internal_max_byte_size(index);
+}
+inline void GraphTransferNodeOutputInfo::set_max_byte_size(int index, int32_t value) {
+  _impl_.max_byte_size_.Set(index, value);
+  // @@protoc_insertion_point(field_set:tensorflow.GraphTransferNodeOutputInfo.max_byte_size)
+}
+inline void GraphTransferNodeOutputInfo::_internal_add_max_byte_size(int32_t value) {
+  _impl_.max_byte_size_.Add(value);
+}
+inline void GraphTransferNodeOutputInfo::add_max_byte_size(int32_t value) {
+  _internal_add_max_byte_size(value);
+  // @@protoc_insertion_point(field_add:tensorflow.GraphTransferNodeOutputInfo.max_byte_size)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+GraphTransferNodeOutputInfo::_internal_max_byte_size() const {
+  return _impl_.max_byte_size_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+GraphTransferNodeOutputInfo::max_byte_size() const {
+  // @@protoc_insertion_point(field_list:tensorflow.GraphTransferNodeOutputInfo.max_byte_size)
+  return _internal_max_byte_size();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+GraphTransferNodeOutputInfo::_internal_mutable_max_byte_size() {
+  return &_impl_.max_byte_size_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+GraphTransferNodeOutputInfo::mutable_max_byte_size() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.GraphTransferNodeOutputInfo.max_byte_size)
+  return _internal_mutable_max_byte_size();
+}
+
+// -------------------------------------------------------------------
+
+// GraphTransferGraphInputNodeInfo
+
+// string name = 1;
+inline void GraphTransferGraphInputNodeInfo::clear_name() {
+  _impl_.name_.ClearToEmpty();
+}
+inline const std::string& GraphTransferGraphInputNodeInfo::name() const {
+  // @@protoc_insertion_point(field_get:tensorflow.GraphTransferGraphInputNodeInfo.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void GraphTransferGraphInputNodeInfo::set_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.GraphTransferGraphInputNodeInfo.name)
+}
+inline std::string* GraphTransferGraphInputNodeInfo::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:tensorflow.GraphTransferGraphInputNodeInfo.name)
+  return _s;
+}
+inline const std::string& GraphTransferGraphInputNodeInfo::_internal_name() const {
+  return _impl_.name_.Get();
+}
+inline void GraphTransferGraphInputNodeInfo::_internal_set_name(const std::string& value) {
+  
+  _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* GraphTransferGraphInputNodeInfo::_internal_mutable_name() {
+  
+  return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* GraphTransferGraphInputNodeInfo::release_name() {
+  // @@protoc_insertion_point(field_release:tensorflow.GraphTransferGraphInputNodeInfo.name)
+  return _impl_.name_.Release();
+}
+inline void GraphTransferGraphInputNodeInfo::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.GraphTransferGraphInputNodeInfo.name)
+}
+
+// repeated int64 shape = 2;
+inline int GraphTransferGraphInputNodeInfo::_internal_shape_size() const {
+  return _impl_.shape_.size();
+}
+inline int GraphTransferGraphInputNodeInfo::shape_size() const {
+  return _internal_shape_size();
+}
+inline void GraphTransferGraphInputNodeInfo::clear_shape() {
+  _impl_.shape_.Clear();
+}
+inline int64_t GraphTransferGraphInputNodeInfo::_internal_shape(int index) const {
+  return _impl_.shape_.Get(index);
+}
+inline int64_t GraphTransferGraphInputNodeInfo::shape(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.GraphTransferGraphInputNodeInfo.shape)
+  return _internal_shape(index);
+}
+inline void GraphTransferGraphInputNodeInfo::set_shape(int index, int64_t value) {
+  _impl_.shape_.Set(index, value);
+  // @@protoc_insertion_point(field_set:tensorflow.GraphTransferGraphInputNodeInfo.shape)
+}
+inline void GraphTransferGraphInputNodeInfo::_internal_add_shape(int64_t value) {
+  _impl_.shape_.Add(value);
+}
+inline void GraphTransferGraphInputNodeInfo::add_shape(int64_t value) {
+  _internal_add_shape(value);
+  // @@protoc_insertion_point(field_add:tensorflow.GraphTransferGraphInputNodeInfo.shape)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
+GraphTransferGraphInputNodeInfo::_internal_shape() const {
+  return _impl_.shape_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
+GraphTransferGraphInputNodeInfo::shape() const {
+  // @@protoc_insertion_point(field_list:tensorflow.GraphTransferGraphInputNodeInfo.shape)
+  return _internal_shape();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
+GraphTransferGraphInputNodeInfo::_internal_mutable_shape() {
+  return &_impl_.shape_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
+GraphTransferGraphInputNodeInfo::mutable_shape() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.GraphTransferGraphInputNodeInfo.shape)
+  return _internal_mutable_shape();
+}
+
+// .tensorflow.DataType dtype = 3;
+inline void GraphTransferGraphInputNodeInfo::clear_dtype() {
+  _impl_.dtype_ = 0;
+}
+inline ::tensorflow::DataType GraphTransferGraphInputNodeInfo::_internal_dtype() const {
+  return static_cast< ::tensorflow::DataType >(_impl_.dtype_);
+}
+inline ::tensorflow::DataType GraphTransferGraphInputNodeInfo::dtype() const {
+  // @@protoc_insertion_point(field_get:tensorflow.GraphTransferGraphInputNodeInfo.dtype)
+  return _internal_dtype();
+}
+inline void GraphTransferGraphInputNodeInfo::_internal_set_dtype(::tensorflow::DataType value) {
+  
+  _impl_.dtype_ = value;
+}
+inline void GraphTransferGraphInputNodeInfo::set_dtype(::tensorflow::DataType value) {
+  _internal_set_dtype(value);
+  // @@protoc_insertion_point(field_set:tensorflow.GraphTransferGraphInputNodeInfo.dtype)
+}
+
+// -------------------------------------------------------------------
+
+// GraphTransferGraphOutputNodeInfo
+
+// string name = 1;
+inline void GraphTransferGraphOutputNodeInfo::clear_name() {
+  _impl_.name_.ClearToEmpty();
+}
+inline const std::string& GraphTransferGraphOutputNodeInfo::name() const {
+  // @@protoc_insertion_point(field_get:tensorflow.GraphTransferGraphOutputNodeInfo.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void GraphTransferGraphOutputNodeInfo::set_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.GraphTransferGraphOutputNodeInfo.name)
+}
+inline std::string* GraphTransferGraphOutputNodeInfo::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:tensorflow.GraphTransferGraphOutputNodeInfo.name)
+  return _s;
+}
+inline const std::string& GraphTransferGraphOutputNodeInfo::_internal_name() const {
+  return _impl_.name_.Get();
+}
+inline void GraphTransferGraphOutputNodeInfo::_internal_set_name(const std::string& value) {
+  
+  _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* GraphTransferGraphOutputNodeInfo::_internal_mutable_name() {
+  
+  return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* GraphTransferGraphOutputNodeInfo::release_name() {
+  // @@protoc_insertion_point(field_release:tensorflow.GraphTransferGraphOutputNodeInfo.name)
+  return _impl_.name_.Release();
+}
+inline void GraphTransferGraphOutputNodeInfo::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.GraphTransferGraphOutputNodeInfo.name)
+}
+
+// repeated int64 shape = 2;
+inline int GraphTransferGraphOutputNodeInfo::_internal_shape_size() const {
+  return _impl_.shape_.size();
+}
+inline int GraphTransferGraphOutputNodeInfo::shape_size() const {
+  return _internal_shape_size();
+}
+inline void GraphTransferGraphOutputNodeInfo::clear_shape() {
+  _impl_.shape_.Clear();
+}
+inline int64_t GraphTransferGraphOutputNodeInfo::_internal_shape(int index) const {
+  return _impl_.shape_.Get(index);
+}
+inline int64_t GraphTransferGraphOutputNodeInfo::shape(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.GraphTransferGraphOutputNodeInfo.shape)
+  return _internal_shape(index);
+}
+inline void GraphTransferGraphOutputNodeInfo::set_shape(int index, int64_t value) {
+  _impl_.shape_.Set(index, value);
+  // @@protoc_insertion_point(field_set:tensorflow.GraphTransferGraphOutputNodeInfo.shape)
+}
+inline void GraphTransferGraphOutputNodeInfo::_internal_add_shape(int64_t value) {
+  _impl_.shape_.Add(value);
+}
+inline void GraphTransferGraphOutputNodeInfo::add_shape(int64_t value) {
+  _internal_add_shape(value);
+  // @@protoc_insertion_point(field_add:tensorflow.GraphTransferGraphOutputNodeInfo.shape)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
+GraphTransferGraphOutputNodeInfo::_internal_shape() const {
+  return _impl_.shape_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
+GraphTransferGraphOutputNodeInfo::shape() const {
+  // @@protoc_insertion_point(field_list:tensorflow.GraphTransferGraphOutputNodeInfo.shape)
+  return _internal_shape();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
+GraphTransferGraphOutputNodeInfo::_internal_mutable_shape() {
+  return &_impl_.shape_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
+GraphTransferGraphOutputNodeInfo::mutable_shape() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.GraphTransferGraphOutputNodeInfo.shape)
+  return _internal_mutable_shape();
+}
+
+// .tensorflow.DataType dtype = 3;
+inline void GraphTransferGraphOutputNodeInfo::clear_dtype() {
+  _impl_.dtype_ = 0;
+}
+inline ::tensorflow::DataType GraphTransferGraphOutputNodeInfo::_internal_dtype() const {
+  return static_cast< ::tensorflow::DataType >(_impl_.dtype_);
+}
+inline ::tensorflow::DataType GraphTransferGraphOutputNodeInfo::dtype() const {
+  // @@protoc_insertion_point(field_get:tensorflow.GraphTransferGraphOutputNodeInfo.dtype)
+  return _internal_dtype();
+}
+inline void GraphTransferGraphOutputNodeInfo::_internal_set_dtype(::tensorflow::DataType value) {
+  
+  _impl_.dtype_ = value;
+}
+inline void GraphTransferGraphOutputNodeInfo::set_dtype(::tensorflow::DataType value) {
+  _internal_set_dtype(value);
+  // @@protoc_insertion_point(field_set:tensorflow.GraphTransferGraphOutputNodeInfo.dtype)
+}
+
+// -------------------------------------------------------------------
+
+// GraphTransferInfo
+
+// repeated .tensorflow.GraphTransferNodeInfo node_info = 1;
+inline int GraphTransferInfo::_internal_node_info_size() const {
+  return _impl_.node_info_.size();
+}
+inline int GraphTransferInfo::node_info_size() const {
+  return _internal_node_info_size();
+}
+inline void GraphTransferInfo::clear_node_info() {
+  _impl_.node_info_.Clear();
+}
+inline ::tensorflow::GraphTransferNodeInfo* GraphTransferInfo::mutable_node_info(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.GraphTransferInfo.node_info)
+  return _impl_.node_info_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::GraphTransferNodeInfo >*
+GraphTransferInfo::mutable_node_info() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.GraphTransferInfo.node_info)
+  return &_impl_.node_info_;
+}
+inline const ::tensorflow::GraphTransferNodeInfo& GraphTransferInfo::_internal_node_info(int index) const {
+  return _impl_.node_info_.Get(index);
+}
+inline const ::tensorflow::GraphTransferNodeInfo& GraphTransferInfo::node_info(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.GraphTransferInfo.node_info)
+  return _internal_node_info(index);
+}
+inline ::tensorflow::GraphTransferNodeInfo* GraphTransferInfo::_internal_add_node_info() {
+  return _impl_.node_info_.Add();
+}
+inline ::tensorflow::GraphTransferNodeInfo* GraphTransferInfo::add_node_info() {
+  ::tensorflow::GraphTransferNodeInfo* _add = _internal_add_node_info();
+  // @@protoc_insertion_point(field_add:tensorflow.GraphTransferInfo.node_info)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::GraphTransferNodeInfo >&
+GraphTransferInfo::node_info() const {
+  // @@protoc_insertion_point(field_list:tensorflow.GraphTransferInfo.node_info)
+  return _impl_.node_info_;
+}
+
+// repeated .tensorflow.GraphTransferConstNodeInfo const_node_info = 2;
+inline int GraphTransferInfo::_internal_const_node_info_size() const {
+  return _impl_.const_node_info_.size();
+}
+inline int GraphTransferInfo::const_node_info_size() const {
+  return _internal_const_node_info_size();
+}
+inline void GraphTransferInfo::clear_const_node_info() {
+  _impl_.const_node_info_.Clear();
+}
+inline ::tensorflow::GraphTransferConstNodeInfo* GraphTransferInfo::mutable_const_node_info(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.GraphTransferInfo.const_node_info)
+  return _impl_.const_node_info_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::GraphTransferConstNodeInfo >*
+GraphTransferInfo::mutable_const_node_info() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.GraphTransferInfo.const_node_info)
+  return &_impl_.const_node_info_;
+}
+inline const ::tensorflow::GraphTransferConstNodeInfo& GraphTransferInfo::_internal_const_node_info(int index) const {
+  return _impl_.const_node_info_.Get(index);
+}
+inline const ::tensorflow::GraphTransferConstNodeInfo& GraphTransferInfo::const_node_info(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.GraphTransferInfo.const_node_info)
+  return _internal_const_node_info(index);
+}
+inline ::tensorflow::GraphTransferConstNodeInfo* GraphTransferInfo::_internal_add_const_node_info() {
+  return _impl_.const_node_info_.Add();
+}
+inline ::tensorflow::GraphTransferConstNodeInfo* GraphTransferInfo::add_const_node_info() {
+  ::tensorflow::GraphTransferConstNodeInfo* _add = _internal_add_const_node_info();
+  // @@protoc_insertion_point(field_add:tensorflow.GraphTransferInfo.const_node_info)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::GraphTransferConstNodeInfo >&
+GraphTransferInfo::const_node_info() const {
+  // @@protoc_insertion_point(field_list:tensorflow.GraphTransferInfo.const_node_info)
+  return _impl_.const_node_info_;
+}
+
+// repeated .tensorflow.GraphTransferNodeInputInfo node_input_info = 3;
+inline int GraphTransferInfo::_internal_node_input_info_size() const {
+  return _impl_.node_input_info_.size();
+}
+inline int GraphTransferInfo::node_input_info_size() const {
+  return _internal_node_input_info_size();
+}
+inline void GraphTransferInfo::clear_node_input_info() {
+  _impl_.node_input_info_.Clear();
+}
+inline ::tensorflow::GraphTransferNodeInputInfo* GraphTransferInfo::mutable_node_input_info(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.GraphTransferInfo.node_input_info)
+  return _impl_.node_input_info_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::GraphTransferNodeInputInfo >*
+GraphTransferInfo::mutable_node_input_info() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.GraphTransferInfo.node_input_info)
+  return &_impl_.node_input_info_;
+}
+inline const ::tensorflow::GraphTransferNodeInputInfo& GraphTransferInfo::_internal_node_input_info(int index) const {
+  return _impl_.node_input_info_.Get(index);
+}
+inline const ::tensorflow::GraphTransferNodeInputInfo& GraphTransferInfo::node_input_info(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.GraphTransferInfo.node_input_info)
+  return _internal_node_input_info(index);
+}
+inline ::tensorflow::GraphTransferNodeInputInfo* GraphTransferInfo::_internal_add_node_input_info() {
+  return _impl_.node_input_info_.Add();
+}
+inline ::tensorflow::GraphTransferNodeInputInfo* GraphTransferInfo::add_node_input_info() {
+  ::tensorflow::GraphTransferNodeInputInfo* _add = _internal_add_node_input_info();
+  // @@protoc_insertion_point(field_add:tensorflow.GraphTransferInfo.node_input_info)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::GraphTransferNodeInputInfo >&
+GraphTransferInfo::node_input_info() const {
+  // @@protoc_insertion_point(field_list:tensorflow.GraphTransferInfo.node_input_info)
+  return _impl_.node_input_info_;
+}
+
+// repeated .tensorflow.GraphTransferNodeOutputInfo node_output_info = 4;
+inline int GraphTransferInfo::_internal_node_output_info_size() const {
+  return _impl_.node_output_info_.size();
+}
+inline int GraphTransferInfo::node_output_info_size() const {
+  return _internal_node_output_info_size();
+}
+inline void GraphTransferInfo::clear_node_output_info() {
+  _impl_.node_output_info_.Clear();
+}
+inline ::tensorflow::GraphTransferNodeOutputInfo* GraphTransferInfo::mutable_node_output_info(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.GraphTransferInfo.node_output_info)
+  return _impl_.node_output_info_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::GraphTransferNodeOutputInfo >*
+GraphTransferInfo::mutable_node_output_info() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.GraphTransferInfo.node_output_info)
+  return &_impl_.node_output_info_;
+}
+inline const ::tensorflow::GraphTransferNodeOutputInfo& GraphTransferInfo::_internal_node_output_info(int index) const {
+  return _impl_.node_output_info_.Get(index);
+}
+inline const ::tensorflow::GraphTransferNodeOutputInfo& GraphTransferInfo::node_output_info(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.GraphTransferInfo.node_output_info)
+  return _internal_node_output_info(index);
+}
+inline ::tensorflow::GraphTransferNodeOutputInfo* GraphTransferInfo::_internal_add_node_output_info() {
+  return _impl_.node_output_info_.Add();
+}
+inline ::tensorflow::GraphTransferNodeOutputInfo* GraphTransferInfo::add_node_output_info() {
+  ::tensorflow::GraphTransferNodeOutputInfo* _add = _internal_add_node_output_info();
+  // @@protoc_insertion_point(field_add:tensorflow.GraphTransferInfo.node_output_info)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::GraphTransferNodeOutputInfo >&
+GraphTransferInfo::node_output_info() const {
+  // @@protoc_insertion_point(field_list:tensorflow.GraphTransferInfo.node_output_info)
+  return _impl_.node_output_info_;
+}
+
+// repeated .tensorflow.GraphTransferGraphInputNodeInfo graph_input_node_info = 5;
+inline int GraphTransferInfo::_internal_graph_input_node_info_size() const {
+  return _impl_.graph_input_node_info_.size();
+}
+inline int GraphTransferInfo::graph_input_node_info_size() const {
+  return _internal_graph_input_node_info_size();
+}
+inline void GraphTransferInfo::clear_graph_input_node_info() {
+  _impl_.graph_input_node_info_.Clear();
+}
+inline ::tensorflow::GraphTransferGraphInputNodeInfo* GraphTransferInfo::mutable_graph_input_node_info(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.GraphTransferInfo.graph_input_node_info)
+  return _impl_.graph_input_node_info_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::GraphTransferGraphInputNodeInfo >*
+GraphTransferInfo::mutable_graph_input_node_info() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.GraphTransferInfo.graph_input_node_info)
+  return &_impl_.graph_input_node_info_;
+}
+inline const ::tensorflow::GraphTransferGraphInputNodeInfo& GraphTransferInfo::_internal_graph_input_node_info(int index) const {
+  return _impl_.graph_input_node_info_.Get(index);
+}
+inline const ::tensorflow::GraphTransferGraphInputNodeInfo& GraphTransferInfo::graph_input_node_info(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.GraphTransferInfo.graph_input_node_info)
+  return _internal_graph_input_node_info(index);
+}
+inline ::tensorflow::GraphTransferGraphInputNodeInfo* GraphTransferInfo::_internal_add_graph_input_node_info() {
+  return _impl_.graph_input_node_info_.Add();
+}
+inline ::tensorflow::GraphTransferGraphInputNodeInfo* GraphTransferInfo::add_graph_input_node_info() {
+  ::tensorflow::GraphTransferGraphInputNodeInfo* _add = _internal_add_graph_input_node_info();
+  // @@protoc_insertion_point(field_add:tensorflow.GraphTransferInfo.graph_input_node_info)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::GraphTransferGraphInputNodeInfo >&
+GraphTransferInfo::graph_input_node_info() const {
+  // @@protoc_insertion_point(field_list:tensorflow.GraphTransferInfo.graph_input_node_info)
+  return _impl_.graph_input_node_info_;
+}
+
+// repeated .tensorflow.GraphTransferGraphOutputNodeInfo graph_output_node_info = 6;
+inline int GraphTransferInfo::_internal_graph_output_node_info_size() const {
+  return _impl_.graph_output_node_info_.size();
+}
+inline int GraphTransferInfo::graph_output_node_info_size() const {
+  return _internal_graph_output_node_info_size();
+}
+inline void GraphTransferInfo::clear_graph_output_node_info() {
+  _impl_.graph_output_node_info_.Clear();
+}
+inline ::tensorflow::GraphTransferGraphOutputNodeInfo* GraphTransferInfo::mutable_graph_output_node_info(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.GraphTransferInfo.graph_output_node_info)
+  return _impl_.graph_output_node_info_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::GraphTransferGraphOutputNodeInfo >*
+GraphTransferInfo::mutable_graph_output_node_info() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.GraphTransferInfo.graph_output_node_info)
+  return &_impl_.graph_output_node_info_;
+}
+inline const ::tensorflow::GraphTransferGraphOutputNodeInfo& GraphTransferInfo::_internal_graph_output_node_info(int index) const {
+  return _impl_.graph_output_node_info_.Get(index);
+}
+inline const ::tensorflow::GraphTransferGraphOutputNodeInfo& GraphTransferInfo::graph_output_node_info(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.GraphTransferInfo.graph_output_node_info)
+  return _internal_graph_output_node_info(index);
+}
+inline ::tensorflow::GraphTransferGraphOutputNodeInfo* GraphTransferInfo::_internal_add_graph_output_node_info() {
+  return _impl_.graph_output_node_info_.Add();
+}
+inline ::tensorflow::GraphTransferGraphOutputNodeInfo* GraphTransferInfo::add_graph_output_node_info() {
+  ::tensorflow::GraphTransferGraphOutputNodeInfo* _add = _internal_add_graph_output_node_info();
+  // @@protoc_insertion_point(field_add:tensorflow.GraphTransferInfo.graph_output_node_info)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::GraphTransferGraphOutputNodeInfo >&
+GraphTransferInfo::graph_output_node_info() const {
+  // @@protoc_insertion_point(field_list:tensorflow.GraphTransferInfo.graph_output_node_info)
+  return _impl_.graph_output_node_info_;
+}
+
+// .tensorflow.GraphTransferInfo.Destination destination = 7;
+inline void GraphTransferInfo::clear_destination() {
+  _impl_.destination_ = 0;
+}
+inline ::tensorflow::GraphTransferInfo_Destination GraphTransferInfo::_internal_destination() const {
+  return static_cast< ::tensorflow::GraphTransferInfo_Destination >(_impl_.destination_);
+}
+inline ::tensorflow::GraphTransferInfo_Destination GraphTransferInfo::destination() const {
+  // @@protoc_insertion_point(field_get:tensorflow.GraphTransferInfo.destination)
+  return _internal_destination();
+}
+inline void GraphTransferInfo::_internal_set_destination(::tensorflow::GraphTransferInfo_Destination value) {
+  
+  _impl_.destination_ = value;
+}
+inline void GraphTransferInfo::set_destination(::tensorflow::GraphTransferInfo_Destination value) {
+  _internal_set_destination(value);
+  // @@protoc_insertion_point(field_set:tensorflow.GraphTransferInfo.destination)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace tensorflow
+
+PROTOBUF_NAMESPACE_OPEN
+
+template <> struct is_proto_enum< ::tensorflow::GraphTransferInfo_Destination> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::tensorflow::GraphTransferInfo_Destination>() {
+  return ::tensorflow::GraphTransferInfo_Destination_descriptor();
+}
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fgraph_5ftransfer_5finfo_2eproto
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/graph_transfer_info.proto b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/graph_transfer_info.proto
new file mode 100644
index 0000000000000000000000000000000000000000..febb162cd6a8d03d8d934035094a71c6843f9e04
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/graph_transfer_info.proto
@@ -0,0 +1,71 @@
+syntax = "proto3";
+
+package tensorflow;
+
+import "tensorflow/core/framework/types.proto";
+
+option cc_enable_arenas = true;
+option java_outer_classname = "GraphTransferInfoProto";
+option java_multiple_files = true;
+option java_package = "org.tensorflow.framework";
+option go_package = "github.com/tensorflow/tensorflow/tensorflow/go/core/framework/graph_transfer_info_go_proto";
+
+message GraphTransferNodeInput {
+  int32 node_id = 1;
+  int32 output_port = 2;
+}
+message GraphTransferNodeInfo {
+  string name = 1;
+  int32 node_id = 2;
+  string type_name = 3;
+  int32 soc_op_id = 4;
+  int32 padding_id = 5;
+  int32 input_count = 6;
+  int32 output_count = 7;
+}
+message GraphTransferConstNodeInfo {
+  string name = 1;
+  int32 node_id = 2;
+  repeated int64 shape = 3;
+  bytes data = 4;
+  DataType dtype = 5;
+}
+message GraphTransferNodeInputInfo {
+  int32 node_id = 1;
+  repeated GraphTransferNodeInput node_input = 2;
+}
+message GraphTransferNodeOutputInfo {
+  int32 node_id = 1;
+  repeated int32 max_byte_size = 2;
+}
+message GraphTransferGraphInputNodeInfo {
+  string name = 1;
+  repeated int64 shape = 2;
+  DataType dtype = 3;
+}
+
+message GraphTransferGraphOutputNodeInfo {
+  string name = 1;
+  repeated int64 shape = 2;
+  DataType dtype = 3;
+}
+
+// Protocol buffer representing a handle to a tensorflow resource. Handles are
+// not valid across executions, but can be serialized back and forth from within
+// a single run.
+message GraphTransferInfo {
+  enum Destination {
+    NOP = 0;
+    HEXAGON = 1;
+  }
+
+  repeated GraphTransferNodeInfo node_info = 1;
+  repeated GraphTransferConstNodeInfo const_node_info = 2;
+  repeated GraphTransferNodeInputInfo node_input_info = 3;
+  repeated GraphTransferNodeOutputInfo node_output_info = 4;
+  // Input Node parameters of transferred graph
+  repeated GraphTransferGraphInputNodeInfo graph_input_node_info = 5;
+  repeated GraphTransferGraphOutputNodeInfo graph_output_node_info = 6;
+  // Destination of graph transfer
+  Destination destination = 7;
+}
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/kernel_def.pb.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/kernel_def.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..debaf8b52744d14f1282180d6e4be9b906652fc8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/kernel_def.pb.h
@@ -0,0 +1,1134 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: tensorflow/core/framework/kernel_def.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fkernel_5fdef_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fkernel_5fdef_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3021000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3021009 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+#include "tensorflow/core/framework/attr_value.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_tensorflow_2fcore_2fframework_2fkernel_5fdef_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_tensorflow_2fcore_2fframework_2fkernel_5fdef_2eproto {
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_tensorflow_2fcore_2fframework_2fkernel_5fdef_2eproto;
+namespace tensorflow {
+class KernelDef;
+struct KernelDefDefaultTypeInternal;
+extern KernelDefDefaultTypeInternal _KernelDef_default_instance_;
+class KernelDef_AttrConstraint;
+struct KernelDef_AttrConstraintDefaultTypeInternal;
+extern KernelDef_AttrConstraintDefaultTypeInternal _KernelDef_AttrConstraint_default_instance_;
+class KernelList;
+struct KernelListDefaultTypeInternal;
+extern KernelListDefaultTypeInternal _KernelList_default_instance_;
+}  // namespace tensorflow
+PROTOBUF_NAMESPACE_OPEN
+template<> ::tensorflow::KernelDef* Arena::CreateMaybeMessage<::tensorflow::KernelDef>(Arena*);
+template<> ::tensorflow::KernelDef_AttrConstraint* Arena::CreateMaybeMessage<::tensorflow::KernelDef_AttrConstraint>(Arena*);
+template<> ::tensorflow::KernelList* Arena::CreateMaybeMessage<::tensorflow::KernelList>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace tensorflow {
+
+// ===================================================================
+
+class KernelDef_AttrConstraint final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.KernelDef.AttrConstraint) */ {
+ public:
+  inline KernelDef_AttrConstraint() : KernelDef_AttrConstraint(nullptr) {}
+  ~KernelDef_AttrConstraint() override;
+  explicit PROTOBUF_CONSTEXPR KernelDef_AttrConstraint(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  KernelDef_AttrConstraint(const KernelDef_AttrConstraint& from);
+  KernelDef_AttrConstraint(KernelDef_AttrConstraint&& from) noexcept
+    : KernelDef_AttrConstraint() {
+    *this = ::std::move(from);
+  }
+
+  inline KernelDef_AttrConstraint& operator=(const KernelDef_AttrConstraint& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline KernelDef_AttrConstraint& operator=(KernelDef_AttrConstraint&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const KernelDef_AttrConstraint& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const KernelDef_AttrConstraint* internal_default_instance() {
+    return reinterpret_cast<const KernelDef_AttrConstraint*>(
+               &_KernelDef_AttrConstraint_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(KernelDef_AttrConstraint& a, KernelDef_AttrConstraint& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(KernelDef_AttrConstraint* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(KernelDef_AttrConstraint* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  KernelDef_AttrConstraint* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<KernelDef_AttrConstraint>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const KernelDef_AttrConstraint& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const KernelDef_AttrConstraint& from) {
+    KernelDef_AttrConstraint::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(KernelDef_AttrConstraint* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.KernelDef.AttrConstraint";
+  }
+  protected:
+  explicit KernelDef_AttrConstraint(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNameFieldNumber = 1,
+    kAllowedValuesFieldNumber = 2,
+  };
+  // string name = 1;
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // .tensorflow.AttrValue allowed_values = 2;
+  bool has_allowed_values() const;
+  private:
+  bool _internal_has_allowed_values() const;
+  public:
+  void clear_allowed_values();
+  const ::tensorflow::AttrValue& allowed_values() const;
+  PROTOBUF_NODISCARD ::tensorflow::AttrValue* release_allowed_values();
+  ::tensorflow::AttrValue* mutable_allowed_values();
+  void set_allocated_allowed_values(::tensorflow::AttrValue* allowed_values);
+  private:
+  const ::tensorflow::AttrValue& _internal_allowed_values() const;
+  ::tensorflow::AttrValue* _internal_mutable_allowed_values();
+  public:
+  void unsafe_arena_set_allocated_allowed_values(
+      ::tensorflow::AttrValue* allowed_values);
+  ::tensorflow::AttrValue* unsafe_arena_release_allowed_values();
+
+  // @@protoc_insertion_point(class_scope:tensorflow.KernelDef.AttrConstraint)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+    ::tensorflow::AttrValue* allowed_values_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fkernel_5fdef_2eproto;
+};
+// -------------------------------------------------------------------
+
+class KernelDef final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.KernelDef) */ {
+ public:
+  inline KernelDef() : KernelDef(nullptr) {}
+  ~KernelDef() override;
+  explicit PROTOBUF_CONSTEXPR KernelDef(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  KernelDef(const KernelDef& from);
+  KernelDef(KernelDef&& from) noexcept
+    : KernelDef() {
+    *this = ::std::move(from);
+  }
+
+  inline KernelDef& operator=(const KernelDef& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline KernelDef& operator=(KernelDef&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const KernelDef& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const KernelDef* internal_default_instance() {
+    return reinterpret_cast<const KernelDef*>(
+               &_KernelDef_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(KernelDef& a, KernelDef& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(KernelDef* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(KernelDef* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  KernelDef* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<KernelDef>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const KernelDef& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const KernelDef& from) {
+    KernelDef::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(KernelDef* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.KernelDef";
+  }
+  protected:
+  explicit KernelDef(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef KernelDef_AttrConstraint AttrConstraint;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kConstraintFieldNumber = 3,
+    kHostMemoryArgFieldNumber = 4,
+    kOpFieldNumber = 1,
+    kDeviceTypeFieldNumber = 2,
+    kLabelFieldNumber = 5,
+    kPriorityFieldNumber = 6,
+  };
+  // repeated .tensorflow.KernelDef.AttrConstraint constraint = 3;
+  int constraint_size() const;
+  private:
+  int _internal_constraint_size() const;
+  public:
+  void clear_constraint();
+  ::tensorflow::KernelDef_AttrConstraint* mutable_constraint(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::KernelDef_AttrConstraint >*
+      mutable_constraint();
+  private:
+  const ::tensorflow::KernelDef_AttrConstraint& _internal_constraint(int index) const;
+  ::tensorflow::KernelDef_AttrConstraint* _internal_add_constraint();
+  public:
+  const ::tensorflow::KernelDef_AttrConstraint& constraint(int index) const;
+  ::tensorflow::KernelDef_AttrConstraint* add_constraint();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::KernelDef_AttrConstraint >&
+      constraint() const;
+
+  // repeated string host_memory_arg = 4;
+  int host_memory_arg_size() const;
+  private:
+  int _internal_host_memory_arg_size() const;
+  public:
+  void clear_host_memory_arg();
+  const std::string& host_memory_arg(int index) const;
+  std::string* mutable_host_memory_arg(int index);
+  void set_host_memory_arg(int index, const std::string& value);
+  void set_host_memory_arg(int index, std::string&& value);
+  void set_host_memory_arg(int index, const char* value);
+  void set_host_memory_arg(int index, const char* value, size_t size);
+  std::string* add_host_memory_arg();
+  void add_host_memory_arg(const std::string& value);
+  void add_host_memory_arg(std::string&& value);
+  void add_host_memory_arg(const char* value);
+  void add_host_memory_arg(const char* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& host_memory_arg() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_host_memory_arg();
+  private:
+  const std::string& _internal_host_memory_arg(int index) const;
+  std::string* _internal_add_host_memory_arg();
+  public:
+
+  // string op = 1;
+  void clear_op();
+  const std::string& op() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_op(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_op();
+  PROTOBUF_NODISCARD std::string* release_op();
+  void set_allocated_op(std::string* op);
+  private:
+  const std::string& _internal_op() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_op(const std::string& value);
+  std::string* _internal_mutable_op();
+  public:
+
+  // string device_type = 2;
+  void clear_device_type();
+  const std::string& device_type() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_device_type(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_device_type();
+  PROTOBUF_NODISCARD std::string* release_device_type();
+  void set_allocated_device_type(std::string* device_type);
+  private:
+  const std::string& _internal_device_type() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_device_type(const std::string& value);
+  std::string* _internal_mutable_device_type();
+  public:
+
+  // string label = 5;
+  void clear_label();
+  const std::string& label() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_label(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_label();
+  PROTOBUF_NODISCARD std::string* release_label();
+  void set_allocated_label(std::string* label);
+  private:
+  const std::string& _internal_label() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_label(const std::string& value);
+  std::string* _internal_mutable_label();
+  public:
+
+  // int32 priority = 6;
+  void clear_priority();
+  int32_t priority() const;
+  void set_priority(int32_t value);
+  private:
+  int32_t _internal_priority() const;
+  void _internal_set_priority(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.KernelDef)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::KernelDef_AttrConstraint > constraint_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> host_memory_arg_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr op_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_type_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr label_;
+    int32_t priority_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fkernel_5fdef_2eproto;
+};
+// -------------------------------------------------------------------
+
+class KernelList final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.KernelList) */ {
+ public:
+  inline KernelList() : KernelList(nullptr) {}
+  ~KernelList() override;
+  explicit PROTOBUF_CONSTEXPR KernelList(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  KernelList(const KernelList& from);
+  KernelList(KernelList&& from) noexcept
+    : KernelList() {
+    *this = ::std::move(from);
+  }
+
+  inline KernelList& operator=(const KernelList& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline KernelList& operator=(KernelList&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const KernelList& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const KernelList* internal_default_instance() {
+    return reinterpret_cast<const KernelList*>(
+               &_KernelList_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(KernelList& a, KernelList& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(KernelList* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(KernelList* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  KernelList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<KernelList>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const KernelList& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const KernelList& from) {
+    KernelList::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(KernelList* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.KernelList";
+  }
+  protected:
+  explicit KernelList(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kKernelFieldNumber = 1,
+  };
+  // repeated .tensorflow.KernelDef kernel = 1;
+  int kernel_size() const;
+  private:
+  int _internal_kernel_size() const;
+  public:
+  void clear_kernel();
+  ::tensorflow::KernelDef* mutable_kernel(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::KernelDef >*
+      mutable_kernel();
+  private:
+  const ::tensorflow::KernelDef& _internal_kernel(int index) const;
+  ::tensorflow::KernelDef* _internal_add_kernel();
+  public:
+  const ::tensorflow::KernelDef& kernel(int index) const;
+  ::tensorflow::KernelDef* add_kernel();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::KernelDef >&
+      kernel() const;
+
+  // @@protoc_insertion_point(class_scope:tensorflow.KernelList)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::KernelDef > kernel_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fkernel_5fdef_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// KernelDef_AttrConstraint
+
+// string name = 1;
+inline void KernelDef_AttrConstraint::clear_name() {
+  _impl_.name_.ClearToEmpty();
+}
+inline const std::string& KernelDef_AttrConstraint::name() const {
+  // @@protoc_insertion_point(field_get:tensorflow.KernelDef.AttrConstraint.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void KernelDef_AttrConstraint::set_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.KernelDef.AttrConstraint.name)
+}
+inline std::string* KernelDef_AttrConstraint::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:tensorflow.KernelDef.AttrConstraint.name)
+  return _s;
+}
+inline const std::string& KernelDef_AttrConstraint::_internal_name() const {
+  return _impl_.name_.Get();
+}
+inline void KernelDef_AttrConstraint::_internal_set_name(const std::string& value) {
+  
+  _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* KernelDef_AttrConstraint::_internal_mutable_name() {
+  
+  return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* KernelDef_AttrConstraint::release_name() {
+  // @@protoc_insertion_point(field_release:tensorflow.KernelDef.AttrConstraint.name)
+  return _impl_.name_.Release();
+}
+inline void KernelDef_AttrConstraint::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.KernelDef.AttrConstraint.name)
+}
+
+// .tensorflow.AttrValue allowed_values = 2;
+inline bool KernelDef_AttrConstraint::_internal_has_allowed_values() const {
+  return this != internal_default_instance() && _impl_.allowed_values_ != nullptr;
+}
+inline bool KernelDef_AttrConstraint::has_allowed_values() const {
+  return _internal_has_allowed_values();
+}
+inline const ::tensorflow::AttrValue& KernelDef_AttrConstraint::_internal_allowed_values() const {
+  const ::tensorflow::AttrValue* p = _impl_.allowed_values_;
+  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::AttrValue&>(
+      ::tensorflow::_AttrValue_default_instance_);
+}
+inline const ::tensorflow::AttrValue& KernelDef_AttrConstraint::allowed_values() const {
+  // @@protoc_insertion_point(field_get:tensorflow.KernelDef.AttrConstraint.allowed_values)
+  return _internal_allowed_values();
+}
+inline void KernelDef_AttrConstraint::unsafe_arena_set_allocated_allowed_values(
+    ::tensorflow::AttrValue* allowed_values) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.allowed_values_);
+  }
+  _impl_.allowed_values_ = allowed_values;
+  if (allowed_values) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.KernelDef.AttrConstraint.allowed_values)
+}
+inline ::tensorflow::AttrValue* KernelDef_AttrConstraint::release_allowed_values() {
+  
+  ::tensorflow::AttrValue* temp = _impl_.allowed_values_;
+  _impl_.allowed_values_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::tensorflow::AttrValue* KernelDef_AttrConstraint::unsafe_arena_release_allowed_values() {
+  // @@protoc_insertion_point(field_release:tensorflow.KernelDef.AttrConstraint.allowed_values)
+  
+  ::tensorflow::AttrValue* temp = _impl_.allowed_values_;
+  _impl_.allowed_values_ = nullptr;
+  return temp;
+}
+inline ::tensorflow::AttrValue* KernelDef_AttrConstraint::_internal_mutable_allowed_values() {
+  
+  if (_impl_.allowed_values_ == nullptr) {
+    auto* p = CreateMaybeMessage<::tensorflow::AttrValue>(GetArenaForAllocation());
+    _impl_.allowed_values_ = p;
+  }
+  return _impl_.allowed_values_;
+}
+inline ::tensorflow::AttrValue* KernelDef_AttrConstraint::mutable_allowed_values() {
+  ::tensorflow::AttrValue* _msg = _internal_mutable_allowed_values();
+  // @@protoc_insertion_point(field_mutable:tensorflow.KernelDef.AttrConstraint.allowed_values)
+  return _msg;
+}
+inline void KernelDef_AttrConstraint::set_allocated_allowed_values(::tensorflow::AttrValue* allowed_values) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.allowed_values_);
+  }
+  if (allowed_values) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(allowed_values));
+    if (message_arena != submessage_arena) {
+      allowed_values = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, allowed_values, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.allowed_values_ = allowed_values;
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.KernelDef.AttrConstraint.allowed_values)
+}
+
+// -------------------------------------------------------------------
+
+// KernelDef
+
+// string op = 1;
+inline void KernelDef::clear_op() {
+  _impl_.op_.ClearToEmpty();
+}
+inline const std::string& KernelDef::op() const {
+  // @@protoc_insertion_point(field_get:tensorflow.KernelDef.op)
+  return _internal_op();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void KernelDef::set_op(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.op_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.KernelDef.op)
+}
+inline std::string* KernelDef::mutable_op() {
+  std::string* _s = _internal_mutable_op();
+  // @@protoc_insertion_point(field_mutable:tensorflow.KernelDef.op)
+  return _s;
+}
+inline const std::string& KernelDef::_internal_op() const {
+  return _impl_.op_.Get();
+}
+inline void KernelDef::_internal_set_op(const std::string& value) {
+  
+  _impl_.op_.Set(value, GetArenaForAllocation());
+}
+inline std::string* KernelDef::_internal_mutable_op() {
+  
+  return _impl_.op_.Mutable(GetArenaForAllocation());
+}
+inline std::string* KernelDef::release_op() {
+  // @@protoc_insertion_point(field_release:tensorflow.KernelDef.op)
+  return _impl_.op_.Release();
+}
+inline void KernelDef::set_allocated_op(std::string* op) {
+  if (op != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.op_.SetAllocated(op, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.op_.IsDefault()) {
+    _impl_.op_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.KernelDef.op)
+}
+
+// string device_type = 2;
+inline void KernelDef::clear_device_type() {
+  _impl_.device_type_.ClearToEmpty();
+}
+inline const std::string& KernelDef::device_type() const {
+  // @@protoc_insertion_point(field_get:tensorflow.KernelDef.device_type)
+  return _internal_device_type();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void KernelDef::set_device_type(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.device_type_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.KernelDef.device_type)
+}
+inline std::string* KernelDef::mutable_device_type() {
+  std::string* _s = _internal_mutable_device_type();
+  // @@protoc_insertion_point(field_mutable:tensorflow.KernelDef.device_type)
+  return _s;
+}
+inline const std::string& KernelDef::_internal_device_type() const {
+  return _impl_.device_type_.Get();
+}
+inline void KernelDef::_internal_set_device_type(const std::string& value) {
+  
+  _impl_.device_type_.Set(value, GetArenaForAllocation());
+}
+inline std::string* KernelDef::_internal_mutable_device_type() {
+  
+  return _impl_.device_type_.Mutable(GetArenaForAllocation());
+}
+inline std::string* KernelDef::release_device_type() {
+  // @@protoc_insertion_point(field_release:tensorflow.KernelDef.device_type)
+  return _impl_.device_type_.Release();
+}
+inline void KernelDef::set_allocated_device_type(std::string* device_type) {
+  if (device_type != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.device_type_.SetAllocated(device_type, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.device_type_.IsDefault()) {
+    _impl_.device_type_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.KernelDef.device_type)
+}
+
+// repeated .tensorflow.KernelDef.AttrConstraint constraint = 3;
+inline int KernelDef::_internal_constraint_size() const {
+  return _impl_.constraint_.size();
+}
+inline int KernelDef::constraint_size() const {
+  return _internal_constraint_size();
+}
+inline void KernelDef::clear_constraint() {
+  _impl_.constraint_.Clear();
+}
+inline ::tensorflow::KernelDef_AttrConstraint* KernelDef::mutable_constraint(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.KernelDef.constraint)
+  return _impl_.constraint_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::KernelDef_AttrConstraint >*
+KernelDef::mutable_constraint() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.KernelDef.constraint)
+  return &_impl_.constraint_;
+}
+inline const ::tensorflow::KernelDef_AttrConstraint& KernelDef::_internal_constraint(int index) const {
+  return _impl_.constraint_.Get(index);
+}
+inline const ::tensorflow::KernelDef_AttrConstraint& KernelDef::constraint(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.KernelDef.constraint)
+  return _internal_constraint(index);
+}
+inline ::tensorflow::KernelDef_AttrConstraint* KernelDef::_internal_add_constraint() {
+  return _impl_.constraint_.Add();
+}
+inline ::tensorflow::KernelDef_AttrConstraint* KernelDef::add_constraint() {
+  ::tensorflow::KernelDef_AttrConstraint* _add = _internal_add_constraint();
+  // @@protoc_insertion_point(field_add:tensorflow.KernelDef.constraint)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::KernelDef_AttrConstraint >&
+KernelDef::constraint() const {
+  // @@protoc_insertion_point(field_list:tensorflow.KernelDef.constraint)
+  return _impl_.constraint_;
+}
+
+// repeated string host_memory_arg = 4;
+inline int KernelDef::_internal_host_memory_arg_size() const {
+  return _impl_.host_memory_arg_.size();
+}
+inline int KernelDef::host_memory_arg_size() const {
+  return _internal_host_memory_arg_size();
+}
+inline void KernelDef::clear_host_memory_arg() {
+  _impl_.host_memory_arg_.Clear();
+}
+inline std::string* KernelDef::add_host_memory_arg() {
+  std::string* _s = _internal_add_host_memory_arg();
+  // @@protoc_insertion_point(field_add_mutable:tensorflow.KernelDef.host_memory_arg)
+  return _s;
+}
+inline const std::string& KernelDef::_internal_host_memory_arg(int index) const {
+  return _impl_.host_memory_arg_.Get(index);
+}
+inline const std::string& KernelDef::host_memory_arg(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.KernelDef.host_memory_arg)
+  return _internal_host_memory_arg(index);
+}
+inline std::string* KernelDef::mutable_host_memory_arg(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.KernelDef.host_memory_arg)
+  return _impl_.host_memory_arg_.Mutable(index);
+}
+inline void KernelDef::set_host_memory_arg(int index, const std::string& value) {
+  _impl_.host_memory_arg_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:tensorflow.KernelDef.host_memory_arg)
+}
+inline void KernelDef::set_host_memory_arg(int index, std::string&& value) {
+  _impl_.host_memory_arg_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:tensorflow.KernelDef.host_memory_arg)
+}
+inline void KernelDef::set_host_memory_arg(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.host_memory_arg_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:tensorflow.KernelDef.host_memory_arg)
+}
+inline void KernelDef::set_host_memory_arg(int index, const char* value, size_t size) {
+  _impl_.host_memory_arg_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:tensorflow.KernelDef.host_memory_arg)
+}
+inline std::string* KernelDef::_internal_add_host_memory_arg() {
+  return _impl_.host_memory_arg_.Add();
+}
+inline void KernelDef::add_host_memory_arg(const std::string& value) {
+  _impl_.host_memory_arg_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:tensorflow.KernelDef.host_memory_arg)
+}
+inline void KernelDef::add_host_memory_arg(std::string&& value) {
+  _impl_.host_memory_arg_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:tensorflow.KernelDef.host_memory_arg)
+}
+inline void KernelDef::add_host_memory_arg(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.host_memory_arg_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:tensorflow.KernelDef.host_memory_arg)
+}
+inline void KernelDef::add_host_memory_arg(const char* value, size_t size) {
+  _impl_.host_memory_arg_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:tensorflow.KernelDef.host_memory_arg)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+KernelDef::host_memory_arg() const {
+  // @@protoc_insertion_point(field_list:tensorflow.KernelDef.host_memory_arg)
+  return _impl_.host_memory_arg_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+KernelDef::mutable_host_memory_arg() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.KernelDef.host_memory_arg)
+  return &_impl_.host_memory_arg_;
+}
+
+// string label = 5;
+inline void KernelDef::clear_label() {
+  _impl_.label_.ClearToEmpty();
+}
+inline const std::string& KernelDef::label() const {
+  // @@protoc_insertion_point(field_get:tensorflow.KernelDef.label)
+  return _internal_label();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void KernelDef::set_label(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.label_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.KernelDef.label)
+}
+inline std::string* KernelDef::mutable_label() {
+  std::string* _s = _internal_mutable_label();
+  // @@protoc_insertion_point(field_mutable:tensorflow.KernelDef.label)
+  return _s;
+}
+inline const std::string& KernelDef::_internal_label() const {
+  return _impl_.label_.Get();
+}
+inline void KernelDef::_internal_set_label(const std::string& value) {
+  
+  _impl_.label_.Set(value, GetArenaForAllocation());
+}
+inline std::string* KernelDef::_internal_mutable_label() {
+  
+  return _impl_.label_.Mutable(GetArenaForAllocation());
+}
+inline std::string* KernelDef::release_label() {
+  // @@protoc_insertion_point(field_release:tensorflow.KernelDef.label)
+  return _impl_.label_.Release();
+}
+inline void KernelDef::set_allocated_label(std::string* label) {
+  if (label != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.label_.SetAllocated(label, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.label_.IsDefault()) {
+    _impl_.label_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.KernelDef.label)
+}
+
+// int32 priority = 6;
+inline void KernelDef::clear_priority() {
+  _impl_.priority_ = 0;
+}
+inline int32_t KernelDef::_internal_priority() const {
+  return _impl_.priority_;
+}
+inline int32_t KernelDef::priority() const {
+  // @@protoc_insertion_point(field_get:tensorflow.KernelDef.priority)
+  return _internal_priority();
+}
+inline void KernelDef::_internal_set_priority(int32_t value) {
+  
+  _impl_.priority_ = value;
+}
+inline void KernelDef::set_priority(int32_t value) {
+  _internal_set_priority(value);
+  // @@protoc_insertion_point(field_set:tensorflow.KernelDef.priority)
+}
+
+// -------------------------------------------------------------------
+
+// KernelList
+
+// repeated .tensorflow.KernelDef kernel = 1;
+inline int KernelList::_internal_kernel_size() const {
+  return _impl_.kernel_.size();
+}
+inline int KernelList::kernel_size() const {
+  return _internal_kernel_size();
+}
+inline void KernelList::clear_kernel() {
+  _impl_.kernel_.Clear();
+}
+inline ::tensorflow::KernelDef* KernelList::mutable_kernel(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.KernelList.kernel)
+  return _impl_.kernel_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::KernelDef >*
+KernelList::mutable_kernel() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.KernelList.kernel)
+  return &_impl_.kernel_;
+}
+inline const ::tensorflow::KernelDef& KernelList::_internal_kernel(int index) const {
+  return _impl_.kernel_.Get(index);
+}
+inline const ::tensorflow::KernelDef& KernelList::kernel(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.KernelList.kernel)
+  return _internal_kernel(index);
+}
+inline ::tensorflow::KernelDef* KernelList::_internal_add_kernel() {
+  return _impl_.kernel_.Add();
+}
+inline ::tensorflow::KernelDef* KernelList::add_kernel() {
+  ::tensorflow::KernelDef* _add = _internal_add_kernel();
+  // @@protoc_insertion_point(field_add:tensorflow.KernelList.kernel)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::KernelDef >&
+KernelList::kernel() const {
+  // @@protoc_insertion_point(field_list:tensorflow.KernelList.kernel)
+  return _impl_.kernel_;
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace tensorflow
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fkernel_5fdef_2eproto
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/kernel_def.proto b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/kernel_def.proto
new file mode 100644
index 0000000000000000000000000000000000000000..44575d9366676068126273d4bcbf40118feb5398
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/kernel_def.proto
@@ -0,0 +1,48 @@
+syntax = "proto3";
+
+package tensorflow;
+
+import "tensorflow/core/framework/attr_value.proto";
+
+option cc_enable_arenas = true;
+option java_outer_classname = "KernelDefProtos";
+option java_multiple_files = true;
+option java_package = "org.tensorflow.framework";
+option go_package = "github.com/tensorflow/tensorflow/tensorflow/go/core/framework/kernel_def_go_proto";
+
+message KernelDef {
+  // Must match the name of an Op.
+  string op = 1;
+
+  // Type of device this kernel runs on.
+  string device_type = 2;
+
+  message AttrConstraint {
+    // Name of an attr from the Op.
+    string name = 1;
+
+    // A list of values that this kernel supports for this attr.
+    // Like OpDef.AttrDef.allowed_values, except for kernels instead of Ops.
+    AttrValue allowed_values = 2;
+  }
+  repeated AttrConstraint constraint = 3;
+
+  // Names of the Op's input_/output_args that reside in host memory
+  // instead of device memory.
+  repeated string host_memory_arg = 4;
+
+  // This allows experimental kernels to be registered for an op that
+  // won't be used unless the user specifies a "_kernel" attr with
+  // value matching this.
+  string label = 5;
+
+  // Prioritization of kernel amongst different devices. By default we assume
+  // priority is 0. The higher the priority the better. By default (i.e. if
+  // this is not set), we prefer GPU kernels over CPU.
+  int32 priority = 6;
+}
+
+// A collection of KernelDefs
+message KernelList {
+  repeated KernelDef kernel = 1;
+}
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/kernel_def_builder.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/kernel_def_builder.h
new file mode 100644
index 0000000000000000000000000000000000000000..f4d2220d90261f8968566c4cb92a11215b06493b
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/kernel_def_builder.h
@@ -0,0 +1,102 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_KERNEL_DEF_BUILDER_H_
+#define TENSORFLOW_CORE_FRAMEWORK_KERNEL_DEF_BUILDER_H_
+
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/lib/gtl/array_slice.h"
+#include "tensorflow/core/platform/macros.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+
+// Forward declare proto so that kernels don't need to depend on it
+class KernelDef;
+
+// Builder class passed to the REGISTER_KERNEL_BUILDER() macro.
+class KernelDefBuilder {
+ public:
+  // Starts with just the name field set.
+  // Caller MUST call Build() and take ownership of the result.
+  explicit KernelDefBuilder(const char* op_name);
+  ~KernelDefBuilder();
+
+  // Required: specify the type of device this kernel supports.
+  // Returns *this.
+  KernelDefBuilder& Device(const char* device_type);
+
+  // Specify that this kernel supports a limited set of values for a
+  // particular type or list(type) attr (a further restriction than
+  // what the Op allows).
+  // Returns *this.
+  template <typename T>
+  KernelDefBuilder& AttrConstraint(const char* attr_name,
+                                   gtl::ArraySlice<T> allowed);
+
+  // Like AttrConstraint above but supports just a single value.
+  template <typename T>
+  KernelDefBuilder& AttrConstraint(const char* attr_name, T allowed);
+
+  // Specify that this kernel supports a limited set of values for a
+  // particular type or list(type) attr (a further restriction than
+  // what the Op allows).
+  // Returns *this.
+  KernelDefBuilder& TypeConstraint(const char* attr_name,
+                                   gtl::ArraySlice<DataType> allowed);
+
+  // Like TypeConstraint but supports just a single type.
+  KernelDefBuilder& TypeConstraint(const char* attr_name, DataType allowed);
+
+  // Like TypeConstraint, but (a) gets the type from a template parameter
+  // and (b) only supports a constraint to a single type.
+  template <class T>
+  KernelDefBuilder& TypeConstraint(const char* attr_name) TF_ATTRIBUTE_NOINLINE;
+  // TODO(josh11b): Support other types of attr constraints as needed.
+
+  // Specify that this kernel requires/provides an input/output arg
+  // in host memory (instead of the default, device memory).
+  // Returns *this.
+  KernelDefBuilder& HostMemory(const char* arg_name);
+
+  // Specify that this kernel requires a particular value for the
+  // "_kernel" attr.  May only be specified once.  Returns *this.
+  KernelDefBuilder& Label(const char* label);
+
+  // Specify a priority number for this kernel.
+  KernelDefBuilder& Priority(int32_t priority);
+
+  // Returns a pointer to a KernelDef with fields set based on the
+  // above calls to this instance.
+  // Caller takes ownership of the result.
+  const KernelDef* Build();
+
+ private:
+  KernelDef* kernel_def_;
+
+  KernelDefBuilder(const KernelDefBuilder&) = delete;
+  void operator=(const KernelDefBuilder&) = delete;
+};
+
+// IMPLEMENTATION
+
+template <class T>
+KernelDefBuilder& KernelDefBuilder::TypeConstraint(const char* attr_name) {
+  return this->TypeConstraint(attr_name, DataTypeToEnum<T>::v());
+}
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_KERNEL_DEF_BUILDER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/kernel_def_util.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/kernel_def_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..b973cefc4f4d24ea033796fbf1849908e4c7805e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/kernel_def_util.h
@@ -0,0 +1,31 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_KERNEL_DEF_UTIL_H_
+#define TENSORFLOW_CORE_FRAMEWORK_KERNEL_DEF_UTIL_H_
+
+#include "tensorflow/core/framework/kernel_def.pb.h"
+#include "tensorflow/core/framework/node_def_util.h"
+
+namespace tensorflow {
+
+// Returns whether the attrs satisfy the constraints in the kernel_def. Returns
+// an error if attrs in kernel_def are not found, or have a mismatching type.
+Status KernelAttrsMatch(const KernelDef& kernel_def, AttrSlice attrs,
+                        bool* match);
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_KERNEL_DEF_UTIL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/kernel_shape_util.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/kernel_shape_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..551a863e3d38e567e19c9f0687ac5bf50355246d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/kernel_shape_util.h
@@ -0,0 +1,111 @@
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_KERNEL_SHAPE_UTIL_H_
+#define TENSORFLOW_CORE_FRAMEWORK_KERNEL_SHAPE_UTIL_H_
+
+#include <array>
+
+#include "tensorflow/core/platform/status.h"
+#include "tensorflow/core/util/padding.h"
+
+namespace tensorflow {
+// GetWindowedOutputSize(): Given an input tensor, kernel, stride and padding
+// type, the function computes the output and padding dimensions.
+//
+// For example, ignoring batches or multiple features, a 1D convolution
+// takes as input a 1D tensor of shape (H), and convolves it with a filter of
+// shape (K).
+//
+// It also takes in a few additional parameters:
+//
+// Stride (S): the stride with which we apply the filters. This is the offset
+// between locations where we apply the filters. A larger stride
+// means that the output will be spatially smaller.
+//
+// Padding (P): the padding we apply to the input tensor along each
+// dimension. This is usually used to make sure that the spatial dimensions
+// do not shrink when we progress with convolutions. This function supports two
+// types of padding.
+//   SAME: the pad value is computed so that the output will have size H/S.
+//   VALID: no padding is carried out.
+// If you want to use EXPLICIT padding, GetWindowedOutputSizeVerbose must be
+// called instead. Note the padded area is zero-filled.
+//
+// The output dimensions are computed as follows:
+// - When adding dilation_rate (D), we compute an effective filter size (K'):
+//     K' = (K - 1) * D + 1
+// - When Padding = SAME: the output size is (H'), where
+//     H' = ceil(float(H) / float(S))
+//   where ceil is the ceiling function. The number of padded cells
+//   is computed as:
+//     Pc = ((H' - 1) * S + K' - H) / 2
+//   When the stride is 1, the expression simplifies to
+//     H' = H, Pc = (K'-1)/2.
+//   This is where SAME comes from - the output has the same size as the input
+//   has.
+//
+// - When Padding = VALID: the output size is computed as
+//     H' = ceil(float(H - K' + 1) / float(S))
+//   and the number of padded cells is always zero.
+//   When the stride is 1, the expression simplifies to
+//     H' = H-K'+1.
+//
+// For convolution, mathematically, the output value at location (r')
+// is the inner product of two vectors: the chunk of input at
+//    ((r'*S-Pr) : (r'*S-Pr+K)),
+// and the filter.
+//
+// For 2D and 3D convolutions, the spatial dimensions are orthogonal, so the
+// size and padding of each spatial dimension can be computed by calling
+// GetWindowedOutputSize separately for each dimension.
+//
+Status GetWindowedOutputSize(int64_t input_size, int64_t filter_size,
+                             int dilation_rate, int64_t stride,
+                             Padding padding_type, int64_t* output_size,
+                             int64_t* padding_size);
+
+// Returns the same output dimensions as in GetWindowedOutputSize, but returns
+// verbose padding dimensions (before/after), and EXPLICIT padding is supported.
+// When padding_type is EXPLICIT, *padding_before and *padding_after must
+// already point to initialized integers with the padding amounts. Otherwise,
+// *padding_before and *padding_after are set by this function, and any
+// excess padding (caused by an odd padding size value) is added to the
+// 'padding_after' dimension.
+Status GetWindowedOutputSizeVerbose(int64_t input_size, int64_t filter_size,
+                                      int64_t dilation_rate, int64_t stride,
+                                      Padding padding_type,
+                                      int64_t* output_size,
+                                      int64_t* padding_before,
+                                      int64_t* padding_after);
+
+// Given an input tensor, kernel, stride and padding type, populates the 3D size
+// of the output tensor and padding to be applied to the input tensor at the
+// lower end of every dimension. Use for 3D convolutions, where the input data
+// is padded with zeros, as well as for 3D avg/max pooling, where the input data
+// is padded with invalid values that are not considered for pooling. EXPLICIT
+// padding is not supported.
+// The V2 version computes the same outputs with arbitrary dilation_rate. For
+// detailed equations, refer to the comments for GetWindowedOutputSize().
+Status Get3dOutputSizeV2(const std::array<int64_t, 3>& input,
+                         const std::array<int64_t, 3>& window,
+                         const std::array<int64_t, 3>& dilations,
+                         const std::array<int64_t, 3>& strides,
+                         Padding padding_type,
+                         std::array<int64_t, 3>* output_ptr,
+                         std::array<int64_t, 3>* padding_ptr);
+
+}  // namespace tensorflow
+#endif  // TENSORFLOW_CORE_FRAMEWORK_KERNEL_SHAPE_UTIL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/local_rendezvous.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/local_rendezvous.h
new file mode 100644
index 0000000000000000000000000000000000000000..48affe938776f3c92b3d716fe0cce55a553d757d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/local_rendezvous.h
@@ -0,0 +1,121 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_LOCAL_RENDEZVOUS_H_
+#define TENSORFLOW_CORE_FRAMEWORK_LOCAL_RENDEZVOUS_H_
+
+#include <memory>
+#include <optional>
+#include <vector>
+
+#include "tensorflow/core/framework/rendezvous.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/lib/gtl/flatmap.h"
+#include "tensorflow/core/platform/macros.h"
+#include "tensorflow/core/platform/mutex.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+
+// Implements the basic logic of matching Send and Recv operations. See
+// RendezvousInterface for more details.
+//
+// NOTE: Most users will use a class that wraps LocalRendezvous, such as
+// IntraProcessRendezvous or RemoteRendezvous. This class does not implement
+// RendezvousInterface because virtual dispatch to LocalRendezvous methods
+// is not expected to be needed.
+class LocalRendezvous {
+ public:
+  // If the class wrapping LocalRendezvous is refcounted (i.e., extending
+  // Rendezvous), pass in its pointer in constructor so the LocalRendezvous
+  // can make sure it outlives the async recv requests.
+  // Pass in nullptr if the wrapping class is not refcounted.
+  explicit LocalRendezvous(Rendezvous* owner, int num_shards)
+      : num_buckets_(num_shards > 0 ? num_shards : 1),
+        rc_owner_(owner),
+        table_buckets_(std::make_unique<TableBucket[]>(num_buckets_)) {}
+  ~LocalRendezvous();
+
+  Status Send(const Rendezvous::ParsedKey& key,
+              const Rendezvous::Args& send_args, const Tensor& val,
+              bool is_dead);
+  void RecvAsync(const Rendezvous::ParsedKey& key,
+                 const Rendezvous::Args& recv_args,
+                 Rendezvous::DoneCallback done);
+  void StartAbort(const Status& status);
+  Status status();
+
+  // Releases all the references to the aborted rendezvous. Used in unit tests.
+  static void ReleaseAbortedRendezvous() {
+    mutex_lock l(aborted_rendezs_mu_);
+    aborted_rendezs_.clear();
+  }
+
+ private:
+  void DoAbort(const Status& status);
+
+  tsl::core::RefCountPtr<Rendezvous> GetOwnerRefCountPtr();
+
+  struct Item;
+
+  // By invariant, the item queue under each key is of the form
+  //   [item.type == kSend]* meaning each item is a sent message.
+  // or
+  //   [item.type == kRecv]* meaning each item is a waiter.
+  struct ItemQueue {
+    void push_back(Item* item);
+
+    Item* head = nullptr;
+    Item* tail = nullptr;
+  };
+
+  typedef gtl::FlatMap<uint64, ItemQueue> Table;
+
+  const int num_buckets_;
+  // Pointer to the owner class of this LocalRendezvous if it is refcounted,
+  // nullptr otherwise.
+  Rendezvous* rc_owner_;
+
+  struct TableBucket {
+    mutex mu;
+    Table table TF_GUARDED_BY(mu);
+
+    // Track the number of pening callbacks using a counter.
+    int pending_callback_counter TF_GUARDED_BY(mu) = 0;
+    condition_variable pending_callback_cond_var TF_GUARDED_BY(mu);
+  };
+
+  // Immutable set of buckets. This uses less memory than std::vector.
+  const std::unique_ptr<TableBucket[]> table_buckets_;
+  mutex mu_;
+  Status status_ TF_GUARDED_BY(mu_);
+
+  // We deliberately leak one reference of the aborted rendezvous here, so that
+  // they won't be destructed, and lose the status_.
+  // This is necessary because subsequent calls to RendezvousMgr::Find() will
+  // return the aborted rendezvous, and proper errors will be propagated.
+  // TODO(hhb): find a better way to manage rendezvous lifespan.
+  static mutex& aborted_rendezs_mu_;
+  static std::vector<tsl::core::RefCountPtr<Rendezvous> >& aborted_rendezs_
+      TF_GUARDED_BY(aborted_rendezs_mu_);
+
+  LocalRendezvous(const LocalRendezvous&) = delete;
+  void operator=(const LocalRendezvous&) = delete;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_LOCAL_RENDEZVOUS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/log_memory.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/log_memory.h
new file mode 100644
index 0000000000000000000000000000000000000000..f6c2b07dfcf5544b6316e13c9eb2934eddea4462
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/log_memory.h
@@ -0,0 +1,112 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_LOG_MEMORY_H_
+#define TENSORFLOW_CORE_FRAMEWORK_LOG_MEMORY_H_
+
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/platform/protobuf.h"
+
+namespace tensorflow {
+
+// LogMemory contains methods for recording memory allocations and
+// frees, associating each allocation with a step identified by a
+// process-wide id. For now, logging is enabled whenever VLOG_IS_ON(1)
+// for the log_memory module.
+//
+// Limitations: We don't log memory allocations by Eigen on the CPU
+// since that would require major changes to plumb through to the
+// Eigen::{DefaultDevice,ThreadPoolDevice} allocate and deallocate
+// methods. We do log Eigen allocations on GPU since the plumbing was
+// already in place.
+class LogMemory {
+ public:
+  // Allocations sometimes happen outside any computation step, and
+  // SpecialStepIds lists the ids used for those steps.
+  enum SpecialStepIds {
+    // Used when performing a just-in-time constant folding optimization.
+    CONSTANT_FOLDING_STEP_ID = -1,
+    // Used when constructing an Op kernel before executing a step.
+    OP_KERNEL_CONSTRUCTION_STEP_ID = -2,
+    // Used when allocating a tensor buffer from external code, e.g.,
+    // the C API.
+    EXTERNAL_TENSOR_ALLOCATION_STEP_ID = -3,
+    // Used when allocating a buffer for network transfer.
+    NETWORK_BUFFER_STEP_ID = -4,
+    // Used when allocating a buffer to fill a Proto from the GPU.
+    PROTO_BUFFER_STEP_ID = -5,
+    // Used when allocating a Tensor where the caller has not indicated
+    // the step.
+    UNKNOWN_STEP_ID = -6,
+  };
+
+  static const std::string kLogMemoryLabel;
+
+  // Test to see if memory logging is enabled. For now, logging is
+  // enabled whenever VLOG_IS_ON(2) for the log_memory module.
+  static bool IsEnabled();
+
+  // Log the beginning of a step.
+  static void RecordStep(int64_t step_id, const std::string& handle);
+
+  // Log a tensor buffer allocation. The name indicates which kernel
+  // made the allocation. If the allocation is made through an
+  // OpKernelContext the step_id indicates which step is executing,
+  // otherwise step_id is one of the SpecialStepIds defined in
+  // op_kernel.h, e.g. Op Kernel construction or an optimization pass
+  // such as constant folding.
+  static void RecordTensorAllocation(const std::string& kernel_name,
+                                     int64_t step_id, const Tensor& tensor);
+
+  // Log a tensor buffer deallocation. The deallocation is triggered
+  // when the buffer's refcount falls to zero, and the tracking
+  // mechanism does not associate it with a particular step or
+  // kernel. The allocation_id/allocator_name should match a
+  // corresponding tensor previously passed in to
+  // RecordTensorAllocation.
+  static void RecordTensorDeallocation(int64_t allocation_id,
+                                       const std::string& allocator_name);
+
+  // Log the use of a tensor as an output from a kernel.
+  static void RecordTensorOutput(const std::string& kernel_name,
+                                 int64_t step_id, int index,
+                                 const Tensor& tensor);
+
+  // Log a "raw" allocation, which is just a buffer sized in
+  // bytes. The Eigen allocator, and memory copies, record their
+  // allocations this way, since they do not allocate TensorFlow
+  // tensors. The operation is set to the OpKernel name if this is
+  // called from within an Op execution, otherwise it indicates an
+  // operation such as memcpy. The step_id if >=0 indicates which step
+  // is executing, otherwise step_id is one of the SpecialStepIds
+  // defined in op_kernel.h, e.g. Op Kernel construction or an
+  // optimization pass such as constant folding.
+  static void RecordRawAllocation(const std::string& operation, int64_t step_id,
+                                  size_t num_bytes, void* ptr,
+                                  Allocator* allocator);
+
+  // Log a "raw" deallocation of a buffer. When deferred is true, the
+  // buffer won't be used again, but a GPU kernel may still be
+  // enqueued using the buffer. A deferred deallocation should always
+  // be followed by a matching non-deferred deallocation when the
+  // buffer is actually returned and can be reused.
+  static void RecordRawDeallocation(const std::string& operation,
+                                    int64_t step_id, void* ptr,
+                                    Allocator* allocator, bool deferred);
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_LOG_MEMORY_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/log_memory.pb.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/log_memory.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..e1b421b2753696465b68244a9351cdfc58632719
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/log_memory.pb.h
@@ -0,0 +1,2062 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: tensorflow/core/framework/log_memory.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2flog_5fmemory_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2flog_5fmemory_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3021000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3021009 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+#include "tensorflow/core/framework/tensor_description.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_tensorflow_2fcore_2fframework_2flog_5fmemory_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_tensorflow_2fcore_2fframework_2flog_5fmemory_2eproto {
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_tensorflow_2fcore_2fframework_2flog_5fmemory_2eproto;
+namespace tensorflow {
+class MemoryLogRawAllocation;
+struct MemoryLogRawAllocationDefaultTypeInternal;
+extern MemoryLogRawAllocationDefaultTypeInternal _MemoryLogRawAllocation_default_instance_;
+class MemoryLogRawDeallocation;
+struct MemoryLogRawDeallocationDefaultTypeInternal;
+extern MemoryLogRawDeallocationDefaultTypeInternal _MemoryLogRawDeallocation_default_instance_;
+class MemoryLogStep;
+struct MemoryLogStepDefaultTypeInternal;
+extern MemoryLogStepDefaultTypeInternal _MemoryLogStep_default_instance_;
+class MemoryLogTensorAllocation;
+struct MemoryLogTensorAllocationDefaultTypeInternal;
+extern MemoryLogTensorAllocationDefaultTypeInternal _MemoryLogTensorAllocation_default_instance_;
+class MemoryLogTensorDeallocation;
+struct MemoryLogTensorDeallocationDefaultTypeInternal;
+extern MemoryLogTensorDeallocationDefaultTypeInternal _MemoryLogTensorDeallocation_default_instance_;
+class MemoryLogTensorOutput;
+struct MemoryLogTensorOutputDefaultTypeInternal;
+extern MemoryLogTensorOutputDefaultTypeInternal _MemoryLogTensorOutput_default_instance_;
+}  // namespace tensorflow
+PROTOBUF_NAMESPACE_OPEN
+template<> ::tensorflow::MemoryLogRawAllocation* Arena::CreateMaybeMessage<::tensorflow::MemoryLogRawAllocation>(Arena*);
+template<> ::tensorflow::MemoryLogRawDeallocation* Arena::CreateMaybeMessage<::tensorflow::MemoryLogRawDeallocation>(Arena*);
+template<> ::tensorflow::MemoryLogStep* Arena::CreateMaybeMessage<::tensorflow::MemoryLogStep>(Arena*);
+template<> ::tensorflow::MemoryLogTensorAllocation* Arena::CreateMaybeMessage<::tensorflow::MemoryLogTensorAllocation>(Arena*);
+template<> ::tensorflow::MemoryLogTensorDeallocation* Arena::CreateMaybeMessage<::tensorflow::MemoryLogTensorDeallocation>(Arena*);
+template<> ::tensorflow::MemoryLogTensorOutput* Arena::CreateMaybeMessage<::tensorflow::MemoryLogTensorOutput>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace tensorflow {
+
+// ===================================================================
+
+class MemoryLogStep final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.MemoryLogStep) */ {
+ public:
+  inline MemoryLogStep() : MemoryLogStep(nullptr) {}
+  ~MemoryLogStep() override;
+  explicit PROTOBUF_CONSTEXPR MemoryLogStep(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  MemoryLogStep(const MemoryLogStep& from);
+  MemoryLogStep(MemoryLogStep&& from) noexcept
+    : MemoryLogStep() {
+    *this = ::std::move(from);
+  }
+
+  inline MemoryLogStep& operator=(const MemoryLogStep& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline MemoryLogStep& operator=(MemoryLogStep&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const MemoryLogStep& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const MemoryLogStep* internal_default_instance() {
+    return reinterpret_cast<const MemoryLogStep*>(
+               &_MemoryLogStep_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(MemoryLogStep& a, MemoryLogStep& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(MemoryLogStep* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(MemoryLogStep* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  MemoryLogStep* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<MemoryLogStep>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const MemoryLogStep& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const MemoryLogStep& from) {
+    MemoryLogStep::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(MemoryLogStep* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.MemoryLogStep";
+  }
+  protected:
+  explicit MemoryLogStep(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kHandleFieldNumber = 2,
+    kStepIdFieldNumber = 1,
+  };
+  // string handle = 2;
+  void clear_handle();
+  const std::string& handle() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_handle(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_handle();
+  PROTOBUF_NODISCARD std::string* release_handle();
+  void set_allocated_handle(std::string* handle);
+  private:
+  const std::string& _internal_handle() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_handle(const std::string& value);
+  std::string* _internal_mutable_handle();
+  public:
+
+  // int64 step_id = 1;
+  void clear_step_id();
+  int64_t step_id() const;
+  void set_step_id(int64_t value);
+  private:
+  int64_t _internal_step_id() const;
+  void _internal_set_step_id(int64_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.MemoryLogStep)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr handle_;
+    int64_t step_id_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2flog_5fmemory_2eproto;
+};
+// -------------------------------------------------------------------
+
+class MemoryLogTensorAllocation final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.MemoryLogTensorAllocation) */ {
+ public:
+  inline MemoryLogTensorAllocation() : MemoryLogTensorAllocation(nullptr) {}
+  ~MemoryLogTensorAllocation() override;
+  explicit PROTOBUF_CONSTEXPR MemoryLogTensorAllocation(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  MemoryLogTensorAllocation(const MemoryLogTensorAllocation& from);
+  MemoryLogTensorAllocation(MemoryLogTensorAllocation&& from) noexcept
+    : MemoryLogTensorAllocation() {
+    *this = ::std::move(from);
+  }
+
+  inline MemoryLogTensorAllocation& operator=(const MemoryLogTensorAllocation& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline MemoryLogTensorAllocation& operator=(MemoryLogTensorAllocation&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const MemoryLogTensorAllocation& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const MemoryLogTensorAllocation* internal_default_instance() {
+    return reinterpret_cast<const MemoryLogTensorAllocation*>(
+               &_MemoryLogTensorAllocation_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(MemoryLogTensorAllocation& a, MemoryLogTensorAllocation& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(MemoryLogTensorAllocation* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(MemoryLogTensorAllocation* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  MemoryLogTensorAllocation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<MemoryLogTensorAllocation>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const MemoryLogTensorAllocation& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const MemoryLogTensorAllocation& from) {
+    MemoryLogTensorAllocation::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(MemoryLogTensorAllocation* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.MemoryLogTensorAllocation";
+  }
+  protected:
+  explicit MemoryLogTensorAllocation(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kKernelNameFieldNumber = 2,
+    kTensorFieldNumber = 3,
+    kStepIdFieldNumber = 1,
+  };
+  // string kernel_name = 2;
+  void clear_kernel_name();
+  const std::string& kernel_name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_kernel_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_kernel_name();
+  PROTOBUF_NODISCARD std::string* release_kernel_name();
+  void set_allocated_kernel_name(std::string* kernel_name);
+  private:
+  const std::string& _internal_kernel_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_kernel_name(const std::string& value);
+  std::string* _internal_mutable_kernel_name();
+  public:
+
+  // .tensorflow.TensorDescription tensor = 3;
+  bool has_tensor() const;
+  private:
+  bool _internal_has_tensor() const;
+  public:
+  void clear_tensor();
+  const ::tensorflow::TensorDescription& tensor() const;
+  PROTOBUF_NODISCARD ::tensorflow::TensorDescription* release_tensor();
+  ::tensorflow::TensorDescription* mutable_tensor();
+  void set_allocated_tensor(::tensorflow::TensorDescription* tensor);
+  private:
+  const ::tensorflow::TensorDescription& _internal_tensor() const;
+  ::tensorflow::TensorDescription* _internal_mutable_tensor();
+  public:
+  void unsafe_arena_set_allocated_tensor(
+      ::tensorflow::TensorDescription* tensor);
+  ::tensorflow::TensorDescription* unsafe_arena_release_tensor();
+
+  // int64 step_id = 1;
+  void clear_step_id();
+  int64_t step_id() const;
+  void set_step_id(int64_t value);
+  private:
+  int64_t _internal_step_id() const;
+  void _internal_set_step_id(int64_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.MemoryLogTensorAllocation)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr kernel_name_;
+    ::tensorflow::TensorDescription* tensor_;
+    int64_t step_id_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2flog_5fmemory_2eproto;
+};
+// -------------------------------------------------------------------
+
+class MemoryLogTensorDeallocation final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.MemoryLogTensorDeallocation) */ {
+ public:
+  inline MemoryLogTensorDeallocation() : MemoryLogTensorDeallocation(nullptr) {}
+  ~MemoryLogTensorDeallocation() override;
+  explicit PROTOBUF_CONSTEXPR MemoryLogTensorDeallocation(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  MemoryLogTensorDeallocation(const MemoryLogTensorDeallocation& from);
+  MemoryLogTensorDeallocation(MemoryLogTensorDeallocation&& from) noexcept
+    : MemoryLogTensorDeallocation() {
+    *this = ::std::move(from);
+  }
+
+  inline MemoryLogTensorDeallocation& operator=(const MemoryLogTensorDeallocation& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline MemoryLogTensorDeallocation& operator=(MemoryLogTensorDeallocation&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const MemoryLogTensorDeallocation& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const MemoryLogTensorDeallocation* internal_default_instance() {
+    return reinterpret_cast<const MemoryLogTensorDeallocation*>(
+               &_MemoryLogTensorDeallocation_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(MemoryLogTensorDeallocation& a, MemoryLogTensorDeallocation& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(MemoryLogTensorDeallocation* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(MemoryLogTensorDeallocation* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  MemoryLogTensorDeallocation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<MemoryLogTensorDeallocation>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const MemoryLogTensorDeallocation& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const MemoryLogTensorDeallocation& from) {
+    MemoryLogTensorDeallocation::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(MemoryLogTensorDeallocation* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.MemoryLogTensorDeallocation";
+  }
+  protected:
+  explicit MemoryLogTensorDeallocation(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kAllocatorNameFieldNumber = 2,
+    kAllocationIdFieldNumber = 1,
+  };
+  // string allocator_name = 2;
+  void clear_allocator_name();
+  const std::string& allocator_name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_allocator_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_allocator_name();
+  PROTOBUF_NODISCARD std::string* release_allocator_name();
+  void set_allocated_allocator_name(std::string* allocator_name);
+  private:
+  const std::string& _internal_allocator_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_allocator_name(const std::string& value);
+  std::string* _internal_mutable_allocator_name();
+  public:
+
+  // int64 allocation_id = 1;
+  void clear_allocation_id();
+  int64_t allocation_id() const;
+  void set_allocation_id(int64_t value);
+  private:
+  int64_t _internal_allocation_id() const;
+  void _internal_set_allocation_id(int64_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.MemoryLogTensorDeallocation)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr allocator_name_;
+    int64_t allocation_id_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2flog_5fmemory_2eproto;
+};
+// -------------------------------------------------------------------
+
+class MemoryLogTensorOutput final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.MemoryLogTensorOutput) */ {
+ public:
+  inline MemoryLogTensorOutput() : MemoryLogTensorOutput(nullptr) {}
+  ~MemoryLogTensorOutput() override;
+  explicit PROTOBUF_CONSTEXPR MemoryLogTensorOutput(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  MemoryLogTensorOutput(const MemoryLogTensorOutput& from);
+  MemoryLogTensorOutput(MemoryLogTensorOutput&& from) noexcept
+    : MemoryLogTensorOutput() {
+    *this = ::std::move(from);
+  }
+
+  inline MemoryLogTensorOutput& operator=(const MemoryLogTensorOutput& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline MemoryLogTensorOutput& operator=(MemoryLogTensorOutput&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const MemoryLogTensorOutput& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const MemoryLogTensorOutput* internal_default_instance() {
+    return reinterpret_cast<const MemoryLogTensorOutput*>(
+               &_MemoryLogTensorOutput_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  friend void swap(MemoryLogTensorOutput& a, MemoryLogTensorOutput& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(MemoryLogTensorOutput* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(MemoryLogTensorOutput* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  MemoryLogTensorOutput* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<MemoryLogTensorOutput>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const MemoryLogTensorOutput& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const MemoryLogTensorOutput& from) {
+    MemoryLogTensorOutput::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(MemoryLogTensorOutput* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.MemoryLogTensorOutput";
+  }
+  protected:
+  explicit MemoryLogTensorOutput(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kKernelNameFieldNumber = 2,
+    kTensorFieldNumber = 4,
+    kStepIdFieldNumber = 1,
+    kIndexFieldNumber = 3,
+  };
+  // string kernel_name = 2;
+  void clear_kernel_name();
+  const std::string& kernel_name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_kernel_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_kernel_name();
+  PROTOBUF_NODISCARD std::string* release_kernel_name();
+  void set_allocated_kernel_name(std::string* kernel_name);
+  private:
+  const std::string& _internal_kernel_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_kernel_name(const std::string& value);
+  std::string* _internal_mutable_kernel_name();
+  public:
+
+  // .tensorflow.TensorDescription tensor = 4;
+  bool has_tensor() const;
+  private:
+  bool _internal_has_tensor() const;
+  public:
+  void clear_tensor();
+  const ::tensorflow::TensorDescription& tensor() const;
+  PROTOBUF_NODISCARD ::tensorflow::TensorDescription* release_tensor();
+  ::tensorflow::TensorDescription* mutable_tensor();
+  void set_allocated_tensor(::tensorflow::TensorDescription* tensor);
+  private:
+  const ::tensorflow::TensorDescription& _internal_tensor() const;
+  ::tensorflow::TensorDescription* _internal_mutable_tensor();
+  public:
+  void unsafe_arena_set_allocated_tensor(
+      ::tensorflow::TensorDescription* tensor);
+  ::tensorflow::TensorDescription* unsafe_arena_release_tensor();
+
+  // int64 step_id = 1;
+  void clear_step_id();
+  int64_t step_id() const;
+  void set_step_id(int64_t value);
+  private:
+  int64_t _internal_step_id() const;
+  void _internal_set_step_id(int64_t value);
+  public:
+
+  // int32 index = 3;
+  void clear_index();
+  int32_t index() const;
+  void set_index(int32_t value);
+  private:
+  int32_t _internal_index() const;
+  void _internal_set_index(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.MemoryLogTensorOutput)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr kernel_name_;
+    ::tensorflow::TensorDescription* tensor_;
+    int64_t step_id_;
+    int32_t index_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2flog_5fmemory_2eproto;
+};
+// -------------------------------------------------------------------
+
+class MemoryLogRawAllocation final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.MemoryLogRawAllocation) */ {
+ public:
+  inline MemoryLogRawAllocation() : MemoryLogRawAllocation(nullptr) {}
+  ~MemoryLogRawAllocation() override;
+  explicit PROTOBUF_CONSTEXPR MemoryLogRawAllocation(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  MemoryLogRawAllocation(const MemoryLogRawAllocation& from);
+  MemoryLogRawAllocation(MemoryLogRawAllocation&& from) noexcept
+    : MemoryLogRawAllocation() {
+    *this = ::std::move(from);
+  }
+
+  inline MemoryLogRawAllocation& operator=(const MemoryLogRawAllocation& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline MemoryLogRawAllocation& operator=(MemoryLogRawAllocation&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const MemoryLogRawAllocation& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const MemoryLogRawAllocation* internal_default_instance() {
+    return reinterpret_cast<const MemoryLogRawAllocation*>(
+               &_MemoryLogRawAllocation_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    4;
+
+  friend void swap(MemoryLogRawAllocation& a, MemoryLogRawAllocation& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(MemoryLogRawAllocation* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(MemoryLogRawAllocation* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  MemoryLogRawAllocation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<MemoryLogRawAllocation>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const MemoryLogRawAllocation& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const MemoryLogRawAllocation& from) {
+    MemoryLogRawAllocation::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(MemoryLogRawAllocation* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.MemoryLogRawAllocation";
+  }
+  protected:
+  explicit MemoryLogRawAllocation(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kOperationFieldNumber = 2,
+    kAllocatorNameFieldNumber = 6,
+    kStepIdFieldNumber = 1,
+    kNumBytesFieldNumber = 3,
+    kPtrFieldNumber = 4,
+    kAllocationIdFieldNumber = 5,
+  };
+  // string operation = 2;
+  void clear_operation();
+  const std::string& operation() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_operation(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_operation();
+  PROTOBUF_NODISCARD std::string* release_operation();
+  void set_allocated_operation(std::string* operation);
+  private:
+  const std::string& _internal_operation() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_operation(const std::string& value);
+  std::string* _internal_mutable_operation();
+  public:
+
+  // string allocator_name = 6;
+  void clear_allocator_name();
+  const std::string& allocator_name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_allocator_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_allocator_name();
+  PROTOBUF_NODISCARD std::string* release_allocator_name();
+  void set_allocated_allocator_name(std::string* allocator_name);
+  private:
+  const std::string& _internal_allocator_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_allocator_name(const std::string& value);
+  std::string* _internal_mutable_allocator_name();
+  public:
+
+  // int64 step_id = 1;
+  void clear_step_id();
+  int64_t step_id() const;
+  void set_step_id(int64_t value);
+  private:
+  int64_t _internal_step_id() const;
+  void _internal_set_step_id(int64_t value);
+  public:
+
+  // int64 num_bytes = 3;
+  void clear_num_bytes();
+  int64_t num_bytes() const;
+  void set_num_bytes(int64_t value);
+  private:
+  int64_t _internal_num_bytes() const;
+  void _internal_set_num_bytes(int64_t value);
+  public:
+
+  // uint64 ptr = 4;
+  void clear_ptr();
+  uint64_t ptr() const;
+  void set_ptr(uint64_t value);
+  private:
+  uint64_t _internal_ptr() const;
+  void _internal_set_ptr(uint64_t value);
+  public:
+
+  // int64 allocation_id = 5;
+  void clear_allocation_id();
+  int64_t allocation_id() const;
+  void set_allocation_id(int64_t value);
+  private:
+  int64_t _internal_allocation_id() const;
+  void _internal_set_allocation_id(int64_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.MemoryLogRawAllocation)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr operation_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr allocator_name_;
+    int64_t step_id_;
+    int64_t num_bytes_;
+    uint64_t ptr_;
+    int64_t allocation_id_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2flog_5fmemory_2eproto;
+};
+// -------------------------------------------------------------------
+
+class MemoryLogRawDeallocation final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.MemoryLogRawDeallocation) */ {
+ public:
+  inline MemoryLogRawDeallocation() : MemoryLogRawDeallocation(nullptr) {}
+  ~MemoryLogRawDeallocation() override;
+  explicit PROTOBUF_CONSTEXPR MemoryLogRawDeallocation(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  MemoryLogRawDeallocation(const MemoryLogRawDeallocation& from);
+  MemoryLogRawDeallocation(MemoryLogRawDeallocation&& from) noexcept
+    : MemoryLogRawDeallocation() {
+    *this = ::std::move(from);
+  }
+
+  inline MemoryLogRawDeallocation& operator=(const MemoryLogRawDeallocation& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline MemoryLogRawDeallocation& operator=(MemoryLogRawDeallocation&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const MemoryLogRawDeallocation& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const MemoryLogRawDeallocation* internal_default_instance() {
+    return reinterpret_cast<const MemoryLogRawDeallocation*>(
+               &_MemoryLogRawDeallocation_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    5;
+
+  friend void swap(MemoryLogRawDeallocation& a, MemoryLogRawDeallocation& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(MemoryLogRawDeallocation* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(MemoryLogRawDeallocation* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  MemoryLogRawDeallocation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<MemoryLogRawDeallocation>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const MemoryLogRawDeallocation& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const MemoryLogRawDeallocation& from) {
+    MemoryLogRawDeallocation::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(MemoryLogRawDeallocation* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.MemoryLogRawDeallocation";
+  }
+  protected:
+  explicit MemoryLogRawDeallocation(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kOperationFieldNumber = 2,
+    kAllocatorNameFieldNumber = 4,
+    kStepIdFieldNumber = 1,
+    kAllocationIdFieldNumber = 3,
+    kDeferredFieldNumber = 5,
+  };
+  // string operation = 2;
+  void clear_operation();
+  const std::string& operation() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_operation(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_operation();
+  PROTOBUF_NODISCARD std::string* release_operation();
+  void set_allocated_operation(std::string* operation);
+  private:
+  const std::string& _internal_operation() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_operation(const std::string& value);
+  std::string* _internal_mutable_operation();
+  public:
+
+  // string allocator_name = 4;
+  void clear_allocator_name();
+  const std::string& allocator_name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_allocator_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_allocator_name();
+  PROTOBUF_NODISCARD std::string* release_allocator_name();
+  void set_allocated_allocator_name(std::string* allocator_name);
+  private:
+  const std::string& _internal_allocator_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_allocator_name(const std::string& value);
+  std::string* _internal_mutable_allocator_name();
+  public:
+
+  // int64 step_id = 1;
+  void clear_step_id();
+  int64_t step_id() const;
+  void set_step_id(int64_t value);
+  private:
+  int64_t _internal_step_id() const;
+  void _internal_set_step_id(int64_t value);
+  public:
+
+  // int64 allocation_id = 3;
+  void clear_allocation_id();
+  int64_t allocation_id() const;
+  void set_allocation_id(int64_t value);
+  private:
+  int64_t _internal_allocation_id() const;
+  void _internal_set_allocation_id(int64_t value);
+  public:
+
+  // bool deferred = 5;
+  void clear_deferred();
+  bool deferred() const;
+  void set_deferred(bool value);
+  private:
+  bool _internal_deferred() const;
+  void _internal_set_deferred(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.MemoryLogRawDeallocation)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr operation_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr allocator_name_;
+    int64_t step_id_;
+    int64_t allocation_id_;
+    bool deferred_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2flog_5fmemory_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// MemoryLogStep
+
+// int64 step_id = 1;
+inline void MemoryLogStep::clear_step_id() {
+  _impl_.step_id_ = int64_t{0};
+}
+inline int64_t MemoryLogStep::_internal_step_id() const {
+  return _impl_.step_id_;
+}
+inline int64_t MemoryLogStep::step_id() const {
+  // @@protoc_insertion_point(field_get:tensorflow.MemoryLogStep.step_id)
+  return _internal_step_id();
+}
+inline void MemoryLogStep::_internal_set_step_id(int64_t value) {
+  
+  _impl_.step_id_ = value;
+}
+inline void MemoryLogStep::set_step_id(int64_t value) {
+  _internal_set_step_id(value);
+  // @@protoc_insertion_point(field_set:tensorflow.MemoryLogStep.step_id)
+}
+
+// string handle = 2;
+inline void MemoryLogStep::clear_handle() {
+  _impl_.handle_.ClearToEmpty();
+}
+inline const std::string& MemoryLogStep::handle() const {
+  // @@protoc_insertion_point(field_get:tensorflow.MemoryLogStep.handle)
+  return _internal_handle();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void MemoryLogStep::set_handle(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.handle_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.MemoryLogStep.handle)
+}
+inline std::string* MemoryLogStep::mutable_handle() {
+  std::string* _s = _internal_mutable_handle();
+  // @@protoc_insertion_point(field_mutable:tensorflow.MemoryLogStep.handle)
+  return _s;
+}
+inline const std::string& MemoryLogStep::_internal_handle() const {
+  return _impl_.handle_.Get();
+}
+inline void MemoryLogStep::_internal_set_handle(const std::string& value) {
+  
+  _impl_.handle_.Set(value, GetArenaForAllocation());
+}
+inline std::string* MemoryLogStep::_internal_mutable_handle() {
+  
+  return _impl_.handle_.Mutable(GetArenaForAllocation());
+}
+inline std::string* MemoryLogStep::release_handle() {
+  // @@protoc_insertion_point(field_release:tensorflow.MemoryLogStep.handle)
+  return _impl_.handle_.Release();
+}
+inline void MemoryLogStep::set_allocated_handle(std::string* handle) {
+  if (handle != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.handle_.SetAllocated(handle, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.handle_.IsDefault()) {
+    _impl_.handle_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.MemoryLogStep.handle)
+}
+
+// -------------------------------------------------------------------
+
+// MemoryLogTensorAllocation
+
+// int64 step_id = 1;
+inline void MemoryLogTensorAllocation::clear_step_id() {
+  _impl_.step_id_ = int64_t{0};
+}
+inline int64_t MemoryLogTensorAllocation::_internal_step_id() const {
+  return _impl_.step_id_;
+}
+inline int64_t MemoryLogTensorAllocation::step_id() const {
+  // @@protoc_insertion_point(field_get:tensorflow.MemoryLogTensorAllocation.step_id)
+  return _internal_step_id();
+}
+inline void MemoryLogTensorAllocation::_internal_set_step_id(int64_t value) {
+  
+  _impl_.step_id_ = value;
+}
+inline void MemoryLogTensorAllocation::set_step_id(int64_t value) {
+  _internal_set_step_id(value);
+  // @@protoc_insertion_point(field_set:tensorflow.MemoryLogTensorAllocation.step_id)
+}
+
+// string kernel_name = 2;
+inline void MemoryLogTensorAllocation::clear_kernel_name() {
+  _impl_.kernel_name_.ClearToEmpty();
+}
+inline const std::string& MemoryLogTensorAllocation::kernel_name() const {
+  // @@protoc_insertion_point(field_get:tensorflow.MemoryLogTensorAllocation.kernel_name)
+  return _internal_kernel_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void MemoryLogTensorAllocation::set_kernel_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.kernel_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.MemoryLogTensorAllocation.kernel_name)
+}
+inline std::string* MemoryLogTensorAllocation::mutable_kernel_name() {
+  std::string* _s = _internal_mutable_kernel_name();
+  // @@protoc_insertion_point(field_mutable:tensorflow.MemoryLogTensorAllocation.kernel_name)
+  return _s;
+}
+inline const std::string& MemoryLogTensorAllocation::_internal_kernel_name() const {
+  return _impl_.kernel_name_.Get();
+}
+inline void MemoryLogTensorAllocation::_internal_set_kernel_name(const std::string& value) {
+  
+  _impl_.kernel_name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* MemoryLogTensorAllocation::_internal_mutable_kernel_name() {
+  
+  return _impl_.kernel_name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* MemoryLogTensorAllocation::release_kernel_name() {
+  // @@protoc_insertion_point(field_release:tensorflow.MemoryLogTensorAllocation.kernel_name)
+  return _impl_.kernel_name_.Release();
+}
+inline void MemoryLogTensorAllocation::set_allocated_kernel_name(std::string* kernel_name) {
+  if (kernel_name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.kernel_name_.SetAllocated(kernel_name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.kernel_name_.IsDefault()) {
+    _impl_.kernel_name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.MemoryLogTensorAllocation.kernel_name)
+}
+
+// .tensorflow.TensorDescription tensor = 3;
+inline bool MemoryLogTensorAllocation::_internal_has_tensor() const {
+  return this != internal_default_instance() && _impl_.tensor_ != nullptr;
+}
+inline bool MemoryLogTensorAllocation::has_tensor() const {
+  return _internal_has_tensor();
+}
+inline const ::tensorflow::TensorDescription& MemoryLogTensorAllocation::_internal_tensor() const {
+  const ::tensorflow::TensorDescription* p = _impl_.tensor_;
+  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::TensorDescription&>(
+      ::tensorflow::_TensorDescription_default_instance_);
+}
+inline const ::tensorflow::TensorDescription& MemoryLogTensorAllocation::tensor() const {
+  // @@protoc_insertion_point(field_get:tensorflow.MemoryLogTensorAllocation.tensor)
+  return _internal_tensor();
+}
+inline void MemoryLogTensorAllocation::unsafe_arena_set_allocated_tensor(
+    ::tensorflow::TensorDescription* tensor) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.tensor_);
+  }
+  _impl_.tensor_ = tensor;
+  if (tensor) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.MemoryLogTensorAllocation.tensor)
+}
+inline ::tensorflow::TensorDescription* MemoryLogTensorAllocation::release_tensor() {
+  
+  ::tensorflow::TensorDescription* temp = _impl_.tensor_;
+  _impl_.tensor_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::tensorflow::TensorDescription* MemoryLogTensorAllocation::unsafe_arena_release_tensor() {
+  // @@protoc_insertion_point(field_release:tensorflow.MemoryLogTensorAllocation.tensor)
+  
+  ::tensorflow::TensorDescription* temp = _impl_.tensor_;
+  _impl_.tensor_ = nullptr;
+  return temp;
+}
+inline ::tensorflow::TensorDescription* MemoryLogTensorAllocation::_internal_mutable_tensor() {
+  
+  if (_impl_.tensor_ == nullptr) {
+    auto* p = CreateMaybeMessage<::tensorflow::TensorDescription>(GetArenaForAllocation());
+    _impl_.tensor_ = p;
+  }
+  return _impl_.tensor_;
+}
+inline ::tensorflow::TensorDescription* MemoryLogTensorAllocation::mutable_tensor() {
+  ::tensorflow::TensorDescription* _msg = _internal_mutable_tensor();
+  // @@protoc_insertion_point(field_mutable:tensorflow.MemoryLogTensorAllocation.tensor)
+  return _msg;
+}
+inline void MemoryLogTensorAllocation::set_allocated_tensor(::tensorflow::TensorDescription* tensor) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.tensor_);
+  }
+  if (tensor) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(tensor));
+    if (message_arena != submessage_arena) {
+      tensor = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, tensor, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.tensor_ = tensor;
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.MemoryLogTensorAllocation.tensor)
+}
+
+// -------------------------------------------------------------------
+
+// MemoryLogTensorDeallocation
+
+// int64 allocation_id = 1;
+inline void MemoryLogTensorDeallocation::clear_allocation_id() {
+  _impl_.allocation_id_ = int64_t{0};
+}
+inline int64_t MemoryLogTensorDeallocation::_internal_allocation_id() const {
+  return _impl_.allocation_id_;
+}
+inline int64_t MemoryLogTensorDeallocation::allocation_id() const {
+  // @@protoc_insertion_point(field_get:tensorflow.MemoryLogTensorDeallocation.allocation_id)
+  return _internal_allocation_id();
+}
+inline void MemoryLogTensorDeallocation::_internal_set_allocation_id(int64_t value) {
+  
+  _impl_.allocation_id_ = value;
+}
+inline void MemoryLogTensorDeallocation::set_allocation_id(int64_t value) {
+  _internal_set_allocation_id(value);
+  // @@protoc_insertion_point(field_set:tensorflow.MemoryLogTensorDeallocation.allocation_id)
+}
+
+// string allocator_name = 2;
+inline void MemoryLogTensorDeallocation::clear_allocator_name() {
+  _impl_.allocator_name_.ClearToEmpty();
+}
+inline const std::string& MemoryLogTensorDeallocation::allocator_name() const {
+  // @@protoc_insertion_point(field_get:tensorflow.MemoryLogTensorDeallocation.allocator_name)
+  return _internal_allocator_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void MemoryLogTensorDeallocation::set_allocator_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.allocator_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.MemoryLogTensorDeallocation.allocator_name)
+}
+inline std::string* MemoryLogTensorDeallocation::mutable_allocator_name() {
+  std::string* _s = _internal_mutable_allocator_name();
+  // @@protoc_insertion_point(field_mutable:tensorflow.MemoryLogTensorDeallocation.allocator_name)
+  return _s;
+}
+inline const std::string& MemoryLogTensorDeallocation::_internal_allocator_name() const {
+  return _impl_.allocator_name_.Get();
+}
+inline void MemoryLogTensorDeallocation::_internal_set_allocator_name(const std::string& value) {
+  
+  _impl_.allocator_name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* MemoryLogTensorDeallocation::_internal_mutable_allocator_name() {
+  
+  return _impl_.allocator_name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* MemoryLogTensorDeallocation::release_allocator_name() {
+  // @@protoc_insertion_point(field_release:tensorflow.MemoryLogTensorDeallocation.allocator_name)
+  return _impl_.allocator_name_.Release();
+}
+inline void MemoryLogTensorDeallocation::set_allocated_allocator_name(std::string* allocator_name) {
+  if (allocator_name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.allocator_name_.SetAllocated(allocator_name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.allocator_name_.IsDefault()) {
+    _impl_.allocator_name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.MemoryLogTensorDeallocation.allocator_name)
+}
+
+// -------------------------------------------------------------------
+
+// MemoryLogTensorOutput
+
+// int64 step_id = 1;
+inline void MemoryLogTensorOutput::clear_step_id() {
+  _impl_.step_id_ = int64_t{0};
+}
+inline int64_t MemoryLogTensorOutput::_internal_step_id() const {
+  return _impl_.step_id_;
+}
+inline int64_t MemoryLogTensorOutput::step_id() const {
+  // @@protoc_insertion_point(field_get:tensorflow.MemoryLogTensorOutput.step_id)
+  return _internal_step_id();
+}
+inline void MemoryLogTensorOutput::_internal_set_step_id(int64_t value) {
+  
+  _impl_.step_id_ = value;
+}
+inline void MemoryLogTensorOutput::set_step_id(int64_t value) {
+  _internal_set_step_id(value);
+  // @@protoc_insertion_point(field_set:tensorflow.MemoryLogTensorOutput.step_id)
+}
+
+// string kernel_name = 2;
+inline void MemoryLogTensorOutput::clear_kernel_name() {
+  _impl_.kernel_name_.ClearToEmpty();
+}
+inline const std::string& MemoryLogTensorOutput::kernel_name() const {
+  // @@protoc_insertion_point(field_get:tensorflow.MemoryLogTensorOutput.kernel_name)
+  return _internal_kernel_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void MemoryLogTensorOutput::set_kernel_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.kernel_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.MemoryLogTensorOutput.kernel_name)
+}
+inline std::string* MemoryLogTensorOutput::mutable_kernel_name() {
+  std::string* _s = _internal_mutable_kernel_name();
+  // @@protoc_insertion_point(field_mutable:tensorflow.MemoryLogTensorOutput.kernel_name)
+  return _s;
+}
+inline const std::string& MemoryLogTensorOutput::_internal_kernel_name() const {
+  return _impl_.kernel_name_.Get();
+}
+inline void MemoryLogTensorOutput::_internal_set_kernel_name(const std::string& value) {
+  
+  _impl_.kernel_name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* MemoryLogTensorOutput::_internal_mutable_kernel_name() {
+  
+  return _impl_.kernel_name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* MemoryLogTensorOutput::release_kernel_name() {
+  // @@protoc_insertion_point(field_release:tensorflow.MemoryLogTensorOutput.kernel_name)
+  return _impl_.kernel_name_.Release();
+}
+inline void MemoryLogTensorOutput::set_allocated_kernel_name(std::string* kernel_name) {
+  if (kernel_name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.kernel_name_.SetAllocated(kernel_name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.kernel_name_.IsDefault()) {
+    _impl_.kernel_name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.MemoryLogTensorOutput.kernel_name)
+}
+
+// int32 index = 3;
+inline void MemoryLogTensorOutput::clear_index() {
+  _impl_.index_ = 0;
+}
+inline int32_t MemoryLogTensorOutput::_internal_index() const {
+  return _impl_.index_;
+}
+inline int32_t MemoryLogTensorOutput::index() const {
+  // @@protoc_insertion_point(field_get:tensorflow.MemoryLogTensorOutput.index)
+  return _internal_index();
+}
+inline void MemoryLogTensorOutput::_internal_set_index(int32_t value) {
+  
+  _impl_.index_ = value;
+}
+inline void MemoryLogTensorOutput::set_index(int32_t value) {
+  _internal_set_index(value);
+  // @@protoc_insertion_point(field_set:tensorflow.MemoryLogTensorOutput.index)
+}
+
+// .tensorflow.TensorDescription tensor = 4;
+inline bool MemoryLogTensorOutput::_internal_has_tensor() const {
+  return this != internal_default_instance() && _impl_.tensor_ != nullptr;
+}
+inline bool MemoryLogTensorOutput::has_tensor() const {
+  return _internal_has_tensor();
+}
+inline const ::tensorflow::TensorDescription& MemoryLogTensorOutput::_internal_tensor() const {
+  const ::tensorflow::TensorDescription* p = _impl_.tensor_;
+  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::TensorDescription&>(
+      ::tensorflow::_TensorDescription_default_instance_);
+}
+inline const ::tensorflow::TensorDescription& MemoryLogTensorOutput::tensor() const {
+  // @@protoc_insertion_point(field_get:tensorflow.MemoryLogTensorOutput.tensor)
+  return _internal_tensor();
+}
+inline void MemoryLogTensorOutput::unsafe_arena_set_allocated_tensor(
+    ::tensorflow::TensorDescription* tensor) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.tensor_);
+  }
+  _impl_.tensor_ = tensor;
+  if (tensor) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.MemoryLogTensorOutput.tensor)
+}
+inline ::tensorflow::TensorDescription* MemoryLogTensorOutput::release_tensor() {
+  
+  ::tensorflow::TensorDescription* temp = _impl_.tensor_;
+  _impl_.tensor_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::tensorflow::TensorDescription* MemoryLogTensorOutput::unsafe_arena_release_tensor() {
+  // @@protoc_insertion_point(field_release:tensorflow.MemoryLogTensorOutput.tensor)
+  
+  ::tensorflow::TensorDescription* temp = _impl_.tensor_;
+  _impl_.tensor_ = nullptr;
+  return temp;
+}
+inline ::tensorflow::TensorDescription* MemoryLogTensorOutput::_internal_mutable_tensor() {
+  
+  if (_impl_.tensor_ == nullptr) {
+    auto* p = CreateMaybeMessage<::tensorflow::TensorDescription>(GetArenaForAllocation());
+    _impl_.tensor_ = p;
+  }
+  return _impl_.tensor_;
+}
+inline ::tensorflow::TensorDescription* MemoryLogTensorOutput::mutable_tensor() {
+  ::tensorflow::TensorDescription* _msg = _internal_mutable_tensor();
+  // @@protoc_insertion_point(field_mutable:tensorflow.MemoryLogTensorOutput.tensor)
+  return _msg;
+}
+inline void MemoryLogTensorOutput::set_allocated_tensor(::tensorflow::TensorDescription* tensor) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.tensor_);
+  }
+  if (tensor) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(tensor));
+    if (message_arena != submessage_arena) {
+      tensor = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, tensor, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.tensor_ = tensor;
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.MemoryLogTensorOutput.tensor)
+}
+
+// -------------------------------------------------------------------
+
+// MemoryLogRawAllocation
+
+// int64 step_id = 1;
+inline void MemoryLogRawAllocation::clear_step_id() {
+  _impl_.step_id_ = int64_t{0};
+}
+inline int64_t MemoryLogRawAllocation::_internal_step_id() const {
+  return _impl_.step_id_;
+}
+inline int64_t MemoryLogRawAllocation::step_id() const {
+  // @@protoc_insertion_point(field_get:tensorflow.MemoryLogRawAllocation.step_id)
+  return _internal_step_id();
+}
+inline void MemoryLogRawAllocation::_internal_set_step_id(int64_t value) {
+  
+  _impl_.step_id_ = value;
+}
+inline void MemoryLogRawAllocation::set_step_id(int64_t value) {
+  _internal_set_step_id(value);
+  // @@protoc_insertion_point(field_set:tensorflow.MemoryLogRawAllocation.step_id)
+}
+
+// string operation = 2;
+inline void MemoryLogRawAllocation::clear_operation() {
+  _impl_.operation_.ClearToEmpty();
+}
+inline const std::string& MemoryLogRawAllocation::operation() const {
+  // @@protoc_insertion_point(field_get:tensorflow.MemoryLogRawAllocation.operation)
+  return _internal_operation();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void MemoryLogRawAllocation::set_operation(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.operation_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.MemoryLogRawAllocation.operation)
+}
+inline std::string* MemoryLogRawAllocation::mutable_operation() {
+  std::string* _s = _internal_mutable_operation();
+  // @@protoc_insertion_point(field_mutable:tensorflow.MemoryLogRawAllocation.operation)
+  return _s;
+}
+inline const std::string& MemoryLogRawAllocation::_internal_operation() const {
+  return _impl_.operation_.Get();
+}
+inline void MemoryLogRawAllocation::_internal_set_operation(const std::string& value) {
+  
+  _impl_.operation_.Set(value, GetArenaForAllocation());
+}
+inline std::string* MemoryLogRawAllocation::_internal_mutable_operation() {
+  
+  return _impl_.operation_.Mutable(GetArenaForAllocation());
+}
+inline std::string* MemoryLogRawAllocation::release_operation() {
+  // @@protoc_insertion_point(field_release:tensorflow.MemoryLogRawAllocation.operation)
+  return _impl_.operation_.Release();
+}
+inline void MemoryLogRawAllocation::set_allocated_operation(std::string* operation) {
+  if (operation != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.operation_.SetAllocated(operation, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.operation_.IsDefault()) {
+    _impl_.operation_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.MemoryLogRawAllocation.operation)
+}
+
+// int64 num_bytes = 3;
+inline void MemoryLogRawAllocation::clear_num_bytes() {
+  _impl_.num_bytes_ = int64_t{0};
+}
+inline int64_t MemoryLogRawAllocation::_internal_num_bytes() const {
+  return _impl_.num_bytes_;
+}
+inline int64_t MemoryLogRawAllocation::num_bytes() const {
+  // @@protoc_insertion_point(field_get:tensorflow.MemoryLogRawAllocation.num_bytes)
+  return _internal_num_bytes();
+}
+inline void MemoryLogRawAllocation::_internal_set_num_bytes(int64_t value) {
+  
+  _impl_.num_bytes_ = value;
+}
+inline void MemoryLogRawAllocation::set_num_bytes(int64_t value) {
+  _internal_set_num_bytes(value);
+  // @@protoc_insertion_point(field_set:tensorflow.MemoryLogRawAllocation.num_bytes)
+}
+
+// uint64 ptr = 4;
+inline void MemoryLogRawAllocation::clear_ptr() {
+  _impl_.ptr_ = uint64_t{0u};
+}
+inline uint64_t MemoryLogRawAllocation::_internal_ptr() const {
+  return _impl_.ptr_;
+}
+inline uint64_t MemoryLogRawAllocation::ptr() const {
+  // @@protoc_insertion_point(field_get:tensorflow.MemoryLogRawAllocation.ptr)
+  return _internal_ptr();
+}
+inline void MemoryLogRawAllocation::_internal_set_ptr(uint64_t value) {
+  
+  _impl_.ptr_ = value;
+}
+inline void MemoryLogRawAllocation::set_ptr(uint64_t value) {
+  _internal_set_ptr(value);
+  // @@protoc_insertion_point(field_set:tensorflow.MemoryLogRawAllocation.ptr)
+}
+
+// int64 allocation_id = 5;
+inline void MemoryLogRawAllocation::clear_allocation_id() {
+  _impl_.allocation_id_ = int64_t{0};
+}
+inline int64_t MemoryLogRawAllocation::_internal_allocation_id() const {
+  return _impl_.allocation_id_;
+}
+inline int64_t MemoryLogRawAllocation::allocation_id() const {
+  // @@protoc_insertion_point(field_get:tensorflow.MemoryLogRawAllocation.allocation_id)
+  return _internal_allocation_id();
+}
+inline void MemoryLogRawAllocation::_internal_set_allocation_id(int64_t value) {
+  
+  _impl_.allocation_id_ = value;
+}
+inline void MemoryLogRawAllocation::set_allocation_id(int64_t value) {
+  _internal_set_allocation_id(value);
+  // @@protoc_insertion_point(field_set:tensorflow.MemoryLogRawAllocation.allocation_id)
+}
+
+// string allocator_name = 6;
+inline void MemoryLogRawAllocation::clear_allocator_name() {
+  _impl_.allocator_name_.ClearToEmpty();
+}
+inline const std::string& MemoryLogRawAllocation::allocator_name() const {
+  // @@protoc_insertion_point(field_get:tensorflow.MemoryLogRawAllocation.allocator_name)
+  return _internal_allocator_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void MemoryLogRawAllocation::set_allocator_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.allocator_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.MemoryLogRawAllocation.allocator_name)
+}
+inline std::string* MemoryLogRawAllocation::mutable_allocator_name() {
+  std::string* _s = _internal_mutable_allocator_name();
+  // @@protoc_insertion_point(field_mutable:tensorflow.MemoryLogRawAllocation.allocator_name)
+  return _s;
+}
+inline const std::string& MemoryLogRawAllocation::_internal_allocator_name() const {
+  return _impl_.allocator_name_.Get();
+}
+inline void MemoryLogRawAllocation::_internal_set_allocator_name(const std::string& value) {
+  
+  _impl_.allocator_name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* MemoryLogRawAllocation::_internal_mutable_allocator_name() {
+  
+  return _impl_.allocator_name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* MemoryLogRawAllocation::release_allocator_name() {
+  // @@protoc_insertion_point(field_release:tensorflow.MemoryLogRawAllocation.allocator_name)
+  return _impl_.allocator_name_.Release();
+}
+inline void MemoryLogRawAllocation::set_allocated_allocator_name(std::string* allocator_name) {
+  if (allocator_name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.allocator_name_.SetAllocated(allocator_name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.allocator_name_.IsDefault()) {
+    _impl_.allocator_name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.MemoryLogRawAllocation.allocator_name)
+}
+
+// -------------------------------------------------------------------
+
+// MemoryLogRawDeallocation
+
+// int64 step_id = 1;
+inline void MemoryLogRawDeallocation::clear_step_id() {
+  _impl_.step_id_ = int64_t{0};
+}
+inline int64_t MemoryLogRawDeallocation::_internal_step_id() const {
+  return _impl_.step_id_;
+}
+inline int64_t MemoryLogRawDeallocation::step_id() const {
+  // @@protoc_insertion_point(field_get:tensorflow.MemoryLogRawDeallocation.step_id)
+  return _internal_step_id();
+}
+inline void MemoryLogRawDeallocation::_internal_set_step_id(int64_t value) {
+  
+  _impl_.step_id_ = value;
+}
+inline void MemoryLogRawDeallocation::set_step_id(int64_t value) {
+  _internal_set_step_id(value);
+  // @@protoc_insertion_point(field_set:tensorflow.MemoryLogRawDeallocation.step_id)
+}
+
+// string operation = 2;
+inline void MemoryLogRawDeallocation::clear_operation() {
+  _impl_.operation_.ClearToEmpty();
+}
+inline const std::string& MemoryLogRawDeallocation::operation() const {
+  // @@protoc_insertion_point(field_get:tensorflow.MemoryLogRawDeallocation.operation)
+  return _internal_operation();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void MemoryLogRawDeallocation::set_operation(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.operation_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.MemoryLogRawDeallocation.operation)
+}
+inline std::string* MemoryLogRawDeallocation::mutable_operation() {
+  std::string* _s = _internal_mutable_operation();
+  // @@protoc_insertion_point(field_mutable:tensorflow.MemoryLogRawDeallocation.operation)
+  return _s;
+}
+inline const std::string& MemoryLogRawDeallocation::_internal_operation() const {
+  return _impl_.operation_.Get();
+}
+inline void MemoryLogRawDeallocation::_internal_set_operation(const std::string& value) {
+  
+  _impl_.operation_.Set(value, GetArenaForAllocation());
+}
+inline std::string* MemoryLogRawDeallocation::_internal_mutable_operation() {
+  
+  return _impl_.operation_.Mutable(GetArenaForAllocation());
+}
+inline std::string* MemoryLogRawDeallocation::release_operation() {
+  // @@protoc_insertion_point(field_release:tensorflow.MemoryLogRawDeallocation.operation)
+  return _impl_.operation_.Release();
+}
+inline void MemoryLogRawDeallocation::set_allocated_operation(std::string* operation) {
+  if (operation != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.operation_.SetAllocated(operation, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.operation_.IsDefault()) {
+    _impl_.operation_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.MemoryLogRawDeallocation.operation)
+}
+
+// int64 allocation_id = 3;
+inline void MemoryLogRawDeallocation::clear_allocation_id() {
+  _impl_.allocation_id_ = int64_t{0};
+}
+inline int64_t MemoryLogRawDeallocation::_internal_allocation_id() const {
+  return _impl_.allocation_id_;
+}
+inline int64_t MemoryLogRawDeallocation::allocation_id() const {
+  // @@protoc_insertion_point(field_get:tensorflow.MemoryLogRawDeallocation.allocation_id)
+  return _internal_allocation_id();
+}
+inline void MemoryLogRawDeallocation::_internal_set_allocation_id(int64_t value) {
+  
+  _impl_.allocation_id_ = value;
+}
+inline void MemoryLogRawDeallocation::set_allocation_id(int64_t value) {
+  _internal_set_allocation_id(value);
+  // @@protoc_insertion_point(field_set:tensorflow.MemoryLogRawDeallocation.allocation_id)
+}
+
+// string allocator_name = 4;
+inline void MemoryLogRawDeallocation::clear_allocator_name() {
+  _impl_.allocator_name_.ClearToEmpty();
+}
+inline const std::string& MemoryLogRawDeallocation::allocator_name() const {
+  // @@protoc_insertion_point(field_get:tensorflow.MemoryLogRawDeallocation.allocator_name)
+  return _internal_allocator_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void MemoryLogRawDeallocation::set_allocator_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.allocator_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.MemoryLogRawDeallocation.allocator_name)
+}
+inline std::string* MemoryLogRawDeallocation::mutable_allocator_name() {
+  std::string* _s = _internal_mutable_allocator_name();
+  // @@protoc_insertion_point(field_mutable:tensorflow.MemoryLogRawDeallocation.allocator_name)
+  return _s;
+}
+inline const std::string& MemoryLogRawDeallocation::_internal_allocator_name() const {
+  return _impl_.allocator_name_.Get();
+}
+inline void MemoryLogRawDeallocation::_internal_set_allocator_name(const std::string& value) {
+  
+  _impl_.allocator_name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* MemoryLogRawDeallocation::_internal_mutable_allocator_name() {
+  
+  return _impl_.allocator_name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* MemoryLogRawDeallocation::release_allocator_name() {
+  // @@protoc_insertion_point(field_release:tensorflow.MemoryLogRawDeallocation.allocator_name)
+  return _impl_.allocator_name_.Release();
+}
+inline void MemoryLogRawDeallocation::set_allocated_allocator_name(std::string* allocator_name) {
+  if (allocator_name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.allocator_name_.SetAllocated(allocator_name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.allocator_name_.IsDefault()) {
+    _impl_.allocator_name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.MemoryLogRawDeallocation.allocator_name)
+}
+
+// bool deferred = 5;
+inline void MemoryLogRawDeallocation::clear_deferred() {
+  _impl_.deferred_ = false;
+}
+inline bool MemoryLogRawDeallocation::_internal_deferred() const {
+  return _impl_.deferred_;
+}
+inline bool MemoryLogRawDeallocation::deferred() const {
+  // @@protoc_insertion_point(field_get:tensorflow.MemoryLogRawDeallocation.deferred)
+  return _internal_deferred();
+}
+inline void MemoryLogRawDeallocation::_internal_set_deferred(bool value) {
+  
+  _impl_.deferred_ = value;
+}
+inline void MemoryLogRawDeallocation::set_deferred(bool value) {
+  _internal_set_deferred(value);
+  // @@protoc_insertion_point(field_set:tensorflow.MemoryLogRawDeallocation.deferred)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace tensorflow
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2flog_5fmemory_2eproto
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/log_memory.proto b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/log_memory.proto
new file mode 100644
index 0000000000000000000000000000000000000000..7ead0dd94cb797bf38151559a9ba78682cdbbe47
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/log_memory.proto
@@ -0,0 +1,95 @@
+syntax = "proto3";
+
+package tensorflow;
+
+import "tensorflow/core/framework/tensor_description.proto";
+
+option cc_enable_arenas = true;
+option java_outer_classname = "LogMemoryProtos";
+option java_multiple_files = true;
+option java_package = "org.tensorflow.framework";
+option go_package = "github.com/tensorflow/tensorflow/tensorflow/go/core/framework/log_memory_go_proto";
+
+message MemoryLogStep {
+  // Process-unique step id.
+  int64 step_id = 1;
+
+  // Handle describing the feeds and fetches of the step.
+  string handle = 2;
+}
+
+message MemoryLogTensorAllocation {
+  // Process-unique step id.
+  int64 step_id = 1;
+
+  // Name of the kernel making the allocation as set in GraphDef,
+  // e.g., "affine2/weights/Assign".
+  string kernel_name = 2;
+
+  // Allocated tensor details.
+  TensorDescription tensor = 3;
+}
+
+message MemoryLogTensorDeallocation {
+  // Id of the tensor buffer being deallocated, used to match to a
+  // corresponding allocation.
+  int64 allocation_id = 1;
+
+  // Name of the allocator used.
+  string allocator_name = 2;
+}
+
+message MemoryLogTensorOutput {
+  // Process-unique step id.
+  int64 step_id = 1;
+
+  // Name of the kernel producing an output as set in GraphDef, e.g.,
+  // "affine2/weights/Assign".
+  string kernel_name = 2;
+
+  // Index of the output being set.
+  int32 index = 3;
+
+  // Output tensor details.
+  TensorDescription tensor = 4;
+}
+
+message MemoryLogRawAllocation {
+  // Process-unique step id.
+  int64 step_id = 1;
+
+  // Name of the operation making the allocation.
+  string operation = 2;
+
+  // Number of bytes in the allocation.
+  int64 num_bytes = 3;
+
+  // Address of the allocation.
+  uint64 ptr = 4;
+
+  // Id of the tensor buffer being allocated, used to match to a
+  // corresponding deallocation.
+  int64 allocation_id = 5;
+
+  // Name of the allocator used.
+  string allocator_name = 6;
+}
+
+message MemoryLogRawDeallocation {
+  // Process-unique step id.
+  int64 step_id = 1;
+
+  // Name of the operation making the deallocation.
+  string operation = 2;
+
+  // Id of the tensor buffer being deallocated, used to match to a
+  // corresponding allocation.
+  int64 allocation_id = 3;
+
+  // Name of the allocator used.
+  string allocator_name = 4;
+
+  // True if the deallocation is queued and will be performed later,
+  // e.g. for GPU lazy freeing of buffers.
+  bool deferred = 5;
+}
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/logging.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/logging.h
new file mode 100644
index 0000000000000000000000000000000000000000..9bde3d51056e9a28a74a308a3e480e659249192c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/logging.h
@@ -0,0 +1,37 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_LOGGING_H_
+#define TENSORFLOW_CORE_FRAMEWORK_LOGGING_H_
+
+#include <string>
+
+namespace tensorflow {
+
+namespace logging {
+
+// Register a listener method to call on any printed messages.
+// Returns true if it is successfully registered.
+bool RegisterListener(void (*listener)(const char*));
+
+// Log string to active listeners. Returns true if any listeners were
+// registered.
+bool LogToListeners(std::string msg, std::string end = "\n");
+
+}  // namespace logging
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_LOGGING_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/lookup_interface.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/lookup_interface.h
new file mode 100644
index 0000000000000000000000000000000000000000..f0234af3110e7d2499cb1105b3ca74649e7ed54a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/lookup_interface.h
@@ -0,0 +1,163 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_LOOKUP_INTERFACE_H_
+#define TENSORFLOW_CORE_FRAMEWORK_LOOKUP_INTERFACE_H_
+
+#include "tensorflow/core/framework/resource_mgr.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/lib/core/status.h"
+
+namespace tensorflow {
+
+class OpKernelContext;
+
+namespace lookup {
+
+// Forward declaration so we can define GetInitializableLookupTable() in
+// LookupInterface.
+class InitializableLookupTable;
+
+// Lookup interface for batch lookups used by table lookup ops.
+class LookupInterface : public ResourceBase {
+ public:
+  // Performs batch lookups, for every element in the key tensor, Find returns
+  // the corresponding value into the values tensor.
+  // If an element is not present in the table, the given default value is used.
+
+  // For tables that require initialization, Find is available once the table
+  // is marked as initialized.
+
+  // Returns the following statuses:
+  // - OK: when the find finishes successfully.
+  // - FailedPrecondition: if the table is not initialized.
+  // - InvalidArgument: if any of the preconditions on the lookup key or value
+  //   fails.
+  // - In addition, other implementations may provide another non-OK status
+  //   specific to their failure modes.
+  virtual Status Find(OpKernelContext* ctx, const Tensor& keys, Tensor* values,
+                      const Tensor& default_value) = 0;
+
+  // Inserts elements into the table. Each element of the key tensor is
+  // associated with the corresponding element in the value tensor.
+  // This method is only implemented in mutable tables that can be updated over
+  // the execution of the graph. It returns Status::NotImplemented for read-only
+  // tables that are initialized once before they can be looked up.
+
+  // Returns the following statuses:
+  // - OK: when the insert finishes successfully.
+  // - InvalidArgument: if any of the preconditions on the lookup key or value
+  //   fails.
+  // - Unimplemented: if the table does not support insertions.
+  virtual Status Insert(OpKernelContext* ctx, const Tensor& keys,
+                        const Tensor& values) = 0;
+
+  // Removes elements from the table.
+  // This method is only implemented in mutable tables that can be updated over
+  // the execution of the graph. It returns Status::NotImplemented for read-only
+  // tables that are initialized once before they can be looked up.
+
+  // Returns the following statuses:
+  // - OK: when the remove finishes successfully.
+  // - InvalidArgument: if any of the preconditions on the lookup key fails.
+  // - Unimplemented: if the table does not support removals.
+  virtual Status Remove(OpKernelContext* ctx, const Tensor& keys) = 0;
+
+  // Returns the number of elements in the table.
+  virtual size_t size() const = 0;
+
+  // Exports the values of the table to two tensors named keys and values.
+  // Note that the shape of the tensors is completely up to the implementation
+  // of the table and can be different than the tensors used for the Insert
+  // function above.
+  virtual Status ExportValues(OpKernelContext* ctx) = 0;
+
+  // Imports previously exported keys and values.
+  // As mentioned above, the shape of the keys and values tensors are determined
+  // by the ExportValues function above and can be different than for the
+  // Insert function.
+  virtual Status ImportValues(OpKernelContext* ctx, const Tensor& keys,
+                              const Tensor& values) = 0;
+
+  // Returns the data type of the key.
+  virtual DataType key_dtype() const = 0;
+
+  // Returns the data type of the value.
+  virtual DataType value_dtype() const = 0;
+
+  // Returns the shape of a key in the table.
+  virtual TensorShape key_shape() const = 0;
+
+  // Returns the shape of a value in the table.
+  virtual TensorShape value_shape() const = 0;
+
+  // Check format of the key and value tensors for the Insert function.
+  // Returns OK if all the following requirements are satisfied, otherwise it
+  // returns InvalidArgument:
+  // - DataType of the tensor keys equals to the table key_dtype
+  // - DataType of the tensor values equals to the table value_dtype
+  // - the values tensor has the required shape given keys and the tables's
+  //   value shape.
+  virtual Status CheckKeyAndValueTensorsForInsert(const Tensor& keys,
+                                                  const Tensor& values);
+
+  // Similar to the function above but instead checks eligibility for the Import
+  // function.
+  virtual Status CheckKeyAndValueTensorsForImport(const Tensor& keys,
+                                                  const Tensor& values);
+
+  // Check format of the key tensor for the Remove function.
+  // Returns OK if all the following requirements are satisfied, otherwise it
+  // returns InvalidArgument:
+  // - DataType of the tensor keys equals to the table key_dtype
+  virtual Status CheckKeyTensorForRemove(const Tensor& keys);
+
+  // Check the arguments of a find operation. Returns OK if all the following
+  // requirements are satisfied, otherwise it returns InvalidArgument:
+  // - DataType of the tensor keys equals to the table key_dtype
+  // - DataType of the tensor default_value equals to the table value_dtype
+  // - the default_value tensor has the required shape given keys and the
+  //   tables's value shape.
+  Status CheckFindArguments(const Tensor& keys, const Tensor& default_value);
+
+  string DebugString() const override {
+    return strings::StrCat("A lookup table of size: ", size());
+  }
+
+  // Returns an InitializableLookupTable, a subclass of LookupInterface, if the
+  // current object is an InitializableLookupTable. Otherwise, returns nullptr.
+  virtual InitializableLookupTable* GetInitializableLookupTable() {
+    return nullptr;
+  }
+
+ protected:
+  virtual ~LookupInterface() = default;
+
+  // Makes sure that the key and value tensor DataType's match the table
+  // key_dtype and value_dtype.
+  Status CheckKeyAndValueTypes(const Tensor& keys, const Tensor& values);
+
+  // Makes sure that the provided shape is consistent with the table keys shape.
+  Status CheckKeyShape(const TensorShape& shape);
+
+ private:
+  Status CheckKeyAndValueTensorsHelper(const Tensor& keys,
+                                       const Tensor& values);
+};
+
+}  // namespace lookup
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_LOOKUP_INTERFACE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/memory_types.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/memory_types.h
new file mode 100644
index 0000000000000000000000000000000000000000..f719131bcb4781e9a0043e1b2000b7a7819b4eb4
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/memory_types.h
@@ -0,0 +1,38 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_MEMORY_TYPES_H_
+#define TENSORFLOW_CORE_FRAMEWORK_MEMORY_TYPES_H_
+
+#include "tensorflow/core/framework/op.h"
+#include "tensorflow/core/framework/types.h"
+
+namespace tensorflow {
+
+class NodeDef;
+
+// Returns into *{input,output}_memory_types the memory type of each
+// {input,output} tensor.
+//
+// REQUIRES: * '*_memory_types' is not nullptr.
+//           * def has all attrs specified (e.g. using AddDefaultsToNodeDef()).
+Status MemoryTypesForNode(const OpRegistryInterface* op_registry,
+                          const DeviceType& device_type, const NodeDef& ndef,
+                          MemoryTypeVector* input_memory_types,
+                          MemoryTypeVector* output_memory_types);
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_MEMORY_TYPES_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/metrics.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/metrics.h
new file mode 100644
index 0000000000000000000000000000000000000000..3015508b82a714dd6d8f2c618a1537de3908272a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/metrics.h
@@ -0,0 +1,473 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_FRAMEWORK_METRICS_H_
+#define TENSORFLOW_CORE_FRAMEWORK_METRICS_H_
+
+#include <cstdint>
+
+#include "tensorflow/core/framework/dataset_options.pb.h"
+#include "tensorflow/core/lib/monitoring/counter.h"
+#include "tensorflow/core/lib/monitoring/gauge.h"
+#include "tensorflow/core/platform/env.h"
+#include "tensorflow/core/platform/statusor.h"
+#include "tensorflow/core/platform/types.h"
+#include "tensorflow/core/protobuf/data_service.pb.h"
+#include "tensorflow/core/protobuf/meta_graph.pb.h"
+
+namespace tensorflow {
+namespace metrics {
+enum class GraphOptimizationSource {
+  kUnknown,
+  kJit,
+  kAot,
+};
+
+// Records when a data-fetching tf.data operation is executed.
+//
+// The `name` argument identifies the operation type (e.g. "ToSingleElementOp").
+void RecordTFDataFetchOp(const string& name);
+
+// Records that a tf.data.Dataset executed by the program used autotuning.
+//
+// The `name` argument identifies the Dataset type (e.g. "ParallelMap").
+void RecordTFDataAutotune(const string& name);
+
+// Returns a counter that can be used to record the number of bytes produced by
+// a tf.data.Dataset.
+//
+// The `name` argument identifies the Dataset type (e.g. "Batch" or "Map").
+monitoring::CounterCell* GetTFDataBytesConsumedCounter(const string& name);
+
+// Returns a counter that can be used to record the number of bytes produced by
+// a tf.data.Dataset.
+//
+// The `name` argument identifies the Dataset type (e.g. "Batch" or "Map").
+monitoring::CounterCell* GetTFDataBytesProducedCounter(const string& name);
+
+// Returns a counter than can be used to record the number of bytes read from
+// the filesystem by a tf.data.Dataset source.
+//
+// The `name` argument identifies the Dataset type (e.g. "TFRecordDataset").
+//
+// TODO(jsimsa): Remove this now that we have GetTFDataBytesConsumedCounter?
+monitoring::CounterCell* GetTFDataBytesReadCounter(const string& name);
+
+// Returns a counter than can be used to record the number of elements produced
+// by a tf.data.Dataset.
+//
+// The `name` argument identifies the Dataset type (e.g. "Batch" or "Map").
+monitoring::CounterCell* GetTFDataElementsCounter(const string& name);
+
+// Returns a gauge than can be used to record the performance model information.
+//
+// The `id` argument represents the (unique) model ID.
+monitoring::GaugeCell<std::function<std::string()>>* GetTFDataModelGauge(
+    const string& id);
+
+// Records the number of bytes fetched from tf.data.Dataset iterator.
+void RecordTFDataBytesFetched(int64_t num_bytes);
+
+// Records the number of times tf.data experiment is applied to input pipelines.
+void RecordTFDataExperiment(const string& name);
+
+// Records the time (in microseconds) spent generating an element and
+// transferring it over the network for the given protocol.
+void RecordTFDataServiceGetElementDuration(const string& data_transfer_protocol,
+                                           uint64 duration_us);
+
+// Records the time (in microseconds) spent in a single invocation of
+// `ItertatorResource::GetNext()`.
+void RecordTFDataGetNextDuration(uint64 duration_us);
+
+// Records the histogram of ratios of tf.data autotune algorithm used RAM over
+// the ram budget.
+void RecordTFDataAutotuneUsedRamBudgetRatio(const double ratio);
+
+// Records the histogram of ratios of tf.data autotune algorithm max buffer
+// bytes over the ram budget.
+void RecordTFDataAutotuneMaxBufferBudgetRatio(const double ratio);
+
+// Records the number of times each tf.data fingerprint is used
+// to measure duplicate pre-processing.
+//
+// The `name` argument identifies the Dataset graph fingerprint,
+// created using GraphHash().
+void RecordTFDataFingerprint(const string& name);
+
+// Records the event of a tf.data service pipeline getting a runtime
+// compression decision.
+void RecordTFDataServiceRuntimeCompressionDecision(bool compression_decision);
+
+// Records the event of a tf.data service pipeline making the compression
+// related action.
+void RecordTFDataServiceCompressionAction(const string& action);
+
+// Records the time (in microseconds) during which `IteratorResource` was busy
+// processing at least one `GetNext()` request.
+void RecordTFDataIteratorBusy(uint64 duration_us);
+
+// Records the time (in microseconds) between `IteratorResource` receiving the
+// first `GetNext()` request and responding to the last `GetNext()` request.
+void RecordTFDataIteratorLifetime(uint64 duration_us);
+
+// Records the time histogram (in microseconds) between `IteratorResource`
+// responding to a `GetNext()` request and receiving the next `GetNext()`
+// request.
+void RecordTFDataIteratorGap(uint64 duration_us);
+
+// Records the number of independent graph changes resulting from the
+// application of a tf.data optimization.
+//
+// The `name` argument identifies the optimization (e.g. "noop_elimination").
+void RecordTFDataOptimization(const string& name, int64_t num_changes);
+
+// Records that a tf.data service worker has been created.
+void RecordTFDataServiceWorkerCreated();
+
+// Records that a tf.data service job has been created.
+void RecordTFDataServiceJobsCreated(
+    const data::ProcessingModeDef& processing_mode, bool is_coordinated_read);
+
+// Records tf.data service iterators created by clients.
+void RecordTFDataServiceClientIterators(
+    int64_t worker_uid, data::DeploymentMode deployment_mode,
+    const data::ProcessingModeDef& processing_mode, bool is_coordinated_read);
+
+// Records that a tf.data service worker client has been created that will use
+// `data_transfer_protocol` to get data from the worker server and whether or
+// not the user explicitly specified the protocol.
+void RecordTFDataServiceDataTransferProtocolUsed(
+    const string& data_transfer_protocol, bool user_specified);
+
+// Records that a tf.data service worker client fell back to gRPC rather than
+// use `data_transfer_protocol` because of an error of type `code` with message
+// `error_message`.
+void RecordTFDataServiceDataTransferProtocolFallback(
+    const string& data_transfer_protocol, error::Code code,
+    const string& error_message);
+
+// Records that a tf.data service worker client got an error of non-retriable
+// type `code` with message `error_message` when trying to transfer data over
+// `data_transfer_protocol`.
+void RecordTFDataServiceDataTransferProtocolError(
+    const string& data_transfer_protocol, error::Code code,
+    const string& error_message);
+
+// Records tf.data service cross-trainer cache queries.
+void RecordTFDataServiceCrossTrainerCacheQuery(bool cache_hit);
+
+// Records tf.data service cross-trainer cache memory usage in bytes.
+void RecordTFDataServiceCrossTrainerCacheSizeBytes(size_t bytes);
+
+// Records distributed tf.data snapshot bytes committed.
+void RecordTFDataServiceSnapshotBytesCommitted(int64_t bytes);
+
+// Records the current estimated optimal number of tf.data service workers.
+void RecordTFDataServiceOptimalNumberOfWorkers(int64_t number_of_workers);
+
+// Records the file name read by a tf.data Dataset.
+//
+// The `name` argument identifies the Dataset type (e.g. "TFRecordDataset").
+void RecordTFDataFilename(const string& name, const string& filename);
+
+// Records statistics of tf.data auto sharding.
+//
+// The `id` is a unique identifier of the input pipeline. The `policy`
+// identifies the auto-sharding policy used, the `num_workers` identifies the
+// number of workers, and `num_replicas` identifies the number of replicas.
+void RecordTFDataAutoShard(const string& id, data::AutoShardPolicy policy,
+                           int64 num_workers, int64 num_replicas);
+
+// Records statistics of whether we can rewrite batch size in tf.data auto
+// sharding.
+//
+// The `id` is a unique identifier of the input pipeline. The `eligible`
+// indicates whether the input pipeline is eligible for the rewrite. The
+// `ineligible_reason` is the reason if the input pipeline is ineligible.
+void RecordTFDataAutoShardRewriteBatchSize(
+    bool eligible, const std::vector<string>& ineligible_reason);
+
+// Records the number of times each tf.data autotuning algorithm stopping
+// criterion is met.
+void RecordTFDataAutotuneStoppingCriteria(const string& name);
+
+// Records the number of times an error of this type occurred with this status
+// code.
+void RecordTFDataError(const string& error_type, const string& error_code);
+
+// Records parsing of dense tensor features.
+void RecordParseDenseFeature(int64_t num_features);
+
+// Records parsing of sparse tensor features.
+void RecordParseSparseFeature(int64_t num_features);
+
+// Records parsing of ragged tensor features.
+void RecordParseRaggedFeature(int64_t num_features);
+
+// Records the size of input/output tensors in bytes.
+void RecordGraphInputTensors(const size_t size);
+void RecordGraphOutputTensors(const size_t size);
+
+// Records the number of cores requested by graphs with XLA SPMD enabled.
+void RecordTPUXlaSpmdCoresPerReplica(int64_t cores_per_replica);
+
+void UpdateGraphExecTime(const uint64 running_time_usecs);
+void UpdateGraphPendingQueueLength(uint64 len);
+
+// Records that one output of an op of type `op_name` was unused.
+void RecordUnusedOutput(const string& op_name);
+
+// Updates the metrics stored about time spent building graphs.
+//
+// By "GraphBuild", we refer to building a client graph, which is a sub-graph of
+// the full graph, induced by a set of options. In particular, these options
+// include the feeds and fetches requested.
+//
+// This includes time spent:
+//   * optimizing the graphs with Grappler
+//   * pruning the sub-graph (unless the place_pruned_graph option is set)
+//
+// When executing eagerly, this will not record any activity.
+//
+// TODO(jtkeeling): Should we record building/optimizing tf.functions?
+void UpdateGraphBuildTime(const uint64 running_time_usecs);
+
+// Updates the metric stored for time spent optimizing function graphs.
+void UpdateFunctionGraphOptimizationTime(const uint64 running_time_usecs);
+
+// Updates the metric stored for time saved by caching graph optimization.
+void UpdateFunctionGraphOptimizationSavingTime(uint64 saving_time_usec,
+                                               GraphOptimizationSource source);
+
+// Retrieves the total time saved by the graph optimization caching.
+uint64 GetFunctionGraphOptimizationSavingTimeUsecs(
+    GraphOptimizationSource source);
+
+// Increments the hit count for the graph optimization cache.
+void IncrementFunctionGraphOptimizationCacheHitCount(
+    int count, GraphOptimizationSource source);
+
+// Gets the hit count for the graph optimization cache.
+int64_t GetFunctionGraphOptimizationCacheHitCount(
+    GraphOptimizationSource source);
+
+// Increments the failure count for the graph optimization cache restoring.
+void IncrementFunctionGraphOptimizationCacheFailureCount(
+    int count, GraphOptimizationSource source);
+
+// Gets the failure count for the graph optimization cache.
+int64_t GetFunctionGraphOptimizationCacheFailureCount(
+    GraphOptimizationSource source);
+
+// Increments the miss count for the graph optimization cache.
+void IncrementFunctionGraphOptimizationCacheMissCount(
+    int count, GraphOptimizationSource source);
+
+// Gets the miss count for the graph optimization cache.
+int64_t GetFunctionGraphOptimizationCacheMissCount(
+    GraphOptimizationSource source);
+
+// Increments the number of restoring function graph optimization cache.
+void IncrementFunctionGraphOptimizationCacheLoadCount(
+    int count, GraphOptimizationSource source);
+
+int64_t GetFunctionGraphOptimizationCacheLoadCount(
+    GraphOptimizationSource source);
+
+// Records the activity of the first phase of the mlir bridge using the
+// tf_metadata.tf_mlir_bridge_first_phase_count metric.
+// device_type: tpu, cpu, gpu, etc.
+// bridge_version: v1 compat, v2, etc.
+// fallback_enabled: true if fallback will happen, false if not
+// result: outcome of bridge (success, failure, disabled, invalid_graph, etc.)
+void UpdateTfMlirBridgeFirstPhaseCounter(const std::string& device_type,
+                                         const std::string& bridge_version,
+                                         bool fallback_enabled,
+                                         const std::string& result);
+
+enum class MlirBridgeSecondPhaseMetric {
+  // MLIR bridge phase 2 was executed and the graph was processed successfully
+  // (fallback enabled).
+  kMlirWithFallbackModeSuccess,
+  // MLIR bridge phase 2 compilation was failure (fallback enabled).
+  kMlirWithFallbackModeFailure,
+  // MLIR bridge phase 2 compilation was successful (manually enabled).
+  kMlirModeSuccess,
+  // MLIR bridge phase 2 compilation fails (manually enabled)
+  kMlirModeFailure,
+  // Old bridge compilation was run successfully (was run because MLIR bridge
+  // could not process the graph).
+  kOldBridgeMlirFilteredSuccess,
+  // Old bridge failed (was run b/c MLIR bridge could not process the graph).
+  kOldBridgeMlirFilteredFailure,
+  // Old bridge compilation was successfully run after MLIR bridge ran and
+  // failed.
+  kOldBridgeWithFallbackModeSuccess,
+  // Old Bridge failed in fallback (was run because MLIR bridge failed first).
+  kOldBridgeWithFallbackModeFailure,
+  // MLIR bridge phase 2 Combined Bridge MLIR was successful
+  kMlirCombinedMlirSuccess,
+  // MLIR bridge phase 2 Combined Bridge MLIR failed
+  kMlirCombinedMlirFailure,
+  // MLIR bridge phase 2 Combined Bridge Old bridge was successful
+  kMlirCombinedOldSuccess,
+  // MLIR bridge phase 2 Combined Bridge Old bridge was successful
+  kMlirCombinedOldFailure,
+};
+
+// Records the activity of the second phase of the mlir bridge.
+void IncrementTfMlirBridgeSecondPhaseCounter(
+    MlirBridgeSecondPhaseMetric metric);
+
+// Records the activity per op using the
+// tf_metadata.tf_mlir_bridge_graph_analysis_per_op.
+// op_name: the name of op.
+// construction_context: eager, session, Not tracked.
+// is_single_core_inference_mode: true, false.
+// unsupported_reason: the reason why the graph is not supported in MLIR-based
+// bridge, like invalid graph, has unsupported ops, etc.
+// has_unsupported_features: true indicates MLIR-based bridge is disabled,
+// false indicates MLIR-based bridge is enabled.
+
+void UpdateTfMlirBridgeGraphAnalysisPerOp(
+    const std::string& op_name, const std::string& construction_context,
+    bool is_single_core_inference_mode, const std::string& num_replicas,
+    const std::string& num_cores_per_replica, const std::string& use_tpu,
+    const std::string& allow_soft_placement,
+    const std::string& use_spmd_for_xla_partitioning,
+    const std::string& unsupported_reason, bool has_unsupported_features);
+
+// Records whether a graph contains any of the TF1 features
+void RecordTFVersionByGraphFeatures(const std::string& device,
+                                    const std::string& context,
+                                    bool hasControlFlowV1,
+                                    bool hasReferenceVariables,
+                                    bool hasManualControlDeps);
+
+// Convenience class allowing RAII style of reporting for a monitoring::Counter.
+template <int NumLabels>
+class ScopedCounter final {
+ public:
+  ScopedCounter(monitoring::Counter<NumLabels>* const counter,
+                const std::array<std::string, NumLabels>& labels)
+      : counter_(counter), labels_(labels) {
+    Init();
+  }
+
+  // Report counter and stop it. Counter needs to be reset to perform
+  // next measurement.
+  void ReportAndStop() {
+    if (started_) {
+      started_ = false;
+      ReportInternal(std::make_index_sequence<NumLabels>());
+    }
+  }
+
+  // Start the measurement with the new set of labels.
+  void Reset(const std::array<std::string, NumLabels>& labels) {
+    labels_ = labels;
+    Init();
+  }
+
+  // Start the measurement with the existing set of labels.
+  void Reset() { Init(); }
+
+  // Returns duration of the current interval in case the timer has started.
+  // Returns nullopt otherwise.
+  std::optional<uint64> DurationMicroSec() const {
+    return started_ ? std::optional<uint64>(accumulated_time_ +
+                                            Env::Default()->NowMicros() -
+                                            start_time_)
+                    : std::nullopt;
+  }
+
+  // Temporarily stop the timer, but keep accumulated time.
+  void AccumulateAndStop() {
+    if (started_) {
+      accumulated_time_ = Env::Default()->NowMicros() - start_time_;
+      started_ = false;
+    }
+  }
+
+  // Start previously stopped timer.
+  void Start() {
+    if (started_) return;
+
+    // Keep previously accumulated time if any.
+    start_time_ = Env::Default()->NowMicros();
+    started_ = true;
+  }
+
+  ~ScopedCounter() { ReportAndStop(); }
+
+ private:
+  template <std::size_t... S>
+  void ReportInternal(std::index_sequence<S...>) {
+    uint64 time_interval = Env::Default()->NowMicros() - start_time_;
+    time_interval += accumulated_time_;
+    if (time_interval > 0) {
+      counter_->GetCell(labels_[S]...)->IncrementBy(time_interval);
+    }
+  }
+
+  void Init() {
+    start_time_ = Env::Default()->NowMicros();
+    started_ = true;
+    accumulated_time_ = 0;
+  }
+
+  monitoring::Counter<NumLabels>* counter_;
+  std::array<std::string, NumLabels> labels_;
+  bool started_{false};
+  uint64 start_time_;
+  uint64 accumulated_time_;
+};
+
+// Returns a counter used to capture timing metrics for graph optimization
+// passes.
+monitoring::Counter<2>* GetGraphOptimizationCounter();
+
+// Updates metrics for time to distribute variables to all TPU hosts.
+void UpdateTpuVariableDistributionTime(const uint64 distribution_time_usecs);
+
+// Updates the metrics stored about time XLA spents compiling graphs.
+void UpdateXlaCompilationTime(const uint64 compilation_time_usecs);
+
+// Increments (by 1) a simple integer counter that is exposed for testing.
+void IncrementTestCounter(const string& name, const string& label);
+
+// Read-only access to a counter for testing.
+const monitoring::CounterCell* TestCounter(const string& name,
+                                           const string& label);
+
+// Read-only wrapper for a TestCounter to track increments between calls.
+class TestDelta {
+ public:
+  TestDelta(const string& name, const string& label);
+  void Reset();
+  int64 Get();
+
+ private:
+  const monitoring::CounterCell* cell_;
+  int64 last_value_;
+};
+void UpdateTpuErrorCounter(const string& op, const string& error_type);
+void UpdateEagerClientErrorCounter(const string& error_source,
+                                   const string& error_type);
+
+}  // namespace metrics
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_METRICS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/model.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/model.h
new file mode 100644
index 0000000000000000000000000000000000000000..727af779489b1b113e95643087e7010236ba58b7
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/model.h
@@ -0,0 +1,1259 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_FRAMEWORK_MODEL_H_
+#define TENSORFLOW_CORE_FRAMEWORK_MODEL_H_
+
+#include <algorithm>
+#include <cstdint>
+#include <deque>
+#include <functional>
+#include <limits>
+#include <list>
+#include <memory>
+#include <string>
+// TODO(b/114492873): Move this include into core/platform.
+#include <thread>  // NOLINT
+#include <utility>
+#include <vector>
+
+#include "absl/container/flat_hash_map.h"
+#include "absl/container/flat_hash_set.h"
+#include "tensorflow/core/framework/cancellation.h"
+#include "tensorflow/core/framework/metrics.h"
+#include "tensorflow/core/framework/model.pb.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/lib/gtl/cleanup.h"
+#include "tensorflow/core/lib/gtl/map_util.h"
+#include "tensorflow/core/lib/histogram/histogram.h"
+#include "tensorflow/core/lib/random/random.h"
+#include "tensorflow/core/platform/cpu_info.h"
+#include "tensorflow/core/platform/env.h"
+#include "tensorflow/core/platform/logging.h"
+#include "tensorflow/core/platform/mutex.h"
+#include "tensorflow/core/platform/path.h"
+#include "tensorflow/core/platform/statusor.h"
+#include "tensorflow/core/platform/strcat.h"
+#include "tensorflow/core/platform/stringprintf.h"
+#include "tsl/platform/mutex.h"
+#include "tsl/platform/thread_annotations.h"
+
+namespace tensorflow {
+namespace data {
+namespace model {
+
+// A constant that can be used to enable auto-tuning.
+constexpr int64_t kAutotune = -1;
+constexpr char kParallelism[] = "parallelism";
+constexpr char kBufferSize[] = "buffer_size";
+constexpr char kCycleLength[] = "cycle_length";
+constexpr char kDeterministic[] = "deterministic";
+constexpr char kMaxBufferedElements[] = "max_buffered_elements";
+
+// A key used to identify the input time of the model.
+constexpr char kModelInputTimeKey[] = "model_input_time";
+
+// Default share of available RAM that can be used by model's internal buffers.
+constexpr double kRamBudgetShare = 0.5;
+
+// Weight of the latest processing time used in computing the exponential moving
+// average of processing time per element.
+constexpr double kProcessingTimeEmaWeight = 0.1;
+
+enum class TraversalOrder {
+  BFS = 0,
+  REVERSE_BFS = 1,
+};
+
+// Represents thread-safe state that can be shared between an input pipeline and
+// the performance model.
+struct SharedState {
+ public:
+  SharedState(int64_t value, std::shared_ptr<mutex> mu,
+              std::shared_ptr<condition_variable> cond_var)
+      : value(value),
+        mu(std::move(mu)),
+        cond_var(std::move(cond_var)),
+        tunable(value == kAutotune) {}
+
+  double value;
+  const std::shared_ptr<mutex> mu;
+  const std::shared_ptr<condition_variable> cond_var;
+  const bool tunable;
+};
+
+// Represents a parameter.
+struct Parameter {
+  Parameter(const string& name, std::shared_ptr<SharedState> state, double min,
+            double max)
+      : name(name),
+        // Sometimes non-autotune nodes (with `autotune_=false`) may contain
+        // parameters (for example inputs of parallel interleave dataset which
+        // are not in the current cycle). To avoid unrealistic situation
+        // (say `buffer_size=-1` or `parallelism=-1`) in the optimization
+        // computation, if the state value is `kAutotune=-1` (just to indicate
+        // the `SharedState` is tunable), we initialize the parameter value to
+        // be the minimal value of the state.
+        value(state == nullptr || state->value == kAutotune ? min
+                                                            : state->value),
+        min(min),
+        max(max),
+        state(std::move(state)) {}
+
+  explicit Parameter(const std::shared_ptr<Parameter> parameter)
+      : name(parameter->name),
+        value(parameter->value),
+        min(parameter->min),
+        max(parameter->max),
+        state(parameter->state) {}
+
+  // Human-readable name of the parameter.
+  const string name;
+
+  // Identifies the model value of the parameter. This can be different from
+  // the actual value (e.g. during optimization search).
+  double value;
+
+  // Identifies the minimum value of the parameter.
+  const double min;
+
+  // Identifies the maximum value of the parameter.
+  const double max;
+
+  // Shared state of the parameter.
+  std::shared_ptr<SharedState> state;
+};
+
+// Returns a new tunable parameter.
+std::shared_ptr<Parameter> MakeParameter(const string& name,
+                                         std::shared_ptr<SharedState> state,
+                                         double min, double max);
+
+// Returns a new non-tunable parameter.
+std::shared_ptr<Parameter> MakeNonTunableParameter(const string& name,
+                                                   double value);
+
+// Class for managing the ram budget of an iterator. This is necessary for
+// coordinating ram usage between the model-based autotuner and the legacy
+// prefetch autotuner. Once the legacy autotuner is retired we can remove this
+// class and move all ram budget management to the model autotuner.
+class RamBudgetManager {
+ public:
+  explicit RamBudgetManager(int64_t budget) : budget_(budget) {
+    if (budget <= 0) {
+      LOG(WARNING) << "RAM budget is " << budget
+                   << " which could prevent autotuner from properly adjusting "
+                      "buffer sizes.";
+    }
+  }
+
+  // Requests a new total memory allocation for the parts of the dataset
+  // tuned by the model.
+  //
+  // The autotuner is expected to follow a pattern like
+  //
+  // int64_t budget = ram_budget_manager.AvailableModelRam();
+  // NewModel potential_new_params = OptimizeModel(budget);
+  // int64_t new_ram_used = potential_new_params.RamUsed();
+  // if (ram_budget_manager.RequestModelAllocation(new_ram_used)) {
+  //   ApplyModel(potential_new_params);
+  // }
+  //
+  // Returns whether the request succeeded.
+  bool RequestModelAllocation(int64_t total_bytes) {
+    mutex_lock l(mu_);
+    if (total_bytes > budget_ - legacy_prefetch_allocated_) {
+      return false;
+    }
+    model_allocated_ = total_bytes;
+    return true;
+  }
+
+  // Requests `delta_elements` allocated to the model where each element is of
+  // size `element_size` bytes. `delta_elements` can be negative.
+  // Returns the actual allocated delta elements.
+  int64_t RequestModelBytes(int64_t delta_elements, double element_size) {
+    if (delta_elements == 0) {
+      return 0;
+    }
+    int64_t allocated_delta_elements = delta_elements;
+    mutex_lock l(mu_);
+    // If `delta_elements` is positive, allocate only up to the available
+    // memory.
+    if (delta_elements > 0) {
+      int64_t max_delta_elements = static_cast<int64_t>(
+          (budget_ - legacy_prefetch_allocated_ - model_allocated_) /
+          element_size);
+      if (max_delta_elements < 0) {
+        return 0;
+      }
+      allocated_delta_elements = std::min(max_delta_elements, delta_elements);
+    }
+    model_allocated_ +=
+        static_cast<int64_t>(allocated_delta_elements * element_size);
+    return allocated_delta_elements;
+  }
+
+  // Requests `bytes` additional bytes for the purpose of legacy prefetch
+  // autotuning.
+  //
+  // Unlike RequestModelAllocation, we use a delta number of bytes, since there
+  // can only be one model per iterator but there may be multiple legacy
+  // prefetch autotuners.
+  //
+  // Returns whether there were enough bytes left in the budget to serve the
+  // request. If not, no bytes are allocated.
+  bool RequestLegacyPrefetchBytes(int64_t delta_bytes) {
+    mutex_lock l(mu_);
+    if (delta_bytes > budget_ - legacy_prefetch_allocated_ - model_allocated_) {
+      return false;
+    }
+    legacy_prefetch_allocated_ += delta_bytes;
+    return true;
+  }
+
+  // The total number of bytes that the model could potentially use.
+  int64_t AvailableModelRam() const {
+    tf_shared_lock l(mu_);
+    return budget_ - legacy_prefetch_allocated_;
+  }
+
+  void UpdateBudget(int64_t budget) {
+    mutex_lock l(mu_);
+    budget_ = budget;
+    VLOG(2) << "Updated ram budget to " << budget;
+  }
+
+ private:
+  mutable mutex mu_;
+  int64_t budget_ TF_GUARDED_BY(mu_) = 0;
+  // Number of bytes allocated by legacy prefetch autotuner.
+  int64_t legacy_prefetch_allocated_ TF_GUARDED_BY(mu_) = 0;
+  // Number of bytes allocated by the model.
+  int64_t model_allocated_ TF_GUARDED_BY(mu_) = 0;
+};
+
+// Abstract representation of a TensorFlow input pipeline node. It collects
+// information about inputs to this node, processing time spent executing the
+// node logic, number of elements produced by the node, various other
+// information (e.g. batch size or execution parallelism).
+//
+// Developers of tf.data transformations are not expected to interact with
+// this class directly. Boiler plate code for creating the abstract
+// representation of the input pipeline and collecting common information has
+// been added to the implementation of `DatasetBase` and `DatasetBaseIterator`
+// respectively.
+//
+// In addition, `DatasetBaseIterator` provides wrappers that can be used for
+// transformation-specific information collection. The `SetMetadata` wrapper
+// can be used to pass arbitrary metadata to the modeling framework, while the
+// `StartWork` and `StopWork` wrappers should be used to correctly account for
+// processing time of multi-threaded transformation that yield the CPU; such
+// transformations should invoke `StartWork()` when a transformation thread
+// starts executing (e.g. when created or woken up) and `StopWork()` when a
+// transformation thread stops executing (e.g. when returning or waiting).
+class Node {
+ public:
+  // Arguments for `Node` constructor.
+  struct Args {
+    int64_t id;
+    string name;
+    std::shared_ptr<Node> output;
+  };
+
+  using Factory = std::function<std::shared_ptr<Node>(Args)>;
+  using NodeVector = std::vector<std::shared_ptr<Node>>;
+  using NodePairList =
+      std::list<std::pair<std::shared_ptr<Node>, std::shared_ptr<Node>>>;
+  using ModelParameters =
+      std::vector<std::pair<string, std::shared_ptr<Parameter>>>;
+  using NodeValues = absl::flat_hash_map<string, double>;
+  using ParameterGradients =
+      absl::flat_hash_map<std::pair<string, string>, double>;
+
+  explicit Node(Args args)
+      : id_(args.id),
+        name_(std::move(args.name)),
+        autotune_(true),
+        buffered_bytes_(0),
+        peak_buffered_bytes_(0),
+        buffered_elements_(0),
+        buffered_elements_low_(std::numeric_limits<int64_t>::max()),
+        buffered_elements_high_(std::numeric_limits<int64_t>::min()),
+        bytes_consumed_(0),
+        bytes_produced_(0),
+        num_elements_(0),
+        processing_time_(0),
+        record_metrics_(true),
+        metrics_(name_),
+        output_(args.output.get()),
+        output_weak_ptr_(args.output) {}
+
+  virtual ~Node() {
+    // Clear the sub-nodes instead of relying on implicit shared pointer
+    // destructor to avoid potential stack overflow when the tree is deep.
+    std::deque<std::shared_ptr<Node>> queue;
+    {
+      mutex_lock l(mu_);
+      while (!inputs_.empty()) {
+        queue.push_back(inputs_.front());
+        inputs_.pop_front();
+      }
+    }
+    while (!queue.empty()) {
+      auto node = queue.back();
+      queue.pop_back();
+      {
+        mutex_lock l(node->mu_);
+        while (!node->inputs_.empty()) {
+          queue.push_back(node->inputs_.front());
+          node->inputs_.pop_front();
+        }
+      }
+    }
+
+    FlushMetrics();
+  }
+
+  // Adds an input.
+  void add_input(std::shared_ptr<Node> node) TF_LOCKS_EXCLUDED(mu_) {
+    mutex_lock l(mu_);
+    inputs_.push_back(node);
+  }
+
+  // Increments the aggregate processing time by the given delta.
+  void add_processing_time(int64_t delta) TF_LOCKS_EXCLUDED(mu_) {
+    processing_time_ += delta;
+  }
+
+  // Returns an indication whether autotuning is enabled for this node.
+  bool autotune() const TF_LOCKS_EXCLUDED(mu_) { return autotune_; }
+
+  // Returns the number of bytes stored in this node's buffer.
+  int64_t buffered_bytes() const TF_LOCKS_EXCLUDED(mu_) {
+    return buffered_bytes_;
+  }
+
+  // Returns the peak number of bytes stored in this node's buffer.
+  int64_t peak_buffered_bytes() const TF_LOCKS_EXCLUDED(mu_) {
+    return peak_buffered_bytes_;
+  }
+
+  // Returns the number of elements stored in this node's buffer.
+  int64_t buffered_elements() const TF_LOCKS_EXCLUDED(mu_) {
+    return buffered_elements_;
+  }
+
+  // Returns the low watermark of the number of elements stored in this node's
+  // buffer. The watermarks are reset at the beginning of the execution time and
+  // each time the buffer is upsized or downsized.
+  int64_t buffered_elements_low() const TF_LOCKS_EXCLUDED(mu_) {
+    return buffered_elements_low_;
+  }
+
+  // Returns the high watermark of the number of elements stored in this node's
+  // buffer. The watermarks are reset at the beginning of the execution time and
+  // each time the buffer is upsized or downsized.
+  int64_t buffered_elements_high() const TF_LOCKS_EXCLUDED(mu_) {
+    return buffered_elements_high_;
+  }
+
+  // Returns the number of bytes consumed by the node.
+  int64_t bytes_consumed() const TF_LOCKS_EXCLUDED(mu_) {
+    return bytes_consumed_;
+  }
+
+  // Returns the number of bytes produced by the node.
+  int64_t bytes_produced() const TF_LOCKS_EXCLUDED(mu_) {
+    return bytes_produced_;
+  }
+
+  // Indicates whether the node has tunable parameters.
+  bool has_tunable_parameters() const TF_LOCKS_EXCLUDED(mu_) {
+    tf_shared_lock l(mu_);
+    for (const auto& pair : parameters_) {
+      if (pair.second->state->tunable) return true;
+    }
+    return false;
+  }
+
+  // Returns the unique node ID.
+  int64_t id() const TF_LOCKS_EXCLUDED(mu_) { return id_; }
+
+  // Returns the node inputs.
+  std::list<std::shared_ptr<Node>> inputs() const TF_LOCKS_EXCLUDED(mu_) {
+    tf_shared_lock l(mu_);
+    return inputs_;
+  }
+
+  // Returns a longer node name that is guaranteed to be unique.
+  string long_name() const { return strings::StrCat(name_, "(id:", id_, ")"); }
+
+  // Returns the node name.
+  const string& name() const { return name_; }
+
+  // Returns the number of elements produced by the node.
+  int64_t num_elements() const TF_LOCKS_EXCLUDED(mu_) { return num_elements_; }
+
+  // Returns the node output.
+  Node* output() const { return output_; }
+  bool output_deleted() { return output_weak_ptr_.expired(); }
+
+  // Returns the parameter value.
+  double parameter_value(const string& name) const TF_LOCKS_EXCLUDED(mu_) {
+    tf_shared_lock l(mu_);
+    return parameters_.at(name)->state->value;
+  }
+
+  // Returns the aggregate processing time.
+  int64_t processing_time() const TF_LOCKS_EXCLUDED(mu_) {
+    return processing_time_;
+  }
+
+  // Records that the node consumed the given number of bytes.
+  void record_bytes_consumed(int64_t num_bytes) {
+    bytes_consumed_ += num_bytes;
+  }
+
+  // Records that the node produced the given number of bytes.
+  void record_bytes_produced(int64_t num_bytes) {
+    bytes_produced_ += num_bytes;
+  }
+
+  // Records the change in this node's buffer.
+  void record_buffer_event(int64_t bytes_delta, int64_t elements_delta) {
+    buffered_bytes_ += bytes_delta;
+    peak_buffered_bytes_.store(std::max(peak_buffered_bytes_, buffered_bytes_));
+    buffered_elements_ += elements_delta;
+    // There is no need to maintain watermarks for synchronous ops because we
+    // will not upsize or downsize the buffers of synchronous ops.
+    if (IsAsync()) {
+      int64_t low_watermark =
+          std::min(buffered_elements_low_, buffered_elements_);
+      buffered_elements_low_ = low_watermark;
+      int64_t high_watermark =
+          std::max(buffered_elements_high_, buffered_elements_);
+      buffered_elements_high_ = high_watermark;
+    }
+  }
+
+  // Records that the node produced an element.
+  void record_element() TF_LOCKS_EXCLUDED(mu_) {
+    num_elements_++;
+    {
+      mutex_lock l(mu_);
+      UpdateProcessingTimeEma();
+    }
+  }
+
+  // Records that a node thread has started executing.
+  void record_start(int64_t time_nanos) TF_LOCKS_EXCLUDED(mu_) {
+    DCHECK_EQ(work_start_, 0);
+    work_start_ = time_nanos;
+  }
+
+  // Records that a node thread has stopped executing.
+  void record_stop(int64_t time_nanos) TF_LOCKS_EXCLUDED(mu_) {
+    // TODO(jsimsa): Use DCHECK_NE(work_start_, 0) here.
+    if (work_start_ != 0) {
+      processing_time_ += time_nanos - work_start_;
+      work_start_ = 0;
+    } else {
+      VLOG(1) << "Encountered a stop event without a matching start event.";
+    }
+  }
+
+  // Returns whether work is currently being recorded, i.e. whether we are
+  // currently between a `record_start` and a `record_stop`.
+  bool is_recording() TF_LOCKS_EXCLUDED(mu_) { return work_start_ > 0; }
+
+  // Removes an input.
+  void remove_input(std::shared_ptr<Node> input) TF_LOCKS_EXCLUDED(mu_) {
+    mutex_lock l(mu_);
+    inputs_.remove(input);
+  }
+
+  // Sets the value that determines whether autotuning is enabled for this node.
+  void set_autotune(bool autotune) TF_LOCKS_EXCLUDED(mu_) {
+    autotune_.store(autotune);
+  }
+
+  // Resets buffer watermarks to the current buffered elements.
+  void ResetBufferWatermarks() {
+    if (!IsAsync()) {
+      return;
+    }
+    int64_t current_buffer_size = buffered_elements_;
+    buffered_elements_low_ = current_buffer_size;
+    buffered_elements_high_ = current_buffer_size;
+  }
+
+  // Returns true for asynchronous nodes; false otherwise.
+  virtual bool IsAsync() const { return false; }
+
+  // Returns the ratio of the node, which is defined as the number of elements
+  // per input needed by the node to produce an element, e.g. batch size of a
+  // `Batch`. It can be 0 if the ratio is unknown.
+  virtual double Ratio() const { return 1.0; }
+
+  // Computes the self time in nanoseconds of the node to produce one element.
+  virtual double ComputeSelfTime() const;
+
+  // Returns the parameter value if it exists, not ok status otherwise.
+  StatusOr<double> ParameterValue(const std::string& parameter_name) const
+      TF_LOCKS_EXCLUDED(mu_) {
+    tf_shared_lock l(mu_);
+    if (parameters_.contains(parameter_name)) {
+      return parameters_.at(parameter_name)->value;
+    }
+    return errors::NotFound("Parameter ", parameter_name,
+                            " was not found in model node ", long_name());
+  }
+
+  // Given the average time between events when the elements in the buffer are
+  // produced (`producer_time`), the average time between events when elements
+  // in the buffer are consumed (`consumer_time`) and the buffer size, the
+  // method computes the expected time a consumer event will have to wait.
+  //
+  // The wait time is approximated as the product of the probability the buffer
+  // will be empty and the time it takes to produce an element into the buffer.
+  //
+  // The formula used for computing the probability is derived by modeling the
+  // problem as an M/M/1/K queue
+  // (https://en.wikipedia.org/wiki/Birth%E2%80%93death_process#M/M/1/K_queue).
+  //
+  // Collects derivatives of `ComputeWaitTime` w.r.t `producer_time`,
+  // `consumer_time' and `buffer_size` if the corresponding pointers are not
+  // `nullptr`.
+  static double ComputeWaitTime(double producer_time, double consumer_time,
+                                double buffer_size,
+                                double* producer_time_derivative,
+                                double* consumer_time_derivative,
+                                double* buffer_size_derivative);
+
+  // Collects tunable parameters in the subtree rooted in this node.
+  ModelParameters CollectTunableParameters() const TF_LOCKS_EXCLUDED(mu_);
+
+  // Collects tunable parameters in this node.
+  ModelParameters CollectNodeTunableParameters() const TF_LOCKS_EXCLUDED(mu_);
+
+  // Returns a human-readable representation of this node.
+  string DebugString() const TF_LOCKS_EXCLUDED(mu_);
+
+  // Flushes the metrics recorded by this node.
+  void FlushMetrics() TF_LOCKS_EXCLUDED(mu_);
+
+  // Returns the per-element output time for this node and if `gradients` is not
+  // `nullptr`, collects the output time gradient w.r.t. tunable parameters of
+  // the subtree rooted in this node.
+  double OutputTime(NodeValues* input_times,
+                    ParameterGradients* gradients) const TF_LOCKS_EXCLUDED(mu_);
+
+  // Returns a copy of this node, making a deep copy of its inputs and a
+  // shallow copy of its tunable parameters.
+  //
+  // The purpose for this method is to allow the model optimization logic to
+  // operate over immutable state while allowing concurrent model updates.
+  std::shared_ptr<Node> Snapshot() const TF_LOCKS_EXCLUDED(mu_);
+
+  // Returns the per-element processing time in nanoseconds spent in this node.
+  double SelfProcessingTime() const TF_LOCKS_EXCLUDED(mu_);
+
+  // Returns the total number of bytes buffered in all nodes in the subtree for
+  // which autotuning is enabled.
+  double TotalBufferedBytes() const TF_LOCKS_EXCLUDED(mu_);
+
+  // Collects the total buffer limit of all nodes in the subtree for which
+  // autotuning is enabled. This number represents the amount of memory that
+  // would be used by the subtree nodes if all of their buffers were full.
+  double TotalMaximumBufferedBytes() const TF_LOCKS_EXCLUDED(mu_);
+
+  // Returns the per-element CPU time in nanoseconds spent in the subtree rooted
+  // in this node. If `processing_times` is not `nullptr`, collects the
+  // per-element CPU time spent in each node of the subtree.
+  double TotalProcessingTime(NodeValues* processing_times)
+      TF_LOCKS_EXCLUDED(mu_);
+
+  // Produces a proto for this node. Does not produce a proto for input nodes.
+  virtual Status ToProto(ModelProto::Node* node_proto) const;
+
+  // Restores a node from the proto. Does not restore input nodes.
+  static Status FromProto(ModelProto::Node node_proto,
+                          std::shared_ptr<Node> output,
+                          std::shared_ptr<Node>* node);
+
+  // Returns a vector of nodes of the subtree rooted in this node. The nodes are
+  // either in breadth-first search or reverse breadth-first search order
+  // depending on the `order` argument. The nodes are collected based on the
+  // results of the `collect_node` predicate: if the predicate returns `false`
+  // for a given node, then the subtree rooted in this node is excluded. The
+  // root node itself is not collected.
+  NodeVector CollectNodes(TraversalOrder order,
+                          bool collect_node(const std::shared_ptr<Node>)) const
+      TF_LOCKS_EXCLUDED(mu_);
+
+  // Downsizes buffer parameters of this node. Returns true if any buffer is
+  // downsized.
+  bool TryDownsizeBuffer();
+
+  // Collects buffer parameters of this node that should be upsized.
+  void CollectBufferParametersToUpsize(
+      absl::flat_hash_map<Node*, Parameter*>& node_parameters);
+
+  // Returns the average size of an element buffered in this node.
+  double AverageBufferedElementSize() const {
+    tf_shared_lock l(mu_);
+    return AverageBufferedElementSizeLocked();
+  }
+
+ protected:
+  // Used for (incrementally) recording metrics. The class is thread-safe.
+  class Metrics {
+   public:
+    explicit Metrics(const string& name)
+        : bytes_consumed_counter_(metrics::GetTFDataBytesConsumedCounter(name)),
+          bytes_produced_counter_(metrics::GetTFDataBytesProducedCounter(name)),
+          num_elements_counter_(metrics::GetTFDataElementsCounter(name)),
+          recorded_bytes_consumed_(0),
+          recorded_bytes_produced_(0),
+          recorded_num_elements_(0) {}
+
+    // Expects the total number of bytes consumed and records the delta since
+    // last invocation.
+    void record_bytes_consumed(int64_t total_bytes) {
+      int64_t delta =
+          total_bytes - recorded_bytes_consumed_.exchange(total_bytes);
+      bytes_consumed_counter_->IncrementBy(delta);
+    }
+
+    // Expects the total number of bytes produced and records the delta since
+    // last invocation.
+    void record_bytes_produced(int64_t total_bytes) {
+      int64_t delta =
+          total_bytes - recorded_bytes_produced_.exchange(total_bytes);
+      bytes_produced_counter_->IncrementBy(delta);
+    }
+
+    // Expects the total number of elements produced and records the delta since
+    // last invocation.
+    void record_num_elements(int64_t total_elements) {
+      int64_t delta =
+          total_elements - recorded_num_elements_.exchange(total_elements);
+      num_elements_counter_->IncrementBy(delta);
+    }
+
+   private:
+    monitoring::CounterCell* const bytes_consumed_counter_;
+    monitoring::CounterCell* const bytes_produced_counter_;
+    monitoring::CounterCell* const num_elements_counter_;
+    std::atomic<int64_t> recorded_bytes_consumed_;
+    std::atomic<int64_t> recorded_bytes_produced_;
+    std::atomic<int64_t> recorded_num_elements_;
+  };
+
+  // Computes the exponential moving average of processing time per element.
+  void UpdateProcessingTimeEma() TF_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
+    if (previous_processing_time_ == 0) {
+      if (num_elements_ > 0) {
+        processing_time_ema_ =
+            static_cast<double>(processing_time_) /
+            static_cast<double>(num_elements_ + buffered_elements_);
+      } else {
+        processing_time_ema_ = static_cast<double>(processing_time_);
+      }
+    } else {
+      processing_time_ema_ =
+          (1.0 - kProcessingTimeEmaWeight) * processing_time_ema_ +
+          kProcessingTimeEmaWeight *
+              static_cast<double>(processing_time_ - previous_processing_time_);
+    }
+    previous_processing_time_ = processing_time_;
+  }
+
+  // Returns the number of inputs.
+  int64_t num_inputs() const TF_SHARED_LOCKS_REQUIRED(mu_) {
+    int64_t num_inputs = 0;
+    for (auto& input : inputs_) {
+      // Inputs for which autotuning is disabled are excluded.
+      if (input->autotune()) {
+        ++num_inputs;
+      }
+    }
+    return num_inputs;
+  }
+
+  // Creates a clone of this node.
+  virtual std::shared_ptr<Node> Clone(std::shared_ptr<Node> output) const
+      TF_SHARED_LOCKS_REQUIRED(mu_) = 0;
+
+  // Returns the average size of an element buffered in this node.
+  double AverageBufferedElementSizeLocked() const TF_SHARED_LOCKS_REQUIRED(mu_);
+
+  // Returns the sum of per-element output time for the tunable inputs of this
+  // node.
+  double OutputTimeForInputs(const NodeValues& output_times) const
+      TF_SHARED_LOCKS_REQUIRED(mu_);
+
+  // Returns the sum of output time gradient w.r.t. input time for the tunable
+  // inputs of this node.
+  double OutputTimeGradientsForInputs(const NodeValues& output_time_gradients)
+      const TF_SHARED_LOCKS_REQUIRED(mu_);
+
+  // Computes the input time for this node and stores it in `input_times`.
+  virtual void InputTimeLocked(NodeValues* input_times) const
+      TF_SHARED_LOCKS_REQUIRED(mu_) = 0;
+
+  // Computes the per-element output time for this node and stores it in
+  // `output_times`. If `gradients` is not `nullptr`, computes the output time
+  // gradient w.r.t. tunable parameters of the subtree rooted in this node and
+  // stores it in `gradients`, also computes the output time gradient w.r.t.
+  // input time and stores it in `output_time_gradients`.
+  virtual void OutputTimeLocked(const NodeValues& input_times,
+                                ParameterGradients* gradients,
+                                NodeValues* output_times,
+                                NodeValues* output_time_gradients) const
+      TF_SHARED_LOCKS_REQUIRED(mu_) = 0;
+
+  // Returns the sum of per-element processing time for the inputs of this node
+  // by adding values for input nodes in `total_processing_times`. Processing
+  // time for a given input is a weighted combination of a statistic based on
+  // history of input processing time and the actual time. This is done to
+  // improve accuracy of processing time estimation for newly created inputs.
+  //
+  // Uniform distribution of per-element processing times across different
+  // inputs is assumed.
+  double TotalProcessingTimeForInputs(const NodeValues& total_processing_times)
+      TF_SHARED_LOCKS_REQUIRED(mu_);
+
+  // Returns the per-element processing time spent in this node.
+  double SelfProcessingTimeLocked() const TF_SHARED_LOCKS_REQUIRED(mu_);
+
+  // Computes the per-element CPU time spent in the subtree rooted in this node
+  // and stores it in `total_processing_times`. If `processing_times` is not
+  // `nullptr`, collects the per-element CPU time spent in each node of the
+  // subtree.
+  virtual void TotalProcessingTimeLocked(NodeValues* processing_times,
+                                         NodeValues* total_processing_times)
+      TF_SHARED_LOCKS_REQUIRED(mu_) = 0;
+
+  // This is the locked version of the public `CollectNodes`.
+  NodeVector CollectNodesLocked(TraversalOrder order,
+                                bool collect_node(const std::shared_ptr<Node>))
+      const TF_SHARED_LOCKS_REQUIRED(mu_);
+
+  // Collects tunable parameters in the subtree rooted in this node assuming
+  // mutex locked.
+  ModelParameters CollectTunableParametersLocked() const
+      TF_SHARED_LOCKS_REQUIRED(mu_);
+
+  // Collect tunable parameters on the nodes which have recorded
+  // elements.
+  void CollectTunableParametersHelper(ModelParameters* parameters) const
+      TF_SHARED_LOCKS_REQUIRED(mu_);
+
+  // Build up debug string for the node and store in the debug strings map.
+  void DebugStringHelper(absl::flat_hash_map<string, string>* debug_strings)
+      const TF_SHARED_LOCKS_REQUIRED(mu_);
+
+  // Copy the node and add the (input, copy) pairs to the NodePairList.
+  std::shared_ptr<Node> SnapshotHelper(std::shared_ptr<Node> cloned_output,
+                                       NodePairList* node_pairs) const;
+
+  // Compute total buffered bytes for the node and store in the total bytes map.
+  void TotalBufferedBytesHelper(NodeValues* total_bytes) const
+      TF_SHARED_LOCKS_REQUIRED(mu_);
+
+  // Compute total maximum buffered bytes for the node and store in the total
+  // bytes map.
+  void TotalMaximumBufferedBytesHelper(NodeValues* total_bytes) const
+      TF_SHARED_LOCKS_REQUIRED(mu_);
+
+  // Compute and return the maximum buffered bytes on the node itself. By
+  // default non-tunable nodes are assumed not to buffer any bytes, so the
+  // tunable nodes as subclasses are expected to override this method to ensure
+  // that the optimization algorithm respects the memory budget.
+  virtual double MaximumBufferedBytes() const TF_SHARED_LOCKS_REQUIRED(mu_);
+
+  // Restores node from the proto. Note that this is not done recursively, i.e.
+  // input nodes are not restored.
+  static Status FromProtoHelper(ModelProto::Node node_proto,
+                                std::shared_ptr<Node> node);
+
+  // Stores the time passed to the last call to `Node::record_start()` on the
+  // current thread.
+  //
+  // NOTE: This thread-local variable is shared between all instances of `Node`
+  // on which the same thread calls `record_start()` or `record_stop()`. It
+  // relies on the invariant that at most one `Node` can be "active" on a
+  // particular thread at any time. Therefore if `n->record_start()` is called
+  // on thread `t`, then `n->record_stop()` must be called before another call
+  // to `Node::record_start()` (for any node).
+  static thread_local int64_t work_start_;  // Will be initialized to zero.
+
+  mutable mutex mu_;
+  const int64_t id_;
+  const string name_;
+
+  // Indicates whether the subtree rooted in this node should be included in
+  // autotuning. In particular, if this is `false`, then the subtree is excluded
+  // from computation of output time and processing time.
+  std::atomic<bool> autotune_;
+  std::atomic<int64_t> buffered_bytes_;
+  std::atomic<int64_t> peak_buffered_bytes_;
+  std::atomic<int64_t> buffered_elements_;
+  std::atomic<int64_t> buffered_elements_low_;
+  std::atomic<int64_t> buffered_elements_high_;
+  std::atomic<int64_t> bytes_consumed_;
+  std::atomic<int64_t> bytes_produced_;
+  std::atomic<int64_t> num_elements_;
+  std::atomic<int64_t> processing_time_;
+  std::atomic<bool> record_metrics_;
+  Metrics metrics_;
+  absl::flat_hash_map<string, std::shared_ptr<Parameter>> parameters_
+      TF_GUARDED_BY(mu_);
+
+  // Statistic of inputs processing time history.
+  double input_processing_time_sum_ = 0.0L;
+  int64_t input_processing_time_count_ = 0;
+
+  // Holds the previous processing time and the per element processing time
+  // exponential moving average.
+  int64_t previous_processing_time_ TF_GUARDED_BY(mu_) = 0;
+  double processing_time_ema_ TF_GUARDED_BY(mu_) = 0.0;
+
+  // Inputs of this node. These can represent an iterator created from the input
+  // dataset but also other input iterators (e.g. created by the user-defined
+  // functions of `flat_map` or `interleave`).
+  std::list<std::shared_ptr<Node>> inputs_ TF_GUARDED_BY(mu_);
+
+  // The reference to the output node is not owned so that deletion of a
+  // node results in recursive deletion of the subtree rooted in the node.
+  Node* const output_;
+  std::weak_ptr<Node> output_weak_ptr_;
+};
+
+// InterleaveMany is used to model datasets whose inputs are used to create
+// datasets whose elements are then interleaved.
+std::shared_ptr<Node> MakeInterleaveManyNode(
+    Node::Args args, std::vector<std::shared_ptr<Parameter>> parameters);
+
+// AsyncInterleaveMany nodes are the asynchronous version of InterleaveMany
+// nodes.
+std::shared_ptr<Node> MakeAsyncInterleaveManyNode(
+    Node::Args args, std::vector<std::shared_ptr<Parameter>> parameters);
+
+// KnownMany nodes model datasets that synchronously consume known number of
+// input element per output element.
+std::shared_ptr<Node> MakeKnownRatioNode(Node::Args args, double ratio);
+
+// AsyncKnownRatio nodes are the asynchronous version of KnownRate nodes.
+std::shared_ptr<Node> MakeAsyncKnownRatioNode(
+    Node::Args args, double ratio, double memory_ratio,
+    std::vector<std::shared_ptr<Parameter>> parameters,
+    bool is_legacy_prefetch_autotuned = false);
+
+std::shared_ptr<Node> MakeAsyncKnownRatioNode(
+    Node::Args args, double ratio,
+    std::vector<std::shared_ptr<Parameter>> parameters,
+    bool is_legacy_prefetch_autotuned = false);
+
+// Source nodes represent data sources.
+std::shared_ptr<Node> MakeSourceNode(Node::Args args);
+
+// UnknownMany nodes represent datasets that synchronously consume an
+// unknown number of input elements per output.
+//
+// Unlike KnownRatio nodes which expect the ratio between inputs and outputs is
+// specified as a parameter, UnknownRatio estimates the ratio empirically.
+std::shared_ptr<Node> MakeUnknownRatioNode(Node::Args args);
+
+// AsyncUnknownRatio nodes are the asynchronous version of unknown ratio nodes.
+std::shared_ptr<Node> MakeAsyncUnknownRatioNode(
+    Node::Args args, std::vector<std::shared_ptr<Parameter>> parameters);
+
+// Unknown nodes represent datasets for which we do not have a model. It acts
+// as pass-through between inputs and output.
+std::shared_ptr<Node> MakeUnknownNode(Node::Args args);
+
+// Abstract representation of a TensorFlow input pipeline that can be used
+// for collecting runtime information and optimizing performance. It collects
+// runtime information about execution of the input pipeline that is used to
+// create a performance model, which is in turn used to identify optimal values
+// of tunable parameters.
+//
+// Developers of tf.data transformations are not expected to interact with this
+// class directly. Boiler plate code for creating the abstract representation of
+// the input pipeline and collecting runtime information has been added to the
+// implementation of `DatasetBase` and `DatasetBaseIterator` respectively.
+//
+// The order of locks acquired is SharedState lock, Model lock, Node lock.
+// SharedState lock is acquired first because it shares the same lock as the
+// dataset iterator that contains it.
+class Model {
+ public:
+  using OptimizationParams = ModelProto::OptimizationParams;
+  using ModelParameters = Node::ModelParameters;
+  using NodeValues = Node::NodeValues;
+  using ParameterGradients = Node::ParameterGradients;
+
+  Model();
+  ~Model();
+
+  // Returns a pointer to the model's output node.
+  std::shared_ptr<Node> output() const {
+    mutex_lock l(mu_);
+    return output_;
+  }
+
+  // Set the experiment that this job is part of.
+  void AddExperiment(const std::string& experiment) {
+    experiments_.insert(experiment);
+  }
+
+  // Adds a node with the given name and given parent.
+  void AddNode(Node::Factory factory, const string& name,
+               std::shared_ptr<Node> parent, std::shared_ptr<Node>* out_node)
+      TF_LOCKS_EXCLUDED(mu_);
+
+  // Returns a human-readable string representation of the model. This method
+  // can be invoked automatically by monitoring gauges and to avoid frequent
+  // recomputation, the implementation caches the result.
+  std::string DebugString();
+
+  // Uses the given algorithm and resource budgets to periodically perform the
+  // autotuning optimization.
+  //
+  // `cpu_budget_func` can be used to provide the optimizer with up-to-date
+  // values in cases where CPUs budgets may be changed by the runtime
+  // dynamically.
+  //
+  // `ram_budget_func` is similar to `cpu_budget_func`. This lambda takes a
+  // parameter that is the total number of bytes currently buffered by the
+  // model.
+  //
+  // To terminate the execution of the optimization loop, the caller needs to
+  // invoke `cancellation_mgr->StartCancel()`.
+  Status OptimizeLoop(AutotuneAlgorithm algorithm,
+                      std::function<int64_t()> cpu_budget_func,
+                      std::function<int64_t(int64_t)> ram_budget_func,
+                      RamBudgetManager& ram_budget_manager,
+                      CancellationManager* cancellation_manager);
+
+  // Uses the given algorithm and resource budgets to perform the autotuning
+  // optimization.
+  void Optimize(AutotuneAlgorithm algorithm,
+                std::function<int64_t()> cpu_budget_func,
+                std::function<int64_t(int64_t)> ram_budget_func,
+                double model_input_time, RamBudgetManager& ram_budget_manager,
+                CancellationManager* cancellation_manager);
+
+  // Optimizes buffers in the pipeline rooted at `snapshot`. It downsizes
+  // buffers that are too large and upsizes buffers that are too small while
+  // respecting the ram budget. If any node is downsized or upsized, the
+  // watermarks of all nodes are reset to the buffered elements.
+  void OptimizeBuffers(std::shared_ptr<Node> snapshot, int64_t ram_budget);
+
+  // Collects the output time and if `gradients` is not `nullptr`, the output
+  // time gradient w.r.t. tunable parameters of the subtree rooted in the given
+  // node.
+  double OutputTime(std::shared_ptr<Node> node, double model_input_time,
+                    ParameterGradients* gradients);
+
+  // Removes the given node.
+  void RemoveNode(std::shared_ptr<Node> node) TF_LOCKS_EXCLUDED(mu_);
+
+  // Produces a proto for this model.
+  Status ToProto(ModelProto* model_proto);
+
+  // Restores a model from the proto.
+  static Status FromProto(ModelProto model_proto,
+                          std::unique_ptr<Model>* model);
+
+  // Saves this model with a given snapshot and its optimization parameters to a
+  // file. Note that the file directory must already exist.
+  Status Save(const string& fname, std::shared_ptr<Node> snapshot,
+              const OptimizationParams& optimization_params);
+
+  // Loads a model and its optimization parameters from a file with the given
+  // name.
+  static Status Load(const string& fname, std::unique_ptr<Model>* model,
+                     OptimizationParams* optimization_params);
+
+  // Records gap time between consecutive `GetNext()` calls.
+  void RecordIteratorGapTime(uint64_t duration_usec);
+
+  // Computes the target time in nsecs to use for `STAGE_BASED` autotune
+  // algorithm. Returns 0 if there if there are not sufficient recorded iterator
+  // gap times to produce a good estimate.
+  double ComputeTargetTimeNsec();
+
+  // Computes the target time in nsecs to use for estimating input bottlenecks.
+  // Returns 0 if there are not sufficient recorded iterator gap times to
+  // produce a good estimate.
+  double ComputeExperimentalTargetTimeNsec();
+
+  // Returns the time in nanoseconds it takes the pipeline to produce an
+  // element, according to the latest model snapshot obtained from optimization.
+  // Returns 0 if the model snapshot is empty or null. This may be caused by not
+  // having executed an optimization round before.
+  double ComputeSnapshotProcessingTimeNsec() const;
+
+ private:
+  // Determines whether optimization should stop given total processing time,
+  // estimated output time, and estimated number of buffers bytes.
+  using StopPredicate =
+      std::function<bool(const ModelParameters&, double, double, double)>;
+
+  static constexpr int64_t kOptimizationPeriodMinMs = 10;
+  static constexpr int64_t kOptimizationPeriodMaxMs =
+      60 * EnvTime::kSecondsToMillis;
+
+  // Collects tunable parameters in the tree rooted in the given node, returning
+  // a vector which contains pairs of node names and tunable parameters.
+  ModelParameters CollectTunableParameters(std::shared_ptr<Node> node);
+
+  // Copy parameter state values to parameter values if necessary.For some
+  // nodes, the parameter state values are not tuned by Autotune and hence the
+  // parameter values can be stale. We do not sync all parameters because it may
+  // increase mutex contention with `GetNext()`.
+  void MaybeSyncStateValuesToValues(ModelParameters* parameters);
+
+  // Downsizes buffers that are too large for all nodes rooted at `snapshot`.
+  // Returns true if any buffer is downsized.
+  bool DownsizeBuffers(std::shared_ptr<Node> snapshot);
+
+  // Upsizes buffers that are too small for all nodes rooted at `snapshot` while
+  // respecting the ram budget. Returns true if any buffer is upsized.
+  bool UpsizeBuffers(std::shared_ptr<Node> snapshot, int64_t ram_budget);
+
+  // Reset buffer watermarks of all asynchronous nodes to their buffered
+  // elements.
+  void ResetBufferWatermarks();
+
+  // Collects buffer parameters of all nodes in the model that should be
+  // upsized.
+  absl::flat_hash_map<Node*, Parameter*> CollectBufferParametersToUpsize(
+      std::shared_ptr<Node> snapshot);
+
+  // Flushes metrics recorded by the model.
+  void FlushMetrics() TF_LOCKS_EXCLUDED(mu_);
+
+  // This optimization algorithm starts by setting all tunable parallelism
+  // parameters to the minimum value. It then improves current parameters by
+  // making a step in the direction opposite to the gradient of `OutputTime` and
+  // projecting resulting values on the feasible intervals. Improvement step is
+  // repeated until either the output time improvement is smaller than threshold
+  // value or the output time is less than the processing time needed to produce
+  // an element divided by CPU budget.
+  void OptimizeGradientDescent(std::shared_ptr<Node> snapshot,
+                               const OptimizationParams& optimization_params,
+                               CancellationManager* cancellation_manager);
+
+  // Helper method for implementing hill-climb optimization that can be
+  // parametrized by a predicate to use for stopping the optimization.
+  void OptimizeHillClimbHelper(std::shared_ptr<Node> snapshot,
+                               const OptimizationParams& optimization_params,
+                               CancellationManager* cancellation_manager,
+                               int64_t ram_budget,
+                               RamBudgetManager& ram_budget_manager,
+                               StopPredicate should_stop);
+
+  // This optimization algorithm starts by setting all tunable parallelism
+  // parameters to the minimum value. It then repeatedly identifies the
+  // parameter whose increase in parallelism decreases the output time the most.
+  // This process is repeated until all parameters reach their maximum values or
+  // the projected output time is less than or equal to the processing time
+  // needed to produce an element divided by CPU budget.
+  void OptimizeHillClimb(std::shared_ptr<Node> snapshot,
+                         const OptimizationParams& optimization_params,
+                         CancellationManager* cancellation_manager,
+                         RamBudgetManager& ram_budget_manager);
+
+  // This optimization behaves similarly to the hill climb optimization but uses
+  // a relaxed stoping condition, allowing the optimization to oversubscribe
+  // CPU.
+  void OptimizeMaxParallelism(std::shared_ptr<Node> snapshot,
+                              const OptimizationParams& optimization_params,
+                              CancellationManager* cancellation_manager,
+                              RamBudgetManager& ram_budget_manager);
+
+  // This optimization starts by setting all tunable parallelism parameters to
+  // their minimum values. It then repeatedly increases the parallelism
+  // parameter of the longest stage by 1 until either the longest stage is
+  // faster than the target time or the memory or CPU budget is fully utilized.
+  // TODO(b/226910071): The second part of this algorithm optimizes the buffer
+  // sizes of parallel ops.
+  void OptimizeStageBased(std::shared_ptr<Node> snapshot,
+                          const OptimizationParams& optimization_params,
+                          CancellationManager* cancellation_manager,
+                          RamBudgetManager& ram_budget_manager);
+
+  // This is the first part of the stage-based optimization that optimizes
+  // tunable parallelism parameters for async interleave many nodes only. We
+  // separately optimize async interleave many nodes more aggressively because
+  // the variance of IO is difficult to predict.
+  void OptimizeStageBasedAsyncInterleaveManyNodes(
+      std::shared_ptr<Node> snapshot,
+      const OptimizationParams& optimization_params,
+      CancellationManager* cancellation_manager,
+      RamBudgetManager& ram_budget_manager);
+
+  // This is the second part of the stage-based optimization that optimizes
+  // tunable parallelism parameters for all nodes other than async interleave
+  // many nodes.
+  void OptimizeStageBasedNonAsyncInterleaveManyNodes(
+      std::shared_ptr<Node> snapshot, double target_time_nsec,
+      const OptimizationParams& optimization_params,
+      CancellationManager* cancellation_manager,
+      RamBudgetManager& ram_budget_manager);
+
+  // Determines if we should stop the gradient descent optimization iterations
+  // based on number of increasable parameters, CPU budget, RAM budget and
+  // current resource usage.
+  bool ShouldStop(int64_t cpu_budget, int64_t ram_budget,
+                  const ModelParameters& parameters,
+                  const ModelParameters& parallelism_parameters,
+                  const ModelParameters& buffer_size_parameters,
+                  std::shared_ptr<Node> snapshot, bool* cpu_budget_reached);
+
+  // Collects the processing time for the given node.
+  double TotalProcessingTime(std::shared_ptr<Node> node);
+
+  // Collects the total number of bytes buffered in all nodes in the subtree
+  // rooted in the given node for which autotuning is enabled.
+  double TotalBufferedBytes(std::shared_ptr<Node> node);
+
+  // Collects the total buffer limit of all nodes in the subtree rooted in the
+  // given node for which autotuning is enabled. This number represents the
+  // amount of memory that would be used by the subtree nodes if all of their
+  // buffers were full.
+  double TotalMaximumBufferedBytes(std::shared_ptr<Node> node);
+
+  // Used for coordination between different input pipeline threads. Exclusive
+  // access is required only when adding or removing nodes. Concurrent access to
+  // existing nodes is protected by a node mutex.
+  mutable mutex mu_;
+  // Used for coordinating the optimization loop and model modifications.
+  condition_variable optimize_cond_var_;
+  int64_t id_counter_ TF_GUARDED_BY(mu_) = 1;
+  std::shared_ptr<Node> output_ TF_GUARDED_BY(mu_) = nullptr;
+
+  // Determines the time the optimization loop should wait between
+  // running optimizations.
+  int64_t optimization_period_ms_ TF_GUARDED_BY(mu_);
+
+  // Gauge cell that can be used to collect the state of the model.
+  monitoring::GaugeCell<std::function<std::string()>>* model_gauge_cell_ =
+      nullptr;
+  // Used to synchronize metrics collection attempts against the model's
+  // destruction.
+  struct GuardedBool {
+    explicit GuardedBool(bool val) : val(val) {}
+    bool val TF_GUARDED_BY(mu);
+    mutex mu;
+  };
+  std::shared_ptr<GuardedBool> safe_to_collect_metrics_;
+
+  // Time use for rate limitting the recomputation of human-readable string
+  // represention of the model.
+  absl::Time cache_until_ = absl::InfinitePast();
+  // Cached result of the `DebugString()` invocation used to implement rate
+  // limitting of the computation.
+  std::string cached_debug_string_ = "";
+  // Used to coordinate gap time updates between different threads. Gap time is
+  // the time between the completion of the previous `GetNext()` and the start
+  // of the next `GetNext()`.
+  mutable mutex gap_mu_;
+  // Stores the latest gap times between consecutive `GetNext()`.
+  std::deque<uint64_t> gap_times_usec_ TF_GUARDED_BY(gap_mu_);
+  // The experiment that this job is part of.
+  absl::flat_hash_set<std::string> experiments_;
+  // Stores the optimization snapshot of the Model.
+  std::shared_ptr<Node> snapshot_ TF_GUARDED_BY(mu_);
+  // Stores the optimization parameters used by autotune.
+  OptimizationParams optimization_params_ TF_GUARDED_BY(mu_);
+};
+
+// Class to compute timing information for a model.
+class ModelTiming {
+ public:
+  struct NodeTiming {
+    // Pipeline ratio is the number of elements this node needs to produce in
+    // order to produce an element at the root of the pipeline.
+    double pipeline_ratio = 0.0;
+    // The self time it takes this node to produce the elements needed to
+    // produce one element of the root of the pipeline.
+    double self_time_nsec = 0.0;
+    // The total time it takes this node and the subtree rooted at this node to
+    // produce the elements needed to produce one element at the root of the
+    // pipeline.
+    double total_time_nsec = 0.0;
+  };
+
+  explicit ModelTiming(std::shared_ptr<Node> root);
+
+  // Returns the timing data for `node`.
+  const NodeTiming* GetTiming(const Node* node) const;
+
+  // Returns the root nodes of all stages.
+  std::vector<std::shared_ptr<Node>> GetStageRoots() const;
+
+  // Returns all the nodes of a stage given the stage root.
+  std::vector<std::shared_ptr<Node>> GetStageNodes(
+      std::shared_ptr<Node> stage_root) const;
+
+  // Computes the total time for a node.
+  void ComputeNodeTotalTime(const Node& node);
+
+ private:
+  // Computes the pipeline ratios of all nodes.
+  void ComputePipelineRatios(const Node::NodeVector& bfs_nodes);
+
+  // Computes the total time for all nodes. The `reverse_bfs_nodes` are assumed
+  // to be a vector of model nodes in reversed BFS manner.
+  void ComputeTotalTimes(const Node::NodeVector& reverse_bfs_nodes);
+
+  // Computes the first input total time of an interleave node.
+  double ComputeInterleaveManyFirstInputTotalTime(const Node& node);
+
+  // Computes the total time of a node of any type other than async interleave.
+  void ComputeNonAsyncInterleaveManyTotalTime(const Node& node);
+
+  // Computes the total time of an async interleave node.
+  void ComputeAsyncInterleaveManyTotalTime(const Node& node);
+  // Computes the interleaved inputs' total time of an async interleave node.
+  double ComputeAsyncInterleaveManyInterleavedInputsTotalTime(const Node& node);
+
+  // Returns a vector of all nodes in the model. The nodes are either in
+  // breadth-first search or reverse breadth-first search order depending on the
+  // `order` argument. The nodes are collected based on the results of the
+  // `collect_node` predicate: if the predicate returns `false` for a given
+  // node, then the subtree rooted in this node is excluded. The root node
+  // itself is not collected.
+  Node::NodeVector CollectNodes(
+      std::shared_ptr<Node> root, TraversalOrder order,
+      bool collect_node(const std::shared_ptr<Node>)) const;
+
+  // Stores a pointer to the root of a model.
+  std::shared_ptr<Node> root_;
+
+  // Holds a mapping from node to its timing node.
+  absl::flat_hash_map<const Node*, NodeTiming> timing_nodes_;
+};
+
+}  // namespace model
+}  // namespace data
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_MODEL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/model.pb.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/model.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..22e9ea0cacca15ed4906f03232c418ed23830f6d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/model.pb.h
@@ -0,0 +1,2054 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: tensorflow/core/framework/model.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fmodel_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fmodel_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3021000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3021009 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/map.h>  // IWYU pragma: export
+#include <google/protobuf/map_entry.h>
+#include <google/protobuf/map_field_inl.h>
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_tensorflow_2fcore_2fframework_2fmodel_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_tensorflow_2fcore_2fframework_2fmodel_2eproto {
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_tensorflow_2fcore_2fframework_2fmodel_2eproto;
+namespace tensorflow {
+namespace data {
+namespace model {
+class ModelProto;
+struct ModelProtoDefaultTypeInternal;
+extern ModelProtoDefaultTypeInternal _ModelProto_default_instance_;
+class ModelProto_Node;
+struct ModelProto_NodeDefaultTypeInternal;
+extern ModelProto_NodeDefaultTypeInternal _ModelProto_Node_default_instance_;
+class ModelProto_Node_Parameter;
+struct ModelProto_Node_ParameterDefaultTypeInternal;
+extern ModelProto_Node_ParameterDefaultTypeInternal _ModelProto_Node_Parameter_default_instance_;
+class ModelProto_NodesEntry_DoNotUse;
+struct ModelProto_NodesEntry_DoNotUseDefaultTypeInternal;
+extern ModelProto_NodesEntry_DoNotUseDefaultTypeInternal _ModelProto_NodesEntry_DoNotUse_default_instance_;
+class ModelProto_OptimizationParams;
+struct ModelProto_OptimizationParamsDefaultTypeInternal;
+extern ModelProto_OptimizationParamsDefaultTypeInternal _ModelProto_OptimizationParams_default_instance_;
+}  // namespace model
+}  // namespace data
+}  // namespace tensorflow
+PROTOBUF_NAMESPACE_OPEN
+template<> ::tensorflow::data::model::ModelProto* Arena::CreateMaybeMessage<::tensorflow::data::model::ModelProto>(Arena*);
+template<> ::tensorflow::data::model::ModelProto_Node* Arena::CreateMaybeMessage<::tensorflow::data::model::ModelProto_Node>(Arena*);
+template<> ::tensorflow::data::model::ModelProto_Node_Parameter* Arena::CreateMaybeMessage<::tensorflow::data::model::ModelProto_Node_Parameter>(Arena*);
+template<> ::tensorflow::data::model::ModelProto_NodesEntry_DoNotUse* Arena::CreateMaybeMessage<::tensorflow::data::model::ModelProto_NodesEntry_DoNotUse>(Arena*);
+template<> ::tensorflow::data::model::ModelProto_OptimizationParams* Arena::CreateMaybeMessage<::tensorflow::data::model::ModelProto_OptimizationParams>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace tensorflow {
+namespace data {
+namespace model {
+
+enum NodeClass : int {
+  UNKNOWN = 0,
+  INTERLEAVE_MANY = 1,
+  ASYNC_INTERLEAVE_MANY = 2,
+  KNOWN_RATIO = 3,
+  ASYNC_KNOWN_RATIO = 4,
+  UNKNOWN_RATIO = 5,
+  ASYNC_UNKNOWN_RATIO = 6,
+  NodeClass_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
+  NodeClass_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
+};
+bool NodeClass_IsValid(int value);
+constexpr NodeClass NodeClass_MIN = UNKNOWN;
+constexpr NodeClass NodeClass_MAX = ASYNC_UNKNOWN_RATIO;
+constexpr int NodeClass_ARRAYSIZE = NodeClass_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* NodeClass_descriptor();
+template<typename T>
+inline const std::string& NodeClass_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, NodeClass>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function NodeClass_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    NodeClass_descriptor(), enum_t_value);
+}
+inline bool NodeClass_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, NodeClass* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<NodeClass>(
+    NodeClass_descriptor(), name, value);
+}
+enum AutotuneAlgorithm : int {
+  DEFAULT = 0,
+  HILL_CLIMB = 1,
+  GRADIENT_DESCENT = 2,
+  MAX_PARALLELISM = 3,
+  STAGE_BASED = 4,
+  AutotuneAlgorithm_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
+  AutotuneAlgorithm_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
+};
+bool AutotuneAlgorithm_IsValid(int value);
+constexpr AutotuneAlgorithm AutotuneAlgorithm_MIN = DEFAULT;
+constexpr AutotuneAlgorithm AutotuneAlgorithm_MAX = STAGE_BASED;
+constexpr int AutotuneAlgorithm_ARRAYSIZE = AutotuneAlgorithm_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* AutotuneAlgorithm_descriptor();
+template<typename T>
+inline const std::string& AutotuneAlgorithm_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, AutotuneAlgorithm>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function AutotuneAlgorithm_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    AutotuneAlgorithm_descriptor(), enum_t_value);
+}
+inline bool AutotuneAlgorithm_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, AutotuneAlgorithm* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<AutotuneAlgorithm>(
+    AutotuneAlgorithm_descriptor(), name, value);
+}
+// ===================================================================
+
+class ModelProto_Node_Parameter final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.data.model.ModelProto.Node.Parameter) */ {
+ public:
+  inline ModelProto_Node_Parameter() : ModelProto_Node_Parameter(nullptr) {}
+  ~ModelProto_Node_Parameter() override;
+  explicit PROTOBUF_CONSTEXPR ModelProto_Node_Parameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ModelProto_Node_Parameter(const ModelProto_Node_Parameter& from);
+  ModelProto_Node_Parameter(ModelProto_Node_Parameter&& from) noexcept
+    : ModelProto_Node_Parameter() {
+    *this = ::std::move(from);
+  }
+
+  inline ModelProto_Node_Parameter& operator=(const ModelProto_Node_Parameter& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ModelProto_Node_Parameter& operator=(ModelProto_Node_Parameter&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ModelProto_Node_Parameter& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ModelProto_Node_Parameter* internal_default_instance() {
+    return reinterpret_cast<const ModelProto_Node_Parameter*>(
+               &_ModelProto_Node_Parameter_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(ModelProto_Node_Parameter& a, ModelProto_Node_Parameter& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ModelProto_Node_Parameter* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ModelProto_Node_Parameter* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ModelProto_Node_Parameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ModelProto_Node_Parameter>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ModelProto_Node_Parameter& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const ModelProto_Node_Parameter& from) {
+    ModelProto_Node_Parameter::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ModelProto_Node_Parameter* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.data.model.ModelProto.Node.Parameter";
+  }
+  protected:
+  explicit ModelProto_Node_Parameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNameFieldNumber = 1,
+    kValueFieldNumber = 2,
+    kStateValueFieldNumber = 3,
+    kMinFieldNumber = 4,
+    kMaxFieldNumber = 5,
+    kTunableFieldNumber = 6,
+  };
+  // string name = 1;
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // double value = 2;
+  void clear_value();
+  double value() const;
+  void set_value(double value);
+  private:
+  double _internal_value() const;
+  void _internal_set_value(double value);
+  public:
+
+  // double state_value = 3;
+  void clear_state_value();
+  double state_value() const;
+  void set_state_value(double value);
+  private:
+  double _internal_state_value() const;
+  void _internal_set_state_value(double value);
+  public:
+
+  // double min = 4;
+  void clear_min();
+  double min() const;
+  void set_min(double value);
+  private:
+  double _internal_min() const;
+  void _internal_set_min(double value);
+  public:
+
+  // double max = 5;
+  void clear_max();
+  double max() const;
+  void set_max(double value);
+  private:
+  double _internal_max() const;
+  void _internal_set_max(double value);
+  public:
+
+  // bool tunable = 6;
+  void clear_tunable();
+  bool tunable() const;
+  void set_tunable(bool value);
+  private:
+  bool _internal_tunable() const;
+  void _internal_set_tunable(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.data.model.ModelProto.Node.Parameter)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+    double value_;
+    double state_value_;
+    double min_;
+    double max_;
+    bool tunable_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fmodel_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ModelProto_Node final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.data.model.ModelProto.Node) */ {
+ public:
+  inline ModelProto_Node() : ModelProto_Node(nullptr) {}
+  ~ModelProto_Node() override;
+  explicit PROTOBUF_CONSTEXPR ModelProto_Node(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ModelProto_Node(const ModelProto_Node& from);
+  ModelProto_Node(ModelProto_Node&& from) noexcept
+    : ModelProto_Node() {
+    *this = ::std::move(from);
+  }
+
+  inline ModelProto_Node& operator=(const ModelProto_Node& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ModelProto_Node& operator=(ModelProto_Node&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ModelProto_Node& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ModelProto_Node* internal_default_instance() {
+    return reinterpret_cast<const ModelProto_Node*>(
+               &_ModelProto_Node_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(ModelProto_Node& a, ModelProto_Node& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ModelProto_Node* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ModelProto_Node* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ModelProto_Node* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ModelProto_Node>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ModelProto_Node& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const ModelProto_Node& from) {
+    ModelProto_Node::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ModelProto_Node* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.data.model.ModelProto.Node";
+  }
+  protected:
+  explicit ModelProto_Node(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ModelProto_Node_Parameter Parameter;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kParametersFieldNumber = 11,
+    kInputsFieldNumber = 14,
+    kNameFieldNumber = 2,
+    kIdFieldNumber = 1,
+    kBufferedBytesFieldNumber = 4,
+    kBufferedElementsFieldNumber = 5,
+    kBytesConsumedFieldNumber = 6,
+    kBytesProducedFieldNumber = 7,
+    kNumElementsFieldNumber = 8,
+    kProcessingTimeFieldNumber = 9,
+    kAutotuneFieldNumber = 3,
+    kRecordMetricsFieldNumber = 10,
+    kNodeClassFieldNumber = 15,
+    kInputProcessingTimeSumFieldNumber = 12,
+    kInputProcessingTimeCountFieldNumber = 13,
+    kRatioFieldNumber = 16,
+    kMemoryRatioFieldNumber = 17,
+  };
+  // repeated .tensorflow.data.model.ModelProto.Node.Parameter parameters = 11;
+  int parameters_size() const;
+  private:
+  int _internal_parameters_size() const;
+  public:
+  void clear_parameters();
+  ::tensorflow::data::model::ModelProto_Node_Parameter* mutable_parameters(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::data::model::ModelProto_Node_Parameter >*
+      mutable_parameters();
+  private:
+  const ::tensorflow::data::model::ModelProto_Node_Parameter& _internal_parameters(int index) const;
+  ::tensorflow::data::model::ModelProto_Node_Parameter* _internal_add_parameters();
+  public:
+  const ::tensorflow::data::model::ModelProto_Node_Parameter& parameters(int index) const;
+  ::tensorflow::data::model::ModelProto_Node_Parameter* add_parameters();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::data::model::ModelProto_Node_Parameter >&
+      parameters() const;
+
+  // repeated int64 inputs = 14;
+  int inputs_size() const;
+  private:
+  int _internal_inputs_size() const;
+  public:
+  void clear_inputs();
+  private:
+  int64_t _internal_inputs(int index) const;
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
+      _internal_inputs() const;
+  void _internal_add_inputs(int64_t value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
+      _internal_mutable_inputs();
+  public:
+  int64_t inputs(int index) const;
+  void set_inputs(int index, int64_t value);
+  void add_inputs(int64_t value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
+      inputs() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
+      mutable_inputs();
+
+  // string name = 2;
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // int64 id = 1;
+  void clear_id();
+  int64_t id() const;
+  void set_id(int64_t value);
+  private:
+  int64_t _internal_id() const;
+  void _internal_set_id(int64_t value);
+  public:
+
+  // int64 buffered_bytes = 4;
+  void clear_buffered_bytes();
+  int64_t buffered_bytes() const;
+  void set_buffered_bytes(int64_t value);
+  private:
+  int64_t _internal_buffered_bytes() const;
+  void _internal_set_buffered_bytes(int64_t value);
+  public:
+
+  // int64 buffered_elements = 5;
+  void clear_buffered_elements();
+  int64_t buffered_elements() const;
+  void set_buffered_elements(int64_t value);
+  private:
+  int64_t _internal_buffered_elements() const;
+  void _internal_set_buffered_elements(int64_t value);
+  public:
+
+  // int64 bytes_consumed = 6;
+  void clear_bytes_consumed();
+  int64_t bytes_consumed() const;
+  void set_bytes_consumed(int64_t value);
+  private:
+  int64_t _internal_bytes_consumed() const;
+  void _internal_set_bytes_consumed(int64_t value);
+  public:
+
+  // int64 bytes_produced = 7;
+  void clear_bytes_produced();
+  int64_t bytes_produced() const;
+  void set_bytes_produced(int64_t value);
+  private:
+  int64_t _internal_bytes_produced() const;
+  void _internal_set_bytes_produced(int64_t value);
+  public:
+
+  // int64 num_elements = 8;
+  void clear_num_elements();
+  int64_t num_elements() const;
+  void set_num_elements(int64_t value);
+  private:
+  int64_t _internal_num_elements() const;
+  void _internal_set_num_elements(int64_t value);
+  public:
+
+  // int64 processing_time = 9;
+  void clear_processing_time();
+  int64_t processing_time() const;
+  void set_processing_time(int64_t value);
+  private:
+  int64_t _internal_processing_time() const;
+  void _internal_set_processing_time(int64_t value);
+  public:
+
+  // bool autotune = 3;
+  void clear_autotune();
+  bool autotune() const;
+  void set_autotune(bool value);
+  private:
+  bool _internal_autotune() const;
+  void _internal_set_autotune(bool value);
+  public:
+
+  // bool record_metrics = 10;
+  void clear_record_metrics();
+  bool record_metrics() const;
+  void set_record_metrics(bool value);
+  private:
+  bool _internal_record_metrics() const;
+  void _internal_set_record_metrics(bool value);
+  public:
+
+  // .tensorflow.data.model.NodeClass node_class = 15;
+  void clear_node_class();
+  ::tensorflow::data::model::NodeClass node_class() const;
+  void set_node_class(::tensorflow::data::model::NodeClass value);
+  private:
+  ::tensorflow::data::model::NodeClass _internal_node_class() const;
+  void _internal_set_node_class(::tensorflow::data::model::NodeClass value);
+  public:
+
+  // double input_processing_time_sum = 12;
+  void clear_input_processing_time_sum();
+  double input_processing_time_sum() const;
+  void set_input_processing_time_sum(double value);
+  private:
+  double _internal_input_processing_time_sum() const;
+  void _internal_set_input_processing_time_sum(double value);
+  public:
+
+  // int64 input_processing_time_count = 13;
+  void clear_input_processing_time_count();
+  int64_t input_processing_time_count() const;
+  void set_input_processing_time_count(int64_t value);
+  private:
+  int64_t _internal_input_processing_time_count() const;
+  void _internal_set_input_processing_time_count(int64_t value);
+  public:
+
+  // double ratio = 16;
+  void clear_ratio();
+  double ratio() const;
+  void set_ratio(double value);
+  private:
+  double _internal_ratio() const;
+  void _internal_set_ratio(double value);
+  public:
+
+  // double memory_ratio = 17;
+  void clear_memory_ratio();
+  double memory_ratio() const;
+  void set_memory_ratio(double value);
+  private:
+  double _internal_memory_ratio() const;
+  void _internal_set_memory_ratio(double value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.data.model.ModelProto.Node)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::data::model::ModelProto_Node_Parameter > parameters_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > inputs_;
+    mutable std::atomic<int> _inputs_cached_byte_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+    int64_t id_;
+    int64_t buffered_bytes_;
+    int64_t buffered_elements_;
+    int64_t bytes_consumed_;
+    int64_t bytes_produced_;
+    int64_t num_elements_;
+    int64_t processing_time_;
+    bool autotune_;
+    bool record_metrics_;
+    int node_class_;
+    double input_processing_time_sum_;
+    int64_t input_processing_time_count_;
+    double ratio_;
+    double memory_ratio_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fmodel_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ModelProto_NodesEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<ModelProto_NodesEntry_DoNotUse, 
+    int64_t, ::tensorflow::data::model::ModelProto_Node,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> {
+public:
+  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<ModelProto_NodesEntry_DoNotUse, 
+    int64_t, ::tensorflow::data::model::ModelProto_Node,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
+  ModelProto_NodesEntry_DoNotUse();
+  explicit PROTOBUF_CONSTEXPR ModelProto_NodesEntry_DoNotUse(
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+  explicit ModelProto_NodesEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  void MergeFrom(const ModelProto_NodesEntry_DoNotUse& other);
+  static const ModelProto_NodesEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const ModelProto_NodesEntry_DoNotUse*>(&_ModelProto_NodesEntry_DoNotUse_default_instance_); }
+  static bool ValidateKey(void*) { return true; }
+  static bool ValidateValue(void*) { return true; }
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fmodel_2eproto;
+};
+
+// -------------------------------------------------------------------
+
+class ModelProto_OptimizationParams final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.data.model.ModelProto.OptimizationParams) */ {
+ public:
+  inline ModelProto_OptimizationParams() : ModelProto_OptimizationParams(nullptr) {}
+  ~ModelProto_OptimizationParams() override;
+  explicit PROTOBUF_CONSTEXPR ModelProto_OptimizationParams(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ModelProto_OptimizationParams(const ModelProto_OptimizationParams& from);
+  ModelProto_OptimizationParams(ModelProto_OptimizationParams&& from) noexcept
+    : ModelProto_OptimizationParams() {
+    *this = ::std::move(from);
+  }
+
+  inline ModelProto_OptimizationParams& operator=(const ModelProto_OptimizationParams& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ModelProto_OptimizationParams& operator=(ModelProto_OptimizationParams&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ModelProto_OptimizationParams& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ModelProto_OptimizationParams* internal_default_instance() {
+    return reinterpret_cast<const ModelProto_OptimizationParams*>(
+               &_ModelProto_OptimizationParams_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  friend void swap(ModelProto_OptimizationParams& a, ModelProto_OptimizationParams& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ModelProto_OptimizationParams* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ModelProto_OptimizationParams* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ModelProto_OptimizationParams* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ModelProto_OptimizationParams>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ModelProto_OptimizationParams& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const ModelProto_OptimizationParams& from) {
+    ModelProto_OptimizationParams::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ModelProto_OptimizationParams* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.data.model.ModelProto.OptimizationParams";
+  }
+  protected:
+  explicit ModelProto_OptimizationParams(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kCpuBudgetFieldNumber = 2,
+    kRamBudgetFieldNumber = 3,
+    kModelInputTimeFieldNumber = 4,
+    kAlgorithmFieldNumber = 1,
+  };
+  // int64 cpu_budget = 2;
+  void clear_cpu_budget();
+  int64_t cpu_budget() const;
+  void set_cpu_budget(int64_t value);
+  private:
+  int64_t _internal_cpu_budget() const;
+  void _internal_set_cpu_budget(int64_t value);
+  public:
+
+  // int64 ram_budget = 3;
+  void clear_ram_budget();
+  int64_t ram_budget() const;
+  void set_ram_budget(int64_t value);
+  private:
+  int64_t _internal_ram_budget() const;
+  void _internal_set_ram_budget(int64_t value);
+  public:
+
+  // double model_input_time = 4;
+  void clear_model_input_time();
+  double model_input_time() const;
+  void set_model_input_time(double value);
+  private:
+  double _internal_model_input_time() const;
+  void _internal_set_model_input_time(double value);
+  public:
+
+  // .tensorflow.data.model.AutotuneAlgorithm algorithm = 1;
+  void clear_algorithm();
+  ::tensorflow::data::model::AutotuneAlgorithm algorithm() const;
+  void set_algorithm(::tensorflow::data::model::AutotuneAlgorithm value);
+  private:
+  ::tensorflow::data::model::AutotuneAlgorithm _internal_algorithm() const;
+  void _internal_set_algorithm(::tensorflow::data::model::AutotuneAlgorithm value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.data.model.ModelProto.OptimizationParams)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    int64_t cpu_budget_;
+    int64_t ram_budget_;
+    double model_input_time_;
+    int algorithm_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fmodel_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ModelProto final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.data.model.ModelProto) */ {
+ public:
+  inline ModelProto() : ModelProto(nullptr) {}
+  ~ModelProto() override;
+  explicit PROTOBUF_CONSTEXPR ModelProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ModelProto(const ModelProto& from);
+  ModelProto(ModelProto&& from) noexcept
+    : ModelProto() {
+    *this = ::std::move(from);
+  }
+
+  inline ModelProto& operator=(const ModelProto& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ModelProto& operator=(ModelProto&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ModelProto& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ModelProto* internal_default_instance() {
+    return reinterpret_cast<const ModelProto*>(
+               &_ModelProto_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    4;
+
+  friend void swap(ModelProto& a, ModelProto& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ModelProto* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ModelProto* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ModelProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ModelProto>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ModelProto& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const ModelProto& from) {
+    ModelProto::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ModelProto* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.data.model.ModelProto";
+  }
+  protected:
+  explicit ModelProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ModelProto_Node Node;
+  typedef ModelProto_OptimizationParams OptimizationParams;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNodesFieldNumber = 1,
+    kGapTimesFieldNumber = 6,
+    kOptimizationParamsFieldNumber = 5,
+    kOutputFieldNumber = 2,
+    kIdCounterFieldNumber = 3,
+  };
+  // map<int64, .tensorflow.data.model.ModelProto.Node> nodes = 1;
+  int nodes_size() const;
+  private:
+  int _internal_nodes_size() const;
+  public:
+  void clear_nodes();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::Map< int64_t, ::tensorflow::data::model::ModelProto_Node >&
+      _internal_nodes() const;
+  ::PROTOBUF_NAMESPACE_ID::Map< int64_t, ::tensorflow::data::model::ModelProto_Node >*
+      _internal_mutable_nodes();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::Map< int64_t, ::tensorflow::data::model::ModelProto_Node >&
+      nodes() const;
+  ::PROTOBUF_NAMESPACE_ID::Map< int64_t, ::tensorflow::data::model::ModelProto_Node >*
+      mutable_nodes();
+
+  // repeated uint64 gap_times = 6;
+  int gap_times_size() const;
+  private:
+  int _internal_gap_times_size() const;
+  public:
+  void clear_gap_times();
+  private:
+  uint64_t _internal_gap_times(int index) const;
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
+      _internal_gap_times() const;
+  void _internal_add_gap_times(uint64_t value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
+      _internal_mutable_gap_times();
+  public:
+  uint64_t gap_times(int index) const;
+  void set_gap_times(int index, uint64_t value);
+  void add_gap_times(uint64_t value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
+      gap_times() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
+      mutable_gap_times();
+
+  // .tensorflow.data.model.ModelProto.OptimizationParams optimization_params = 5;
+  bool has_optimization_params() const;
+  private:
+  bool _internal_has_optimization_params() const;
+  public:
+  void clear_optimization_params();
+  const ::tensorflow::data::model::ModelProto_OptimizationParams& optimization_params() const;
+  PROTOBUF_NODISCARD ::tensorflow::data::model::ModelProto_OptimizationParams* release_optimization_params();
+  ::tensorflow::data::model::ModelProto_OptimizationParams* mutable_optimization_params();
+  void set_allocated_optimization_params(::tensorflow::data::model::ModelProto_OptimizationParams* optimization_params);
+  private:
+  const ::tensorflow::data::model::ModelProto_OptimizationParams& _internal_optimization_params() const;
+  ::tensorflow::data::model::ModelProto_OptimizationParams* _internal_mutable_optimization_params();
+  public:
+  void unsafe_arena_set_allocated_optimization_params(
+      ::tensorflow::data::model::ModelProto_OptimizationParams* optimization_params);
+  ::tensorflow::data::model::ModelProto_OptimizationParams* unsafe_arena_release_optimization_params();
+
+  // int64 output = 2;
+  void clear_output();
+  int64_t output() const;
+  void set_output(int64_t value);
+  private:
+  int64_t _internal_output() const;
+  void _internal_set_output(int64_t value);
+  public:
+
+  // int64 id_counter = 3;
+  void clear_id_counter();
+  int64_t id_counter() const;
+  void set_id_counter(int64_t value);
+  private:
+  int64_t _internal_id_counter() const;
+  void _internal_set_id_counter(int64_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.data.model.ModelProto)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::MapField<
+        ModelProto_NodesEntry_DoNotUse,
+        int64_t, ::tensorflow::data::model::ModelProto_Node,
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64,
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> nodes_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t > gap_times_;
+    mutable std::atomic<int> _gap_times_cached_byte_size_;
+    ::tensorflow::data::model::ModelProto_OptimizationParams* optimization_params_;
+    int64_t output_;
+    int64_t id_counter_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fmodel_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// ModelProto_Node_Parameter
+
+// string name = 1;
+inline void ModelProto_Node_Parameter::clear_name() {
+  _impl_.name_.ClearToEmpty();
+}
+inline const std::string& ModelProto_Node_Parameter::name() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.model.ModelProto.Node.Parameter.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ModelProto_Node_Parameter::set_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.data.model.ModelProto.Node.Parameter.name)
+}
+inline std::string* ModelProto_Node_Parameter::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:tensorflow.data.model.ModelProto.Node.Parameter.name)
+  return _s;
+}
+inline const std::string& ModelProto_Node_Parameter::_internal_name() const {
+  return _impl_.name_.Get();
+}
+inline void ModelProto_Node_Parameter::_internal_set_name(const std::string& value) {
+  
+  _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ModelProto_Node_Parameter::_internal_mutable_name() {
+  
+  return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ModelProto_Node_Parameter::release_name() {
+  // @@protoc_insertion_point(field_release:tensorflow.data.model.ModelProto.Node.Parameter.name)
+  return _impl_.name_.Release();
+}
+inline void ModelProto_Node_Parameter::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.data.model.ModelProto.Node.Parameter.name)
+}
+
+// double value = 2;
+inline void ModelProto_Node_Parameter::clear_value() {
+  _impl_.value_ = 0;
+}
+inline double ModelProto_Node_Parameter::_internal_value() const {
+  return _impl_.value_;
+}
+inline double ModelProto_Node_Parameter::value() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.model.ModelProto.Node.Parameter.value)
+  return _internal_value();
+}
+inline void ModelProto_Node_Parameter::_internal_set_value(double value) {
+  
+  _impl_.value_ = value;
+}
+inline void ModelProto_Node_Parameter::set_value(double value) {
+  _internal_set_value(value);
+  // @@protoc_insertion_point(field_set:tensorflow.data.model.ModelProto.Node.Parameter.value)
+}
+
+// double state_value = 3;
+inline void ModelProto_Node_Parameter::clear_state_value() {
+  _impl_.state_value_ = 0;
+}
+inline double ModelProto_Node_Parameter::_internal_state_value() const {
+  return _impl_.state_value_;
+}
+inline double ModelProto_Node_Parameter::state_value() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.model.ModelProto.Node.Parameter.state_value)
+  return _internal_state_value();
+}
+inline void ModelProto_Node_Parameter::_internal_set_state_value(double value) {
+  
+  _impl_.state_value_ = value;
+}
+inline void ModelProto_Node_Parameter::set_state_value(double value) {
+  _internal_set_state_value(value);
+  // @@protoc_insertion_point(field_set:tensorflow.data.model.ModelProto.Node.Parameter.state_value)
+}
+
+// double min = 4;
+inline void ModelProto_Node_Parameter::clear_min() {
+  _impl_.min_ = 0;
+}
+inline double ModelProto_Node_Parameter::_internal_min() const {
+  return _impl_.min_;
+}
+inline double ModelProto_Node_Parameter::min() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.model.ModelProto.Node.Parameter.min)
+  return _internal_min();
+}
+inline void ModelProto_Node_Parameter::_internal_set_min(double value) {
+  
+  _impl_.min_ = value;
+}
+inline void ModelProto_Node_Parameter::set_min(double value) {
+  _internal_set_min(value);
+  // @@protoc_insertion_point(field_set:tensorflow.data.model.ModelProto.Node.Parameter.min)
+}
+
+// double max = 5;
+inline void ModelProto_Node_Parameter::clear_max() {
+  _impl_.max_ = 0;
+}
+inline double ModelProto_Node_Parameter::_internal_max() const {
+  return _impl_.max_;
+}
+inline double ModelProto_Node_Parameter::max() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.model.ModelProto.Node.Parameter.max)
+  return _internal_max();
+}
+inline void ModelProto_Node_Parameter::_internal_set_max(double value) {
+  
+  _impl_.max_ = value;
+}
+inline void ModelProto_Node_Parameter::set_max(double value) {
+  _internal_set_max(value);
+  // @@protoc_insertion_point(field_set:tensorflow.data.model.ModelProto.Node.Parameter.max)
+}
+
+// bool tunable = 6;
+inline void ModelProto_Node_Parameter::clear_tunable() {
+  _impl_.tunable_ = false;
+}
+inline bool ModelProto_Node_Parameter::_internal_tunable() const {
+  return _impl_.tunable_;
+}
+inline bool ModelProto_Node_Parameter::tunable() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.model.ModelProto.Node.Parameter.tunable)
+  return _internal_tunable();
+}
+inline void ModelProto_Node_Parameter::_internal_set_tunable(bool value) {
+  
+  _impl_.tunable_ = value;
+}
+inline void ModelProto_Node_Parameter::set_tunable(bool value) {
+  _internal_set_tunable(value);
+  // @@protoc_insertion_point(field_set:tensorflow.data.model.ModelProto.Node.Parameter.tunable)
+}
+
+// -------------------------------------------------------------------
+
+// ModelProto_Node
+
+// int64 id = 1;
+inline void ModelProto_Node::clear_id() {
+  _impl_.id_ = int64_t{0};
+}
+inline int64_t ModelProto_Node::_internal_id() const {
+  return _impl_.id_;
+}
+inline int64_t ModelProto_Node::id() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.model.ModelProto.Node.id)
+  return _internal_id();
+}
+inline void ModelProto_Node::_internal_set_id(int64_t value) {
+  
+  _impl_.id_ = value;
+}
+inline void ModelProto_Node::set_id(int64_t value) {
+  _internal_set_id(value);
+  // @@protoc_insertion_point(field_set:tensorflow.data.model.ModelProto.Node.id)
+}
+
+// string name = 2;
+inline void ModelProto_Node::clear_name() {
+  _impl_.name_.ClearToEmpty();
+}
+inline const std::string& ModelProto_Node::name() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.model.ModelProto.Node.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ModelProto_Node::set_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.data.model.ModelProto.Node.name)
+}
+inline std::string* ModelProto_Node::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:tensorflow.data.model.ModelProto.Node.name)
+  return _s;
+}
+inline const std::string& ModelProto_Node::_internal_name() const {
+  return _impl_.name_.Get();
+}
+inline void ModelProto_Node::_internal_set_name(const std::string& value) {
+  
+  _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ModelProto_Node::_internal_mutable_name() {
+  
+  return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ModelProto_Node::release_name() {
+  // @@protoc_insertion_point(field_release:tensorflow.data.model.ModelProto.Node.name)
+  return _impl_.name_.Release();
+}
+inline void ModelProto_Node::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.data.model.ModelProto.Node.name)
+}
+
+// bool autotune = 3;
+inline void ModelProto_Node::clear_autotune() {
+  _impl_.autotune_ = false;
+}
+inline bool ModelProto_Node::_internal_autotune() const {
+  return _impl_.autotune_;
+}
+inline bool ModelProto_Node::autotune() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.model.ModelProto.Node.autotune)
+  return _internal_autotune();
+}
+inline void ModelProto_Node::_internal_set_autotune(bool value) {
+  
+  _impl_.autotune_ = value;
+}
+inline void ModelProto_Node::set_autotune(bool value) {
+  _internal_set_autotune(value);
+  // @@protoc_insertion_point(field_set:tensorflow.data.model.ModelProto.Node.autotune)
+}
+
+// int64 buffered_bytes = 4;
+inline void ModelProto_Node::clear_buffered_bytes() {
+  _impl_.buffered_bytes_ = int64_t{0};
+}
+inline int64_t ModelProto_Node::_internal_buffered_bytes() const {
+  return _impl_.buffered_bytes_;
+}
+inline int64_t ModelProto_Node::buffered_bytes() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.model.ModelProto.Node.buffered_bytes)
+  return _internal_buffered_bytes();
+}
+inline void ModelProto_Node::_internal_set_buffered_bytes(int64_t value) {
+  
+  _impl_.buffered_bytes_ = value;
+}
+inline void ModelProto_Node::set_buffered_bytes(int64_t value) {
+  _internal_set_buffered_bytes(value);
+  // @@protoc_insertion_point(field_set:tensorflow.data.model.ModelProto.Node.buffered_bytes)
+}
+
+// int64 buffered_elements = 5;
+inline void ModelProto_Node::clear_buffered_elements() {
+  _impl_.buffered_elements_ = int64_t{0};
+}
+inline int64_t ModelProto_Node::_internal_buffered_elements() const {
+  return _impl_.buffered_elements_;
+}
+inline int64_t ModelProto_Node::buffered_elements() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.model.ModelProto.Node.buffered_elements)
+  return _internal_buffered_elements();
+}
+inline void ModelProto_Node::_internal_set_buffered_elements(int64_t value) {
+  
+  _impl_.buffered_elements_ = value;
+}
+inline void ModelProto_Node::set_buffered_elements(int64_t value) {
+  _internal_set_buffered_elements(value);
+  // @@protoc_insertion_point(field_set:tensorflow.data.model.ModelProto.Node.buffered_elements)
+}
+
+// int64 bytes_consumed = 6;
+inline void ModelProto_Node::clear_bytes_consumed() {
+  _impl_.bytes_consumed_ = int64_t{0};
+}
+inline int64_t ModelProto_Node::_internal_bytes_consumed() const {
+  return _impl_.bytes_consumed_;
+}
+inline int64_t ModelProto_Node::bytes_consumed() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.model.ModelProto.Node.bytes_consumed)
+  return _internal_bytes_consumed();
+}
+inline void ModelProto_Node::_internal_set_bytes_consumed(int64_t value) {
+  
+  _impl_.bytes_consumed_ = value;
+}
+inline void ModelProto_Node::set_bytes_consumed(int64_t value) {
+  _internal_set_bytes_consumed(value);
+  // @@protoc_insertion_point(field_set:tensorflow.data.model.ModelProto.Node.bytes_consumed)
+}
+
+// int64 bytes_produced = 7;
+inline void ModelProto_Node::clear_bytes_produced() {
+  _impl_.bytes_produced_ = int64_t{0};
+}
+inline int64_t ModelProto_Node::_internal_bytes_produced() const {
+  return _impl_.bytes_produced_;
+}
+inline int64_t ModelProto_Node::bytes_produced() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.model.ModelProto.Node.bytes_produced)
+  return _internal_bytes_produced();
+}
+inline void ModelProto_Node::_internal_set_bytes_produced(int64_t value) {
+  
+  _impl_.bytes_produced_ = value;
+}
+inline void ModelProto_Node::set_bytes_produced(int64_t value) {
+  _internal_set_bytes_produced(value);
+  // @@protoc_insertion_point(field_set:tensorflow.data.model.ModelProto.Node.bytes_produced)
+}
+
+// int64 num_elements = 8;
+inline void ModelProto_Node::clear_num_elements() {
+  _impl_.num_elements_ = int64_t{0};
+}
+inline int64_t ModelProto_Node::_internal_num_elements() const {
+  return _impl_.num_elements_;
+}
+inline int64_t ModelProto_Node::num_elements() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.model.ModelProto.Node.num_elements)
+  return _internal_num_elements();
+}
+inline void ModelProto_Node::_internal_set_num_elements(int64_t value) {
+  
+  _impl_.num_elements_ = value;
+}
+inline void ModelProto_Node::set_num_elements(int64_t value) {
+  _internal_set_num_elements(value);
+  // @@protoc_insertion_point(field_set:tensorflow.data.model.ModelProto.Node.num_elements)
+}
+
+// int64 processing_time = 9;
+inline void ModelProto_Node::clear_processing_time() {
+  _impl_.processing_time_ = int64_t{0};
+}
+inline int64_t ModelProto_Node::_internal_processing_time() const {
+  return _impl_.processing_time_;
+}
+inline int64_t ModelProto_Node::processing_time() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.model.ModelProto.Node.processing_time)
+  return _internal_processing_time();
+}
+inline void ModelProto_Node::_internal_set_processing_time(int64_t value) {
+  
+  _impl_.processing_time_ = value;
+}
+inline void ModelProto_Node::set_processing_time(int64_t value) {
+  _internal_set_processing_time(value);
+  // @@protoc_insertion_point(field_set:tensorflow.data.model.ModelProto.Node.processing_time)
+}
+
+// bool record_metrics = 10;
+inline void ModelProto_Node::clear_record_metrics() {
+  _impl_.record_metrics_ = false;
+}
+inline bool ModelProto_Node::_internal_record_metrics() const {
+  return _impl_.record_metrics_;
+}
+inline bool ModelProto_Node::record_metrics() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.model.ModelProto.Node.record_metrics)
+  return _internal_record_metrics();
+}
+inline void ModelProto_Node::_internal_set_record_metrics(bool value) {
+  
+  _impl_.record_metrics_ = value;
+}
+inline void ModelProto_Node::set_record_metrics(bool value) {
+  _internal_set_record_metrics(value);
+  // @@protoc_insertion_point(field_set:tensorflow.data.model.ModelProto.Node.record_metrics)
+}
+
+// repeated .tensorflow.data.model.ModelProto.Node.Parameter parameters = 11;
+inline int ModelProto_Node::_internal_parameters_size() const {
+  return _impl_.parameters_.size();
+}
+inline int ModelProto_Node::parameters_size() const {
+  return _internal_parameters_size();
+}
+inline void ModelProto_Node::clear_parameters() {
+  _impl_.parameters_.Clear();
+}
+inline ::tensorflow::data::model::ModelProto_Node_Parameter* ModelProto_Node::mutable_parameters(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.data.model.ModelProto.Node.parameters)
+  return _impl_.parameters_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::data::model::ModelProto_Node_Parameter >*
+ModelProto_Node::mutable_parameters() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.data.model.ModelProto.Node.parameters)
+  return &_impl_.parameters_;
+}
+inline const ::tensorflow::data::model::ModelProto_Node_Parameter& ModelProto_Node::_internal_parameters(int index) const {
+  return _impl_.parameters_.Get(index);
+}
+inline const ::tensorflow::data::model::ModelProto_Node_Parameter& ModelProto_Node::parameters(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.model.ModelProto.Node.parameters)
+  return _internal_parameters(index);
+}
+inline ::tensorflow::data::model::ModelProto_Node_Parameter* ModelProto_Node::_internal_add_parameters() {
+  return _impl_.parameters_.Add();
+}
+inline ::tensorflow::data::model::ModelProto_Node_Parameter* ModelProto_Node::add_parameters() {
+  ::tensorflow::data::model::ModelProto_Node_Parameter* _add = _internal_add_parameters();
+  // @@protoc_insertion_point(field_add:tensorflow.data.model.ModelProto.Node.parameters)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::data::model::ModelProto_Node_Parameter >&
+ModelProto_Node::parameters() const {
+  // @@protoc_insertion_point(field_list:tensorflow.data.model.ModelProto.Node.parameters)
+  return _impl_.parameters_;
+}
+
+// double input_processing_time_sum = 12;
+inline void ModelProto_Node::clear_input_processing_time_sum() {
+  _impl_.input_processing_time_sum_ = 0;
+}
+inline double ModelProto_Node::_internal_input_processing_time_sum() const {
+  return _impl_.input_processing_time_sum_;
+}
+inline double ModelProto_Node::input_processing_time_sum() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.model.ModelProto.Node.input_processing_time_sum)
+  return _internal_input_processing_time_sum();
+}
+inline void ModelProto_Node::_internal_set_input_processing_time_sum(double value) {
+  
+  _impl_.input_processing_time_sum_ = value;
+}
+inline void ModelProto_Node::set_input_processing_time_sum(double value) {
+  _internal_set_input_processing_time_sum(value);
+  // @@protoc_insertion_point(field_set:tensorflow.data.model.ModelProto.Node.input_processing_time_sum)
+}
+
+// int64 input_processing_time_count = 13;
+inline void ModelProto_Node::clear_input_processing_time_count() {
+  _impl_.input_processing_time_count_ = int64_t{0};
+}
+inline int64_t ModelProto_Node::_internal_input_processing_time_count() const {
+  return _impl_.input_processing_time_count_;
+}
+inline int64_t ModelProto_Node::input_processing_time_count() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.model.ModelProto.Node.input_processing_time_count)
+  return _internal_input_processing_time_count();
+}
+inline void ModelProto_Node::_internal_set_input_processing_time_count(int64_t value) {
+  
+  _impl_.input_processing_time_count_ = value;
+}
+inline void ModelProto_Node::set_input_processing_time_count(int64_t value) {
+  _internal_set_input_processing_time_count(value);
+  // @@protoc_insertion_point(field_set:tensorflow.data.model.ModelProto.Node.input_processing_time_count)
+}
+
+// repeated int64 inputs = 14;
+inline int ModelProto_Node::_internal_inputs_size() const {
+  return _impl_.inputs_.size();
+}
+inline int ModelProto_Node::inputs_size() const {
+  return _internal_inputs_size();
+}
+inline void ModelProto_Node::clear_inputs() {
+  _impl_.inputs_.Clear();
+}
+inline int64_t ModelProto_Node::_internal_inputs(int index) const {
+  return _impl_.inputs_.Get(index);
+}
+inline int64_t ModelProto_Node::inputs(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.model.ModelProto.Node.inputs)
+  return _internal_inputs(index);
+}
+inline void ModelProto_Node::set_inputs(int index, int64_t value) {
+  _impl_.inputs_.Set(index, value);
+  // @@protoc_insertion_point(field_set:tensorflow.data.model.ModelProto.Node.inputs)
+}
+inline void ModelProto_Node::_internal_add_inputs(int64_t value) {
+  _impl_.inputs_.Add(value);
+}
+inline void ModelProto_Node::add_inputs(int64_t value) {
+  _internal_add_inputs(value);
+  // @@protoc_insertion_point(field_add:tensorflow.data.model.ModelProto.Node.inputs)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
+ModelProto_Node::_internal_inputs() const {
+  return _impl_.inputs_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
+ModelProto_Node::inputs() const {
+  // @@protoc_insertion_point(field_list:tensorflow.data.model.ModelProto.Node.inputs)
+  return _internal_inputs();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
+ModelProto_Node::_internal_mutable_inputs() {
+  return &_impl_.inputs_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
+ModelProto_Node::mutable_inputs() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.data.model.ModelProto.Node.inputs)
+  return _internal_mutable_inputs();
+}
+
+// .tensorflow.data.model.NodeClass node_class = 15;
+inline void ModelProto_Node::clear_node_class() {
+  _impl_.node_class_ = 0;
+}
+inline ::tensorflow::data::model::NodeClass ModelProto_Node::_internal_node_class() const {
+  return static_cast< ::tensorflow::data::model::NodeClass >(_impl_.node_class_);
+}
+inline ::tensorflow::data::model::NodeClass ModelProto_Node::node_class() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.model.ModelProto.Node.node_class)
+  return _internal_node_class();
+}
+inline void ModelProto_Node::_internal_set_node_class(::tensorflow::data::model::NodeClass value) {
+  
+  _impl_.node_class_ = value;
+}
+inline void ModelProto_Node::set_node_class(::tensorflow::data::model::NodeClass value) {
+  _internal_set_node_class(value);
+  // @@protoc_insertion_point(field_set:tensorflow.data.model.ModelProto.Node.node_class)
+}
+
+// double ratio = 16;
+inline void ModelProto_Node::clear_ratio() {
+  _impl_.ratio_ = 0;
+}
+inline double ModelProto_Node::_internal_ratio() const {
+  return _impl_.ratio_;
+}
+inline double ModelProto_Node::ratio() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.model.ModelProto.Node.ratio)
+  return _internal_ratio();
+}
+inline void ModelProto_Node::_internal_set_ratio(double value) {
+  
+  _impl_.ratio_ = value;
+}
+inline void ModelProto_Node::set_ratio(double value) {
+  _internal_set_ratio(value);
+  // @@protoc_insertion_point(field_set:tensorflow.data.model.ModelProto.Node.ratio)
+}
+
+// double memory_ratio = 17;
+inline void ModelProto_Node::clear_memory_ratio() {
+  _impl_.memory_ratio_ = 0;
+}
+inline double ModelProto_Node::_internal_memory_ratio() const {
+  return _impl_.memory_ratio_;
+}
+inline double ModelProto_Node::memory_ratio() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.model.ModelProto.Node.memory_ratio)
+  return _internal_memory_ratio();
+}
+inline void ModelProto_Node::_internal_set_memory_ratio(double value) {
+  
+  _impl_.memory_ratio_ = value;
+}
+inline void ModelProto_Node::set_memory_ratio(double value) {
+  _internal_set_memory_ratio(value);
+  // @@protoc_insertion_point(field_set:tensorflow.data.model.ModelProto.Node.memory_ratio)
+}
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// ModelProto_OptimizationParams
+
+// .tensorflow.data.model.AutotuneAlgorithm algorithm = 1;
+inline void ModelProto_OptimizationParams::clear_algorithm() {
+  _impl_.algorithm_ = 0;
+}
+inline ::tensorflow::data::model::AutotuneAlgorithm ModelProto_OptimizationParams::_internal_algorithm() const {
+  return static_cast< ::tensorflow::data::model::AutotuneAlgorithm >(_impl_.algorithm_);
+}
+inline ::tensorflow::data::model::AutotuneAlgorithm ModelProto_OptimizationParams::algorithm() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.model.ModelProto.OptimizationParams.algorithm)
+  return _internal_algorithm();
+}
+inline void ModelProto_OptimizationParams::_internal_set_algorithm(::tensorflow::data::model::AutotuneAlgorithm value) {
+  
+  _impl_.algorithm_ = value;
+}
+inline void ModelProto_OptimizationParams::set_algorithm(::tensorflow::data::model::AutotuneAlgorithm value) {
+  _internal_set_algorithm(value);
+  // @@protoc_insertion_point(field_set:tensorflow.data.model.ModelProto.OptimizationParams.algorithm)
+}
+
+// int64 cpu_budget = 2;
+inline void ModelProto_OptimizationParams::clear_cpu_budget() {
+  _impl_.cpu_budget_ = int64_t{0};
+}
+inline int64_t ModelProto_OptimizationParams::_internal_cpu_budget() const {
+  return _impl_.cpu_budget_;
+}
+inline int64_t ModelProto_OptimizationParams::cpu_budget() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.model.ModelProto.OptimizationParams.cpu_budget)
+  return _internal_cpu_budget();
+}
+inline void ModelProto_OptimizationParams::_internal_set_cpu_budget(int64_t value) {
+  
+  _impl_.cpu_budget_ = value;
+}
+inline void ModelProto_OptimizationParams::set_cpu_budget(int64_t value) {
+  _internal_set_cpu_budget(value);
+  // @@protoc_insertion_point(field_set:tensorflow.data.model.ModelProto.OptimizationParams.cpu_budget)
+}
+
+// int64 ram_budget = 3;
+inline void ModelProto_OptimizationParams::clear_ram_budget() {
+  _impl_.ram_budget_ = int64_t{0};
+}
+inline int64_t ModelProto_OptimizationParams::_internal_ram_budget() const {
+  return _impl_.ram_budget_;
+}
+inline int64_t ModelProto_OptimizationParams::ram_budget() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.model.ModelProto.OptimizationParams.ram_budget)
+  return _internal_ram_budget();
+}
+inline void ModelProto_OptimizationParams::_internal_set_ram_budget(int64_t value) {
+  
+  _impl_.ram_budget_ = value;
+}
+inline void ModelProto_OptimizationParams::set_ram_budget(int64_t value) {
+  _internal_set_ram_budget(value);
+  // @@protoc_insertion_point(field_set:tensorflow.data.model.ModelProto.OptimizationParams.ram_budget)
+}
+
+// double model_input_time = 4;
+inline void ModelProto_OptimizationParams::clear_model_input_time() {
+  _impl_.model_input_time_ = 0;
+}
+inline double ModelProto_OptimizationParams::_internal_model_input_time() const {
+  return _impl_.model_input_time_;
+}
+inline double ModelProto_OptimizationParams::model_input_time() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.model.ModelProto.OptimizationParams.model_input_time)
+  return _internal_model_input_time();
+}
+inline void ModelProto_OptimizationParams::_internal_set_model_input_time(double value) {
+  
+  _impl_.model_input_time_ = value;
+}
+inline void ModelProto_OptimizationParams::set_model_input_time(double value) {
+  _internal_set_model_input_time(value);
+  // @@protoc_insertion_point(field_set:tensorflow.data.model.ModelProto.OptimizationParams.model_input_time)
+}
+
+// -------------------------------------------------------------------
+
+// ModelProto
+
+// map<int64, .tensorflow.data.model.ModelProto.Node> nodes = 1;
+inline int ModelProto::_internal_nodes_size() const {
+  return _impl_.nodes_.size();
+}
+inline int ModelProto::nodes_size() const {
+  return _internal_nodes_size();
+}
+inline void ModelProto::clear_nodes() {
+  _impl_.nodes_.Clear();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< int64_t, ::tensorflow::data::model::ModelProto_Node >&
+ModelProto::_internal_nodes() const {
+  return _impl_.nodes_.GetMap();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< int64_t, ::tensorflow::data::model::ModelProto_Node >&
+ModelProto::nodes() const {
+  // @@protoc_insertion_point(field_map:tensorflow.data.model.ModelProto.nodes)
+  return _internal_nodes();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< int64_t, ::tensorflow::data::model::ModelProto_Node >*
+ModelProto::_internal_mutable_nodes() {
+  return _impl_.nodes_.MutableMap();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< int64_t, ::tensorflow::data::model::ModelProto_Node >*
+ModelProto::mutable_nodes() {
+  // @@protoc_insertion_point(field_mutable_map:tensorflow.data.model.ModelProto.nodes)
+  return _internal_mutable_nodes();
+}
+
+// int64 output = 2;
+inline void ModelProto::clear_output() {
+  _impl_.output_ = int64_t{0};
+}
+inline int64_t ModelProto::_internal_output() const {
+  return _impl_.output_;
+}
+inline int64_t ModelProto::output() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.model.ModelProto.output)
+  return _internal_output();
+}
+inline void ModelProto::_internal_set_output(int64_t value) {
+  
+  _impl_.output_ = value;
+}
+inline void ModelProto::set_output(int64_t value) {
+  _internal_set_output(value);
+  // @@protoc_insertion_point(field_set:tensorflow.data.model.ModelProto.output)
+}
+
+// int64 id_counter = 3;
+inline void ModelProto::clear_id_counter() {
+  _impl_.id_counter_ = int64_t{0};
+}
+inline int64_t ModelProto::_internal_id_counter() const {
+  return _impl_.id_counter_;
+}
+inline int64_t ModelProto::id_counter() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.model.ModelProto.id_counter)
+  return _internal_id_counter();
+}
+inline void ModelProto::_internal_set_id_counter(int64_t value) {
+  
+  _impl_.id_counter_ = value;
+}
+inline void ModelProto::set_id_counter(int64_t value) {
+  _internal_set_id_counter(value);
+  // @@protoc_insertion_point(field_set:tensorflow.data.model.ModelProto.id_counter)
+}
+
+// .tensorflow.data.model.ModelProto.OptimizationParams optimization_params = 5;
+inline bool ModelProto::_internal_has_optimization_params() const {
+  return this != internal_default_instance() && _impl_.optimization_params_ != nullptr;
+}
+inline bool ModelProto::has_optimization_params() const {
+  return _internal_has_optimization_params();
+}
+inline void ModelProto::clear_optimization_params() {
+  if (GetArenaForAllocation() == nullptr && _impl_.optimization_params_ != nullptr) {
+    delete _impl_.optimization_params_;
+  }
+  _impl_.optimization_params_ = nullptr;
+}
+inline const ::tensorflow::data::model::ModelProto_OptimizationParams& ModelProto::_internal_optimization_params() const {
+  const ::tensorflow::data::model::ModelProto_OptimizationParams* p = _impl_.optimization_params_;
+  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::data::model::ModelProto_OptimizationParams&>(
+      ::tensorflow::data::model::_ModelProto_OptimizationParams_default_instance_);
+}
+inline const ::tensorflow::data::model::ModelProto_OptimizationParams& ModelProto::optimization_params() const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.model.ModelProto.optimization_params)
+  return _internal_optimization_params();
+}
+inline void ModelProto::unsafe_arena_set_allocated_optimization_params(
+    ::tensorflow::data::model::ModelProto_OptimizationParams* optimization_params) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.optimization_params_);
+  }
+  _impl_.optimization_params_ = optimization_params;
+  if (optimization_params) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.data.model.ModelProto.optimization_params)
+}
+inline ::tensorflow::data::model::ModelProto_OptimizationParams* ModelProto::release_optimization_params() {
+  
+  ::tensorflow::data::model::ModelProto_OptimizationParams* temp = _impl_.optimization_params_;
+  _impl_.optimization_params_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::tensorflow::data::model::ModelProto_OptimizationParams* ModelProto::unsafe_arena_release_optimization_params() {
+  // @@protoc_insertion_point(field_release:tensorflow.data.model.ModelProto.optimization_params)
+  
+  ::tensorflow::data::model::ModelProto_OptimizationParams* temp = _impl_.optimization_params_;
+  _impl_.optimization_params_ = nullptr;
+  return temp;
+}
+inline ::tensorflow::data::model::ModelProto_OptimizationParams* ModelProto::_internal_mutable_optimization_params() {
+  
+  if (_impl_.optimization_params_ == nullptr) {
+    auto* p = CreateMaybeMessage<::tensorflow::data::model::ModelProto_OptimizationParams>(GetArenaForAllocation());
+    _impl_.optimization_params_ = p;
+  }
+  return _impl_.optimization_params_;
+}
+inline ::tensorflow::data::model::ModelProto_OptimizationParams* ModelProto::mutable_optimization_params() {
+  ::tensorflow::data::model::ModelProto_OptimizationParams* _msg = _internal_mutable_optimization_params();
+  // @@protoc_insertion_point(field_mutable:tensorflow.data.model.ModelProto.optimization_params)
+  return _msg;
+}
+inline void ModelProto::set_allocated_optimization_params(::tensorflow::data::model::ModelProto_OptimizationParams* optimization_params) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.optimization_params_;
+  }
+  if (optimization_params) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(optimization_params);
+    if (message_arena != submessage_arena) {
+      optimization_params = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, optimization_params, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.optimization_params_ = optimization_params;
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.data.model.ModelProto.optimization_params)
+}
+
+// repeated uint64 gap_times = 6;
+inline int ModelProto::_internal_gap_times_size() const {
+  return _impl_.gap_times_.size();
+}
+inline int ModelProto::gap_times_size() const {
+  return _internal_gap_times_size();
+}
+inline void ModelProto::clear_gap_times() {
+  _impl_.gap_times_.Clear();
+}
+inline uint64_t ModelProto::_internal_gap_times(int index) const {
+  return _impl_.gap_times_.Get(index);
+}
+inline uint64_t ModelProto::gap_times(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.data.model.ModelProto.gap_times)
+  return _internal_gap_times(index);
+}
+inline void ModelProto::set_gap_times(int index, uint64_t value) {
+  _impl_.gap_times_.Set(index, value);
+  // @@protoc_insertion_point(field_set:tensorflow.data.model.ModelProto.gap_times)
+}
+inline void ModelProto::_internal_add_gap_times(uint64_t value) {
+  _impl_.gap_times_.Add(value);
+}
+inline void ModelProto::add_gap_times(uint64_t value) {
+  _internal_add_gap_times(value);
+  // @@protoc_insertion_point(field_add:tensorflow.data.model.ModelProto.gap_times)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
+ModelProto::_internal_gap_times() const {
+  return _impl_.gap_times_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
+ModelProto::gap_times() const {
+  // @@protoc_insertion_point(field_list:tensorflow.data.model.ModelProto.gap_times)
+  return _internal_gap_times();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
+ModelProto::_internal_mutable_gap_times() {
+  return &_impl_.gap_times_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
+ModelProto::mutable_gap_times() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.data.model.ModelProto.gap_times)
+  return _internal_mutable_gap_times();
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace model
+}  // namespace data
+}  // namespace tensorflow
+
+PROTOBUF_NAMESPACE_OPEN
+
+template <> struct is_proto_enum< ::tensorflow::data::model::NodeClass> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::tensorflow::data::model::NodeClass>() {
+  return ::tensorflow::data::model::NodeClass_descriptor();
+}
+template <> struct is_proto_enum< ::tensorflow::data::model::AutotuneAlgorithm> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::tensorflow::data::model::AutotuneAlgorithm>() {
+  return ::tensorflow::data::model::AutotuneAlgorithm_descriptor();
+}
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fmodel_2eproto
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/model.proto b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/model.proto
new file mode 100644
index 0000000000000000000000000000000000000000..c017aeb580f7626adc34cfd7c55662211b7d0426
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/model.proto
@@ -0,0 +1,138 @@
+syntax = "proto3";
+
+package tensorflow.data.model;
+
+option cc_enable_arenas = true;
+option go_package = "github.com/tensorflow/tensorflow/tensorflow/go/core/framework/model_go_proto";
+
+// Class of a node in the performance model.
+enum NodeClass {
+  UNKNOWN = 0;
+  INTERLEAVE_MANY = 1;
+  ASYNC_INTERLEAVE_MANY = 2;
+  KNOWN_RATIO = 3;
+  ASYNC_KNOWN_RATIO = 4;
+  UNKNOWN_RATIO = 5;
+  ASYNC_UNKNOWN_RATIO = 6;
+}
+
+// Algorithm used for model autotuning optimization.
+enum AutotuneAlgorithm {
+  DEFAULT = 0;
+  HILL_CLIMB = 1;
+  GRADIENT_DESCENT = 2;
+  MAX_PARALLELISM = 3;
+  STAGE_BASED = 4;
+}
+
+// Protocol buffer representing the data used by the autotuning modeling
+// framework.
+message ModelProto {
+  // General representation of a node in the model.
+  message Node {
+    // Unique node ID.
+    int64 id = 1;
+
+    // Human-readable name of the node.
+    string name = 2;
+
+    // An indication whether autotuning is enabled for this node.
+    bool autotune = 3;
+
+    // The number of bytes stored in this node's buffer.
+    int64 buffered_bytes = 4;
+
+    // The number of elements stored in this node's buffer.
+    int64 buffered_elements = 5;
+
+    // The number of bytes consumed by the node.
+    int64 bytes_consumed = 6;
+
+    // The number of bytes produced by the node.
+    int64 bytes_produced = 7;
+
+    // The number of elements produced by the node.
+    int64 num_elements = 8;
+
+    // The aggregate processing time spent in this node in nanoseconds.
+    int64 processing_time = 9;
+
+    // An indication whether this node records metrics about produced and
+    // consumed elements.
+    bool record_metrics = 10;
+
+    // Represents a node parameter.
+    message Parameter {
+      // Human-readable name of the parameter.
+      string name = 1;
+
+      // Identifies the model value of the parameter. This can be different from
+      // the actual value (e.g. during optimization search).
+      double value = 2;
+
+      // The actual value of the parameter.
+      double state_value = 3;
+
+      // Minimum value of the parameter.
+      double min = 4;
+
+      // Maximum value of the parameter.
+      double max = 5;
+
+      // Identifies whether the parameter should participate in autotuning.
+      bool tunable = 6;
+    }
+
+    // Parameters of this node.
+    repeated Parameter parameters = 11;
+
+    // Statistic of inputs processing time history.
+    double input_processing_time_sum = 12;
+    int64 input_processing_time_count = 13;
+
+    // IDs of inputs of this node.
+    repeated int64 inputs = 14;
+
+    // Class of this node.
+    NodeClass node_class = 15;
+
+    // Ratio of input to output elements. This is only used by KNOWN_RATIO and
+    // ASYNC_KNOWN_RATIO nodes.
+    double ratio = 16;
+
+    // Ratio identifies how many parallelism calls are introduced by one
+    // buffered element. This is only used by ASYNC_KNOWN_RATIO nodes.
+    double memory_ratio = 17;
+  }
+
+  // Map of node IDs to nodes of this model.
+  map<int64, Node> nodes = 1;
+
+  // ID of the output node of this model.
+  int64 output = 2;
+
+  // Counter for node IDs of this model.
+  int64 id_counter = 3;
+
+  reserved 4;
+
+  // Contains parameters of the model autotuning optimization.
+  message OptimizationParams {
+    // Algorithm used for autotuning optimization.
+    AutotuneAlgorithm algorithm = 1;
+
+    // Number of available logical threads.
+    int64 cpu_budget = 2;
+
+    // Amount of available memory in bytes.
+    int64 ram_budget = 3;
+
+    // Time between two consecutive `GetNext` calls to the iterator represented
+    // by the output node.
+    double model_input_time = 4;
+  }
+
+  OptimizationParams optimization_params = 5;
+
+  repeated uint64 gap_times = 6;
+}
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/node_def.pb.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/node_def.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..2df1c5d42ba22459c5d47f0e9e6b7510d2a5b348
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/node_def.pb.h
@@ -0,0 +1,1171 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: tensorflow/core/framework/node_def.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fnode_5fdef_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fnode_5fdef_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3021000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3021009 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/map.h>  // IWYU pragma: export
+#include <google/protobuf/map_entry.h>
+#include <google/protobuf/map_field_inl.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "tensorflow/core/framework/attr_value.pb.h"
+#include "tensorflow/core/framework/full_type.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_tensorflow_2fcore_2fframework_2fnode_5fdef_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_tensorflow_2fcore_2fframework_2fnode_5fdef_2eproto {
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_tensorflow_2fcore_2fframework_2fnode_5fdef_2eproto;
+namespace tensorflow {
+class NodeDef;
+struct NodeDefDefaultTypeInternal;
+extern NodeDefDefaultTypeInternal _NodeDef_default_instance_;
+class NodeDef_AttrEntry_DoNotUse;
+struct NodeDef_AttrEntry_DoNotUseDefaultTypeInternal;
+extern NodeDef_AttrEntry_DoNotUseDefaultTypeInternal _NodeDef_AttrEntry_DoNotUse_default_instance_;
+class NodeDef_ExperimentalDebugInfo;
+struct NodeDef_ExperimentalDebugInfoDefaultTypeInternal;
+extern NodeDef_ExperimentalDebugInfoDefaultTypeInternal _NodeDef_ExperimentalDebugInfo_default_instance_;
+}  // namespace tensorflow
+PROTOBUF_NAMESPACE_OPEN
+template<> ::tensorflow::NodeDef* Arena::CreateMaybeMessage<::tensorflow::NodeDef>(Arena*);
+template<> ::tensorflow::NodeDef_AttrEntry_DoNotUse* Arena::CreateMaybeMessage<::tensorflow::NodeDef_AttrEntry_DoNotUse>(Arena*);
+template<> ::tensorflow::NodeDef_ExperimentalDebugInfo* Arena::CreateMaybeMessage<::tensorflow::NodeDef_ExperimentalDebugInfo>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace tensorflow {
+
+// ===================================================================
+
+class NodeDef_AttrEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<NodeDef_AttrEntry_DoNotUse, 
+    std::string, ::tensorflow::AttrValue,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> {
+public:
+  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<NodeDef_AttrEntry_DoNotUse, 
+    std::string, ::tensorflow::AttrValue,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
+  NodeDef_AttrEntry_DoNotUse();
+  explicit PROTOBUF_CONSTEXPR NodeDef_AttrEntry_DoNotUse(
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+  explicit NodeDef_AttrEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  void MergeFrom(const NodeDef_AttrEntry_DoNotUse& other);
+  static const NodeDef_AttrEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const NodeDef_AttrEntry_DoNotUse*>(&_NodeDef_AttrEntry_DoNotUse_default_instance_); }
+  static bool ValidateKey(std::string* s) {
+    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "tensorflow.NodeDef.AttrEntry.key");
+ }
+  static bool ValidateValue(void*) { return true; }
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fnode_5fdef_2eproto;
+};
+
+// -------------------------------------------------------------------
+
+class NodeDef_ExperimentalDebugInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.NodeDef.ExperimentalDebugInfo) */ {
+ public:
+  inline NodeDef_ExperimentalDebugInfo() : NodeDef_ExperimentalDebugInfo(nullptr) {}
+  ~NodeDef_ExperimentalDebugInfo() override;
+  explicit PROTOBUF_CONSTEXPR NodeDef_ExperimentalDebugInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  NodeDef_ExperimentalDebugInfo(const NodeDef_ExperimentalDebugInfo& from);
+  NodeDef_ExperimentalDebugInfo(NodeDef_ExperimentalDebugInfo&& from) noexcept
+    : NodeDef_ExperimentalDebugInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline NodeDef_ExperimentalDebugInfo& operator=(const NodeDef_ExperimentalDebugInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline NodeDef_ExperimentalDebugInfo& operator=(NodeDef_ExperimentalDebugInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const NodeDef_ExperimentalDebugInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const NodeDef_ExperimentalDebugInfo* internal_default_instance() {
+    return reinterpret_cast<const NodeDef_ExperimentalDebugInfo*>(
+               &_NodeDef_ExperimentalDebugInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(NodeDef_ExperimentalDebugInfo& a, NodeDef_ExperimentalDebugInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(NodeDef_ExperimentalDebugInfo* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(NodeDef_ExperimentalDebugInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  NodeDef_ExperimentalDebugInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<NodeDef_ExperimentalDebugInfo>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const NodeDef_ExperimentalDebugInfo& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const NodeDef_ExperimentalDebugInfo& from) {
+    NodeDef_ExperimentalDebugInfo::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(NodeDef_ExperimentalDebugInfo* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.NodeDef.ExperimentalDebugInfo";
+  }
+  protected:
+  explicit NodeDef_ExperimentalDebugInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kOriginalNodeNamesFieldNumber = 1,
+    kOriginalFuncNamesFieldNumber = 2,
+  };
+  // repeated string original_node_names = 1;
+  int original_node_names_size() const;
+  private:
+  int _internal_original_node_names_size() const;
+  public:
+  void clear_original_node_names();
+  const std::string& original_node_names(int index) const;
+  std::string* mutable_original_node_names(int index);
+  void set_original_node_names(int index, const std::string& value);
+  void set_original_node_names(int index, std::string&& value);
+  void set_original_node_names(int index, const char* value);
+  void set_original_node_names(int index, const char* value, size_t size);
+  std::string* add_original_node_names();
+  void add_original_node_names(const std::string& value);
+  void add_original_node_names(std::string&& value);
+  void add_original_node_names(const char* value);
+  void add_original_node_names(const char* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& original_node_names() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_original_node_names();
+  private:
+  const std::string& _internal_original_node_names(int index) const;
+  std::string* _internal_add_original_node_names();
+  public:
+
+  // repeated string original_func_names = 2;
+  int original_func_names_size() const;
+  private:
+  int _internal_original_func_names_size() const;
+  public:
+  void clear_original_func_names();
+  const std::string& original_func_names(int index) const;
+  std::string* mutable_original_func_names(int index);
+  void set_original_func_names(int index, const std::string& value);
+  void set_original_func_names(int index, std::string&& value);
+  void set_original_func_names(int index, const char* value);
+  void set_original_func_names(int index, const char* value, size_t size);
+  std::string* add_original_func_names();
+  void add_original_func_names(const std::string& value);
+  void add_original_func_names(std::string&& value);
+  void add_original_func_names(const char* value);
+  void add_original_func_names(const char* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& original_func_names() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_original_func_names();
+  private:
+  const std::string& _internal_original_func_names(int index) const;
+  std::string* _internal_add_original_func_names();
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.NodeDef.ExperimentalDebugInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> original_node_names_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> original_func_names_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fnode_5fdef_2eproto;
+};
+// -------------------------------------------------------------------
+
+class NodeDef final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.NodeDef) */ {
+ public:
+  inline NodeDef() : NodeDef(nullptr) {}
+  ~NodeDef() override;
+  explicit PROTOBUF_CONSTEXPR NodeDef(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  NodeDef(const NodeDef& from);
+  NodeDef(NodeDef&& from) noexcept
+    : NodeDef() {
+    *this = ::std::move(from);
+  }
+
+  inline NodeDef& operator=(const NodeDef& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline NodeDef& operator=(NodeDef&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const NodeDef& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const NodeDef* internal_default_instance() {
+    return reinterpret_cast<const NodeDef*>(
+               &_NodeDef_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(NodeDef& a, NodeDef& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(NodeDef* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(NodeDef* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  NodeDef* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<NodeDef>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const NodeDef& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const NodeDef& from) {
+    NodeDef::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(NodeDef* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.NodeDef";
+  }
+  protected:
+  explicit NodeDef(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef NodeDef_ExperimentalDebugInfo ExperimentalDebugInfo;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kInputFieldNumber = 3,
+    kAttrFieldNumber = 5,
+    kNameFieldNumber = 1,
+    kOpFieldNumber = 2,
+    kDeviceFieldNumber = 4,
+    kExperimentalDebugInfoFieldNumber = 6,
+    kExperimentalTypeFieldNumber = 7,
+  };
+  // repeated string input = 3;
+  int input_size() const;
+  private:
+  int _internal_input_size() const;
+  public:
+  void clear_input();
+  const std::string& input(int index) const;
+  std::string* mutable_input(int index);
+  void set_input(int index, const std::string& value);
+  void set_input(int index, std::string&& value);
+  void set_input(int index, const char* value);
+  void set_input(int index, const char* value, size_t size);
+  std::string* add_input();
+  void add_input(const std::string& value);
+  void add_input(std::string&& value);
+  void add_input(const char* value);
+  void add_input(const char* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& input() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_input();
+  private:
+  const std::string& _internal_input(int index) const;
+  std::string* _internal_add_input();
+  public:
+
+  // map<string, .tensorflow.AttrValue> attr = 5;
+  int attr_size() const;
+  private:
+  int _internal_attr_size() const;
+  public:
+  void clear_attr();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::AttrValue >&
+      _internal_attr() const;
+  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::AttrValue >*
+      _internal_mutable_attr();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::AttrValue >&
+      attr() const;
+  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::AttrValue >*
+      mutable_attr();
+
+  // string name = 1;
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // string op = 2;
+  void clear_op();
+  const std::string& op() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_op(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_op();
+  PROTOBUF_NODISCARD std::string* release_op();
+  void set_allocated_op(std::string* op);
+  private:
+  const std::string& _internal_op() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_op(const std::string& value);
+  std::string* _internal_mutable_op();
+  public:
+
+  // string device = 4;
+  void clear_device();
+  const std::string& device() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_device(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_device();
+  PROTOBUF_NODISCARD std::string* release_device();
+  void set_allocated_device(std::string* device);
+  private:
+  const std::string& _internal_device() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_device(const std::string& value);
+  std::string* _internal_mutable_device();
+  public:
+
+  // .tensorflow.NodeDef.ExperimentalDebugInfo experimental_debug_info = 6;
+  bool has_experimental_debug_info() const;
+  private:
+  bool _internal_has_experimental_debug_info() const;
+  public:
+  void clear_experimental_debug_info();
+  const ::tensorflow::NodeDef_ExperimentalDebugInfo& experimental_debug_info() const;
+  PROTOBUF_NODISCARD ::tensorflow::NodeDef_ExperimentalDebugInfo* release_experimental_debug_info();
+  ::tensorflow::NodeDef_ExperimentalDebugInfo* mutable_experimental_debug_info();
+  void set_allocated_experimental_debug_info(::tensorflow::NodeDef_ExperimentalDebugInfo* experimental_debug_info);
+  private:
+  const ::tensorflow::NodeDef_ExperimentalDebugInfo& _internal_experimental_debug_info() const;
+  ::tensorflow::NodeDef_ExperimentalDebugInfo* _internal_mutable_experimental_debug_info();
+  public:
+  void unsafe_arena_set_allocated_experimental_debug_info(
+      ::tensorflow::NodeDef_ExperimentalDebugInfo* experimental_debug_info);
+  ::tensorflow::NodeDef_ExperimentalDebugInfo* unsafe_arena_release_experimental_debug_info();
+
+  // .tensorflow.FullTypeDef experimental_type = 7;
+  bool has_experimental_type() const;
+  private:
+  bool _internal_has_experimental_type() const;
+  public:
+  void clear_experimental_type();
+  const ::tensorflow::FullTypeDef& experimental_type() const;
+  PROTOBUF_NODISCARD ::tensorflow::FullTypeDef* release_experimental_type();
+  ::tensorflow::FullTypeDef* mutable_experimental_type();
+  void set_allocated_experimental_type(::tensorflow::FullTypeDef* experimental_type);
+  private:
+  const ::tensorflow::FullTypeDef& _internal_experimental_type() const;
+  ::tensorflow::FullTypeDef* _internal_mutable_experimental_type();
+  public:
+  void unsafe_arena_set_allocated_experimental_type(
+      ::tensorflow::FullTypeDef* experimental_type);
+  ::tensorflow::FullTypeDef* unsafe_arena_release_experimental_type();
+
+  // @@protoc_insertion_point(class_scope:tensorflow.NodeDef)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> input_;
+    ::PROTOBUF_NAMESPACE_ID::internal::MapField<
+        NodeDef_AttrEntry_DoNotUse,
+        std::string, ::tensorflow::AttrValue,
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> attr_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr op_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_;
+    ::tensorflow::NodeDef_ExperimentalDebugInfo* experimental_debug_info_;
+    ::tensorflow::FullTypeDef* experimental_type_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fnode_5fdef_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// NodeDef_ExperimentalDebugInfo
+
+// repeated string original_node_names = 1;
+inline int NodeDef_ExperimentalDebugInfo::_internal_original_node_names_size() const {
+  return _impl_.original_node_names_.size();
+}
+inline int NodeDef_ExperimentalDebugInfo::original_node_names_size() const {
+  return _internal_original_node_names_size();
+}
+inline void NodeDef_ExperimentalDebugInfo::clear_original_node_names() {
+  _impl_.original_node_names_.Clear();
+}
+inline std::string* NodeDef_ExperimentalDebugInfo::add_original_node_names() {
+  std::string* _s = _internal_add_original_node_names();
+  // @@protoc_insertion_point(field_add_mutable:tensorflow.NodeDef.ExperimentalDebugInfo.original_node_names)
+  return _s;
+}
+inline const std::string& NodeDef_ExperimentalDebugInfo::_internal_original_node_names(int index) const {
+  return _impl_.original_node_names_.Get(index);
+}
+inline const std::string& NodeDef_ExperimentalDebugInfo::original_node_names(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.NodeDef.ExperimentalDebugInfo.original_node_names)
+  return _internal_original_node_names(index);
+}
+inline std::string* NodeDef_ExperimentalDebugInfo::mutable_original_node_names(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.NodeDef.ExperimentalDebugInfo.original_node_names)
+  return _impl_.original_node_names_.Mutable(index);
+}
+inline void NodeDef_ExperimentalDebugInfo::set_original_node_names(int index, const std::string& value) {
+  _impl_.original_node_names_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:tensorflow.NodeDef.ExperimentalDebugInfo.original_node_names)
+}
+inline void NodeDef_ExperimentalDebugInfo::set_original_node_names(int index, std::string&& value) {
+  _impl_.original_node_names_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:tensorflow.NodeDef.ExperimentalDebugInfo.original_node_names)
+}
+inline void NodeDef_ExperimentalDebugInfo::set_original_node_names(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.original_node_names_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:tensorflow.NodeDef.ExperimentalDebugInfo.original_node_names)
+}
+inline void NodeDef_ExperimentalDebugInfo::set_original_node_names(int index, const char* value, size_t size) {
+  _impl_.original_node_names_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:tensorflow.NodeDef.ExperimentalDebugInfo.original_node_names)
+}
+inline std::string* NodeDef_ExperimentalDebugInfo::_internal_add_original_node_names() {
+  return _impl_.original_node_names_.Add();
+}
+inline void NodeDef_ExperimentalDebugInfo::add_original_node_names(const std::string& value) {
+  _impl_.original_node_names_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:tensorflow.NodeDef.ExperimentalDebugInfo.original_node_names)
+}
+inline void NodeDef_ExperimentalDebugInfo::add_original_node_names(std::string&& value) {
+  _impl_.original_node_names_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:tensorflow.NodeDef.ExperimentalDebugInfo.original_node_names)
+}
+inline void NodeDef_ExperimentalDebugInfo::add_original_node_names(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.original_node_names_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:tensorflow.NodeDef.ExperimentalDebugInfo.original_node_names)
+}
+inline void NodeDef_ExperimentalDebugInfo::add_original_node_names(const char* value, size_t size) {
+  _impl_.original_node_names_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:tensorflow.NodeDef.ExperimentalDebugInfo.original_node_names)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+NodeDef_ExperimentalDebugInfo::original_node_names() const {
+  // @@protoc_insertion_point(field_list:tensorflow.NodeDef.ExperimentalDebugInfo.original_node_names)
+  return _impl_.original_node_names_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+NodeDef_ExperimentalDebugInfo::mutable_original_node_names() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.NodeDef.ExperimentalDebugInfo.original_node_names)
+  return &_impl_.original_node_names_;
+}
+
+// repeated string original_func_names = 2;
+inline int NodeDef_ExperimentalDebugInfo::_internal_original_func_names_size() const {
+  return _impl_.original_func_names_.size();
+}
+inline int NodeDef_ExperimentalDebugInfo::original_func_names_size() const {
+  return _internal_original_func_names_size();
+}
+inline void NodeDef_ExperimentalDebugInfo::clear_original_func_names() {
+  _impl_.original_func_names_.Clear();
+}
+inline std::string* NodeDef_ExperimentalDebugInfo::add_original_func_names() {
+  std::string* _s = _internal_add_original_func_names();
+  // @@protoc_insertion_point(field_add_mutable:tensorflow.NodeDef.ExperimentalDebugInfo.original_func_names)
+  return _s;
+}
+inline const std::string& NodeDef_ExperimentalDebugInfo::_internal_original_func_names(int index) const {
+  return _impl_.original_func_names_.Get(index);
+}
+inline const std::string& NodeDef_ExperimentalDebugInfo::original_func_names(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.NodeDef.ExperimentalDebugInfo.original_func_names)
+  return _internal_original_func_names(index);
+}
+inline std::string* NodeDef_ExperimentalDebugInfo::mutable_original_func_names(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.NodeDef.ExperimentalDebugInfo.original_func_names)
+  return _impl_.original_func_names_.Mutable(index);
+}
+inline void NodeDef_ExperimentalDebugInfo::set_original_func_names(int index, const std::string& value) {
+  _impl_.original_func_names_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:tensorflow.NodeDef.ExperimentalDebugInfo.original_func_names)
+}
+inline void NodeDef_ExperimentalDebugInfo::set_original_func_names(int index, std::string&& value) {
+  _impl_.original_func_names_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:tensorflow.NodeDef.ExperimentalDebugInfo.original_func_names)
+}
+inline void NodeDef_ExperimentalDebugInfo::set_original_func_names(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.original_func_names_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:tensorflow.NodeDef.ExperimentalDebugInfo.original_func_names)
+}
+inline void NodeDef_ExperimentalDebugInfo::set_original_func_names(int index, const char* value, size_t size) {
+  _impl_.original_func_names_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:tensorflow.NodeDef.ExperimentalDebugInfo.original_func_names)
+}
+inline std::string* NodeDef_ExperimentalDebugInfo::_internal_add_original_func_names() {
+  return _impl_.original_func_names_.Add();
+}
+inline void NodeDef_ExperimentalDebugInfo::add_original_func_names(const std::string& value) {
+  _impl_.original_func_names_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:tensorflow.NodeDef.ExperimentalDebugInfo.original_func_names)
+}
+inline void NodeDef_ExperimentalDebugInfo::add_original_func_names(std::string&& value) {
+  _impl_.original_func_names_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:tensorflow.NodeDef.ExperimentalDebugInfo.original_func_names)
+}
+inline void NodeDef_ExperimentalDebugInfo::add_original_func_names(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.original_func_names_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:tensorflow.NodeDef.ExperimentalDebugInfo.original_func_names)
+}
+inline void NodeDef_ExperimentalDebugInfo::add_original_func_names(const char* value, size_t size) {
+  _impl_.original_func_names_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:tensorflow.NodeDef.ExperimentalDebugInfo.original_func_names)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+NodeDef_ExperimentalDebugInfo::original_func_names() const {
+  // @@protoc_insertion_point(field_list:tensorflow.NodeDef.ExperimentalDebugInfo.original_func_names)
+  return _impl_.original_func_names_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+NodeDef_ExperimentalDebugInfo::mutable_original_func_names() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.NodeDef.ExperimentalDebugInfo.original_func_names)
+  return &_impl_.original_func_names_;
+}
+
+// -------------------------------------------------------------------
+
+// NodeDef
+
+// string name = 1;
+inline void NodeDef::clear_name() {
+  _impl_.name_.ClearToEmpty();
+}
+inline const std::string& NodeDef::name() const {
+  // @@protoc_insertion_point(field_get:tensorflow.NodeDef.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void NodeDef::set_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.NodeDef.name)
+}
+inline std::string* NodeDef::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:tensorflow.NodeDef.name)
+  return _s;
+}
+inline const std::string& NodeDef::_internal_name() const {
+  return _impl_.name_.Get();
+}
+inline void NodeDef::_internal_set_name(const std::string& value) {
+  
+  _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* NodeDef::_internal_mutable_name() {
+  
+  return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* NodeDef::release_name() {
+  // @@protoc_insertion_point(field_release:tensorflow.NodeDef.name)
+  return _impl_.name_.Release();
+}
+inline void NodeDef::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.NodeDef.name)
+}
+
+// string op = 2;
+inline void NodeDef::clear_op() {
+  _impl_.op_.ClearToEmpty();
+}
+inline const std::string& NodeDef::op() const {
+  // @@protoc_insertion_point(field_get:tensorflow.NodeDef.op)
+  return _internal_op();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void NodeDef::set_op(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.op_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.NodeDef.op)
+}
+inline std::string* NodeDef::mutable_op() {
+  std::string* _s = _internal_mutable_op();
+  // @@protoc_insertion_point(field_mutable:tensorflow.NodeDef.op)
+  return _s;
+}
+inline const std::string& NodeDef::_internal_op() const {
+  return _impl_.op_.Get();
+}
+inline void NodeDef::_internal_set_op(const std::string& value) {
+  
+  _impl_.op_.Set(value, GetArenaForAllocation());
+}
+inline std::string* NodeDef::_internal_mutable_op() {
+  
+  return _impl_.op_.Mutable(GetArenaForAllocation());
+}
+inline std::string* NodeDef::release_op() {
+  // @@protoc_insertion_point(field_release:tensorflow.NodeDef.op)
+  return _impl_.op_.Release();
+}
+inline void NodeDef::set_allocated_op(std::string* op) {
+  if (op != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.op_.SetAllocated(op, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.op_.IsDefault()) {
+    _impl_.op_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.NodeDef.op)
+}
+
+// repeated string input = 3;
+inline int NodeDef::_internal_input_size() const {
+  return _impl_.input_.size();
+}
+inline int NodeDef::input_size() const {
+  return _internal_input_size();
+}
+inline void NodeDef::clear_input() {
+  _impl_.input_.Clear();
+}
+inline std::string* NodeDef::add_input() {
+  std::string* _s = _internal_add_input();
+  // @@protoc_insertion_point(field_add_mutable:tensorflow.NodeDef.input)
+  return _s;
+}
+inline const std::string& NodeDef::_internal_input(int index) const {
+  return _impl_.input_.Get(index);
+}
+inline const std::string& NodeDef::input(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.NodeDef.input)
+  return _internal_input(index);
+}
+inline std::string* NodeDef::mutable_input(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.NodeDef.input)
+  return _impl_.input_.Mutable(index);
+}
+inline void NodeDef::set_input(int index, const std::string& value) {
+  _impl_.input_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:tensorflow.NodeDef.input)
+}
+inline void NodeDef::set_input(int index, std::string&& value) {
+  _impl_.input_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:tensorflow.NodeDef.input)
+}
+inline void NodeDef::set_input(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.input_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:tensorflow.NodeDef.input)
+}
+inline void NodeDef::set_input(int index, const char* value, size_t size) {
+  _impl_.input_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:tensorflow.NodeDef.input)
+}
+inline std::string* NodeDef::_internal_add_input() {
+  return _impl_.input_.Add();
+}
+inline void NodeDef::add_input(const std::string& value) {
+  _impl_.input_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:tensorflow.NodeDef.input)
+}
+inline void NodeDef::add_input(std::string&& value) {
+  _impl_.input_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:tensorflow.NodeDef.input)
+}
+inline void NodeDef::add_input(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.input_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:tensorflow.NodeDef.input)
+}
+inline void NodeDef::add_input(const char* value, size_t size) {
+  _impl_.input_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:tensorflow.NodeDef.input)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+NodeDef::input() const {
+  // @@protoc_insertion_point(field_list:tensorflow.NodeDef.input)
+  return _impl_.input_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+NodeDef::mutable_input() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.NodeDef.input)
+  return &_impl_.input_;
+}
+
+// string device = 4;
+inline void NodeDef::clear_device() {
+  _impl_.device_.ClearToEmpty();
+}
+inline const std::string& NodeDef::device() const {
+  // @@protoc_insertion_point(field_get:tensorflow.NodeDef.device)
+  return _internal_device();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void NodeDef::set_device(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.device_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.NodeDef.device)
+}
+inline std::string* NodeDef::mutable_device() {
+  std::string* _s = _internal_mutable_device();
+  // @@protoc_insertion_point(field_mutable:tensorflow.NodeDef.device)
+  return _s;
+}
+inline const std::string& NodeDef::_internal_device() const {
+  return _impl_.device_.Get();
+}
+inline void NodeDef::_internal_set_device(const std::string& value) {
+  
+  _impl_.device_.Set(value, GetArenaForAllocation());
+}
+inline std::string* NodeDef::_internal_mutable_device() {
+  
+  return _impl_.device_.Mutable(GetArenaForAllocation());
+}
+inline std::string* NodeDef::release_device() {
+  // @@protoc_insertion_point(field_release:tensorflow.NodeDef.device)
+  return _impl_.device_.Release();
+}
+inline void NodeDef::set_allocated_device(std::string* device) {
+  if (device != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.device_.SetAllocated(device, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.device_.IsDefault()) {
+    _impl_.device_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.NodeDef.device)
+}
+
+// map<string, .tensorflow.AttrValue> attr = 5;
+inline int NodeDef::_internal_attr_size() const {
+  return _impl_.attr_.size();
+}
+inline int NodeDef::attr_size() const {
+  return _internal_attr_size();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::AttrValue >&
+NodeDef::_internal_attr() const {
+  return _impl_.attr_.GetMap();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::AttrValue >&
+NodeDef::attr() const {
+  // @@protoc_insertion_point(field_map:tensorflow.NodeDef.attr)
+  return _internal_attr();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::AttrValue >*
+NodeDef::_internal_mutable_attr() {
+  return _impl_.attr_.MutableMap();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::AttrValue >*
+NodeDef::mutable_attr() {
+  // @@protoc_insertion_point(field_mutable_map:tensorflow.NodeDef.attr)
+  return _internal_mutable_attr();
+}
+
+// .tensorflow.NodeDef.ExperimentalDebugInfo experimental_debug_info = 6;
+inline bool NodeDef::_internal_has_experimental_debug_info() const {
+  return this != internal_default_instance() && _impl_.experimental_debug_info_ != nullptr;
+}
+inline bool NodeDef::has_experimental_debug_info() const {
+  return _internal_has_experimental_debug_info();
+}
+inline void NodeDef::clear_experimental_debug_info() {
+  if (GetArenaForAllocation() == nullptr && _impl_.experimental_debug_info_ != nullptr) {
+    delete _impl_.experimental_debug_info_;
+  }
+  _impl_.experimental_debug_info_ = nullptr;
+}
+inline const ::tensorflow::NodeDef_ExperimentalDebugInfo& NodeDef::_internal_experimental_debug_info() const {
+  const ::tensorflow::NodeDef_ExperimentalDebugInfo* p = _impl_.experimental_debug_info_;
+  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::NodeDef_ExperimentalDebugInfo&>(
+      ::tensorflow::_NodeDef_ExperimentalDebugInfo_default_instance_);
+}
+inline const ::tensorflow::NodeDef_ExperimentalDebugInfo& NodeDef::experimental_debug_info() const {
+  // @@protoc_insertion_point(field_get:tensorflow.NodeDef.experimental_debug_info)
+  return _internal_experimental_debug_info();
+}
+inline void NodeDef::unsafe_arena_set_allocated_experimental_debug_info(
+    ::tensorflow::NodeDef_ExperimentalDebugInfo* experimental_debug_info) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.experimental_debug_info_);
+  }
+  _impl_.experimental_debug_info_ = experimental_debug_info;
+  if (experimental_debug_info) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.NodeDef.experimental_debug_info)
+}
+inline ::tensorflow::NodeDef_ExperimentalDebugInfo* NodeDef::release_experimental_debug_info() {
+  
+  ::tensorflow::NodeDef_ExperimentalDebugInfo* temp = _impl_.experimental_debug_info_;
+  _impl_.experimental_debug_info_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::tensorflow::NodeDef_ExperimentalDebugInfo* NodeDef::unsafe_arena_release_experimental_debug_info() {
+  // @@protoc_insertion_point(field_release:tensorflow.NodeDef.experimental_debug_info)
+  
+  ::tensorflow::NodeDef_ExperimentalDebugInfo* temp = _impl_.experimental_debug_info_;
+  _impl_.experimental_debug_info_ = nullptr;
+  return temp;
+}
+inline ::tensorflow::NodeDef_ExperimentalDebugInfo* NodeDef::_internal_mutable_experimental_debug_info() {
+  
+  if (_impl_.experimental_debug_info_ == nullptr) {
+    auto* p = CreateMaybeMessage<::tensorflow::NodeDef_ExperimentalDebugInfo>(GetArenaForAllocation());
+    _impl_.experimental_debug_info_ = p;
+  }
+  return _impl_.experimental_debug_info_;
+}
+inline ::tensorflow::NodeDef_ExperimentalDebugInfo* NodeDef::mutable_experimental_debug_info() {
+  ::tensorflow::NodeDef_ExperimentalDebugInfo* _msg = _internal_mutable_experimental_debug_info();
+  // @@protoc_insertion_point(field_mutable:tensorflow.NodeDef.experimental_debug_info)
+  return _msg;
+}
+inline void NodeDef::set_allocated_experimental_debug_info(::tensorflow::NodeDef_ExperimentalDebugInfo* experimental_debug_info) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.experimental_debug_info_;
+  }
+  if (experimental_debug_info) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(experimental_debug_info);
+    if (message_arena != submessage_arena) {
+      experimental_debug_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, experimental_debug_info, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.experimental_debug_info_ = experimental_debug_info;
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.NodeDef.experimental_debug_info)
+}
+
+// .tensorflow.FullTypeDef experimental_type = 7;
+inline bool NodeDef::_internal_has_experimental_type() const {
+  return this != internal_default_instance() && _impl_.experimental_type_ != nullptr;
+}
+inline bool NodeDef::has_experimental_type() const {
+  return _internal_has_experimental_type();
+}
+inline const ::tensorflow::FullTypeDef& NodeDef::_internal_experimental_type() const {
+  const ::tensorflow::FullTypeDef* p = _impl_.experimental_type_;
+  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::FullTypeDef&>(
+      ::tensorflow::_FullTypeDef_default_instance_);
+}
+inline const ::tensorflow::FullTypeDef& NodeDef::experimental_type() const {
+  // @@protoc_insertion_point(field_get:tensorflow.NodeDef.experimental_type)
+  return _internal_experimental_type();
+}
+inline void NodeDef::unsafe_arena_set_allocated_experimental_type(
+    ::tensorflow::FullTypeDef* experimental_type) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.experimental_type_);
+  }
+  _impl_.experimental_type_ = experimental_type;
+  if (experimental_type) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.NodeDef.experimental_type)
+}
+inline ::tensorflow::FullTypeDef* NodeDef::release_experimental_type() {
+  
+  ::tensorflow::FullTypeDef* temp = _impl_.experimental_type_;
+  _impl_.experimental_type_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::tensorflow::FullTypeDef* NodeDef::unsafe_arena_release_experimental_type() {
+  // @@protoc_insertion_point(field_release:tensorflow.NodeDef.experimental_type)
+  
+  ::tensorflow::FullTypeDef* temp = _impl_.experimental_type_;
+  _impl_.experimental_type_ = nullptr;
+  return temp;
+}
+inline ::tensorflow::FullTypeDef* NodeDef::_internal_mutable_experimental_type() {
+  
+  if (_impl_.experimental_type_ == nullptr) {
+    auto* p = CreateMaybeMessage<::tensorflow::FullTypeDef>(GetArenaForAllocation());
+    _impl_.experimental_type_ = p;
+  }
+  return _impl_.experimental_type_;
+}
+inline ::tensorflow::FullTypeDef* NodeDef::mutable_experimental_type() {
+  ::tensorflow::FullTypeDef* _msg = _internal_mutable_experimental_type();
+  // @@protoc_insertion_point(field_mutable:tensorflow.NodeDef.experimental_type)
+  return _msg;
+}
+inline void NodeDef::set_allocated_experimental_type(::tensorflow::FullTypeDef* experimental_type) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.experimental_type_);
+  }
+  if (experimental_type) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(experimental_type));
+    if (message_arena != submessage_arena) {
+      experimental_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, experimental_type, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.experimental_type_ = experimental_type;
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.NodeDef.experimental_type)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace tensorflow
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fnode_5fdef_2eproto
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/node_def.proto b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/node_def.proto
new file mode 100644
index 0000000000000000000000000000000000000000..705e90aa3d165dac0848925f1b6ed45967eea99b
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/node_def.proto
@@ -0,0 +1,95 @@
+syntax = "proto3";
+
+package tensorflow;
+
+import "tensorflow/core/framework/attr_value.proto";
+import "tensorflow/core/framework/full_type.proto";
+
+option cc_enable_arenas = true;
+option java_outer_classname = "NodeProto";
+option java_multiple_files = true;
+option java_package = "org.tensorflow.framework";
+option go_package = "github.com/tensorflow/tensorflow/tensorflow/go/core/framework/node_def_go_proto";
+
+message NodeDef {
+  // The name given to this operator. Used for naming inputs,
+  // logging, visualization, etc.  Unique within a single GraphDef.
+  // Must match the regexp "[A-Za-z0-9.][A-Za-z0-9_>./]*".
+  string name = 1;
+
+  // The operation name.  There may be custom parameters in attrs.
+  // Op names starting with an underscore are reserved for internal use.
+  string op = 2;
+
+  // Each input is "node:src_output" with "node" being a string name and
+  // "src_output" indicating which output tensor to use from "node". If
+  // "src_output" is 0 the ":0" suffix can be omitted.  Regular inputs
+  // may optionally be followed by control inputs that have the format
+  // "^node".
+  repeated string input = 3;
+
+  // A (possibly partial) specification for the device on which this
+  // node should be placed.
+  // The expected syntax for this string is as follows:
+  //
+  // DEVICE_SPEC ::= PARTIAL_SPEC
+  //
+  // PARTIAL_SPEC ::= ("/" CONSTRAINT) *
+  // CONSTRAINT ::= ("job:" JOB_NAME)
+  //              | ("replica:" [1-9][0-9]*)
+  //              | ("task:" [1-9][0-9]*)
+  //              | ("device:" [A-Za-z]* ":" ([1-9][0-9]* | "*") )
+  //
+  // Valid values for this string include:
+  // * "/job:worker/replica:0/task:1/device:GPU:3"  (full specification)
+  // * "/job:worker/device:GPU:3"                   (partial specification)
+  // * ""                                    (no specification)
+  //
+  // If the constraints do not resolve to a single device (or if this
+  // field is empty or not present), the runtime will attempt to
+  // choose a device automatically.
+  string device = 4;
+
+  // Operation-specific graph-construction-time configuration.
+  // Note that this should include all attrs defined in the
+  // corresponding OpDef, including those with a value matching
+  // the default -- this allows the default to change and makes
+  // NodeDefs easier to interpret on their own.  However, if
+  // an attr with a default is not specified in this list, the
+  // default will be used.
+  // The "names" (keys) must match the regexp "[a-z][a-z0-9_]+" (and
+  // one of the names from the corresponding OpDef's attr field).
+  // The values must have a type matching the corresponding OpDef
+  // attr's type field.
+  // TODO(josh11b): Add some examples here showing best practices.
+  map<string, AttrValue> attr = 5;
+
+  message ExperimentalDebugInfo {
+    // Opaque string inserted into error messages created by the runtime.
+    //
+    // This is intended to store the list of names of the nodes from the
+    // original graph that this node was derived. For example if this node, say
+    // C, was result of a fusion of 2 nodes A and B, then 'original_node' would
+    // be {A, B}. This information can be used to map errors originating at the
+    // current node to some top level source code.
+    repeated string original_node_names = 1;
+
+    // This is intended to store the list of names of the functions from the
+    // original graph that this node was derived. For example if this node, say
+    // C, was result of a fusion of node A in function FA and node B in function
+    // FB, then `original_funcs` would be {FA, FB}. If the node is in the top
+    // level graph, the `original_func` is empty. This information, with the
+    // `original_node_names` can be used to map errors originating at the
+    // current ndoe to some top level source code.
+    repeated string original_func_names = 2;
+  }
+
+  // This stores debug information associated with the node.
+  ExperimentalDebugInfo experimental_debug_info = 6;
+
+  // The complete type of this node. Experimental and subject to change.
+  // Currently, the field only contains the return types of the node. That will
+  // extend in the future to contain the entire signature of the node, as a
+  // function type.
+  FullTypeDef experimental_type = 7;
+}
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/node_def_builder.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/node_def_builder.h
new file mode 100644
index 0000000000000000000000000000000000000000..0e8a5911b343882a114cdc87a9eb28755a22d454
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/node_def_builder.h
@@ -0,0 +1,193 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_NODE_DEF_BUILDER_H_
+#define TENSORFLOW_CORE_FRAMEWORK_NODE_DEF_BUILDER_H_
+
+#include <functional>
+#include <vector>
+
+#include "tensorflow/core/framework/attr_value_util.h"
+#include "tensorflow/core/framework/node_def.pb.h"
+#include "tensorflow/core/framework/node_def_util.h"
+#include "tensorflow/core/framework/op.h"
+#include "tensorflow/core/framework/op_def.pb.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/graph/graph.h"
+#include "tensorflow/core/graph/graph_node_util.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/lib/gtl/array_slice.h"
+#include "tensorflow/core/lib/strings/strcat.h"
+
+namespace tensorflow {
+
+class NodeDefBuilder;
+typedef std::function<Status(const OpDef&, int, const NodeDef&,
+                             NodeDefBuilder*)>
+    FakeInputFunctor;
+
+// This is a helper for creating a NodeDef.  Automatically sets attrs
+// that can be inferred from the inputs, and uses default values
+// (where they exist) for unspecified attrs.  Example usage:
+//
+//  NodeDef node_def;
+//  Status status = NodeDefBuilder(node_name, op_name)
+//                           .Input(...)
+//                           .Attr(...)
+//                           .Finalize(&node_def);
+//  if (!status.ok()) return status;
+//  // Use node_def here.
+class NodeDefBuilder {
+ public:
+  // To specify an output to be consumed by one of the Input() methods below.
+  struct NodeOut {
+    NodeOut(StringPiece n, int i, DataType dt);
+    NodeOut();  // uninitialized, call Reset() before use.
+    void Reset(StringPiece n, int i, DataType dt);
+    string node;
+    int index;
+    DataType data_type;
+  };
+
+  // Specify the name and the Op (either via an OpDef or the name of
+  // the Op plus a registry) for the NodeDef.  Other fields are
+  // specified by calling the methods below.
+  // REQUIRES: The OpDef must satisfy ValidateOpDef().
+  NodeDefBuilder(StringPiece name, StringPiece op_name,
+                 const OpRegistryInterface* op_registry = OpRegistry::Global(),
+                 const NodeDebugInfo* debug = nullptr);
+  NodeDefBuilder(StringPiece name, StringPiece op_name,
+                 const NodeDebugInfo& debug);
+  // REQUIRES: in addition, *op_def must outlive *this.
+  NodeDefBuilder(StringPiece name, const OpDef* op_def);
+
+  // You must call one Input() function per input_arg in the Op,
+  // *and in the same order as the input_args appear in the OpDef.*
+
+  // For inputs that take a single tensor.
+  NodeDefBuilder& Input(StringPiece src_node, int src_index, DataType dt);
+  NodeDefBuilder& Input(const NodeOut& src);
+
+  // For inputs that take a list of tensors.
+  NodeDefBuilder& Input(gtl::ArraySlice<NodeOut> src_list);
+
+  // To create inputs in tests, see fake_input.h.
+  NodeDefBuilder& Input(FakeInputFunctor fake_input);
+
+  // Specify that this node must only run after src_node.
+  NodeDefBuilder& ControlInput(StringPiece src_node);
+
+  // Constrains what devices this node may be scheduled on.
+  NodeDefBuilder& Device(StringPiece device_spec);
+
+  // Sets the attr, if not already set.  If already set with a different
+  // value, an error will be returned from Finalize().
+  NodeDefBuilder& Attr(StringPiece name, const AttrValue& value);
+  NodeDefBuilder& Attr(StringPiece name, AttrValue&& value);
+  NodeDefBuilder& Attr(StringPiece name, StringPiece value);
+  NodeDefBuilder& Attr(StringPiece name, const char* value);
+  NodeDefBuilder& Attr(StringPiece name, int32_t value);
+  NodeDefBuilder& Attr(StringPiece name, int64_t value);
+  NodeDefBuilder& Attr(StringPiece name, float value);
+  NodeDefBuilder& Attr(StringPiece name, double value);
+  NodeDefBuilder& Attr(StringPiece name, bool value);
+  NodeDefBuilder& Attr(StringPiece name, DataType value);
+  NodeDefBuilder& Attr(StringPiece name, const PartialTensorShape& value);
+  NodeDefBuilder& Attr(StringPiece name, const Tensor& value);
+  NodeDefBuilder& Attr(StringPiece name, const TensorProto& value);
+  NodeDefBuilder& Attr(StringPiece name, const NameAttrList& value);
+  NodeDefBuilder& Attr(StringPiece name, gtl::ArraySlice<StringPiece> value);
+  NodeDefBuilder& Attr(StringPiece name, gtl::ArraySlice<const char*> value);
+  NodeDefBuilder& Attr(StringPiece name, gtl::ArraySlice<string> value);
+  NodeDefBuilder& Attr(StringPiece name, gtl::ArraySlice<tstring> value);
+  NodeDefBuilder& Attr(StringPiece name, gtl::ArraySlice<int32> value);
+  NodeDefBuilder& Attr(StringPiece name, gtl::ArraySlice<int64_t> value);
+  NodeDefBuilder& Attr(StringPiece name, gtl::ArraySlice<float> value);
+  NodeDefBuilder& Attr(StringPiece name, gtl::ArraySlice<bool> value);
+  NodeDefBuilder& Attr(StringPiece name, const std::vector<bool>& value);
+  NodeDefBuilder& Attr(StringPiece name, gtl::ArraySlice<DataType> value);
+  NodeDefBuilder& Attr(StringPiece name, gtl::ArraySlice<TensorShape> value);
+  NodeDefBuilder& Attr(StringPiece name,
+                       gtl::ArraySlice<PartialTensorShape> value);
+  NodeDefBuilder& Attr(StringPiece name,
+                       gtl::ArraySlice<TensorShapeProto> value);
+  NodeDefBuilder& Attr(StringPiece name, gtl::ArraySlice<Tensor> value);
+  NodeDefBuilder& Attr(StringPiece name, gtl::ArraySlice<NameAttrList> value);
+
+  template <class T>
+  NodeDefBuilder& Attr(StringPiece name, std::initializer_list<T> value) {
+    return Attr(name, gtl::ArraySlice<T>(value));
+  }
+
+  // Finish building the NodeDef, returning any errors or setting
+  // *node_def if none.
+  // If `consume` is true, the builder state will be moved into `node_def`,
+  // and the builder will be left in an undefined state.
+  // WARNING: Not all problems are detected!  The resulting NodeDef may
+  // not be valid!  Call ValidateNodeDef() from node_def_utils to be sure.
+  Status Finalize(NodeDef* node_def, bool consume = false);
+
+  // Accessors for the values set in the constructor.
+  const string& node_name() const { return node_def_.name(); }
+  const OpDef& op_def() const { return *op_def_; }
+
+ private:
+  // Called in the constructors.
+  void Initialize();
+
+  // Get the current ArgDef and advance to the next one. Returns nullptr
+  // if no more inputs are available.
+  const OpDef::ArgDef* NextArgDef();
+
+  // Returns true if there is still an input_arg available in *op_def_,
+  // otherwise adds to error_ and returns false.
+  bool NextArgAvailable();
+
+  // These do the main work of the Input() methods.
+  void SingleInput(const OpDef::ArgDef* input_arg, StringPiece src_node,
+                   int src_index, DataType dt);
+  void ListInput(const OpDef::ArgDef* input_arg,
+                 gtl::ArraySlice<NodeOut> src_list);
+
+  // Add "src_node:src_index" to the list of inputs in the node_def_.
+  void AddInput(StringPiece src_node, int src_index);
+
+  // Generate an error if you can't pass dt when expected is expected.
+  void VerifyInputType(const OpDef::ArgDef* input_arg, DataType expected,
+                       DataType dt);
+
+  // If input_arg->is_ref() is true, generate an error if dt is not a ref.
+  void VerifyInputRef(const OpDef::ArgDef* input_arg, DataType dt);
+
+  // Makes dt a ref type if that is what the input_arg specifies.
+  DataType MaybeAddRef(const OpDef::ArgDef* input_arg, DataType dt) {
+    return input_arg->is_ref() ? MakeRefType(dt) : dt;
+  }
+
+  // Returns true if an attr named `name` is already present in the node_def_.
+  // If such an attr is already present and `value` is not equal to the present
+  // value, an error is generated.
+  bool AttrValueAlreadyPresent(StringPiece name, const AttrValue& value);
+
+  const OpDef* op_def_;
+  NodeDef node_def_;
+  int inputs_specified_;
+  std::vector<string> control_inputs_;
+  std::vector<string> errors_;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_NODE_DEF_BUILDER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/node_def_util.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/node_def_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..7987e5ebb03e373168859e6c73e9b3730b1d574d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/node_def_util.h
@@ -0,0 +1,451 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_NODE_DEF_UTIL_H_
+#define TENSORFLOW_CORE_FRAMEWORK_NODE_DEF_UTIL_H_
+
+#include <string>
+#include <unordered_set>
+#include <vector>
+
+#include "tensorflow/core/framework/attr_value_util.h"
+#include "tensorflow/core/framework/node_def.pb.h"
+#include "tensorflow/core/framework/op_def.pb.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/tensor_shape.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/framework/types.pb.h"
+#include "tensorflow/core/lib/core/stringpiece.h"
+#include "tensorflow/core/lib/gtl/array_slice.h"
+#include "tensorflow/core/lib/gtl/flatmap.h"
+#include "tensorflow/core/lib/hash/hash.h"
+#include "tensorflow/core/platform/hash.h"
+#include "tensorflow/core/platform/protobuf.h"
+#include "tensorflow/core/platform/status.h"
+#include "tensorflow/core/platform/stringpiece.h"
+#include "tensorflow/core/platform/types.h"
+#include "tensorflow/core/util/padding.h"
+
+namespace tensorflow {
+
+class AttrSlice;
+// We forward declare protos so that kernels don't need to depend on them
+class OpDef;
+class AttrValue;
+class NameAttrList;
+class TensorProto;
+class TensorShapeProto;
+
+// Name of the attribute used to encode node colocation constraints.
+//
+// Nodes can be co-located on the same device. Desire for explicit co-location
+// is described by list(string) attribute containing the name of colocation
+// groups.
+extern const char* const kColocationAttrName;
+
+// String prefix applied to the operation name for colocation constraints.
+extern const char* const kColocationGroupPrefix;
+
+// Constants for host CPU staging op for TPUExecute.
+extern const char* const kTpuExecuteStagingOp;
+extern const char* const kTpuExecuteStagingNodeName;
+
+// Produce a human-readable version of a Node or NodeDef that is more concise
+// than a text-format proto.
+//
+// The parameter `max_inputs_in_summary` specifies how many inputs at most to
+// serialize in the output (in order not to get a string which is overly large).
+// The value `-1` specifies that all inputs will be shown.
+std::string SummarizeNodeDef(const NodeDef& node_def,
+                             int max_inputs_in_summary = -1);
+std::string SummarizeAttrs(const NodeDef& node_def);
+std::string SummarizeAttrsHelper(AttrSlice attrs, StringPiece device);
+
+// Produces a formatted string pattern from the node which can uniquely identify
+// this node upstream to produce an informative error message. The pattern
+// followed is: {{node <node_name>}}
+std::string FormatNodeDefForError(const NodeDef& node_def);
+std::string FormatNodeDefForError(
+    StringPiece node_name, bool has_experimental_debug_info,
+    const NodeDef_ExperimentalDebugInfo& experimental_debug_info);
+
+typedef protobuf::Map<string, AttrValue> AttrValueMap;
+
+// Adds an attr with name <name> and value <value> to *node_def.
+// The type of the attr is based on the type of value.
+void AddNodeAttr(StringPiece name, const AttrValue& value, NodeDef* node_def);
+void AddNodeAttr(StringPiece name, AttrValue&& value, NodeDef* node_def);
+void AddNodeAttr(StringPiece name, StringPiece value, NodeDef* node_def);
+void AddNodeAttr(StringPiece name, const char* value, NodeDef* node_def);
+void AddNodeAttr(StringPiece name, int32_t value, NodeDef* node_def);
+void AddNodeAttr(StringPiece name, int64_t value, NodeDef* node_def);
+void AddNodeAttr(StringPiece name, float value, NodeDef* node_def);
+void AddNodeAttr(StringPiece name, double value, NodeDef* node_def);
+void AddNodeAttr(StringPiece name, bool value, NodeDef* node_def);
+void AddNodeAttr(StringPiece name, DataType value, NodeDef* node_def);
+void AddNodeAttr(StringPiece name, const PartialTensorShape& value,
+                 NodeDef* node_def);
+void AddNodeAttr(StringPiece name, const Tensor& value, NodeDef* node_def);
+void AddNodeAttr(StringPiece name, const TensorProto& value, NodeDef* node_def);
+void AddNodeAttr(StringPiece name, const NameAttrList& value,
+                 NodeDef* node_def);
+void AddNodeAttr(StringPiece name, gtl::ArraySlice<StringPiece> value,
+                 NodeDef* node_def);
+void AddNodeAttr(StringPiece name, gtl::ArraySlice<const char*> value,
+                 NodeDef* node_def);
+void AddNodeAttr(StringPiece name, gtl::ArraySlice<string> value,
+                 NodeDef* node_def);
+void AddNodeAttr(StringPiece name, gtl::ArraySlice<int32> value,
+                 NodeDef* node_def);
+void AddNodeAttr(StringPiece name, gtl::ArraySlice<int64_t> value,
+                 NodeDef* node_def);
+void AddNodeAttr(StringPiece name, gtl::ArraySlice<float> value,
+                 NodeDef* node_def);
+void AddNodeAttr(StringPiece name, gtl::ArraySlice<bool> value,
+                 NodeDef* node_def);
+void AddNodeAttr(StringPiece name, const std::vector<bool>& value,
+                 NodeDef* node_def);
+void AddNodeAttr(StringPiece name, gtl::ArraySlice<DataType> value,
+                 NodeDef* node_def);
+void AddNodeAttr(StringPiece name, gtl::ArraySlice<TensorShape> value,
+                 NodeDef* node_def);
+void AddNodeAttr(StringPiece name, gtl::ArraySlice<PartialTensorShape> value,
+                 NodeDef* node_def);
+void AddNodeAttr(StringPiece name, gtl::ArraySlice<TensorShapeProto> value,
+                 NodeDef* node_def);
+void AddNodeAttr(StringPiece name, gtl::ArraySlice<Tensor> value,
+                 NodeDef* node_def);
+void AddNodeAttr(StringPiece name, gtl::ArraySlice<NameAttrList> value,
+                 NodeDef* node_def);
+
+// Version to workaround C++'s "perfect" forwarding not being able to
+// forward {...} initialization.
+template <class T>
+void AddNodeAttr(StringPiece name, std::initializer_list<T> value,
+                 NodeDef* node_def) {
+  AddNodeAttr(name, gtl::ArraySlice<T>(value), node_def);
+}
+
+// Adds an attr to an attr value map.
+void AddAttr(StringPiece name, const AttrValue& value, AttrValueMap* map);
+void AddAttr(StringPiece name, bool value, AttrValueMap* map);
+
+class AttrSlice {
+ public:
+  AttrSlice(const NodeDef& node_def);  // NOLINT(runtime/explicit)
+
+  AttrSlice();  // Empty
+  explicit AttrSlice(const AttrValueMap* a);
+
+  int size() const { return attrs()->size(); }
+
+  // Returns the attr with attr_name if found.  Otherwise, returns
+  // nullptr.
+  const AttrValue* Find(StringPiece attr_name) const;
+  const AttrValue* FindByString(const std::string& attr_name) const;
+
+  // Returns the attr_value for attr_name if found. Otherwise, returns a
+  // NotFound status.
+  Status Find(StringPiece attr_name, const AttrValue** attr_value) const;
+  Status FindByString(const std::string& attr_name,
+                      const AttrValue** attr_value) const;
+
+  // Helper class to avoid allocations in EqualAttrs.
+  // TODO(irving): Will go away once NodeInfo is used.
+  struct Scratch {
+    std::string a;
+    std::string b;
+  };
+
+  // Check if all attrs and attr values match.  Does not take defaults into
+  // account.
+  //
+  // TODO(irving): There is a bug in this routine inherited from its
+  // OptimizerCSE::EqualAttrs predecessor.  The same tensor attr can be
+  // represented in more than one way as an AttrValue, since TensorProto is
+  // not 1-1.  This bug will go away once I replace everything with NodeInfo,
+  // which stores a Tensor object directly.  The Scratch object will also go
+  // away.
+  bool EqualAttrs(AttrSlice other, Scratch* scratch) const;
+
+  // If this AttrSlice has an attached NodeDef, summarize it.  This is for
+  // error messages only: we intentionally do not provide direct access to the
+  // NodeDef, since it is not always there.
+  std::string SummarizeNode() const;
+
+  // Iteration over all attrs
+  AttrValueMap::const_iterator begin() const { return attrs()->begin(); }
+  AttrValueMap::const_iterator end() const { return attrs()->end(); }
+
+  std::string DebugString() const;
+
+ private:
+  const AttrValueMap* attrs() const {
+    return ndef_ != nullptr ? &ndef_->attr() : attrs_;
+  }
+
+  Status CheckFind(StringPiece attr_name, const AttrValue* attr_value) const;
+
+  const NodeDef* ndef_;
+  const AttrValueMap* attrs_;
+};
+
+// Return true if the attr with the name attr_name is defined in node_def.
+bool HasNodeAttr(const NodeDef& node_def, StringPiece attr_name);
+
+// Look up the attr with name attr_name and set *value to its value.  If no
+// attr with attr_name is found in node_def, or the attr does not have
+// a matching type, a non-ok status will be returned.
+Status GetNodeAttr(const AttrSlice& attrs, StringPiece attr_name,
+                   std::string* value);  // type: "string"
+Status GetNodeAttr(const AttrSlice& attrs, StringPiece attr_name,
+                   tstring* value);  // type: "tstring"
+Status GetNodeAttr(const AttrSlice& attrs, StringPiece attr_name,
+                   int64_t* value);  // type: "int"
+Status GetNodeAttr(const AttrSlice& attrs, StringPiece attr_name,
+                   int32* value);  // type: "int"
+Status GetNodeAttr(const AttrSlice& attrs, StringPiece attr_name,
+                   float* value);  // type: "float"
+Status GetNodeAttr(const AttrSlice& attrs, StringPiece attr_name,
+                   bool* value);  // type: "bool"
+Status GetNodeAttr(const AttrSlice& attrs, StringPiece attr_name,
+                   DataType* value);  // type: "type"
+Status GetNodeAttr(const AttrSlice& attrs, StringPiece attr_name,
+                   TensorShapeProto* value);  // type: "shape"
+Status GetNodeAttr(const AttrSlice& attrs, StringPiece attr_name,
+                   TensorShape* value);  // type: "shape"
+Status GetNodeAttr(const AttrSlice& attrs, StringPiece attr_name,
+                   PartialTensorShape* value);  // type: "shape"
+Status GetNodeAttr(const AttrSlice& attrs, StringPiece attr_name,
+                   Tensor* value);  // type: "tensor"
+Status GetNodeAttr(const AttrSlice& attrs, StringPiece attr_name,
+                   std::vector<string>* value);  // type "list(string)"
+Status GetNodeAttr(const AttrSlice& attrs, StringPiece attr_name,
+                   std::vector<tstring>* value);  // type "list(tstring)"
+Status GetNodeAttr(const AttrSlice& attrs, StringPiece attr_name,
+                   std::vector<int64_t>* value);  // type "list(int)"
+Status GetNodeAttr(const AttrSlice& attrs, StringPiece attr_name,
+                   std::vector<int32>* value);  // type "list(int)"
+Status GetNodeAttr(const AttrSlice& attrs, StringPiece attr_name,
+                   std::vector<float>* value);  // type "list(float)"
+Status GetNodeAttr(const AttrSlice& attrs, StringPiece attr_name,
+                   std::vector<bool>* value);  // type "list(bool)"
+Status GetNodeAttr(const AttrSlice& attrs, StringPiece attr_name,
+                   std::vector<DataType>* value);  // type "list(type)"
+Status GetNodeAttr(const AttrSlice& attrs, StringPiece attr_name,
+                   DataTypeVector* value);  // type "list(type)"
+Status GetNodeAttr(const AttrSlice& attrs, StringPiece attr_name,
+                   std::vector<TensorShapeProto>* value);  // type "list(shape)"
+Status GetNodeAttr(const AttrSlice& attrs, StringPiece attr_name,
+                   std::vector<TensorShape>* value);  // type "list(shape)"
+Status GetNodeAttr(
+    const AttrSlice& attrs, StringPiece attr_name,
+    std::vector<PartialTensorShape>* value);  // type "list(shape)"
+Status GetNodeAttr(const AttrSlice& attrs, StringPiece attr_name,
+                   std::vector<Tensor>* value);  // type: "list(tensor)"
+
+template <typename T>
+StatusOr<T> GetNodeAttr(const NodeDef& ndef, absl::string_view attr_name) {
+  T val;
+  TF_RETURN_IF_ERROR(GetNodeAttr(ndef, attr_name, &val));
+  return val;
+}
+
+// This version avoids copying the TensorProto.
+// REQUIRES: Must not use *value beyond the lifetime of node_def.
+Status GetNodeAttr(const AttrSlice& attrs, StringPiece attr_name,
+                   const TensorProto** value);  // type: "tensor"
+bool TryGetNodeAttr(const AttrSlice& attrs, StringPiece attr_name,
+                    const TensorProto** value);  // type: "tensor"
+
+// This version avoids copying the NameAttrList.
+// REQUIRES: Must not use *value beyond the lifetime of node_def.
+Status GetNodeAttr(const AttrSlice& attrs, StringPiece attr_name,
+                   const NameAttrList** value);  // type: "func"
+bool TryGetNodeAttr(const AttrSlice& attrs, StringPiece attr_name,
+                    const NameAttrList** value);  // type: "func"
+
+// These versions copies the NameAttrList(s).
+Status GetNodeAttr(const AttrSlice& attrs, StringPiece attr_name,
+                   NameAttrList* value);  // type: "func"
+Status GetNodeAttr(const AttrSlice& attrs, StringPiece attr_name,
+                   std::vector<NameAttrList>* value);  // type: "list(func)"
+
+// Look up the attr with name attr_name and set *value to its value.  If no
+// attr with attr_name is found in node_def, or the attr does not have
+// a matching type, false is returned.
+bool TryGetNodeAttr(const AttrSlice& attrs, StringPiece attr_name,
+                    std::string* value);  // type: "string"
+bool TryGetNodeAttr(const AttrSlice& attrs, StringPiece attr_name,
+                    int64_t* value);  // type: "int"
+bool TryGetNodeAttr(const AttrSlice& attrs, StringPiece attr_name,
+                    std::vector<int64_t>* value);  // type: "int"
+bool TryGetNodeAttr(const AttrSlice& attrs, StringPiece attr_name,
+                    int32* value);  // type: "int"
+bool TryGetNodeAttr(const AttrSlice& attrs, StringPiece attr_name,
+                    float* value);  // type: "float"
+bool TryGetNodeAttr(const AttrSlice& attrs, StringPiece attr_name,
+                    bool* value);  // type: "bool"
+bool TryGetNodeAttr(const AttrSlice& attrs, StringPiece attr_name,
+                    DataType* value);  // type: "type"
+bool TryGetNodeAttr(const AttrSlice& attrs, StringPiece attr_name,
+                    TensorShape* value);  // type: "shape"
+
+bool TryGetNodeAttr(const AttrSlice& attrs, StringPiece attr_name,
+                    std::vector<string>* value);  // type: "list(string)"
+bool TryGetNodeAttr(const AttrSlice& attrs, StringPiece attr_name,
+                    std::vector<tstring>* value);  // type: "list(tstring)"
+bool TryGetNodeAttr(const AttrSlice& attrs, StringPiece attr_name,
+                    std::vector<int32>* value);  // type: "list(int)"
+bool TryGetNodeAttr(const AttrSlice& attrs, StringPiece attr_name,
+                    std::vector<float>* value);  // type: "list(float)"
+bool TryGetNodeAttr(const AttrSlice& attrs, StringPiece attr_name,
+                    std::vector<bool>* value);  // type: "list(bool)"
+bool TryGetNodeAttr(const AttrSlice& attrs, StringPiece attr_name,
+                    std::vector<DataType>* value);  // type: "list(type)"
+bool TryGetNodeAttr(const AttrSlice& attrs, StringPiece attr_name,
+                    std::vector<TensorShape> value);  // type: "shape"
+
+// Overloads of TryGetNodeAttr() that avoid copying the non-POD attribute
+// values.
+bool TryGetNodeAttr(const AttrSlice& attrs, StringPiece attr_name,
+                    std::vector<const string*>* value);  // type: "list(string)"
+bool TryGetNodeAttr(
+    const AttrSlice& attrs, StringPiece attr_name,
+    std::vector<const TensorShapeProto*>* value);  // type: "list(shape)"
+
+// Look up the attr with name attr_name and return a reference to its value.
+// If no attr with attr_name is found in node_def, or the attr does not have
+// a matching type, a reference to an empty string is returned.
+// REQUIRES: Must not use the returned value beyond the lifetime of node_def.
+const std::string& GetNodeAttrString(const AttrSlice& attrs,
+                                     StringPiece attr_name);
+
+// Specialization to parse an attribute directly into a Padding enum.
+Status GetNodeAttr(const AttrSlice& attrs, StringPiece attr_name,
+                   Padding* value);
+
+// Computes the input type for a specific node input.
+// REQUIRES: ValidateOpDef(op_def).ok()
+Status InputTypeForNode(const NodeDef& node_def, const OpDef& op_def,
+                        int input_port, DataType* input_type);
+// Computes the input types for a specific node.
+// REQUIRES: ValidateOpDef(op_def).ok()
+Status InputTypesForNode(const NodeDef& node_def, const OpDef& op_def,
+                         DataTypeVector* inputs);
+// Computes the output type for a specific node output.
+// REQUIRES: ValidateOpDef(op_def).ok()
+Status OutputTypeForNode(const NodeDef& node_def, const OpDef& op_def,
+                         int output_port, DataType* output_type);
+// Computes the output types for a specific node.
+// REQUIRES: ValidateOpDef(op_def).ok()
+Status OutputTypesForNode(const NodeDef& node_def, const OpDef& op_def,
+                          DataTypeVector* outputs);
+Status OutputTypesForNode(const AttrSlice& attrs, const OpDef& op_def,
+                          DataTypeVector* outputs);
+
+// Computes the input and output types for a specific node.
+// REQUIRES: ValidateOpDef(op_def).ok()
+Status InOutTypesForNode(const NodeDef& node_def, const OpDef& op_def,
+                         DataTypeVector* inputs, DataTypeVector* outputs);
+// Computes the number of outputs for a specific node.
+// REQUIRES: ValidateOpDef(op_def).ok()
+Status NumOutputsForNode(const NodeDef& node_def, const OpDef& op_def,
+                         int* num_outputs);
+
+// Map a node/op's input/output port_id to arg_id.
+//
+// The port_id refers to the n-th tensor of the node, while the arg_id refers to
+// the n-th arg of the op. These two can be different if an op's arg is a list
+// of tensors.
+//
+// We return -1 for any invalid port_id (i.e., no corresponding arg_id).
+int OpPortIdToArgId(const NodeDef& node,
+                    const protobuf::RepeatedPtrField<OpDef::ArgDef>& args,
+                    int port_id);
+
+// Validates that the NodeDef:
+// * Defines all expected attrs from the OpDef.
+// * All attrs satisfies constraints from the OpDef.
+// * Has a signature matching SignatureForNode().
+// etc.
+Status ValidateNodeDef(const NodeDef& node_def, const OpDef& op_def);
+
+// Computes the mapping from input/output argument name to the
+// corresponding input/output index range.  For example,
+// input "foo" corresponds to input indices
+//   [ (*inputs)["foo"].first, (*inputs)["foo"].second ).
+// NOTE(mrry): To reduce allocations when the map is used and save
+// space, the returned `NameRangeMap` objects borrow the input/output
+// argument names from `op_def`. The `op_def` must outlive the
+// returned `NameRangeMap` objects.
+typedef gtl::FlatMap<StringPiece, std::pair<int, int>, hash<StringPiece>>
+    NameRangeMap;
+Status NameRangesForNode(const AttrSlice& attrs, const OpDef& op_def,
+                         NameRangeMap* inputs, NameRangeMap* outputs);
+// Adds default values to *node_def for unspecified attrs from op_def.
+void AddDefaultsToNodeDef(const OpDef& op_def, NodeDef* node_def);
+
+// Remove attributes from node_def when the value is the default from the
+// op_def.
+void StripDefaultsFromNodeDef(const OpDef& op_def, NodeDef* node_def);
+
+// Validates the syntax of a NodeDef provided externally.
+//
+// The following is an EBNF-style syntax for NodeDef objects. Note that
+// Node objects are actually specified as tensorflow::NodeDef protocol buffers,
+// which contain many other fields that are not (currently) validated.
+//
+// Node         = NodeName, Inputs
+// Inputs       = ( DataInput * ), ( ControlInput * )
+// DataInput    = NodeName, ( ":", [1-9], [0-9] * ) ?
+// ControlInput = "^", NodeName
+// NodeName     = [A-Za-z0-9.], [A-Za-z0-9_./] *
+Status ValidateExternalNodeDefSyntax(const NodeDef& node_def);
+
+// Returns "status" with formatted NodeDef attached as additional text
+// in the error message. If 'allow_multiple_formatted_node' is false and there
+// is already a formatted NodeDef present in 'status', we simply attach the name
+// of the NodeDef instead of the formatted string.
+Status AttachDef(const Status& status, const NodeDef& node_def,
+                 bool allow_multiple_formatted_node = false);
+// Appends the given prefix and suffix to the original node name in order to
+// make the name unique. If it's an "Enter" node and uniquify_frame_name is
+// true, use the same way to reset attribute "frame_name".
+Status AddPrefixAndSuffixToNode(StringPiece prefix, StringPiece suffix,
+                                NodeDef* node_def,
+                                bool uniquify_frame_name = true);
+
+// Appends the given prefix to the colocation group name if the name exists
+// in `to_match`.
+Status MaybeAddPrefixToColocationConstraints(
+    const std::unordered_set<string>& match, StringPiece prefix,
+    NodeDef* node_def);
+
+// Updates the colocation constraint name with the one provided in the map (if
+// it exists in the map) for node_def.
+Status MaybeUpdateColocationConstraintsWithMap(
+    const std::map<absl::string_view, absl::string_view>& node_name_map,
+    NodeDef* node_def);
+
+// For replacing a existing node with a NoOp, change the op and clear full type
+// information (since a NoOp has no output). Note that (duplicate control or
+// all) inputs, (regular, output or all) attributes and output properperties are
+// NOT cleared (and should be cleared if appropriate elsewhere).
+void ChangeToNoOp(NodeDef* node_def);
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_NODE_DEF_UTIL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/node_properties.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/node_properties.h
new file mode 100644
index 0000000000000000000000000000000000000000..88489f44fc4acc8270a7542b90b31c477d8ff323
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/node_properties.h
@@ -0,0 +1,64 @@
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_NODE_PROPERTIES_H_
+#define TENSORFLOW_CORE_FRAMEWORK_NODE_PROPERTIES_H_
+
+#include "tensorflow/core/framework/node_def.pb.h"
+#include "tensorflow/core/framework/op_def.pb.h"
+#include "tensorflow/core/framework/op_def_builder.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/lib/core/status.h"
+
+namespace tensorflow {
+
+class OpRegistryInterface;
+
+struct NodeProperties {
+ public:
+  NodeProperties(const OpDef* op_def, NodeDef node_def,
+                 const DataTypeSlice inputs, const DataTypeSlice outputs)
+      : NodeProperties(op_def, std::move(node_def),
+                       DataTypeVector(inputs.begin(), inputs.end()),
+                       DataTypeVector(outputs.begin(), outputs.end())) {}
+
+  NodeProperties(const OpDef* _op_def, NodeDef&& _node_def,
+                 DataTypeVector inputs, DataTypeVector outputs)
+      : op_def(_op_def),
+        node_def(std::move(_node_def)),
+        input_types(std::move(inputs)),
+        input_types_slice(input_types),
+        output_types(std::move(outputs)),
+        output_types_slice(output_types) {}
+
+  // Resets the 'props' shared pointer to point to a new NodeProperties created
+  // from the given NodeDef. 'op_registry' is used to look up the OpDef
+  // corresponding to node_def.op(). Returns an error if OpDef lookup or
+  // creation failed.
+  static Status CreateFromNodeDef(NodeDef node_def,
+                                  const OpRegistryInterface* op_registry,
+                                  std::shared_ptr<const NodeProperties>* props);
+
+  const OpDef* op_def;  // not owned.
+  NodeDef node_def;
+  DataTypeVector input_types;
+  DataTypeSlice input_types_slice;
+  DataTypeVector output_types;
+  DataTypeSlice output_types_slice;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_NODE_PROPERTIES_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/numeric_op.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/numeric_op.h
new file mode 100644
index 0000000000000000000000000000000000000000..0167e21f113fecfd9b0f7708b202f3ceb22e02a4
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/numeric_op.h
@@ -0,0 +1,113 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_NUMERIC_OP_H_
+#define TENSORFLOW_CORE_FRAMEWORK_NUMERIC_OP_H_
+
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/framework/types.pb.h"
+#include "tensorflow/core/lib/core/errors.h"
+#include "tensorflow/core/lib/core/status.h"
+
+namespace tensorflow {
+
+// One input and one output, both the same type.
+template <class T>
+class UnaryOp : public OpKernel {
+ public:
+  explicit UnaryOp(OpKernelConstruction* context) : OpKernel(context) {
+    const DataType dt = DataTypeToEnum<T>::v();
+    OP_REQUIRES_OK(context, context->MatchSignature({dt}, {dt}));
+  }
+};
+
+// Two inputs and one output, all the same type.
+template <class T>
+class BinaryOp : public OpKernel {
+ public:
+  explicit BinaryOp(OpKernelConstruction* context) : OpKernel(context) {
+    const DataType dt = DataTypeToEnum<T>::v();
+    OP_REQUIRES_OK(context, context->MatchSignature({dt, dt}, {dt}));
+  }
+};
+
+// For operations where the input and output are the same shape.
+//
+// For usage, see ../framework/elementwise_ops.cc.
+template <class T, class CHILD>
+class UnaryElementWiseOp : public UnaryOp<T> {
+ public:
+  using UnaryOp<T>::UnaryOp;
+
+  void Compute(OpKernelContext* context) override {
+    // Output shape is the same as input shape.
+    const Tensor& input = context->input(0);
+    Tensor* output = nullptr;
+    OP_REQUIRES_OK(context, context->forward_input_or_allocate_output(
+                                {0}, 0, input.shape(), &output));
+    static_cast<CHILD*>(this)->Operate(context, input, output);
+  }
+};
+
+// For binary elementwise operations.
+template <class T, class CHILD>
+class BinaryElementWiseOp : public BinaryOp<T> {
+ public:
+  using BinaryOp<T>::BinaryOp;
+
+  void Compute(OpKernelContext* context) override {
+    const Tensor& a = context->input(0);
+    const Tensor& b = context->input(1);
+
+    if (!context->ValidateInputsAreSameShape(this)) {
+      return;
+    }
+
+    Tensor* output = nullptr;
+    OP_REQUIRES_OK(context, context->forward_input_or_allocate_output(
+                                {0, 1}, 0, a.shape(), &output));
+
+    // Dispatch to the descendant's Operate() function.
+    switch (a.dims()) {
+#define NDIM_CASE(NDIMS)                                                       \
+  case NDIMS: {                                                                \
+    static_cast<CHILD*>(this)->template Operate<NDIMS>(context, a, b, output); \
+    break;                                                                     \
+  }
+
+      NDIM_CASE(0);
+      NDIM_CASE(1);
+      NDIM_CASE(2);
+      NDIM_CASE(3);
+      NDIM_CASE(4);
+      NDIM_CASE(5);
+      NDIM_CASE(6);
+      NDIM_CASE(7);
+      NDIM_CASE(8);
+#undef NDIM_CASE
+
+      default:
+        context->SetStatus(errors::InvalidArgument(
+            "We only handle up to Tensor::dims() up to 8, not ", a.dims()));
+        break;
+    }
+  }
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_NUMERIC_OP_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/numeric_types.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/numeric_types.h
new file mode 100644
index 0000000000000000000000000000000000000000..45b8765325e2fe3b9a8573ee9af4642ed3d8b57e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/numeric_types.h
@@ -0,0 +1,44 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_NUMERIC_TYPES_H_
+#define TENSORFLOW_CORE_FRAMEWORK_NUMERIC_TYPES_H_
+
+#include <complex>
+
+// clang-format off
+// This include order is required to avoid instantiating templates
+// quantized types in the Eigen namespace before their specialization.
+#include "tsl/framework/numeric_types.h"
+#include "tensorflow/core/platform/types.h"
+// clang-format on
+
+namespace tensorflow {
+
+// NOLINTBEGIN(misc-unused-using-decls)
+using tsl::complex128;
+using tsl::complex64;
+
+// We use Eigen's QInt implementations for our quantized int types.
+using tsl::qint16;
+using tsl::qint32;
+using tsl::qint8;
+using tsl::quint16;
+using tsl::quint8;
+// NOLINTEND(misc-unused-using-decls)
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_NUMERIC_TYPES_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/op.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/op.h
new file mode 100644
index 0000000000000000000000000000000000000000..993ac59112a1a71f6764ac7385d17a3a7658a32f
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/op.h
@@ -0,0 +1,326 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_OP_H_
+#define TENSORFLOW_CORE_FRAMEWORK_OP_H_
+
+#include <functional>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "absl/container/flat_hash_map.h"
+#include "tensorflow/core/framework/full_type.pb.h"
+#include "tensorflow/core/framework/full_type_inference_util.h"  // IWYU pragma: export
+#include "tensorflow/core/framework/full_type_util.h"  // IWYU pragma: export
+#include "tensorflow/core/framework/op_def_builder.h"
+#include "tensorflow/core/framework/op_def_util.h"  // IWYU pragma: export
+#include "tensorflow/core/framework/registration/registration.h"
+#include "tensorflow/core/lib/core/errors.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/platform/macros.h"
+#include "tensorflow/core/platform/mutex.h"
+#include "tensorflow/core/platform/thread_annotations.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+
+// Users that want to look up an OpDef by type name should take an
+// OpRegistryInterface.  Functions accepting a
+// (const) OpRegistryInterface* may call LookUp() from multiple threads.
+class OpRegistryInterface {
+ public:
+  virtual ~OpRegistryInterface() = default;
+
+  // Returns an error status and sets *op_reg_data to nullptr if no OpDef is
+  // registered under that name, otherwise returns the registered OpDef.
+  // Caller must not delete the returned pointer.
+  virtual Status LookUp(const std::string& op_type_name,
+                        const OpRegistrationData** op_reg_data) const = 0;
+
+  // Shorthand for calling LookUp to get the OpDef.
+  Status LookUpOpDef(const std::string& op_type_name,
+                     const OpDef** op_def) const;
+};
+
+// The standard implementation of OpRegistryInterface, along with a
+// global singleton used for registering ops via the REGISTER
+// macros below.  Thread-safe.
+//
+// Example registration:
+//   OpRegistry::Global()->Register(
+//     [](OpRegistrationData* op_reg_data)->Status {
+//       // Populate *op_reg_data here.
+//       return OkStatus();
+//   });
+class OpRegistry : public OpRegistryInterface {
+ public:
+  typedef std::function<Status(OpRegistrationData*)> OpRegistrationDataFactory;
+
+  OpRegistry();
+
+  void Register(const OpRegistrationDataFactory& op_data_factory);
+
+  Status LookUp(const std::string& op_type_name,
+                const OpRegistrationData** op_reg_data) const override;
+
+  // Returns OpRegistrationData* of registered op type, else returns nullptr.
+  const OpRegistrationData* LookUp(const std::string& op_type_name) const;
+
+  // Fills *ops with all registered OpDefs (except those with names
+  // starting with '_' if include_internal == false) sorted in
+  // ascending alphabetical order.
+  void Export(bool include_internal, OpList* ops) const;
+
+  // Returns ASCII-format OpList for all registered OpDefs (except
+  // those with names starting with '_' if include_internal == false).
+  std::string DebugString(bool include_internal) const;
+
+  // A singleton available at startup.
+  static OpRegistry* Global();
+
+  // Get all registered ops.
+  void GetRegisteredOps(std::vector<OpDef>* op_defs);
+
+  // Get all `OpRegistrationData`s.
+  void GetOpRegistrationData(std::vector<OpRegistrationData>* op_data);
+
+  // Registers a function that validates op registry.
+  void RegisterValidator(
+      std::function<Status(const OpRegistryInterface&)> validator) {
+    op_registry_validator_ = std::move(validator);
+  }
+
+  // Watcher, a function object.
+  // The watcher, if set by SetWatcher(), is called every time an op is
+  // registered via the Register function. The watcher is passed the Status
+  // obtained from building and adding the OpDef to the registry, and the OpDef
+  // itself if it was successfully built. A watcher returns a Status which is in
+  // turn returned as the final registration status.
+  typedef std::function<Status(const Status&, const OpDef&)> Watcher;
+
+  // An OpRegistry object has only one watcher. This interface is not thread
+  // safe, as different clients are free to set the watcher any time.
+  // Clients are expected to atomically perform the following sequence of
+  // operations :
+  // SetWatcher(a_watcher);
+  // Register some ops;
+  // op_registry->ProcessRegistrations();
+  // SetWatcher(nullptr);
+  // Returns a non-OK status if a non-null watcher is over-written by another
+  // non-null watcher.
+  Status SetWatcher(const Watcher& watcher);
+
+  // Process the current list of deferred registrations. Note that calls to
+  // Export, LookUp and DebugString would also implicitly process the deferred
+  // registrations. Returns the status of the first failed op registration or
+  // OkStatus() otherwise.
+  Status ProcessRegistrations() const;
+
+  // Defer the registrations until a later call to a function that processes
+  // deferred registrations are made. Normally, registrations that happen after
+  // calls to Export, LookUp, ProcessRegistrations and DebugString are processed
+  // immediately. Call this to defer future registrations.
+  void DeferRegistrations();
+
+  // Clear the registrations that have been deferred.
+  void ClearDeferredRegistrations();
+
+ private:
+  // Ensures that all the functions in deferred_ get called, their OpDef's
+  // registered, and returns with deferred_ empty.  Returns true the first
+  // time it is called. Prints a fatal log if any op registration fails.
+  bool MustCallDeferred() const TF_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+
+  // Calls the functions in deferred_ and registers their OpDef's
+  // It returns the Status of the first failed op registration or OkStatus()
+  // otherwise.
+  Status CallDeferred() const TF_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+
+  // Add 'def' to the registry with additional data 'data'. On failure, or if
+  // there is already an OpDef with that name registered, returns a non-okay
+  // status.
+  Status RegisterAlreadyLocked(const OpRegistrationDataFactory& op_data_factory)
+      const TF_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+
+  const OpRegistrationData* LookUpSlow(const std::string& op_type_name) const;
+
+  mutable mutex mu_;
+  // Functions in deferred_ may only be called with mu_ held.
+  mutable std::vector<OpRegistrationDataFactory> deferred_ TF_GUARDED_BY(mu_);
+  // Values are owned.
+  mutable absl::flat_hash_map<string, std::unique_ptr<const OpRegistrationData>>
+      registry_ TF_GUARDED_BY(mu_);
+  mutable bool initialized_ TF_GUARDED_BY(mu_);
+
+  // Registry watcher.
+  mutable Watcher watcher_ TF_GUARDED_BY(mu_);
+
+  std::function<Status(const OpRegistryInterface&)> op_registry_validator_;
+};
+
+// An adapter to allow an OpList to be used as an OpRegistryInterface.
+//
+// Note that shape inference functions are not passed in to OpListOpRegistry, so
+// it will return an unusable shape inference function for every op it supports;
+// therefore, it should only be used in contexts where this is okay.
+class OpListOpRegistry : public OpRegistryInterface {
+ public:
+  // Does not take ownership of op_list, *op_list must outlive *this.
+  explicit OpListOpRegistry(const OpList* op_list);
+  Status LookUp(const std::string& op_type_name,
+                const OpRegistrationData** op_reg_data) const override;
+
+  // Returns OpRegistrationData* of op type in list, else returns nullptr.
+  const OpRegistrationData* LookUp(const std::string& op_type_name) const;
+
+ private:
+  // Values are owned.
+  absl::flat_hash_map<string, std::unique_ptr<const OpRegistrationData>> index_;
+};
+
+// Support for defining the OpDef (specifying the semantics of the Op and how
+// it should be created) and registering it in the OpRegistry::Global()
+// registry.  Usage:
+//
+// REGISTER_OP("my_op_name")
+//     .Attr("<name>:<type>")
+//     .Attr("<name>:<type>=<default>")
+//     .Input("<name>:<type-expr>")
+//     .Input("<name>:Ref(<type-expr>)")
+//     .Output("<name>:<type-expr>")
+//     .Doc(R"(
+// <1-line summary>
+// <rest of the description (potentially many lines)>
+// <name-of-attr-input-or-output>: <description of name>
+// <name-of-attr-input-or-output>: <description of name;
+//   if long, indent the description on subsequent lines>
+// )");
+//
+// Note: .Doc() should be last.
+// For details, see the OpDefBuilder class in op_def_builder.h.
+
+namespace register_op {
+
+class OpDefBuilderWrapper {
+ public:
+  explicit OpDefBuilderWrapper(const char name[]) : builder_(name) {}
+  OpDefBuilderWrapper& Attr(std::string spec) {
+    builder_.Attr(std::move(spec));
+    return *this;
+  }
+  OpDefBuilderWrapper& Attr(const char* spec) TF_ATTRIBUTE_NOINLINE {
+    return Attr(std::string(spec));
+  }
+  OpDefBuilderWrapper& Input(std::string spec) {
+    builder_.Input(std::move(spec));
+    return *this;
+  }
+  OpDefBuilderWrapper& Input(const char* spec) TF_ATTRIBUTE_NOINLINE {
+    return Input(std::string(spec));
+  }
+  OpDefBuilderWrapper& Output(std::string spec) {
+    builder_.Output(std::move(spec));
+    return *this;
+  }
+  OpDefBuilderWrapper& Output(const char* spec) TF_ATTRIBUTE_NOINLINE {
+    return Output(std::string(spec));
+  }
+  OpDefBuilderWrapper& SetIsCommutative() {
+    builder_.SetIsCommutative();
+    return *this;
+  }
+  OpDefBuilderWrapper& SetIsAggregate() {
+    builder_.SetIsAggregate();
+    return *this;
+  }
+  OpDefBuilderWrapper& SetIsStateful() {
+    builder_.SetIsStateful();
+    return *this;
+  }
+  OpDefBuilderWrapper& SetDoNotOptimize() {
+    // We don't have a separate flag to disable optimizations such as constant
+    // folding and CSE so we reuse the stateful flag.
+    builder_.SetIsStateful();
+    return *this;
+  }
+  OpDefBuilderWrapper& SetAllowsUninitializedInput() {
+    builder_.SetAllowsUninitializedInput();
+    return *this;
+  }
+  OpDefBuilderWrapper& Deprecated(int version, std::string explanation) {
+    builder_.Deprecated(version, std::move(explanation));
+    return *this;
+  }
+  OpDefBuilderWrapper& Doc(std::string text) {
+    builder_.Doc(std::move(text));
+    return *this;
+  }
+  OpDefBuilderWrapper& SetShapeFn(OpShapeInferenceFn fn) {
+    builder_.SetShapeFn(std::move(fn));
+    return *this;
+  }
+  OpDefBuilderWrapper& SetIsDistributedCommunication() {
+    builder_.SetIsDistributedCommunication();
+    return *this;
+  }
+
+  OpDefBuilderWrapper& SetTypeConstructor(OpTypeConstructor fn) {
+    builder_.SetTypeConstructor(std::move(fn));
+    return *this;
+  }
+
+  OpDefBuilderWrapper& SetForwardTypeFn(TypeInferenceFn fn) {
+    builder_.SetForwardTypeFn(std::move(fn));
+    return *this;
+  }
+
+  OpDefBuilderWrapper& SetReverseTypeFn(int input_number, TypeInferenceFn fn) {
+    builder_.SetReverseTypeFn(input_number, std::move(fn));
+    return *this;
+  }
+
+  const ::tensorflow::OpDefBuilder& builder() const { return builder_; }
+
+  InitOnStartupMarker operator()();
+
+ private:
+  mutable ::tensorflow::OpDefBuilder builder_;
+};
+
+}  // namespace register_op
+
+#define REGISTER_OP_IMPL(ctr, name, is_system_op)                         \
+  static ::tensorflow::InitOnStartupMarker const register_op##ctr         \
+      TF_ATTRIBUTE_UNUSED =                                               \
+          TF_INIT_ON_STARTUP_IF(is_system_op || SHOULD_REGISTER_OP(name)) \
+          << ::tensorflow::register_op::OpDefBuilderWrapper(name)
+
+#define REGISTER_OP(name)        \
+  TF_ATTRIBUTE_ANNOTATE("tf:op") \
+  TF_NEW_ID_FOR_INIT(REGISTER_OP_IMPL, name, false)
+
+// The `REGISTER_SYSTEM_OP()` macro acts as `REGISTER_OP()` except
+// that the op is registered unconditionally even when selective
+// registration is used.
+#define REGISTER_SYSTEM_OP(name)        \
+  TF_ATTRIBUTE_ANNOTATE("tf:op")        \
+  TF_ATTRIBUTE_ANNOTATE("tf:op:system") \
+  TF_NEW_ID_FOR_INIT(REGISTER_OP_IMPL, name, true)
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_OP_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/op_def.pb.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/op_def.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..8c0fd8f58af53a26cedce40b2ae13fc094cf9ac3
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/op_def.pb.h
@@ -0,0 +1,2736 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: tensorflow/core/framework/op_def.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fop_5fdef_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fop_5fdef_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3021000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3021009 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+#include "tensorflow/core/framework/attr_value.pb.h"
+#include "tensorflow/core/framework/full_type.pb.h"
+#include "tensorflow/core/framework/resource_handle.pb.h"
+#include "tensorflow/core/framework/types.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_tensorflow_2fcore_2fframework_2fop_5fdef_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_tensorflow_2fcore_2fframework_2fop_5fdef_2eproto {
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_tensorflow_2fcore_2fframework_2fop_5fdef_2eproto;
+namespace tensorflow {
+class OpDef;
+struct OpDefDefaultTypeInternal;
+extern OpDefDefaultTypeInternal _OpDef_default_instance_;
+class OpDef_ArgDef;
+struct OpDef_ArgDefDefaultTypeInternal;
+extern OpDef_ArgDefDefaultTypeInternal _OpDef_ArgDef_default_instance_;
+class OpDef_AttrDef;
+struct OpDef_AttrDefDefaultTypeInternal;
+extern OpDef_AttrDefDefaultTypeInternal _OpDef_AttrDef_default_instance_;
+class OpDeprecation;
+struct OpDeprecationDefaultTypeInternal;
+extern OpDeprecationDefaultTypeInternal _OpDeprecation_default_instance_;
+class OpList;
+struct OpListDefaultTypeInternal;
+extern OpListDefaultTypeInternal _OpList_default_instance_;
+}  // namespace tensorflow
+PROTOBUF_NAMESPACE_OPEN
+template<> ::tensorflow::OpDef* Arena::CreateMaybeMessage<::tensorflow::OpDef>(Arena*);
+template<> ::tensorflow::OpDef_ArgDef* Arena::CreateMaybeMessage<::tensorflow::OpDef_ArgDef>(Arena*);
+template<> ::tensorflow::OpDef_AttrDef* Arena::CreateMaybeMessage<::tensorflow::OpDef_AttrDef>(Arena*);
+template<> ::tensorflow::OpDeprecation* Arena::CreateMaybeMessage<::tensorflow::OpDeprecation>(Arena*);
+template<> ::tensorflow::OpList* Arena::CreateMaybeMessage<::tensorflow::OpList>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace tensorflow {
+
+// ===================================================================
+
+class OpDef_ArgDef final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.OpDef.ArgDef) */ {
+ public:
+  inline OpDef_ArgDef() : OpDef_ArgDef(nullptr) {}
+  ~OpDef_ArgDef() override;
+  explicit PROTOBUF_CONSTEXPR OpDef_ArgDef(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  OpDef_ArgDef(const OpDef_ArgDef& from);
+  OpDef_ArgDef(OpDef_ArgDef&& from) noexcept
+    : OpDef_ArgDef() {
+    *this = ::std::move(from);
+  }
+
+  inline OpDef_ArgDef& operator=(const OpDef_ArgDef& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline OpDef_ArgDef& operator=(OpDef_ArgDef&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const OpDef_ArgDef& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const OpDef_ArgDef* internal_default_instance() {
+    return reinterpret_cast<const OpDef_ArgDef*>(
+               &_OpDef_ArgDef_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(OpDef_ArgDef& a, OpDef_ArgDef& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(OpDef_ArgDef* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(OpDef_ArgDef* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  OpDef_ArgDef* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<OpDef_ArgDef>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const OpDef_ArgDef& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const OpDef_ArgDef& from) {
+    OpDef_ArgDef::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(OpDef_ArgDef* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.OpDef.ArgDef";
+  }
+  protected:
+  explicit OpDef_ArgDef(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kHandleDataFieldNumber = 7,
+    kNameFieldNumber = 1,
+    kDescriptionFieldNumber = 2,
+    kTypeAttrFieldNumber = 4,
+    kNumberAttrFieldNumber = 5,
+    kTypeListAttrFieldNumber = 6,
+    kExperimentalFullTypeFieldNumber = 17,
+    kTypeFieldNumber = 3,
+    kIsRefFieldNumber = 16,
+  };
+  // repeated .tensorflow.ResourceHandleProto.DtypeAndShape handle_data = 7;
+  int handle_data_size() const;
+  private:
+  int _internal_handle_data_size() const;
+  public:
+  void clear_handle_data();
+  ::tensorflow::ResourceHandleProto_DtypeAndShape* mutable_handle_data(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::ResourceHandleProto_DtypeAndShape >*
+      mutable_handle_data();
+  private:
+  const ::tensorflow::ResourceHandleProto_DtypeAndShape& _internal_handle_data(int index) const;
+  ::tensorflow::ResourceHandleProto_DtypeAndShape* _internal_add_handle_data();
+  public:
+  const ::tensorflow::ResourceHandleProto_DtypeAndShape& handle_data(int index) const;
+  ::tensorflow::ResourceHandleProto_DtypeAndShape* add_handle_data();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::ResourceHandleProto_DtypeAndShape >&
+      handle_data() const;
+
+  // string name = 1;
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // string description = 2;
+  void clear_description();
+  const std::string& description() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_description(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_description();
+  PROTOBUF_NODISCARD std::string* release_description();
+  void set_allocated_description(std::string* description);
+  private:
+  const std::string& _internal_description() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_description(const std::string& value);
+  std::string* _internal_mutable_description();
+  public:
+
+  // string type_attr = 4;
+  void clear_type_attr();
+  const std::string& type_attr() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_type_attr(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_type_attr();
+  PROTOBUF_NODISCARD std::string* release_type_attr();
+  void set_allocated_type_attr(std::string* type_attr);
+  private:
+  const std::string& _internal_type_attr() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_type_attr(const std::string& value);
+  std::string* _internal_mutable_type_attr();
+  public:
+
+  // string number_attr = 5;
+  void clear_number_attr();
+  const std::string& number_attr() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_number_attr(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_number_attr();
+  PROTOBUF_NODISCARD std::string* release_number_attr();
+  void set_allocated_number_attr(std::string* number_attr);
+  private:
+  const std::string& _internal_number_attr() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_number_attr(const std::string& value);
+  std::string* _internal_mutable_number_attr();
+  public:
+
+  // string type_list_attr = 6;
+  void clear_type_list_attr();
+  const std::string& type_list_attr() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_type_list_attr(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_type_list_attr();
+  PROTOBUF_NODISCARD std::string* release_type_list_attr();
+  void set_allocated_type_list_attr(std::string* type_list_attr);
+  private:
+  const std::string& _internal_type_list_attr() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_type_list_attr(const std::string& value);
+  std::string* _internal_mutable_type_list_attr();
+  public:
+
+  // .tensorflow.FullTypeDef experimental_full_type = 17;
+  bool has_experimental_full_type() const;
+  private:
+  bool _internal_has_experimental_full_type() const;
+  public:
+  void clear_experimental_full_type();
+  const ::tensorflow::FullTypeDef& experimental_full_type() const;
+  PROTOBUF_NODISCARD ::tensorflow::FullTypeDef* release_experimental_full_type();
+  ::tensorflow::FullTypeDef* mutable_experimental_full_type();
+  void set_allocated_experimental_full_type(::tensorflow::FullTypeDef* experimental_full_type);
+  private:
+  const ::tensorflow::FullTypeDef& _internal_experimental_full_type() const;
+  ::tensorflow::FullTypeDef* _internal_mutable_experimental_full_type();
+  public:
+  void unsafe_arena_set_allocated_experimental_full_type(
+      ::tensorflow::FullTypeDef* experimental_full_type);
+  ::tensorflow::FullTypeDef* unsafe_arena_release_experimental_full_type();
+
+  // .tensorflow.DataType type = 3;
+  void clear_type();
+  ::tensorflow::DataType type() const;
+  void set_type(::tensorflow::DataType value);
+  private:
+  ::tensorflow::DataType _internal_type() const;
+  void _internal_set_type(::tensorflow::DataType value);
+  public:
+
+  // bool is_ref = 16;
+  void clear_is_ref();
+  bool is_ref() const;
+  void set_is_ref(bool value);
+  private:
+  bool _internal_is_ref() const;
+  void _internal_set_is_ref(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.OpDef.ArgDef)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::ResourceHandleProto_DtypeAndShape > handle_data_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_attr_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr number_attr_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_list_attr_;
+    ::tensorflow::FullTypeDef* experimental_full_type_;
+    int type_;
+    bool is_ref_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fop_5fdef_2eproto;
+};
+// -------------------------------------------------------------------
+
+class OpDef_AttrDef final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.OpDef.AttrDef) */ {
+ public:
+  inline OpDef_AttrDef() : OpDef_AttrDef(nullptr) {}
+  ~OpDef_AttrDef() override;
+  explicit PROTOBUF_CONSTEXPR OpDef_AttrDef(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  OpDef_AttrDef(const OpDef_AttrDef& from);
+  OpDef_AttrDef(OpDef_AttrDef&& from) noexcept
+    : OpDef_AttrDef() {
+    *this = ::std::move(from);
+  }
+
+  inline OpDef_AttrDef& operator=(const OpDef_AttrDef& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline OpDef_AttrDef& operator=(OpDef_AttrDef&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const OpDef_AttrDef& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const OpDef_AttrDef* internal_default_instance() {
+    return reinterpret_cast<const OpDef_AttrDef*>(
+               &_OpDef_AttrDef_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(OpDef_AttrDef& a, OpDef_AttrDef& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(OpDef_AttrDef* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(OpDef_AttrDef* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  OpDef_AttrDef* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<OpDef_AttrDef>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const OpDef_AttrDef& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const OpDef_AttrDef& from) {
+    OpDef_AttrDef::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(OpDef_AttrDef* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.OpDef.AttrDef";
+  }
+  protected:
+  explicit OpDef_AttrDef(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNameFieldNumber = 1,
+    kTypeFieldNumber = 2,
+    kDescriptionFieldNumber = 4,
+    kDefaultValueFieldNumber = 3,
+    kAllowedValuesFieldNumber = 7,
+    kMinimumFieldNumber = 6,
+    kHasMinimumFieldNumber = 5,
+  };
+  // string name = 1;
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // string type = 2;
+  void clear_type();
+  const std::string& type() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_type(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_type();
+  PROTOBUF_NODISCARD std::string* release_type();
+  void set_allocated_type(std::string* type);
+  private:
+  const std::string& _internal_type() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_type(const std::string& value);
+  std::string* _internal_mutable_type();
+  public:
+
+  // string description = 4;
+  void clear_description();
+  const std::string& description() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_description(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_description();
+  PROTOBUF_NODISCARD std::string* release_description();
+  void set_allocated_description(std::string* description);
+  private:
+  const std::string& _internal_description() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_description(const std::string& value);
+  std::string* _internal_mutable_description();
+  public:
+
+  // .tensorflow.AttrValue default_value = 3;
+  bool has_default_value() const;
+  private:
+  bool _internal_has_default_value() const;
+  public:
+  void clear_default_value();
+  const ::tensorflow::AttrValue& default_value() const;
+  PROTOBUF_NODISCARD ::tensorflow::AttrValue* release_default_value();
+  ::tensorflow::AttrValue* mutable_default_value();
+  void set_allocated_default_value(::tensorflow::AttrValue* default_value);
+  private:
+  const ::tensorflow::AttrValue& _internal_default_value() const;
+  ::tensorflow::AttrValue* _internal_mutable_default_value();
+  public:
+  void unsafe_arena_set_allocated_default_value(
+      ::tensorflow::AttrValue* default_value);
+  ::tensorflow::AttrValue* unsafe_arena_release_default_value();
+
+  // .tensorflow.AttrValue allowed_values = 7;
+  bool has_allowed_values() const;
+  private:
+  bool _internal_has_allowed_values() const;
+  public:
+  void clear_allowed_values();
+  const ::tensorflow::AttrValue& allowed_values() const;
+  PROTOBUF_NODISCARD ::tensorflow::AttrValue* release_allowed_values();
+  ::tensorflow::AttrValue* mutable_allowed_values();
+  void set_allocated_allowed_values(::tensorflow::AttrValue* allowed_values);
+  private:
+  const ::tensorflow::AttrValue& _internal_allowed_values() const;
+  ::tensorflow::AttrValue* _internal_mutable_allowed_values();
+  public:
+  void unsafe_arena_set_allocated_allowed_values(
+      ::tensorflow::AttrValue* allowed_values);
+  ::tensorflow::AttrValue* unsafe_arena_release_allowed_values();
+
+  // int64 minimum = 6;
+  void clear_minimum();
+  int64_t minimum() const;
+  void set_minimum(int64_t value);
+  private:
+  int64_t _internal_minimum() const;
+  void _internal_set_minimum(int64_t value);
+  public:
+
+  // bool has_minimum = 5;
+  void clear_has_minimum();
+  bool has_minimum() const;
+  void set_has_minimum(bool value);
+  private:
+  bool _internal_has_minimum() const;
+  void _internal_set_has_minimum(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.OpDef.AttrDef)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_;
+    ::tensorflow::AttrValue* default_value_;
+    ::tensorflow::AttrValue* allowed_values_;
+    int64_t minimum_;
+    bool has_minimum_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fop_5fdef_2eproto;
+};
+// -------------------------------------------------------------------
+
+class OpDef final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.OpDef) */ {
+ public:
+  inline OpDef() : OpDef(nullptr) {}
+  ~OpDef() override;
+  explicit PROTOBUF_CONSTEXPR OpDef(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  OpDef(const OpDef& from);
+  OpDef(OpDef&& from) noexcept
+    : OpDef() {
+    *this = ::std::move(from);
+  }
+
+  inline OpDef& operator=(const OpDef& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline OpDef& operator=(OpDef&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const OpDef& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const OpDef* internal_default_instance() {
+    return reinterpret_cast<const OpDef*>(
+               &_OpDef_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(OpDef& a, OpDef& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(OpDef* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(OpDef* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  OpDef* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<OpDef>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const OpDef& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const OpDef& from) {
+    OpDef::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(OpDef* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.OpDef";
+  }
+  protected:
+  explicit OpDef(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef OpDef_ArgDef ArgDef;
+  typedef OpDef_AttrDef AttrDef;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kInputArgFieldNumber = 2,
+    kOutputArgFieldNumber = 3,
+    kAttrFieldNumber = 4,
+    kControlOutputFieldNumber = 20,
+    kNameFieldNumber = 1,
+    kSummaryFieldNumber = 5,
+    kDescriptionFieldNumber = 6,
+    kDeprecationFieldNumber = 8,
+    kIsCommutativeFieldNumber = 18,
+    kIsAggregateFieldNumber = 16,
+    kIsStatefulFieldNumber = 17,
+    kAllowsUninitializedInputFieldNumber = 19,
+    kIsDistributedCommunicationFieldNumber = 21,
+  };
+  // repeated .tensorflow.OpDef.ArgDef input_arg = 2;
+  int input_arg_size() const;
+  private:
+  int _internal_input_arg_size() const;
+  public:
+  void clear_input_arg();
+  ::tensorflow::OpDef_ArgDef* mutable_input_arg(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpDef_ArgDef >*
+      mutable_input_arg();
+  private:
+  const ::tensorflow::OpDef_ArgDef& _internal_input_arg(int index) const;
+  ::tensorflow::OpDef_ArgDef* _internal_add_input_arg();
+  public:
+  const ::tensorflow::OpDef_ArgDef& input_arg(int index) const;
+  ::tensorflow::OpDef_ArgDef* add_input_arg();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpDef_ArgDef >&
+      input_arg() const;
+
+  // repeated .tensorflow.OpDef.ArgDef output_arg = 3;
+  int output_arg_size() const;
+  private:
+  int _internal_output_arg_size() const;
+  public:
+  void clear_output_arg();
+  ::tensorflow::OpDef_ArgDef* mutable_output_arg(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpDef_ArgDef >*
+      mutable_output_arg();
+  private:
+  const ::tensorflow::OpDef_ArgDef& _internal_output_arg(int index) const;
+  ::tensorflow::OpDef_ArgDef* _internal_add_output_arg();
+  public:
+  const ::tensorflow::OpDef_ArgDef& output_arg(int index) const;
+  ::tensorflow::OpDef_ArgDef* add_output_arg();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpDef_ArgDef >&
+      output_arg() const;
+
+  // repeated .tensorflow.OpDef.AttrDef attr = 4;
+  int attr_size() const;
+  private:
+  int _internal_attr_size() const;
+  public:
+  void clear_attr();
+  ::tensorflow::OpDef_AttrDef* mutable_attr(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpDef_AttrDef >*
+      mutable_attr();
+  private:
+  const ::tensorflow::OpDef_AttrDef& _internal_attr(int index) const;
+  ::tensorflow::OpDef_AttrDef* _internal_add_attr();
+  public:
+  const ::tensorflow::OpDef_AttrDef& attr(int index) const;
+  ::tensorflow::OpDef_AttrDef* add_attr();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpDef_AttrDef >&
+      attr() const;
+
+  // repeated string control_output = 20;
+  int control_output_size() const;
+  private:
+  int _internal_control_output_size() const;
+  public:
+  void clear_control_output();
+  const std::string& control_output(int index) const;
+  std::string* mutable_control_output(int index);
+  void set_control_output(int index, const std::string& value);
+  void set_control_output(int index, std::string&& value);
+  void set_control_output(int index, const char* value);
+  void set_control_output(int index, const char* value, size_t size);
+  std::string* add_control_output();
+  void add_control_output(const std::string& value);
+  void add_control_output(std::string&& value);
+  void add_control_output(const char* value);
+  void add_control_output(const char* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& control_output() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_control_output();
+  private:
+  const std::string& _internal_control_output(int index) const;
+  std::string* _internal_add_control_output();
+  public:
+
+  // string name = 1;
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // string summary = 5;
+  void clear_summary();
+  const std::string& summary() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_summary(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_summary();
+  PROTOBUF_NODISCARD std::string* release_summary();
+  void set_allocated_summary(std::string* summary);
+  private:
+  const std::string& _internal_summary() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_summary(const std::string& value);
+  std::string* _internal_mutable_summary();
+  public:
+
+  // string description = 6;
+  void clear_description();
+  const std::string& description() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_description(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_description();
+  PROTOBUF_NODISCARD std::string* release_description();
+  void set_allocated_description(std::string* description);
+  private:
+  const std::string& _internal_description() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_description(const std::string& value);
+  std::string* _internal_mutable_description();
+  public:
+
+  // .tensorflow.OpDeprecation deprecation = 8;
+  bool has_deprecation() const;
+  private:
+  bool _internal_has_deprecation() const;
+  public:
+  void clear_deprecation();
+  const ::tensorflow::OpDeprecation& deprecation() const;
+  PROTOBUF_NODISCARD ::tensorflow::OpDeprecation* release_deprecation();
+  ::tensorflow::OpDeprecation* mutable_deprecation();
+  void set_allocated_deprecation(::tensorflow::OpDeprecation* deprecation);
+  private:
+  const ::tensorflow::OpDeprecation& _internal_deprecation() const;
+  ::tensorflow::OpDeprecation* _internal_mutable_deprecation();
+  public:
+  void unsafe_arena_set_allocated_deprecation(
+      ::tensorflow::OpDeprecation* deprecation);
+  ::tensorflow::OpDeprecation* unsafe_arena_release_deprecation();
+
+  // bool is_commutative = 18;
+  void clear_is_commutative();
+  bool is_commutative() const;
+  void set_is_commutative(bool value);
+  private:
+  bool _internal_is_commutative() const;
+  void _internal_set_is_commutative(bool value);
+  public:
+
+  // bool is_aggregate = 16;
+  void clear_is_aggregate();
+  bool is_aggregate() const;
+  void set_is_aggregate(bool value);
+  private:
+  bool _internal_is_aggregate() const;
+  void _internal_set_is_aggregate(bool value);
+  public:
+
+  // bool is_stateful = 17;
+  void clear_is_stateful();
+  bool is_stateful() const;
+  void set_is_stateful(bool value);
+  private:
+  bool _internal_is_stateful() const;
+  void _internal_set_is_stateful(bool value);
+  public:
+
+  // bool allows_uninitialized_input = 19;
+  void clear_allows_uninitialized_input();
+  bool allows_uninitialized_input() const;
+  void set_allows_uninitialized_input(bool value);
+  private:
+  bool _internal_allows_uninitialized_input() const;
+  void _internal_set_allows_uninitialized_input(bool value);
+  public:
+
+  // bool is_distributed_communication = 21;
+  void clear_is_distributed_communication();
+  bool is_distributed_communication() const;
+  void set_is_distributed_communication(bool value);
+  private:
+  bool _internal_is_distributed_communication() const;
+  void _internal_set_is_distributed_communication(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.OpDef)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpDef_ArgDef > input_arg_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpDef_ArgDef > output_arg_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpDef_AttrDef > attr_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> control_output_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr summary_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_;
+    ::tensorflow::OpDeprecation* deprecation_;
+    bool is_commutative_;
+    bool is_aggregate_;
+    bool is_stateful_;
+    bool allows_uninitialized_input_;
+    bool is_distributed_communication_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fop_5fdef_2eproto;
+};
+// -------------------------------------------------------------------
+
+class OpDeprecation final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.OpDeprecation) */ {
+ public:
+  inline OpDeprecation() : OpDeprecation(nullptr) {}
+  ~OpDeprecation() override;
+  explicit PROTOBUF_CONSTEXPR OpDeprecation(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  OpDeprecation(const OpDeprecation& from);
+  OpDeprecation(OpDeprecation&& from) noexcept
+    : OpDeprecation() {
+    *this = ::std::move(from);
+  }
+
+  inline OpDeprecation& operator=(const OpDeprecation& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline OpDeprecation& operator=(OpDeprecation&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const OpDeprecation& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const OpDeprecation* internal_default_instance() {
+    return reinterpret_cast<const OpDeprecation*>(
+               &_OpDeprecation_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  friend void swap(OpDeprecation& a, OpDeprecation& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(OpDeprecation* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(OpDeprecation* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  OpDeprecation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<OpDeprecation>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const OpDeprecation& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const OpDeprecation& from) {
+    OpDeprecation::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(OpDeprecation* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.OpDeprecation";
+  }
+  protected:
+  explicit OpDeprecation(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kExplanationFieldNumber = 2,
+    kVersionFieldNumber = 1,
+  };
+  // string explanation = 2;
+  void clear_explanation();
+  const std::string& explanation() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_explanation(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_explanation();
+  PROTOBUF_NODISCARD std::string* release_explanation();
+  void set_allocated_explanation(std::string* explanation);
+  private:
+  const std::string& _internal_explanation() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_explanation(const std::string& value);
+  std::string* _internal_mutable_explanation();
+  public:
+
+  // int32 version = 1;
+  void clear_version();
+  int32_t version() const;
+  void set_version(int32_t value);
+  private:
+  int32_t _internal_version() const;
+  void _internal_set_version(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.OpDeprecation)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr explanation_;
+    int32_t version_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fop_5fdef_2eproto;
+};
+// -------------------------------------------------------------------
+
+class OpList final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.OpList) */ {
+ public:
+  inline OpList() : OpList(nullptr) {}
+  ~OpList() override;
+  explicit PROTOBUF_CONSTEXPR OpList(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  OpList(const OpList& from);
+  OpList(OpList&& from) noexcept
+    : OpList() {
+    *this = ::std::move(from);
+  }
+
+  inline OpList& operator=(const OpList& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline OpList& operator=(OpList&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const OpList& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const OpList* internal_default_instance() {
+    return reinterpret_cast<const OpList*>(
+               &_OpList_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    4;
+
+  friend void swap(OpList& a, OpList& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(OpList* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(OpList* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  OpList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<OpList>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const OpList& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const OpList& from) {
+    OpList::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(OpList* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.OpList";
+  }
+  protected:
+  explicit OpList(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kOpFieldNumber = 1,
+  };
+  // repeated .tensorflow.OpDef op = 1;
+  int op_size() const;
+  private:
+  int _internal_op_size() const;
+  public:
+  void clear_op();
+  ::tensorflow::OpDef* mutable_op(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpDef >*
+      mutable_op();
+  private:
+  const ::tensorflow::OpDef& _internal_op(int index) const;
+  ::tensorflow::OpDef* _internal_add_op();
+  public:
+  const ::tensorflow::OpDef& op(int index) const;
+  ::tensorflow::OpDef* add_op();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpDef >&
+      op() const;
+
+  // @@protoc_insertion_point(class_scope:tensorflow.OpList)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpDef > op_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fop_5fdef_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// OpDef_ArgDef
+
+// string name = 1;
+inline void OpDef_ArgDef::clear_name() {
+  _impl_.name_.ClearToEmpty();
+}
+inline const std::string& OpDef_ArgDef::name() const {
+  // @@protoc_insertion_point(field_get:tensorflow.OpDef.ArgDef.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void OpDef_ArgDef::set_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.OpDef.ArgDef.name)
+}
+inline std::string* OpDef_ArgDef::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.ArgDef.name)
+  return _s;
+}
+inline const std::string& OpDef_ArgDef::_internal_name() const {
+  return _impl_.name_.Get();
+}
+inline void OpDef_ArgDef::_internal_set_name(const std::string& value) {
+  
+  _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* OpDef_ArgDef::_internal_mutable_name() {
+  
+  return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* OpDef_ArgDef::release_name() {
+  // @@protoc_insertion_point(field_release:tensorflow.OpDef.ArgDef.name)
+  return _impl_.name_.Release();
+}
+inline void OpDef_ArgDef::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDef.ArgDef.name)
+}
+
+// string description = 2;
+inline void OpDef_ArgDef::clear_description() {
+  _impl_.description_.ClearToEmpty();
+}
+inline const std::string& OpDef_ArgDef::description() const {
+  // @@protoc_insertion_point(field_get:tensorflow.OpDef.ArgDef.description)
+  return _internal_description();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void OpDef_ArgDef::set_description(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.description_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.OpDef.ArgDef.description)
+}
+inline std::string* OpDef_ArgDef::mutable_description() {
+  std::string* _s = _internal_mutable_description();
+  // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.ArgDef.description)
+  return _s;
+}
+inline const std::string& OpDef_ArgDef::_internal_description() const {
+  return _impl_.description_.Get();
+}
+inline void OpDef_ArgDef::_internal_set_description(const std::string& value) {
+  
+  _impl_.description_.Set(value, GetArenaForAllocation());
+}
+inline std::string* OpDef_ArgDef::_internal_mutable_description() {
+  
+  return _impl_.description_.Mutable(GetArenaForAllocation());
+}
+inline std::string* OpDef_ArgDef::release_description() {
+  // @@protoc_insertion_point(field_release:tensorflow.OpDef.ArgDef.description)
+  return _impl_.description_.Release();
+}
+inline void OpDef_ArgDef::set_allocated_description(std::string* description) {
+  if (description != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.description_.SetAllocated(description, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.description_.IsDefault()) {
+    _impl_.description_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDef.ArgDef.description)
+}
+
+// .tensorflow.DataType type = 3;
+inline void OpDef_ArgDef::clear_type() {
+  _impl_.type_ = 0;
+}
+inline ::tensorflow::DataType OpDef_ArgDef::_internal_type() const {
+  return static_cast< ::tensorflow::DataType >(_impl_.type_);
+}
+inline ::tensorflow::DataType OpDef_ArgDef::type() const {
+  // @@protoc_insertion_point(field_get:tensorflow.OpDef.ArgDef.type)
+  return _internal_type();
+}
+inline void OpDef_ArgDef::_internal_set_type(::tensorflow::DataType value) {
+  
+  _impl_.type_ = value;
+}
+inline void OpDef_ArgDef::set_type(::tensorflow::DataType value) {
+  _internal_set_type(value);
+  // @@protoc_insertion_point(field_set:tensorflow.OpDef.ArgDef.type)
+}
+
+// string type_attr = 4;
+inline void OpDef_ArgDef::clear_type_attr() {
+  _impl_.type_attr_.ClearToEmpty();
+}
+inline const std::string& OpDef_ArgDef::type_attr() const {
+  // @@protoc_insertion_point(field_get:tensorflow.OpDef.ArgDef.type_attr)
+  return _internal_type_attr();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void OpDef_ArgDef::set_type_attr(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.type_attr_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.OpDef.ArgDef.type_attr)
+}
+inline std::string* OpDef_ArgDef::mutable_type_attr() {
+  std::string* _s = _internal_mutable_type_attr();
+  // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.ArgDef.type_attr)
+  return _s;
+}
+inline const std::string& OpDef_ArgDef::_internal_type_attr() const {
+  return _impl_.type_attr_.Get();
+}
+inline void OpDef_ArgDef::_internal_set_type_attr(const std::string& value) {
+  
+  _impl_.type_attr_.Set(value, GetArenaForAllocation());
+}
+inline std::string* OpDef_ArgDef::_internal_mutable_type_attr() {
+  
+  return _impl_.type_attr_.Mutable(GetArenaForAllocation());
+}
+inline std::string* OpDef_ArgDef::release_type_attr() {
+  // @@protoc_insertion_point(field_release:tensorflow.OpDef.ArgDef.type_attr)
+  return _impl_.type_attr_.Release();
+}
+inline void OpDef_ArgDef::set_allocated_type_attr(std::string* type_attr) {
+  if (type_attr != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.type_attr_.SetAllocated(type_attr, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.type_attr_.IsDefault()) {
+    _impl_.type_attr_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDef.ArgDef.type_attr)
+}
+
+// string number_attr = 5;
+inline void OpDef_ArgDef::clear_number_attr() {
+  _impl_.number_attr_.ClearToEmpty();
+}
+inline const std::string& OpDef_ArgDef::number_attr() const {
+  // @@protoc_insertion_point(field_get:tensorflow.OpDef.ArgDef.number_attr)
+  return _internal_number_attr();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void OpDef_ArgDef::set_number_attr(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.number_attr_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.OpDef.ArgDef.number_attr)
+}
+inline std::string* OpDef_ArgDef::mutable_number_attr() {
+  std::string* _s = _internal_mutable_number_attr();
+  // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.ArgDef.number_attr)
+  return _s;
+}
+inline const std::string& OpDef_ArgDef::_internal_number_attr() const {
+  return _impl_.number_attr_.Get();
+}
+inline void OpDef_ArgDef::_internal_set_number_attr(const std::string& value) {
+  
+  _impl_.number_attr_.Set(value, GetArenaForAllocation());
+}
+inline std::string* OpDef_ArgDef::_internal_mutable_number_attr() {
+  
+  return _impl_.number_attr_.Mutable(GetArenaForAllocation());
+}
+inline std::string* OpDef_ArgDef::release_number_attr() {
+  // @@protoc_insertion_point(field_release:tensorflow.OpDef.ArgDef.number_attr)
+  return _impl_.number_attr_.Release();
+}
+inline void OpDef_ArgDef::set_allocated_number_attr(std::string* number_attr) {
+  if (number_attr != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.number_attr_.SetAllocated(number_attr, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.number_attr_.IsDefault()) {
+    _impl_.number_attr_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDef.ArgDef.number_attr)
+}
+
+// string type_list_attr = 6;
+inline void OpDef_ArgDef::clear_type_list_attr() {
+  _impl_.type_list_attr_.ClearToEmpty();
+}
+inline const std::string& OpDef_ArgDef::type_list_attr() const {
+  // @@protoc_insertion_point(field_get:tensorflow.OpDef.ArgDef.type_list_attr)
+  return _internal_type_list_attr();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void OpDef_ArgDef::set_type_list_attr(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.type_list_attr_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.OpDef.ArgDef.type_list_attr)
+}
+inline std::string* OpDef_ArgDef::mutable_type_list_attr() {
+  std::string* _s = _internal_mutable_type_list_attr();
+  // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.ArgDef.type_list_attr)
+  return _s;
+}
+inline const std::string& OpDef_ArgDef::_internal_type_list_attr() const {
+  return _impl_.type_list_attr_.Get();
+}
+inline void OpDef_ArgDef::_internal_set_type_list_attr(const std::string& value) {
+  
+  _impl_.type_list_attr_.Set(value, GetArenaForAllocation());
+}
+inline std::string* OpDef_ArgDef::_internal_mutable_type_list_attr() {
+  
+  return _impl_.type_list_attr_.Mutable(GetArenaForAllocation());
+}
+inline std::string* OpDef_ArgDef::release_type_list_attr() {
+  // @@protoc_insertion_point(field_release:tensorflow.OpDef.ArgDef.type_list_attr)
+  return _impl_.type_list_attr_.Release();
+}
+inline void OpDef_ArgDef::set_allocated_type_list_attr(std::string* type_list_attr) {
+  if (type_list_attr != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.type_list_attr_.SetAllocated(type_list_attr, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.type_list_attr_.IsDefault()) {
+    _impl_.type_list_attr_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDef.ArgDef.type_list_attr)
+}
+
+// repeated .tensorflow.ResourceHandleProto.DtypeAndShape handle_data = 7;
+inline int OpDef_ArgDef::_internal_handle_data_size() const {
+  return _impl_.handle_data_.size();
+}
+inline int OpDef_ArgDef::handle_data_size() const {
+  return _internal_handle_data_size();
+}
+inline ::tensorflow::ResourceHandleProto_DtypeAndShape* OpDef_ArgDef::mutable_handle_data(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.ArgDef.handle_data)
+  return _impl_.handle_data_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::ResourceHandleProto_DtypeAndShape >*
+OpDef_ArgDef::mutable_handle_data() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.OpDef.ArgDef.handle_data)
+  return &_impl_.handle_data_;
+}
+inline const ::tensorflow::ResourceHandleProto_DtypeAndShape& OpDef_ArgDef::_internal_handle_data(int index) const {
+  return _impl_.handle_data_.Get(index);
+}
+inline const ::tensorflow::ResourceHandleProto_DtypeAndShape& OpDef_ArgDef::handle_data(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.OpDef.ArgDef.handle_data)
+  return _internal_handle_data(index);
+}
+inline ::tensorflow::ResourceHandleProto_DtypeAndShape* OpDef_ArgDef::_internal_add_handle_data() {
+  return _impl_.handle_data_.Add();
+}
+inline ::tensorflow::ResourceHandleProto_DtypeAndShape* OpDef_ArgDef::add_handle_data() {
+  ::tensorflow::ResourceHandleProto_DtypeAndShape* _add = _internal_add_handle_data();
+  // @@protoc_insertion_point(field_add:tensorflow.OpDef.ArgDef.handle_data)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::ResourceHandleProto_DtypeAndShape >&
+OpDef_ArgDef::handle_data() const {
+  // @@protoc_insertion_point(field_list:tensorflow.OpDef.ArgDef.handle_data)
+  return _impl_.handle_data_;
+}
+
+// bool is_ref = 16;
+inline void OpDef_ArgDef::clear_is_ref() {
+  _impl_.is_ref_ = false;
+}
+inline bool OpDef_ArgDef::_internal_is_ref() const {
+  return _impl_.is_ref_;
+}
+inline bool OpDef_ArgDef::is_ref() const {
+  // @@protoc_insertion_point(field_get:tensorflow.OpDef.ArgDef.is_ref)
+  return _internal_is_ref();
+}
+inline void OpDef_ArgDef::_internal_set_is_ref(bool value) {
+  
+  _impl_.is_ref_ = value;
+}
+inline void OpDef_ArgDef::set_is_ref(bool value) {
+  _internal_set_is_ref(value);
+  // @@protoc_insertion_point(field_set:tensorflow.OpDef.ArgDef.is_ref)
+}
+
+// .tensorflow.FullTypeDef experimental_full_type = 17;
+inline bool OpDef_ArgDef::_internal_has_experimental_full_type() const {
+  return this != internal_default_instance() && _impl_.experimental_full_type_ != nullptr;
+}
+inline bool OpDef_ArgDef::has_experimental_full_type() const {
+  return _internal_has_experimental_full_type();
+}
+inline const ::tensorflow::FullTypeDef& OpDef_ArgDef::_internal_experimental_full_type() const {
+  const ::tensorflow::FullTypeDef* p = _impl_.experimental_full_type_;
+  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::FullTypeDef&>(
+      ::tensorflow::_FullTypeDef_default_instance_);
+}
+inline const ::tensorflow::FullTypeDef& OpDef_ArgDef::experimental_full_type() const {
+  // @@protoc_insertion_point(field_get:tensorflow.OpDef.ArgDef.experimental_full_type)
+  return _internal_experimental_full_type();
+}
+inline void OpDef_ArgDef::unsafe_arena_set_allocated_experimental_full_type(
+    ::tensorflow::FullTypeDef* experimental_full_type) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.experimental_full_type_);
+  }
+  _impl_.experimental_full_type_ = experimental_full_type;
+  if (experimental_full_type) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.OpDef.ArgDef.experimental_full_type)
+}
+inline ::tensorflow::FullTypeDef* OpDef_ArgDef::release_experimental_full_type() {
+  
+  ::tensorflow::FullTypeDef* temp = _impl_.experimental_full_type_;
+  _impl_.experimental_full_type_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::tensorflow::FullTypeDef* OpDef_ArgDef::unsafe_arena_release_experimental_full_type() {
+  // @@protoc_insertion_point(field_release:tensorflow.OpDef.ArgDef.experimental_full_type)
+  
+  ::tensorflow::FullTypeDef* temp = _impl_.experimental_full_type_;
+  _impl_.experimental_full_type_ = nullptr;
+  return temp;
+}
+inline ::tensorflow::FullTypeDef* OpDef_ArgDef::_internal_mutable_experimental_full_type() {
+  
+  if (_impl_.experimental_full_type_ == nullptr) {
+    auto* p = CreateMaybeMessage<::tensorflow::FullTypeDef>(GetArenaForAllocation());
+    _impl_.experimental_full_type_ = p;
+  }
+  return _impl_.experimental_full_type_;
+}
+inline ::tensorflow::FullTypeDef* OpDef_ArgDef::mutable_experimental_full_type() {
+  ::tensorflow::FullTypeDef* _msg = _internal_mutable_experimental_full_type();
+  // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.ArgDef.experimental_full_type)
+  return _msg;
+}
+inline void OpDef_ArgDef::set_allocated_experimental_full_type(::tensorflow::FullTypeDef* experimental_full_type) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.experimental_full_type_);
+  }
+  if (experimental_full_type) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(experimental_full_type));
+    if (message_arena != submessage_arena) {
+      experimental_full_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, experimental_full_type, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.experimental_full_type_ = experimental_full_type;
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDef.ArgDef.experimental_full_type)
+}
+
+// -------------------------------------------------------------------
+
+// OpDef_AttrDef
+
+// string name = 1;
+inline void OpDef_AttrDef::clear_name() {
+  _impl_.name_.ClearToEmpty();
+}
+inline const std::string& OpDef_AttrDef::name() const {
+  // @@protoc_insertion_point(field_get:tensorflow.OpDef.AttrDef.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void OpDef_AttrDef::set_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.OpDef.AttrDef.name)
+}
+inline std::string* OpDef_AttrDef::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.AttrDef.name)
+  return _s;
+}
+inline const std::string& OpDef_AttrDef::_internal_name() const {
+  return _impl_.name_.Get();
+}
+inline void OpDef_AttrDef::_internal_set_name(const std::string& value) {
+  
+  _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* OpDef_AttrDef::_internal_mutable_name() {
+  
+  return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* OpDef_AttrDef::release_name() {
+  // @@protoc_insertion_point(field_release:tensorflow.OpDef.AttrDef.name)
+  return _impl_.name_.Release();
+}
+inline void OpDef_AttrDef::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDef.AttrDef.name)
+}
+
+// string type = 2;
+inline void OpDef_AttrDef::clear_type() {
+  _impl_.type_.ClearToEmpty();
+}
+inline const std::string& OpDef_AttrDef::type() const {
+  // @@protoc_insertion_point(field_get:tensorflow.OpDef.AttrDef.type)
+  return _internal_type();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void OpDef_AttrDef::set_type(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.type_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.OpDef.AttrDef.type)
+}
+inline std::string* OpDef_AttrDef::mutable_type() {
+  std::string* _s = _internal_mutable_type();
+  // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.AttrDef.type)
+  return _s;
+}
+inline const std::string& OpDef_AttrDef::_internal_type() const {
+  return _impl_.type_.Get();
+}
+inline void OpDef_AttrDef::_internal_set_type(const std::string& value) {
+  
+  _impl_.type_.Set(value, GetArenaForAllocation());
+}
+inline std::string* OpDef_AttrDef::_internal_mutable_type() {
+  
+  return _impl_.type_.Mutable(GetArenaForAllocation());
+}
+inline std::string* OpDef_AttrDef::release_type() {
+  // @@protoc_insertion_point(field_release:tensorflow.OpDef.AttrDef.type)
+  return _impl_.type_.Release();
+}
+inline void OpDef_AttrDef::set_allocated_type(std::string* type) {
+  if (type != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.type_.SetAllocated(type, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.type_.IsDefault()) {
+    _impl_.type_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDef.AttrDef.type)
+}
+
+// .tensorflow.AttrValue default_value = 3;
+inline bool OpDef_AttrDef::_internal_has_default_value() const {
+  return this != internal_default_instance() && _impl_.default_value_ != nullptr;
+}
+inline bool OpDef_AttrDef::has_default_value() const {
+  return _internal_has_default_value();
+}
+inline const ::tensorflow::AttrValue& OpDef_AttrDef::_internal_default_value() const {
+  const ::tensorflow::AttrValue* p = _impl_.default_value_;
+  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::AttrValue&>(
+      ::tensorflow::_AttrValue_default_instance_);
+}
+inline const ::tensorflow::AttrValue& OpDef_AttrDef::default_value() const {
+  // @@protoc_insertion_point(field_get:tensorflow.OpDef.AttrDef.default_value)
+  return _internal_default_value();
+}
+inline void OpDef_AttrDef::unsafe_arena_set_allocated_default_value(
+    ::tensorflow::AttrValue* default_value) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.default_value_);
+  }
+  _impl_.default_value_ = default_value;
+  if (default_value) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.OpDef.AttrDef.default_value)
+}
+inline ::tensorflow::AttrValue* OpDef_AttrDef::release_default_value() {
+  
+  ::tensorflow::AttrValue* temp = _impl_.default_value_;
+  _impl_.default_value_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::tensorflow::AttrValue* OpDef_AttrDef::unsafe_arena_release_default_value() {
+  // @@protoc_insertion_point(field_release:tensorflow.OpDef.AttrDef.default_value)
+  
+  ::tensorflow::AttrValue* temp = _impl_.default_value_;
+  _impl_.default_value_ = nullptr;
+  return temp;
+}
+inline ::tensorflow::AttrValue* OpDef_AttrDef::_internal_mutable_default_value() {
+  
+  if (_impl_.default_value_ == nullptr) {
+    auto* p = CreateMaybeMessage<::tensorflow::AttrValue>(GetArenaForAllocation());
+    _impl_.default_value_ = p;
+  }
+  return _impl_.default_value_;
+}
+inline ::tensorflow::AttrValue* OpDef_AttrDef::mutable_default_value() {
+  ::tensorflow::AttrValue* _msg = _internal_mutable_default_value();
+  // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.AttrDef.default_value)
+  return _msg;
+}
+inline void OpDef_AttrDef::set_allocated_default_value(::tensorflow::AttrValue* default_value) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.default_value_);
+  }
+  if (default_value) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(default_value));
+    if (message_arena != submessage_arena) {
+      default_value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, default_value, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.default_value_ = default_value;
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDef.AttrDef.default_value)
+}
+
+// string description = 4;
+inline void OpDef_AttrDef::clear_description() {
+  _impl_.description_.ClearToEmpty();
+}
+inline const std::string& OpDef_AttrDef::description() const {
+  // @@protoc_insertion_point(field_get:tensorflow.OpDef.AttrDef.description)
+  return _internal_description();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void OpDef_AttrDef::set_description(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.description_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.OpDef.AttrDef.description)
+}
+inline std::string* OpDef_AttrDef::mutable_description() {
+  std::string* _s = _internal_mutable_description();
+  // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.AttrDef.description)
+  return _s;
+}
+inline const std::string& OpDef_AttrDef::_internal_description() const {
+  return _impl_.description_.Get();
+}
+inline void OpDef_AttrDef::_internal_set_description(const std::string& value) {
+  
+  _impl_.description_.Set(value, GetArenaForAllocation());
+}
+inline std::string* OpDef_AttrDef::_internal_mutable_description() {
+  
+  return _impl_.description_.Mutable(GetArenaForAllocation());
+}
+inline std::string* OpDef_AttrDef::release_description() {
+  // @@protoc_insertion_point(field_release:tensorflow.OpDef.AttrDef.description)
+  return _impl_.description_.Release();
+}
+inline void OpDef_AttrDef::set_allocated_description(std::string* description) {
+  if (description != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.description_.SetAllocated(description, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.description_.IsDefault()) {
+    _impl_.description_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDef.AttrDef.description)
+}
+
+// bool has_minimum = 5;
+inline void OpDef_AttrDef::clear_has_minimum() {
+  _impl_.has_minimum_ = false;
+}
+inline bool OpDef_AttrDef::_internal_has_minimum() const {
+  return _impl_.has_minimum_;
+}
+inline bool OpDef_AttrDef::has_minimum() const {
+  // @@protoc_insertion_point(field_get:tensorflow.OpDef.AttrDef.has_minimum)
+  return _internal_has_minimum();
+}
+inline void OpDef_AttrDef::_internal_set_has_minimum(bool value) {
+  
+  _impl_.has_minimum_ = value;
+}
+inline void OpDef_AttrDef::set_has_minimum(bool value) {
+  _internal_set_has_minimum(value);
+  // @@protoc_insertion_point(field_set:tensorflow.OpDef.AttrDef.has_minimum)
+}
+
+// int64 minimum = 6;
+inline void OpDef_AttrDef::clear_minimum() {
+  _impl_.minimum_ = int64_t{0};
+}
+inline int64_t OpDef_AttrDef::_internal_minimum() const {
+  return _impl_.minimum_;
+}
+inline int64_t OpDef_AttrDef::minimum() const {
+  // @@protoc_insertion_point(field_get:tensorflow.OpDef.AttrDef.minimum)
+  return _internal_minimum();
+}
+inline void OpDef_AttrDef::_internal_set_minimum(int64_t value) {
+  
+  _impl_.minimum_ = value;
+}
+inline void OpDef_AttrDef::set_minimum(int64_t value) {
+  _internal_set_minimum(value);
+  // @@protoc_insertion_point(field_set:tensorflow.OpDef.AttrDef.minimum)
+}
+
+// .tensorflow.AttrValue allowed_values = 7;
+inline bool OpDef_AttrDef::_internal_has_allowed_values() const {
+  return this != internal_default_instance() && _impl_.allowed_values_ != nullptr;
+}
+inline bool OpDef_AttrDef::has_allowed_values() const {
+  return _internal_has_allowed_values();
+}
+inline const ::tensorflow::AttrValue& OpDef_AttrDef::_internal_allowed_values() const {
+  const ::tensorflow::AttrValue* p = _impl_.allowed_values_;
+  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::AttrValue&>(
+      ::tensorflow::_AttrValue_default_instance_);
+}
+inline const ::tensorflow::AttrValue& OpDef_AttrDef::allowed_values() const {
+  // @@protoc_insertion_point(field_get:tensorflow.OpDef.AttrDef.allowed_values)
+  return _internal_allowed_values();
+}
+inline void OpDef_AttrDef::unsafe_arena_set_allocated_allowed_values(
+    ::tensorflow::AttrValue* allowed_values) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.allowed_values_);
+  }
+  _impl_.allowed_values_ = allowed_values;
+  if (allowed_values) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.OpDef.AttrDef.allowed_values)
+}
+inline ::tensorflow::AttrValue* OpDef_AttrDef::release_allowed_values() {
+  
+  ::tensorflow::AttrValue* temp = _impl_.allowed_values_;
+  _impl_.allowed_values_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::tensorflow::AttrValue* OpDef_AttrDef::unsafe_arena_release_allowed_values() {
+  // @@protoc_insertion_point(field_release:tensorflow.OpDef.AttrDef.allowed_values)
+  
+  ::tensorflow::AttrValue* temp = _impl_.allowed_values_;
+  _impl_.allowed_values_ = nullptr;
+  return temp;
+}
+inline ::tensorflow::AttrValue* OpDef_AttrDef::_internal_mutable_allowed_values() {
+  
+  if (_impl_.allowed_values_ == nullptr) {
+    auto* p = CreateMaybeMessage<::tensorflow::AttrValue>(GetArenaForAllocation());
+    _impl_.allowed_values_ = p;
+  }
+  return _impl_.allowed_values_;
+}
+inline ::tensorflow::AttrValue* OpDef_AttrDef::mutable_allowed_values() {
+  ::tensorflow::AttrValue* _msg = _internal_mutable_allowed_values();
+  // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.AttrDef.allowed_values)
+  return _msg;
+}
+inline void OpDef_AttrDef::set_allocated_allowed_values(::tensorflow::AttrValue* allowed_values) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.allowed_values_);
+  }
+  if (allowed_values) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(allowed_values));
+    if (message_arena != submessage_arena) {
+      allowed_values = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, allowed_values, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.allowed_values_ = allowed_values;
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDef.AttrDef.allowed_values)
+}
+
+// -------------------------------------------------------------------
+
+// OpDef
+
+// string name = 1;
+inline void OpDef::clear_name() {
+  _impl_.name_.ClearToEmpty();
+}
+inline const std::string& OpDef::name() const {
+  // @@protoc_insertion_point(field_get:tensorflow.OpDef.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void OpDef::set_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.OpDef.name)
+}
+inline std::string* OpDef::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.name)
+  return _s;
+}
+inline const std::string& OpDef::_internal_name() const {
+  return _impl_.name_.Get();
+}
+inline void OpDef::_internal_set_name(const std::string& value) {
+  
+  _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* OpDef::_internal_mutable_name() {
+  
+  return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* OpDef::release_name() {
+  // @@protoc_insertion_point(field_release:tensorflow.OpDef.name)
+  return _impl_.name_.Release();
+}
+inline void OpDef::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDef.name)
+}
+
+// repeated .tensorflow.OpDef.ArgDef input_arg = 2;
+inline int OpDef::_internal_input_arg_size() const {
+  return _impl_.input_arg_.size();
+}
+inline int OpDef::input_arg_size() const {
+  return _internal_input_arg_size();
+}
+inline void OpDef::clear_input_arg() {
+  _impl_.input_arg_.Clear();
+}
+inline ::tensorflow::OpDef_ArgDef* OpDef::mutable_input_arg(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.input_arg)
+  return _impl_.input_arg_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpDef_ArgDef >*
+OpDef::mutable_input_arg() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.OpDef.input_arg)
+  return &_impl_.input_arg_;
+}
+inline const ::tensorflow::OpDef_ArgDef& OpDef::_internal_input_arg(int index) const {
+  return _impl_.input_arg_.Get(index);
+}
+inline const ::tensorflow::OpDef_ArgDef& OpDef::input_arg(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.OpDef.input_arg)
+  return _internal_input_arg(index);
+}
+inline ::tensorflow::OpDef_ArgDef* OpDef::_internal_add_input_arg() {
+  return _impl_.input_arg_.Add();
+}
+inline ::tensorflow::OpDef_ArgDef* OpDef::add_input_arg() {
+  ::tensorflow::OpDef_ArgDef* _add = _internal_add_input_arg();
+  // @@protoc_insertion_point(field_add:tensorflow.OpDef.input_arg)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpDef_ArgDef >&
+OpDef::input_arg() const {
+  // @@protoc_insertion_point(field_list:tensorflow.OpDef.input_arg)
+  return _impl_.input_arg_;
+}
+
+// repeated .tensorflow.OpDef.ArgDef output_arg = 3;
+inline int OpDef::_internal_output_arg_size() const {
+  return _impl_.output_arg_.size();
+}
+inline int OpDef::output_arg_size() const {
+  return _internal_output_arg_size();
+}
+inline void OpDef::clear_output_arg() {
+  _impl_.output_arg_.Clear();
+}
+inline ::tensorflow::OpDef_ArgDef* OpDef::mutable_output_arg(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.output_arg)
+  return _impl_.output_arg_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpDef_ArgDef >*
+OpDef::mutable_output_arg() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.OpDef.output_arg)
+  return &_impl_.output_arg_;
+}
+inline const ::tensorflow::OpDef_ArgDef& OpDef::_internal_output_arg(int index) const {
+  return _impl_.output_arg_.Get(index);
+}
+inline const ::tensorflow::OpDef_ArgDef& OpDef::output_arg(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.OpDef.output_arg)
+  return _internal_output_arg(index);
+}
+inline ::tensorflow::OpDef_ArgDef* OpDef::_internal_add_output_arg() {
+  return _impl_.output_arg_.Add();
+}
+inline ::tensorflow::OpDef_ArgDef* OpDef::add_output_arg() {
+  ::tensorflow::OpDef_ArgDef* _add = _internal_add_output_arg();
+  // @@protoc_insertion_point(field_add:tensorflow.OpDef.output_arg)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpDef_ArgDef >&
+OpDef::output_arg() const {
+  // @@protoc_insertion_point(field_list:tensorflow.OpDef.output_arg)
+  return _impl_.output_arg_;
+}
+
+// repeated string control_output = 20;
+inline int OpDef::_internal_control_output_size() const {
+  return _impl_.control_output_.size();
+}
+inline int OpDef::control_output_size() const {
+  return _internal_control_output_size();
+}
+inline void OpDef::clear_control_output() {
+  _impl_.control_output_.Clear();
+}
+inline std::string* OpDef::add_control_output() {
+  std::string* _s = _internal_add_control_output();
+  // @@protoc_insertion_point(field_add_mutable:tensorflow.OpDef.control_output)
+  return _s;
+}
+inline const std::string& OpDef::_internal_control_output(int index) const {
+  return _impl_.control_output_.Get(index);
+}
+inline const std::string& OpDef::control_output(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.OpDef.control_output)
+  return _internal_control_output(index);
+}
+inline std::string* OpDef::mutable_control_output(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.control_output)
+  return _impl_.control_output_.Mutable(index);
+}
+inline void OpDef::set_control_output(int index, const std::string& value) {
+  _impl_.control_output_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:tensorflow.OpDef.control_output)
+}
+inline void OpDef::set_control_output(int index, std::string&& value) {
+  _impl_.control_output_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:tensorflow.OpDef.control_output)
+}
+inline void OpDef::set_control_output(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.control_output_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:tensorflow.OpDef.control_output)
+}
+inline void OpDef::set_control_output(int index, const char* value, size_t size) {
+  _impl_.control_output_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:tensorflow.OpDef.control_output)
+}
+inline std::string* OpDef::_internal_add_control_output() {
+  return _impl_.control_output_.Add();
+}
+inline void OpDef::add_control_output(const std::string& value) {
+  _impl_.control_output_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:tensorflow.OpDef.control_output)
+}
+inline void OpDef::add_control_output(std::string&& value) {
+  _impl_.control_output_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:tensorflow.OpDef.control_output)
+}
+inline void OpDef::add_control_output(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.control_output_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:tensorflow.OpDef.control_output)
+}
+inline void OpDef::add_control_output(const char* value, size_t size) {
+  _impl_.control_output_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:tensorflow.OpDef.control_output)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+OpDef::control_output() const {
+  // @@protoc_insertion_point(field_list:tensorflow.OpDef.control_output)
+  return _impl_.control_output_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+OpDef::mutable_control_output() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.OpDef.control_output)
+  return &_impl_.control_output_;
+}
+
+// repeated .tensorflow.OpDef.AttrDef attr = 4;
+inline int OpDef::_internal_attr_size() const {
+  return _impl_.attr_.size();
+}
+inline int OpDef::attr_size() const {
+  return _internal_attr_size();
+}
+inline void OpDef::clear_attr() {
+  _impl_.attr_.Clear();
+}
+inline ::tensorflow::OpDef_AttrDef* OpDef::mutable_attr(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.attr)
+  return _impl_.attr_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpDef_AttrDef >*
+OpDef::mutable_attr() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.OpDef.attr)
+  return &_impl_.attr_;
+}
+inline const ::tensorflow::OpDef_AttrDef& OpDef::_internal_attr(int index) const {
+  return _impl_.attr_.Get(index);
+}
+inline const ::tensorflow::OpDef_AttrDef& OpDef::attr(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.OpDef.attr)
+  return _internal_attr(index);
+}
+inline ::tensorflow::OpDef_AttrDef* OpDef::_internal_add_attr() {
+  return _impl_.attr_.Add();
+}
+inline ::tensorflow::OpDef_AttrDef* OpDef::add_attr() {
+  ::tensorflow::OpDef_AttrDef* _add = _internal_add_attr();
+  // @@protoc_insertion_point(field_add:tensorflow.OpDef.attr)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpDef_AttrDef >&
+OpDef::attr() const {
+  // @@protoc_insertion_point(field_list:tensorflow.OpDef.attr)
+  return _impl_.attr_;
+}
+
+// .tensorflow.OpDeprecation deprecation = 8;
+inline bool OpDef::_internal_has_deprecation() const {
+  return this != internal_default_instance() && _impl_.deprecation_ != nullptr;
+}
+inline bool OpDef::has_deprecation() const {
+  return _internal_has_deprecation();
+}
+inline void OpDef::clear_deprecation() {
+  if (GetArenaForAllocation() == nullptr && _impl_.deprecation_ != nullptr) {
+    delete _impl_.deprecation_;
+  }
+  _impl_.deprecation_ = nullptr;
+}
+inline const ::tensorflow::OpDeprecation& OpDef::_internal_deprecation() const {
+  const ::tensorflow::OpDeprecation* p = _impl_.deprecation_;
+  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::OpDeprecation&>(
+      ::tensorflow::_OpDeprecation_default_instance_);
+}
+inline const ::tensorflow::OpDeprecation& OpDef::deprecation() const {
+  // @@protoc_insertion_point(field_get:tensorflow.OpDef.deprecation)
+  return _internal_deprecation();
+}
+inline void OpDef::unsafe_arena_set_allocated_deprecation(
+    ::tensorflow::OpDeprecation* deprecation) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.deprecation_);
+  }
+  _impl_.deprecation_ = deprecation;
+  if (deprecation) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.OpDef.deprecation)
+}
+inline ::tensorflow::OpDeprecation* OpDef::release_deprecation() {
+  
+  ::tensorflow::OpDeprecation* temp = _impl_.deprecation_;
+  _impl_.deprecation_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::tensorflow::OpDeprecation* OpDef::unsafe_arena_release_deprecation() {
+  // @@protoc_insertion_point(field_release:tensorflow.OpDef.deprecation)
+  
+  ::tensorflow::OpDeprecation* temp = _impl_.deprecation_;
+  _impl_.deprecation_ = nullptr;
+  return temp;
+}
+inline ::tensorflow::OpDeprecation* OpDef::_internal_mutable_deprecation() {
+  
+  if (_impl_.deprecation_ == nullptr) {
+    auto* p = CreateMaybeMessage<::tensorflow::OpDeprecation>(GetArenaForAllocation());
+    _impl_.deprecation_ = p;
+  }
+  return _impl_.deprecation_;
+}
+inline ::tensorflow::OpDeprecation* OpDef::mutable_deprecation() {
+  ::tensorflow::OpDeprecation* _msg = _internal_mutable_deprecation();
+  // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.deprecation)
+  return _msg;
+}
+inline void OpDef::set_allocated_deprecation(::tensorflow::OpDeprecation* deprecation) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.deprecation_;
+  }
+  if (deprecation) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(deprecation);
+    if (message_arena != submessage_arena) {
+      deprecation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, deprecation, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.deprecation_ = deprecation;
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDef.deprecation)
+}
+
+// string summary = 5;
+inline void OpDef::clear_summary() {
+  _impl_.summary_.ClearToEmpty();
+}
+inline const std::string& OpDef::summary() const {
+  // @@protoc_insertion_point(field_get:tensorflow.OpDef.summary)
+  return _internal_summary();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void OpDef::set_summary(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.summary_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.OpDef.summary)
+}
+inline std::string* OpDef::mutable_summary() {
+  std::string* _s = _internal_mutable_summary();
+  // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.summary)
+  return _s;
+}
+inline const std::string& OpDef::_internal_summary() const {
+  return _impl_.summary_.Get();
+}
+inline void OpDef::_internal_set_summary(const std::string& value) {
+  
+  _impl_.summary_.Set(value, GetArenaForAllocation());
+}
+inline std::string* OpDef::_internal_mutable_summary() {
+  
+  return _impl_.summary_.Mutable(GetArenaForAllocation());
+}
+inline std::string* OpDef::release_summary() {
+  // @@protoc_insertion_point(field_release:tensorflow.OpDef.summary)
+  return _impl_.summary_.Release();
+}
+inline void OpDef::set_allocated_summary(std::string* summary) {
+  if (summary != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.summary_.SetAllocated(summary, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.summary_.IsDefault()) {
+    _impl_.summary_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDef.summary)
+}
+
+// string description = 6;
+inline void OpDef::clear_description() {
+  _impl_.description_.ClearToEmpty();
+}
+inline const std::string& OpDef::description() const {
+  // @@protoc_insertion_point(field_get:tensorflow.OpDef.description)
+  return _internal_description();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void OpDef::set_description(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.description_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.OpDef.description)
+}
+inline std::string* OpDef::mutable_description() {
+  std::string* _s = _internal_mutable_description();
+  // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.description)
+  return _s;
+}
+inline const std::string& OpDef::_internal_description() const {
+  return _impl_.description_.Get();
+}
+inline void OpDef::_internal_set_description(const std::string& value) {
+  
+  _impl_.description_.Set(value, GetArenaForAllocation());
+}
+inline std::string* OpDef::_internal_mutable_description() {
+  
+  return _impl_.description_.Mutable(GetArenaForAllocation());
+}
+inline std::string* OpDef::release_description() {
+  // @@protoc_insertion_point(field_release:tensorflow.OpDef.description)
+  return _impl_.description_.Release();
+}
+inline void OpDef::set_allocated_description(std::string* description) {
+  if (description != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.description_.SetAllocated(description, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.description_.IsDefault()) {
+    _impl_.description_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDef.description)
+}
+
+// bool is_commutative = 18;
+inline void OpDef::clear_is_commutative() {
+  _impl_.is_commutative_ = false;
+}
+inline bool OpDef::_internal_is_commutative() const {
+  return _impl_.is_commutative_;
+}
+inline bool OpDef::is_commutative() const {
+  // @@protoc_insertion_point(field_get:tensorflow.OpDef.is_commutative)
+  return _internal_is_commutative();
+}
+inline void OpDef::_internal_set_is_commutative(bool value) {
+  
+  _impl_.is_commutative_ = value;
+}
+inline void OpDef::set_is_commutative(bool value) {
+  _internal_set_is_commutative(value);
+  // @@protoc_insertion_point(field_set:tensorflow.OpDef.is_commutative)
+}
+
+// bool is_aggregate = 16;
+inline void OpDef::clear_is_aggregate() {
+  _impl_.is_aggregate_ = false;
+}
+inline bool OpDef::_internal_is_aggregate() const {
+  return _impl_.is_aggregate_;
+}
+inline bool OpDef::is_aggregate() const {
+  // @@protoc_insertion_point(field_get:tensorflow.OpDef.is_aggregate)
+  return _internal_is_aggregate();
+}
+inline void OpDef::_internal_set_is_aggregate(bool value) {
+  
+  _impl_.is_aggregate_ = value;
+}
+inline void OpDef::set_is_aggregate(bool value) {
+  _internal_set_is_aggregate(value);
+  // @@protoc_insertion_point(field_set:tensorflow.OpDef.is_aggregate)
+}
+
+// bool is_stateful = 17;
+inline void OpDef::clear_is_stateful() {
+  _impl_.is_stateful_ = false;
+}
+inline bool OpDef::_internal_is_stateful() const {
+  return _impl_.is_stateful_;
+}
+inline bool OpDef::is_stateful() const {
+  // @@protoc_insertion_point(field_get:tensorflow.OpDef.is_stateful)
+  return _internal_is_stateful();
+}
+inline void OpDef::_internal_set_is_stateful(bool value) {
+  
+  _impl_.is_stateful_ = value;
+}
+inline void OpDef::set_is_stateful(bool value) {
+  _internal_set_is_stateful(value);
+  // @@protoc_insertion_point(field_set:tensorflow.OpDef.is_stateful)
+}
+
+// bool allows_uninitialized_input = 19;
+inline void OpDef::clear_allows_uninitialized_input() {
+  _impl_.allows_uninitialized_input_ = false;
+}
+inline bool OpDef::_internal_allows_uninitialized_input() const {
+  return _impl_.allows_uninitialized_input_;
+}
+inline bool OpDef::allows_uninitialized_input() const {
+  // @@protoc_insertion_point(field_get:tensorflow.OpDef.allows_uninitialized_input)
+  return _internal_allows_uninitialized_input();
+}
+inline void OpDef::_internal_set_allows_uninitialized_input(bool value) {
+  
+  _impl_.allows_uninitialized_input_ = value;
+}
+inline void OpDef::set_allows_uninitialized_input(bool value) {
+  _internal_set_allows_uninitialized_input(value);
+  // @@protoc_insertion_point(field_set:tensorflow.OpDef.allows_uninitialized_input)
+}
+
+// bool is_distributed_communication = 21;
+inline void OpDef::clear_is_distributed_communication() {
+  _impl_.is_distributed_communication_ = false;
+}
+inline bool OpDef::_internal_is_distributed_communication() const {
+  return _impl_.is_distributed_communication_;
+}
+inline bool OpDef::is_distributed_communication() const {
+  // @@protoc_insertion_point(field_get:tensorflow.OpDef.is_distributed_communication)
+  return _internal_is_distributed_communication();
+}
+inline void OpDef::_internal_set_is_distributed_communication(bool value) {
+  
+  _impl_.is_distributed_communication_ = value;
+}
+inline void OpDef::set_is_distributed_communication(bool value) {
+  _internal_set_is_distributed_communication(value);
+  // @@protoc_insertion_point(field_set:tensorflow.OpDef.is_distributed_communication)
+}
+
+// -------------------------------------------------------------------
+
+// OpDeprecation
+
+// int32 version = 1;
+inline void OpDeprecation::clear_version() {
+  _impl_.version_ = 0;
+}
+inline int32_t OpDeprecation::_internal_version() const {
+  return _impl_.version_;
+}
+inline int32_t OpDeprecation::version() const {
+  // @@protoc_insertion_point(field_get:tensorflow.OpDeprecation.version)
+  return _internal_version();
+}
+inline void OpDeprecation::_internal_set_version(int32_t value) {
+  
+  _impl_.version_ = value;
+}
+inline void OpDeprecation::set_version(int32_t value) {
+  _internal_set_version(value);
+  // @@protoc_insertion_point(field_set:tensorflow.OpDeprecation.version)
+}
+
+// string explanation = 2;
+inline void OpDeprecation::clear_explanation() {
+  _impl_.explanation_.ClearToEmpty();
+}
+inline const std::string& OpDeprecation::explanation() const {
+  // @@protoc_insertion_point(field_get:tensorflow.OpDeprecation.explanation)
+  return _internal_explanation();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void OpDeprecation::set_explanation(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.explanation_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.OpDeprecation.explanation)
+}
+inline std::string* OpDeprecation::mutable_explanation() {
+  std::string* _s = _internal_mutable_explanation();
+  // @@protoc_insertion_point(field_mutable:tensorflow.OpDeprecation.explanation)
+  return _s;
+}
+inline const std::string& OpDeprecation::_internal_explanation() const {
+  return _impl_.explanation_.Get();
+}
+inline void OpDeprecation::_internal_set_explanation(const std::string& value) {
+  
+  _impl_.explanation_.Set(value, GetArenaForAllocation());
+}
+inline std::string* OpDeprecation::_internal_mutable_explanation() {
+  
+  return _impl_.explanation_.Mutable(GetArenaForAllocation());
+}
+inline std::string* OpDeprecation::release_explanation() {
+  // @@protoc_insertion_point(field_release:tensorflow.OpDeprecation.explanation)
+  return _impl_.explanation_.Release();
+}
+inline void OpDeprecation::set_allocated_explanation(std::string* explanation) {
+  if (explanation != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.explanation_.SetAllocated(explanation, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.explanation_.IsDefault()) {
+    _impl_.explanation_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDeprecation.explanation)
+}
+
+// -------------------------------------------------------------------
+
+// OpList
+
+// repeated .tensorflow.OpDef op = 1;
+inline int OpList::_internal_op_size() const {
+  return _impl_.op_.size();
+}
+inline int OpList::op_size() const {
+  return _internal_op_size();
+}
+inline void OpList::clear_op() {
+  _impl_.op_.Clear();
+}
+inline ::tensorflow::OpDef* OpList::mutable_op(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.OpList.op)
+  return _impl_.op_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpDef >*
+OpList::mutable_op() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.OpList.op)
+  return &_impl_.op_;
+}
+inline const ::tensorflow::OpDef& OpList::_internal_op(int index) const {
+  return _impl_.op_.Get(index);
+}
+inline const ::tensorflow::OpDef& OpList::op(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.OpList.op)
+  return _internal_op(index);
+}
+inline ::tensorflow::OpDef* OpList::_internal_add_op() {
+  return _impl_.op_.Add();
+}
+inline ::tensorflow::OpDef* OpList::add_op() {
+  ::tensorflow::OpDef* _add = _internal_add_op();
+  // @@protoc_insertion_point(field_add:tensorflow.OpList.op)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpDef >&
+OpList::op() const {
+  // @@protoc_insertion_point(field_list:tensorflow.OpList.op)
+  return _impl_.op_;
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace tensorflow
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fop_5fdef_2eproto
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/op_def.proto b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/op_def.proto
new file mode 100644
index 0000000000000000000000000000000000000000..b71f5ce87a286750ad1b79ee5df7c735891c28bf
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/op_def.proto
@@ -0,0 +1,193 @@
+syntax = "proto3";
+
+package tensorflow;
+
+import "tensorflow/core/framework/attr_value.proto";
+import "tensorflow/core/framework/full_type.proto";
+import "tensorflow/core/framework/resource_handle.proto";
+import "tensorflow/core/framework/types.proto";
+
+option cc_enable_arenas = true;
+option java_outer_classname = "OpDefProtos";
+option java_multiple_files = true;
+option java_package = "org.tensorflow.framework";
+option go_package = "github.com/tensorflow/tensorflow/tensorflow/go/core/framework/op_def_go_proto";
+
+// Defines an operation. A NodeDef in a GraphDef specifies an Op by
+// using the "op" field which should match the name of a OpDef.
+// LINT.IfChange
+message OpDef {
+  // Op names starting with an underscore are reserved for internal use.
+  // Names should be CamelCase and match the regexp "[A-Z][a-zA-Z0-9>_]*".
+  string name = 1;
+
+  // For describing inputs and outputs.
+  message ArgDef {
+    // Name for the input/output.  Should match the regexp "[a-z][a-z0-9_]*".
+    string name = 1;
+
+    // Human readable description.
+    string description = 2;
+
+    // Describes the type of one or more tensors that are accepted/produced
+    // by this input/output arg.  The only legal combinations are:
+    // * For a single tensor: either the "type" field is set or the
+    //   "type_attr" field is set to the name of an attr with type "type".
+    // * For a sequence of tensors with the same type: the "number_attr"
+    //   field will be set to the name of an attr with type "int", and
+    //   either the "type" or "type_attr" field will be set as for
+    //   single tensors.
+    // * For a sequence of tensors, the "type_list_attr" field will be set
+    //   to the name of an attr with type "list(type)".
+    DataType type = 3;
+    string type_attr = 4;    // if specified, attr must have type "type"
+    string number_attr = 5;  // if specified, attr must have type "int"
+    // If specified, attr must have type "list(type)", and none of
+    // type, type_attr, and number_attr may be specified.
+    string type_list_attr = 6;
+
+    // The handle data for resource inputs.
+    repeated ResourceHandleProto.DtypeAndShape handle_data = 7;
+
+    // For inputs: if true, the inputs are required to be refs.
+    //   By default, inputs can be either refs or non-refs.
+    // For outputs: if true, outputs are refs, otherwise they are not.
+    bool is_ref = 16;
+
+    // Experimental. Full type declaration for this argument.
+    // The full type specification combines type, type_attr, type_list_attr,
+    // etc. into a unified representation.
+    // This declaration may contain non-concrete types (for example,
+    // Tensor<TypeVar<'T'>> is a valid type declaration.
+    //
+    // Note: this is a transient field. The long-term aim is to represent the
+    // entire OpDef as a single type: a callable. In that context, this field is
+    // just the type of a single argument.
+    FullTypeDef experimental_full_type = 17;
+  }
+
+  // Description of the input(s).
+  repeated ArgDef input_arg = 2;
+
+  // Description of the output(s).
+  repeated ArgDef output_arg = 3;
+
+  // Named control outputs for this operation. Useful only for composite
+  // operations (i.e. functions) which want to name different control outputs.
+  repeated string control_output = 20;
+
+  // Description of the graph-construction-time configuration of this
+  // Op.  That is to say, this describes the attr fields that will
+  // be specified in the NodeDef.
+  message AttrDef {
+    // A descriptive name for the argument.  May be used, e.g. by the
+    // Python client, as a keyword argument name, and so should match
+    // the regexp "[a-z][a-z0-9_]+".
+    string name = 1;
+
+    // One of the type names from attr_value.proto ("string", "list(string)",
+    // "int", etc.).
+    string type = 2;
+
+    // A reasonable default for this attribute if the user does not supply
+    // a value.  If not specified, the user must supply a value.
+    AttrValue default_value = 3;
+
+    // Human-readable description.
+    string description = 4;
+
+    // TODO(josh11b): bool is_optional?
+
+    // --- Constraints ---
+    // These constraints are only in effect if specified.  Default is no
+    // constraints.
+
+    // For type == "int", this is a minimum value.  For "list(___)"
+    // types, this is the minimum length.
+    bool has_minimum = 5;
+    int64 minimum = 6;
+
+    // The set of allowed values.  Has type that is the "list" version
+    // of the "type" field above (uses the "list" field of AttrValue).
+    // If type == "type" or "list(type)" above, then the "type" field
+    // of "allowed_values.list" has the set of allowed DataTypes.
+    // If type == "string" or "list(string)", then the "s" field of
+    // "allowed_values.list" has the set of allowed strings.
+    AttrValue allowed_values = 7;
+  }
+  repeated AttrDef attr = 4;
+
+  // Optional deprecation based on GraphDef versions.
+  OpDeprecation deprecation = 8;
+
+  // One-line human-readable description of what the Op does.
+  string summary = 5;
+
+  // Additional, longer human-readable description of what the Op does.
+  string description = 6;
+
+  // -------------------------------------------------------------------------
+  // Which optimizations this operation can participate in.
+
+  // True if the operation is commutative ("op(a,b) == op(b,a)" for all inputs)
+  bool is_commutative = 18;
+
+  // If is_aggregate is true, then this operation accepts N >= 2
+  // inputs and produces 1 output all of the same type.  Should be
+  // associative and commutative, and produce output with the same
+  // shape as the input.  The optimizer may replace an aggregate op
+  // taking input from multiple devices with a tree of aggregate ops
+  // that aggregate locally within each device (and possibly within
+  // groups of nearby devices) before communicating.
+  // TODO(josh11b): Implement that optimization.
+  bool is_aggregate = 16;  // for things like add
+
+  // Other optimizations go here, like
+  //   can_alias_input, rewrite_when_output_unused, partitioning_strategy, etc.
+
+  // -------------------------------------------------------------------------
+  // Optimization constraints.
+
+  // Ops are marked as stateful if their behavior depends on some state beyond
+  // their input tensors (e.g. variable reading op) or if they have
+  // a side-effect (e.g. printing or asserting ops). Equivalently, stateless ops
+  // must always produce the same output for the same input and have
+  // no side-effects.
+  //
+  // By default Ops may be moved between devices.  Stateful ops should
+  // either not be moved, or should only be moved if that state can also
+  // be moved (e.g. via some sort of save / restore).
+  // Stateful ops are guaranteed to never be optimized away by Common
+  // Subexpression Elimination (CSE).
+  bool is_stateful = 17;  // for things like variables, queue
+
+  // -------------------------------------------------------------------------
+  // Non-standard options.
+
+  // By default, all inputs to an Op must be initialized Tensors.  Ops
+  // that may initialize tensors for the first time should set this
+  // field to true, to allow the Op to take an uninitialized Tensor as
+  // input.
+  bool allows_uninitialized_input = 19;  // for Assign, etc.
+
+  // Indicates whether the op implementation uses distributed communication.
+  // If True, the op is allowed to return errors for network disconnection and
+  // trigger TF network failure handling logics.
+  bool is_distributed_communication = 21;
+}
+// LINT.ThenChange(
+//     https://www.tensorflow.org/code/tensorflow/core/framework/op_def_util.cc)
+
+// Information about version-dependent deprecation of an op
+message OpDeprecation {
+  // First GraphDef version at which the op is disallowed.
+  int32 version = 1;
+
+  // Explanation of why it was deprecated and what to use instead.
+  string explanation = 2;
+}
+
+// A collection of OpDefs
+message OpList {
+  repeated OpDef op = 1;
+}
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/op_def_builder.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/op_def_builder.h
new file mode 100644
index 0000000000000000000000000000000000000000..fd96bdcf675d16470217292215ac19bcaff3d48c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/op_def_builder.h
@@ -0,0 +1,280 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// Class and associated machinery for specifying an Op's OpDef and shape
+// inference function for Op registration.
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_OP_DEF_BUILDER_H_
+#define TENSORFLOW_CORE_FRAMEWORK_OP_DEF_BUILDER_H_
+
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "tensorflow/core/framework/full_type.pb.h"
+#include "tensorflow/core/framework/op_def.pb.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/lib/core/stringpiece.h"
+#include "tensorflow/core/platform/macros.h"
+
+namespace tensorflow {
+
+// TODO(b/62899350): Refactor without proto dependencies.
+typedef std::function<Status(OpDef* c)> OpTypeConstructor;
+
+typedef std::vector<std::reference_wrapper<const FullTypeDef>> TypeRefVector;
+
+// A callback into the type inference process, allowing type inference functions
+// to request inferring the type of some function (assumed to exist in the
+// runtime). The function is specified by name.
+typedef std::function<StatusOr<FullTypeDef>(const string&,
+                                            const TypeRefVector&)>
+    FunctionTypeInferrer;
+
+// A type inference function, called for each node during type inference
+// (possibly multiple times).
+// The first argument (input_types) will hold the type of each of the node's
+// inputs. The second argument (type_vars) will hold the return type of
+// each function referred from any type variable (e.g. `FuncVar`) present
+// in the node's corresponding op definition.
+//
+// TODO(mdan): Consider a vector-in, vector-out contract.
+typedef std::function<StatusOr<FullTypeDef>(const TypeRefVector&,
+                                            const FunctionTypeInferrer&)>
+    TypeInferenceFn;
+
+class FunctionDefHelper;
+
+namespace shape_inference {
+class InferenceContext;
+}
+typedef std::function<Status(shape_inference::InferenceContext* c)>
+    OpShapeInferenceFn;
+
+struct OpRegistrationData {
+ public:
+  OpRegistrationData() {}
+  OpRegistrationData(const OpDef& def) : op_def(def) {}
+  OpRegistrationData(const OpDef& def, const OpShapeInferenceFn& fn,
+                     bool is_function = false)
+      : op_def(def), shape_inference_fn(fn), is_function_op(is_function) {}
+
+  OpDef op_def;
+  OpShapeInferenceFn shape_inference_fn;
+
+  // Type constructor. This callable initializes the type of this op.
+  // It is provided as a programmatic mechanism for defining an op's
+  // type, as part of its registration. It is to be eventually replaced by a
+  // textual language.
+  //
+  // Important: historically, op registrations only contained partial
+  // input/output type information in non-standardized attribute declarations
+  // (e.g. typically, input types were held in a `dtype` attribute). The type
+  // constructor currently duplicates such attribute information, with the aim
+  // of entirely subsuming it, and eventually deprecating all type-related
+  // attributes.
+  //
+  // Since ops are typically parametrized, the type created by this constructor
+  // is also parametric.
+  //
+  // Example: for an op `Foo(x: T) -> Bar[T]`:
+  //
+  //  * typically, its op registration included a single attribute `T: type`;
+  //    then the respective input was defined as `x: T`; the output type `Bar`
+  //    was implied by the op name.
+  //  * the type constructor creates a FullType object containing `Bar[T]`; this
+  //    still relies on the `T` attribute which it references.
+  //  * in the future, the type constructor will create a FullType containing
+  //    `Callable[(x: T), Bar[T]]`, and the attribute `T` will be deprecated.
+  OpTypeConstructor type_ctor;
+
+  // Forward type inference function. This callable infers the return type of an
+  // op based on its input types.
+  //
+  // Note that the type constructor and forward inference functions need not be
+  // mutually exclusive: if there is some static information that can be set
+  // based on attributes, then that should be set in the constructor. If more
+  // information can be extracted from inputs, that should be done in the
+  // forward inference function.
+  //
+  // This is similar to the shape function, but is more general, and applied
+  // directly to NodeDefs, rather than working on the ShapeAndType structures.
+  // Note that the op input/output declarations may specify some implicit type
+  // constraints through attribute references (i.e. two inputs pointing to the
+  // same type attribute). Those constraints may duplicate what this function
+  // specifies in its body. That's intended, for a gradual transition to a more
+  // formal type system.
+  //
+  // These type inference functions are intermediate solutions as well: once the
+  // op registration has a complete, formal type definition, along with
+  // a solver-based type inference, it will replace these functions.
+  //
+  // TODO(mdan): Merge with shape inference.
+  // TODO(mdan): Replace with a union-based type inference algorithm.
+  TypeInferenceFn fwd_type_fn;
+
+  // Reverse type inference function. This callable infers some input types
+  // based on the return type.
+  //
+  // TODO(mdan): Replace with a union-based type inference algorithm.
+  TypeInferenceFn rev_type_fn;
+
+  // The input number affected by reverse type inference. Only one input may be
+  // updated in this manner.
+  // TODO(mdan): Encode in a manner more consistent with the forward version.
+  int rev_type_input;
+
+  bool is_function_op = false;
+};
+
+// Builder class passed to the REGISTER_OP() macro.
+class OpDefBuilder {
+ public:
+  // Constructs an OpDef with just the name field set.
+  explicit OpDefBuilder(std::string op_name);
+
+  // Adds an attr to this OpDefBuilder (and returns *this). The spec has
+  // format "<name>:<type>" or "<name>:<type>=<default>"
+  // where <name> matches regexp [a-zA-Z][a-zA-Z0-9_]*
+  // (by convention only using capital letters for attrs that can be inferred)
+  // <type> can be:
+  //   "string", "int", "float", "bool", "type", "shape", or "tensor"
+  //   "numbertype", "realnumbertype", "quantizedtype"
+  //       (meaning "type" with a restriction on valid values)
+  //   "{int32,int64}" or {realnumbertype,quantizedtype,string}"
+  //       (meaning "type" with a restriction containing unions of value types)
+  //   "{\"foo\", \"bar\n baz\"}", or "{'foo', 'bar\n baz'}"
+  //       (meaning "string" with a restriction on valid values)
+  //   "list(string)", ..., "list(tensor)", "list(numbertype)", ...
+  //       (meaning lists of the above types)
+  //   "int >= 2" (meaning "int" with a restriction on valid values)
+  //   "list(string) >= 2", "list(int) >= 2"
+  //       (meaning "list(string)" / "list(int)" with length at least 2)
+  // <default>, if included, should use the Proto text format
+  // of <type>.  For lists use [a, b, c] format.
+  //
+  // Note that any attr specifying the length of an input or output will
+  // get a default minimum of 1 unless the >= # syntax is used.
+  //
+  // TODO(josh11b): Perhaps support restrictions and defaults as optional
+  // extra arguments to Attr() instead of encoding them in the spec string.
+  // TODO(josh11b): Would like to have better dtype handling for tensor attrs:
+  // * Ability to say the type of an input/output matches the type of
+  //   the tensor.
+  // * Ability to restrict the type of the tensor like the existing
+  //   restrictions for type attrs.
+  // Perhaps by linking the type of the tensor to a type attr?
+  OpDefBuilder& Attr(std::string spec);
+
+  // Adds an input or output to this OpDefBuilder (and returns *this).
+  // The spec has form "<name>:<type-expr>" or "<name>:Ref(<type-expr>)"
+  // where <name> matches regexp [a-z][a-z0-9_]* and <type-expr> can be:
+  // * For a single tensor: <type>
+  // * For a sequence of tensors with the same type: <number>*<type>
+  // * For a sequence of tensors with different types: <type-list>
+  // Where:
+  //   <type> is either one of "float", "int32", "string", ...
+  //                 or the name of an attr (see above) with type "type".
+  //   <number> is the name of an attr with type "int".
+  //   <type-list> is the name of an attr with type "list(type)".
+  // TODO(josh11b): Indicate Ref() via an optional argument instead of
+  // in the spec?
+  // TODO(josh11b): SparseInput() and SparseOutput() matching the Python
+  // handling?
+  OpDefBuilder& Input(std::string spec);
+  OpDefBuilder& Output(std::string spec);
+
+  // Turns on the indicated boolean flag in this OpDefBuilder (and
+  // returns *this).
+  OpDefBuilder& SetIsCommutative();
+  OpDefBuilder& SetIsAggregate();
+  OpDefBuilder& SetIsStateful();
+  OpDefBuilder& SetAllowsUninitializedInput();
+  OpDefBuilder& SetIsDistributedCommunication();
+
+  // Deprecate the op at a certain GraphDef version.
+  OpDefBuilder& Deprecated(int version, std::string explanation);
+
+  // Adds docs to this OpDefBuilder (and returns *this).
+  // Docs have the format:
+  //   <1-line summary>
+  //   <rest of the description>
+  //   <name>: <description of name>
+  //   <name>: <description of name>
+  //     <if long, indent the description on subsequent lines>
+  // Where <name> is the name of an attr, input, or output.  Please
+  // wrap docs at 72 columns so that it may be indented in the
+  // generated output.  For tensor inputs or outputs (not attrs), you
+  // may start the description with an "=" (like name:= <description>)
+  // to suppress the automatically-generated type documentation in
+  // generated output.
+  OpDefBuilder& Doc(std::string text);
+
+  // Sets the function to be used as type constructor.
+  // See OpRegistrationData::type_ctor.
+  OpDefBuilder& SetTypeConstructor(OpTypeConstructor c);
+
+  // Sets the function to be used for forward type inference.
+  // See OpRegistrationData::fwd_type_fn.
+  OpDefBuilder& SetForwardTypeFn(TypeInferenceFn f);
+
+  // Sets the function to be used for reverse type inference.
+  // See OpRegistrationData::rew_type_fn.
+  OpDefBuilder& SetReverseTypeFn(int input_number, TypeInferenceFn f);
+
+  // Sets the shape function to be used for shape inference.
+  //
+  // Note that currently (October 2016), python code still requires a
+  // RegisterShape call to invoke this; see call_cpp_shape_fn in
+  // python/framework/common_shapes.py
+  OpDefBuilder& SetShapeFn(OpShapeInferenceFn fn);
+
+  // Allows the `<type>` in calls to `Attr()` to be "any".
+  // This is used by PythonAPIWrapper for pass-through parameters.
+  OpDefBuilder& AllowAttrTypeAny();
+
+  // Sets op_reg_data->op_def to the requested OpDef and
+  // op_reg_data->shape_inference_fn to the requested shape inference function,
+  // or returns an error.
+  // Must be called after all of the above methods.
+  //
+  // Note that OpDefBuilder only reports parsing errors.  You should also
+  // call ValidateOpDef() to detect other problems.
+  Status Finalize(OpRegistrationData* op_reg_data) const;
+
+ private:
+  friend class FunctionDefHelper;
+
+  // Adds control output to this OpDefBuilder (and returns *this).
+  // The <name> must be a valid node name (matches regexp
+  // [a-zA-Z][a-zA-Z0-9_]*). Named control output can only exist for functions.
+  OpDefBuilder& ControlOutput(std::string name);
+
+  OpDef* op_def() { return &op_reg_data_.op_def; }
+
+  OpRegistrationData op_reg_data_;
+  std::vector<string> attrs_;
+  std::vector<string> inputs_;
+  std::vector<string> outputs_;
+  std::vector<string> control_outputs_;
+  std::string doc_;
+  std::vector<string> errors_;
+  bool allow_attr_type_any_ = false;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_OP_DEF_BUILDER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/op_def_util.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/op_def_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..09c6c0cf72e271a39aec3094783b3321b120d3e3
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/op_def_util.h
@@ -0,0 +1,109 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// TODO(josh11b): Probably not needed for OpKernel authors, so doesn't
+// need to be as publicly accessible as other files in framework/.
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_OP_DEF_UTIL_H_
+#define TENSORFLOW_CORE_FRAMEWORK_OP_DEF_UTIL_H_
+
+#include <string>
+
+#include "tensorflow/core/framework/api_def.pb.h"
+#include "tensorflow/core/framework/op_def.pb.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/lib/core/stringpiece.h"
+#include "tensorflow/core/platform/protobuf.h"
+
+namespace tensorflow {
+
+// Performs a consistency check across the fields of the op_def.
+Status ValidateOpDef(const OpDef& op_def);
+
+// Check if an op is deprecated at the given GraphDef version.  If the op is
+// deprecated at a future version, a warning will be logged.
+Status CheckOpDeprecation(const OpDef& op_def, int graph_def_version);
+
+// Validates that attr_value satisfies the type and constraints from attr.
+// REQUIRES: attr has already been validated.
+Status ValidateAttrValue(const AttrValue& attr_value,
+                         const OpDef::AttrDef& attr);
+
+// The following search through op_def for an attr with the indicated name.
+// Returns nullptr if no such attr is found.
+const OpDef::AttrDef* FindAttr(StringPiece name, const OpDef& op_def);
+OpDef::AttrDef* FindAttrMutable(StringPiece name, OpDef* op_def);
+
+// Searches op_def for input argument with the indicated name.
+// Returns nullptr if no such attr is found.
+const OpDef::ArgDef* FindInputArg(StringPiece name, const OpDef& op_def);
+
+// Searches api_def for input argument with the indicated name.
+// Returns nullptr if no such attr is found.
+const ApiDef::Arg* FindInputArg(StringPiece name, const ApiDef& api_def);
+
+// Produce a human-readable version of an op_def that is more concise
+// than a text-format proto.  Excludes descriptions.
+std::string SummarizeOpDef(const OpDef& op_def);
+
+// Returns an error if new_op is not backwards-compatible with (more
+// accepting than) old_op.
+// REQUIRES: old_op and new_op must pass validation.
+Status OpDefCompatible(const OpDef& old_op, const OpDef& new_op);
+
+// Returns an error if any attr in penultimate_op that is not in old_op
+// has a different default value in new_op.  In general it is not safe
+// to change the default for an attr that has been added to an op.
+Status OpDefAddedDefaultsUnchanged(const OpDef& old_op,
+                                   const OpDef& penultimate_op,
+                                   const OpDef& new_op);
+
+// Returns an error if the default value for any attr is removed or modified
+// in new_op compared to old_op.  Adding new default values is safe, and does
+// not raise an error.
+Status OpDefAttrDefaultsUnchanged(const OpDef& old_op, const OpDef& new_op);
+
+// Remove all docs from *op_def / *op_list.
+void RemoveDescriptionsFromOpDef(OpDef* op_def);
+void RemoveDescriptionsFromOpList(OpList* op_list);
+
+// Remove docs from *op_def but leave explanations of deprecations.
+void RemoveNonDeprecationDescriptionsFromOpDef(OpDef* op_def);
+
+// Returns true if `a1` is equal to `a2`.
+// Equality includes all the fields.
+bool AttrDefEqual(const OpDef::AttrDef& a1, const OpDef::AttrDef& a2);
+
+// Returns hash of `a` that is consistent with AttrDefEqual.
+uint64 AttrDefHash(const OpDef::AttrDef& a);
+
+// Returns true if all AttrDefs in `a1` equal corresponding AttrDefs in
+// `a2`. Correspondence is established by name.
+bool RepeatedAttrDefEqual(const protobuf::RepeatedPtrField<OpDef::AttrDef>& a1,
+                          const protobuf::RepeatedPtrField<OpDef::AttrDef>& a2);
+
+// Returns hash of `a` that is consistent with RepeatedAttrDefEqual
+uint64 RepeatedAttrDefHash(const protobuf::RepeatedPtrField<OpDef::AttrDef>& a);
+
+// Returns true if `o1` is equal to `o2`.
+// Equality includes all the fields. OpDef.attr field is treated as a set.
+bool OpDefEqual(const OpDef& o1, const OpDef& o2);
+
+// Returns hash of `o` that is consistent with AttrDefEqual.
+uint64 OpDefHash(const OpDef& o);
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_OP_DEF_UTIL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/op_gen_lib.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/op_gen_lib.h
new file mode 100644
index 0000000000000000000000000000000000000000..c269e2df04973c58cf92207562308451d6ae0cf1
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/op_gen_lib.h
@@ -0,0 +1,100 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_OP_GEN_LIB_H_
+#define TENSORFLOW_CORE_FRAMEWORK_OP_GEN_LIB_H_
+
+#include <string>
+#include <unordered_map>
+#include "tensorflow/core/framework/api_def.pb.h"
+#include "tensorflow/core/framework/op_def.pb.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/lib/core/stringpiece.h"
+#include "tensorflow/core/platform/env.h"
+
+namespace tensorflow {
+
+// Forward declare protos so their symbols can be removed from .so exports
+class OpDef;
+
+inline string Spaces(int n) { return string(n, ' '); }
+
+// Wrap prefix + str to be at most width characters, indenting every line
+// after the first by prefix.size() spaces.  Intended use case is something
+// like prefix = "  Foo(" and str is a list of arguments (terminated by a ")").
+// TODO(josh11b): Option to wrap on ", " instead of " " when possible.
+string WordWrap(StringPiece prefix, StringPiece str, int width);
+
+// Looks for an "=" at the beginning of *description.  If found, strips it off
+// (and any following spaces) from *description and return true.  Otherwise
+// returns false.
+bool ConsumeEquals(StringPiece* description);
+
+// Convert text-serialized protobufs to/from multiline format.
+string PBTxtToMultiline(StringPiece pbtxt,
+                        const std::vector<string>& multi_line_fields);
+string PBTxtFromMultiline(StringPiece multiline_pbtxt);
+
+// Takes a list of files with ApiDefs text protos, and allows you to
+// look up the specific ApiDef for any given op.
+class ApiDefMap {
+ public:
+  // OpList must be a superset of ops of any subsequently loaded
+  // ApiDef.
+  explicit ApiDefMap(const OpList& op_list);
+  ~ApiDefMap();
+
+  // You can call this method multiple times to load multiple
+  // sets of files. Api definitions are merged if the same
+  // op definition is loaded multiple times. Later-loaded
+  // definitions take precedence.
+  // ApiDefs loaded from files must contain a subset of ops defined
+  // in the OpList passed to the constructor.
+  Status LoadFileList(Env* env, const std::vector<string>& filenames);
+
+  // Load a single file. Api definitions are merged if the same
+  // op definition is loaded multiple times. Later-loaded
+  // definitions take precedence.
+  // ApiDefs loaded from file must contain a subset of ops defined
+  // in the OpList passed to the constructor.
+  Status LoadFile(Env* env, const string& filename);
+
+  // Load ApiDefs from string containing ApiDefs text proto.
+  // api_def_file_contents is expected to be in "multiline format".
+  // ApiDefs must contain a subset of ops defined in OpsList
+  // passed to the constructor.
+  Status LoadApiDef(const string& api_def_file_contents);
+
+  // Updates ApiDef docs. For example, if ApiDef renames an argument
+  // or attribute, applies these renames to descriptions as well.
+  // UpdateDocs should only be called once after all ApiDefs are loaded
+  // since it replaces original op names.
+  void UpdateDocs();
+
+  // Look up ApiDef proto based on the given graph op name.
+  // If graph op name is not in this ApiDefMap, returns nullptr.
+  //
+  // Note: Returned ApiDef pointer should stay valid even after calling
+  // Load* functions defined above. Subsequent calls to Load* might modify
+  // returned ApiDef contents, but should never remove the ApiDef itself.
+  const ApiDef* GetApiDef(const string& name) const;
+
+ private:
+  std::unordered_map<string, ApiDef> map_;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_OP_GEN_LIB_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/op_kernel.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/op_kernel.h
new file mode 100644
index 0000000000000000000000000000000000000000..a70034b29b0d4bb229a0a275eb6201af738b0957
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/op_kernel.h
@@ -0,0 +1,1722 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_OP_KERNEL_H_
+#define TENSORFLOW_CORE_FRAMEWORK_OP_KERNEL_H_
+
+#include <functional>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+#include "absl/time/time.h"
+#include "absl/types/optional.h"
+#include "absl/types/span.h"
+#include "tensorflow/core/framework/allocator.h"
+#include "tensorflow/core/framework/cancellation.h"
+#include "tensorflow/core/framework/control_flow.h"
+#include "tensorflow/core/framework/device_base.h"
+#include "tensorflow/core/framework/graph.pb.h"
+#include "tensorflow/core/framework/kernel_def.pb.h"
+#include "tensorflow/core/framework/kernel_def_builder.h"
+#include "tensorflow/core/framework/node_def.pb.h"
+#include "tensorflow/core/framework/node_def_util.h"
+#include "tensorflow/core/framework/node_properties.h"
+#include "tensorflow/core/framework/op.h"  // TODO(b/62899350): Remove
+#include "tensorflow/core/framework/op_requires.h"
+#include "tensorflow/core/framework/registration/registration.h"
+#include "tensorflow/core/framework/rendezvous.h"
+#include "tensorflow/core/framework/session_state.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/tensor_shape.h"
+#include "tensorflow/core/framework/tensor_shape.pb.h"  // TODO(b/62899350): Remove
+#include "tensorflow/core/framework/tracking_allocator.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/framework/types.pb.h"
+#include "tensorflow/core/lib/core/errors.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/lib/gtl/array_slice.h"
+#include "tensorflow/core/lib/gtl/manual_constructor.h"
+#include "tensorflow/core/platform/env.h"
+#include "tensorflow/core/platform/logging.h"
+#include "tensorflow/core/platform/macros.h"
+#include "tensorflow/core/platform/mutex.h"
+#include "tensorflow/core/platform/profile_utils/cpu_utils.h"
+#include "tensorflow/core/platform/thread_annotations.h"
+#include "tensorflow/core/platform/types.h"
+#include "tensorflow/core/protobuf/config.pb.h"
+#include "tensorflow/core/util/managed_stack_trace.h"
+
+// Used to match ops to kernel sources (and eventually to kernel targets)
+#ifdef TF_LOG_KERNEL_SOURCES
+#define LOG_KERNEL_SOURCES(name) \
+  LOG(INFO) << "Kernel found: " << name << " " << __FILE__ << "\n";
+#else
+#define LOG_KERNEL_SOURCES(name)
+#endif
+
+namespace Eigen {
+struct ThreadPoolDevice;
+struct GpuDevice;
+}  // end namespace Eigen
+
+namespace tsl {
+class CoordinationServiceAgent;
+}
+
+namespace tensorflow {
+
+namespace checkpoint {
+class TensorSliceReaderCacheWrapper;
+}  // namespace checkpoint
+
+class AsyncOpKernel;
+class CallFrameInterface;
+class DeviceMgr;
+class FunctionLibraryRuntime;
+class OpKernelConstruction;  // declared below
+class OpKernelContext;       // declared below,
+class OpRegistryInterface;
+class ResourceMgr;
+class ScopedStepContainer;
+class CollectiveExecutor;
+class StepStatsCollectorInterface;
+
+// A label that is added to kernels that are JIT compiled. These labels will be
+// removed before kernels are looked up, so they can be used without specifying
+// the label. This label is a temporary measure to allow JIT kernels to be
+// disabled if needed.
+extern const char* kJitKernelLabel;
+extern const char* kDisableJitKernelsEnvVar;
+
+class OpKernel {
+ public:
+  // OpKernel won't be instantiated by the scheduler, so you may perform
+  // expensive initialization in the descendant's constructor.
+  explicit OpKernel(OpKernelConstruction* context);
+
+  // Specialized constructor that allows a kernel implementation to mark itself
+  // as a "deferred" op. If true, the executor will provide access to the
+  // `OpKernelContext::inc_num_deferred_ops_function()` and
+  // `OpKernelContext::dec_num_deferred_ops_function()` methods at run-time.
+  OpKernel(OpKernelConstruction* context, bool is_deferred);
+
+  // Specialized constructor that enables the descendant to provide a custom
+  // `NodeDef` value. For example, this constructor can be used to provide a
+  // stripped-down `NodeDef` that does not contain the full set of attrs (such
+  // as tensor values) if the descendant stores them in a different form.
+  OpKernel(OpKernelConstruction* context, NodeDef&& custom_def,
+           bool is_deferred);
+
+  virtual ~OpKernel();
+
+  // An OpKernel's computation can be either synchronous or
+  // asynchronous. All OpKernel Compute() methods must be thread-safe as they
+  // may be called concurrently (e.g. by multiple executions of the same graph
+  // concurrently).
+  //
+  // Most OpKernels should compute synchronously. They should
+  // subclass OpKernel and override the Compute() method and have it
+  // return after completing the supplied work.
+  //
+  // A synchronous OpKernel *MUST NOT* block the calling thread on a
+  // synchronization mechanism (condition variable, Notification, etc.) that
+  // will be unblocked by the execution of another OpKernel. Execution may
+  // deadlock in that case, because the executor may use a bounded number of
+  // threads.
+  //
+  // If an OpKernel must block on the execution of another OpKernel (e.g. a
+  // RecvOp, or a DequeueOp), the implementation *MUST* subclass AsyncOpKernel,
+  // and override `AsyncOpKernel::ComputeAsync()`. In addition, because the
+  // unblocking kernel may never run (due to an error or cancellation), in most
+  // cases the AsyncOpKernel should implement cancellation support via
+  // `ctx->cancellation_manager()`.
+  //
+  // In both cases, implementations of Compute() and ComputeAsync()
+  // get inputs and write outputs through the given OpKernelContext
+  // and returns a status via context->SetStatus(). They must be
+  // thread-safe.
+
+  // Synchronous compute.
+  //
+  // "context" is guaranteed to be alive until Compute() returns.
+  virtual void Compute(OpKernelContext* context) = 0;
+
+  // Returns nullptr iff this op kernel is synchronous.
+  virtual AsyncOpKernel* AsAsync() { return nullptr; }
+
+  // Returns true iff this op kernel is considered "expensive". The
+  // runtime may use this flag to optimize graph execution for example
+  // to "inline" inexpensive kernels.
+  virtual bool IsExpensive() { return expensive_; }
+
+  // Returns a pointer to the tensor stored inside constant ops.
+  virtual const Tensor* const_tensor() const { return nullptr; }
+
+  // Accessors.
+  const NodeDef& def() const { return props_->node_def; }
+  const std::string& name() const { return props_->node_def.name(); }
+  absl::string_view name_view() const { return name_view_; }
+  const std::string& type_string() const { return props_->node_def.op(); }
+  absl::string_view type_string_view() const { return type_string_view_; }
+  const std::string& requested_input(int i) const {
+    return props_->node_def.input(i);
+  }
+  const std::string& requested_device() const {
+    return props_->node_def.device();
+  }
+
+  int num_inputs() const { return props_->input_types.size(); }
+  DataType input_type(int i) const { return props_->input_types[i]; }
+  const DataTypeVector& input_types() const { return props_->input_types; }
+  const MemoryTypeVector& input_memory_types() const {
+    return input_memory_types_;
+  }
+
+  int num_outputs() const { return props_->output_types.size(); }
+  DataType output_type(int o) const { return props_->output_types[o]; }
+  const DataTypeVector& output_types() const { return props_->output_types; }
+  const MemoryTypeVector& output_memory_types() const {
+    return output_memory_types_;
+  }
+
+  Status InputRange(StringPiece input_name, int* start, int* stop) const;
+  Status OutputRange(StringPiece output_name, int* start, int* stop) const;
+
+  // Returns `true` if and only if this kernel uses deferred execution.
+  bool is_deferred() const { return is_deferred_; }
+
+  // Returns a trace string for current computation, op name/type and input
+  // tensor shape/dtype are encoded for profiler cost analysis. Most OpKernel
+  // should use the default implementation.
+  virtual std::string TraceString(const OpKernelContext& ctx,
+                                  bool verbose) const;
+
+ protected:
+  std::string ShapeTraceString(const OpKernelContext& ctx) const;
+
+ private:
+  const std::shared_ptr<const NodeProperties> props_;
+  const MemoryTypeVector input_memory_types_;
+  const MemoryTypeVector output_memory_types_;
+  NameRangeMap input_name_map_;
+  NameRangeMap output_name_map_;
+  const absl::string_view name_view_;
+  const absl::string_view type_string_view_;
+  const int graph_def_version_;
+  const bool is_deferred_;
+  bool expensive_;
+
+  OpKernel(const OpKernel&) = delete;
+  void operator=(const OpKernel&) = delete;
+};
+
+class AsyncOpKernel : public OpKernel {
+ public:
+  using OpKernel::OpKernel;  // Lift OpKernel constructors.
+
+  // Asynchronous compute.
+  //
+  // Implementations of ComputeAsync() must ensure that `done` is (eventually)
+  // called exactly once to signal the completion of the computation. The
+  // implementation of ComputeAsync() must not block on the execution of another
+  // OpKernel. `done` may be called by the current thread, or by another thread.
+  // `context` is guaranteed to stay alive until the `done` callback starts.
+  //
+  // Since it is possible that the unblocking kernel may never run (due to an
+  // error or cancellation), in most cases the AsyncOpKernel should implement
+  // cancellation support via `context->cancellation_manager()`.
+  //
+  // WARNING: As soon as the `done` callback starts, `context` and `this` may be
+  // deleted. No code depending on these objects should execute after the call
+  // to `done`.
+  typedef std::function<void()> DoneCallback;
+  virtual void ComputeAsync(OpKernelContext* context, DoneCallback done) = 0;
+
+  AsyncOpKernel* AsAsync() override { return this; }
+
+  void Compute(OpKernelContext* context) override;
+};
+
+class OpKernelConstruction {
+ public:
+  OpKernelConstruction(DeviceType device_type, DeviceBase* device,
+                       Allocator* allocator, FunctionLibraryRuntime* flib,
+                       ResourceMgr* resource_mgr,
+                       const std::shared_ptr<const NodeProperties>& props,
+                       const MemoryTypeSlice& input_memory_types,
+                       const MemoryTypeSlice& output_memory_types,
+                       int graph_def_version, Status* status);
+
+  Env* env() const { return device_->env(); }
+
+  // Allocation of tensors during kernel construction:
+  //
+  // It is legal to temporarily allocate scratch tensor storage during
+  // Op kernel construction. Scratch tensors should be allocated using
+  // allocate_temp below. Some kernels need to keep tensors in between
+  // invocations. If such a Tensor is allocated during kernel
+  // construction this also must be done using allocate_temp, and the
+  // Op may only store the returned Tensor object.
+
+  // Allocates a temporary Tensor of the specified type and shape. The
+  // Tensor must not be used after kernel construction is
+  // complete. See comment above.
+  Status allocate_temp(DataType type, const TensorShape& shape,
+                       Tensor* out_temp);
+  Status allocate_temp(DataType type, const TensorShape& shape,
+                       Tensor* out_temp, AllocatorAttributes allocator_attr);
+
+  // User-supplied configuration of this operation.
+  const NodeDef& def() const { return props_->node_def; }
+
+  // For inspecting the inputs to this operation.
+  int num_inputs() const { return props_->input_types.size(); }
+  DataType input_type(int i) const { return props_->input_types[i]; }
+  const DataTypeSlice& input_types() const { return props_->input_types_slice; }
+  const MemoryTypeSlice& input_memory_types() const {
+    return input_memory_types_;
+  }
+
+  // For inspecting the outputs expected from this operation.
+  int num_outputs() const { return props_->output_types.size(); }
+  DataType output_type(int i) const { return props_->output_types[i]; }
+  const DataTypeSlice& output_types() const {
+    return props_->output_types_slice;
+  }
+  const MemoryTypeSlice& output_memory_types() const {
+    return output_memory_types_;
+  }
+
+  // If expected_inputs == inputs() and expected_outputs == output_types(),
+  // returns OK, else returns INVALID_ARGUMENT with an error message.
+  // Recommended for Ops with dynamic signatures.
+  Status MatchSignature(const DataTypeSlice expected_inputs,
+                        const DataTypeSlice expected_outputs);
+
+  // For recording configuration errors during construction.
+  void SetStatus(const Status& status);
+  const Status& status() const { return *status_; }
+
+  // Look up the attr with name attr_name and set *value to its value.  If no
+  // attr with attr_name is found in def(), or the attr does not have
+  // a matching type, a non-ok status will be returned.
+  template <class T>
+  Status GetAttr(StringPiece attr_name, T* value) const TF_ATTRIBUTE_NOINLINE;
+
+  // Return true if the attr_name is defined in def().
+  bool HasAttr(StringPiece attr_name) const;
+
+  // Return the device type.
+  const DeviceType& device_type() const { return device_type_; }
+
+  // If not nullptr, the kernel can instantiate functions defined in
+  // the library. E.g.,
+  // CHECK_NOTNULL(function_library())->Instantiate("Foo", ...).
+  FunctionLibraryRuntime* function_library() const { return flib_; }
+
+  // Shared resources accessible to this kernel.
+  ResourceMgr* resource_manager() const { return resource_mgr_; }
+
+  // The GraphDef version whose behavior we should follow.
+  int graph_def_version() const { return graph_def_version_; }
+
+  // Helper routines for the OP_REQUIRES macros
+  void CtxFailure(const Status& s);
+  void CtxFailureWithWarning(const Status& s);
+  void CtxFailure(const char* file, int line, const Status& s);
+  void CtxFailureWithWarning(const char* file, int line, const Status& s);
+
+  // Unrecommended functions: these are functions that have some
+  // current uses but are not recommended for use, and may go away at
+  // some future major version release.
+
+  // May be used, e.g., to get GPU handles, etc.
+  //
+  // Currently only used to call MakeTensorFromProto() for
+  // implementing ConstantOp for every device.  See comments
+  // on Device::MakeTensorFromProto for longer-term replacement
+  // ideas.
+  DeviceBase* device() const { return device_; }
+
+ private:
+  const DeviceType device_type_;
+  DeviceBase* const device_;
+  Allocator* allocator_;
+  FunctionLibraryRuntime* flib_;
+  ResourceMgr* const resource_mgr_;
+  std::shared_ptr<const NodeProperties> props_;
+  MemoryTypeSlice input_memory_types_;
+  MemoryTypeSlice output_memory_types_;
+  const int graph_def_version_;
+  Status* status_;
+
+  // Allow access from OpKernel ctor.
+  friend class OpKernel;
+
+  OpKernelConstruction(const OpKernelConstruction&) = delete;
+  void operator=(const OpKernelConstruction&) = delete;
+};
+
+// TODO(mrry): Consider converting to a random_access_iterator, and upgrading
+// tensorflow::gtl::iterator_range to make the below container classes
+// unnecessary.
+template <typename ListType, typename ElementType>
+class OpArgIterator {
+ public:
+  using iterator_category = std::forward_iterator_tag;
+  using value_type = ElementType;
+  using pointer = ElementType*;
+  using const_pointer = const ElementType*;
+  using reference = ElementType&;
+  using const_reference = const ElementType&;
+  using difference_type = ptrdiff_t;
+
+  OpArgIterator(const ListType* list, int i) : list_(list), i_(i) {}
+
+  bool operator==(const OpArgIterator& rhs) {
+    DCHECK(list_ == rhs.list_);
+    return i_ == rhs.i_;
+  }
+
+  bool operator!=(const OpArgIterator& rhs) {
+    DCHECK(list_ == rhs.list_);
+    return i_ != rhs.i_;
+  }
+
+  OpArgIterator operator++() {  // prefix ++it
+    ++i_;
+    return *this;
+  }
+
+  OpArgIterator operator++(int) {  // postfix it++
+    OpArgIterator old_value = *this;
+    ++i_;
+    return old_value;
+  }
+
+  reference operator*() { return (*list_)[i_]; }
+  pointer operator->() { return &(*list_)[i_]; }
+
+  const_reference operator*() const { return (*list_)[i_]; }
+  const_pointer operator->() const { return &(*list_)[i_]; }
+
+ private:
+  const ListType* const list_;
+  int i_;
+};
+
+// Utility class for representing a list of immutable input tensors
+// that are passed to the op as a single named argument.
+class OpInputList {
+ public:
+  typedef OpArgIterator<OpInputList, const Tensor> Iterator;
+  OpInputList() : ctx_(nullptr), start_(0), stop_(0) {}
+  OpInputList(OpKernelContext* ctx, int start, int stop)
+      : ctx_(ctx), start_(start), stop_(stop) {}
+  OpInputList& operator=(const OpInputList& other) = default;
+  const Tensor& operator[](int i) const;
+  int size() const { return stop_ - start_; }
+  Iterator begin() const { return Iterator(this, 0); }
+  Iterator end() const { return Iterator(this, size()); }
+
+ private:
+  OpKernelContext* ctx_;  // not owned
+  int start_;
+  int stop_;
+};
+
+// Utility class for representing a list of mutable ("ref") input tensors
+// that are passed to the op as a single named argument.
+class OpMutableInputList {
+ public:
+  typedef OpArgIterator<OpMutableInputList, Tensor*> Iterator;
+  OpMutableInputList(OpKernelContext* ctx, int start, int stop)
+      : ctx_(ctx), start_(start), stop_(stop) {}
+  OpMutableInputList() : ctx_(nullptr), start_(0), stop_(0) {}
+  OpMutableInputList& operator=(const OpMutableInputList& other) = default;
+  Tensor at(int i, bool lock_held);
+  mutex* ref_mutex(int i);
+  int size() const { return stop_ - start_; }
+  Iterator begin() const { return Iterator(this, 0); }
+  Iterator end() const { return Iterator(this, size()); }
+
+ private:
+  OpKernelContext* ctx_;  // not owned
+  int start_;
+  int stop_;
+};
+
+// Utility class for representing a list of output tensors that are
+// grouped as a single named output.
+class OpOutputList {
+ public:
+  typedef OpArgIterator<OpOutputList, const Tensor*> Iterator;
+  OpOutputList() : ctx_(nullptr), start_(0), stop_(0) {}
+  OpOutputList(OpKernelContext* ctx, int start, int stop)
+      : ctx_(ctx), start_(start), stop_(stop) {}
+  OpOutputList& operator=(const OpOutputList& other) = default;
+  Tensor* operator[](int i);
+  bool required(int i) const;
+  DataType expected_output_dtype(int i) const;
+  Status allocate(int i, const TensorShape& shape, Tensor** output);
+  void set(int i, const Tensor& tensor);
+  void set(int i, Tensor&& tensor);
+  void set_ref(int i, mutex* mu, Tensor* tensor_for_ref);
+  int size() const { return stop_ - start_; }
+  Iterator begin() const { return Iterator(this, 0); }
+  Iterator end() const { return Iterator(this, size()); }
+
+ private:
+  OpKernelContext* ctx_;  // not owned
+  int start_;
+  int stop_;
+};
+
+// Holds a tensor or tensor reference. For tensor references, we need
+// a mutex to prevent concurrent access to the tensor.
+struct TensorValue {
+  TensorValue() : mutex_if_ref(nullptr), tensor(nullptr) {}
+  explicit TensorValue(Tensor* t) : mutex_if_ref(nullptr), tensor(t) {}
+  TensorValue(mutex* mu, Tensor* t) : mutex_if_ref(mu), tensor(t) {}
+  Tensor* operator->() const { return tensor; }
+  bool is_ref() const { return mutex_if_ref != nullptr; }
+
+  // Return the dtype of the Tensor. For references, return the underlying type.
+  DataType dtype() const {
+    if (is_ref()) {
+      return MakeRefType(tensor->dtype());
+    } else {
+      return tensor->dtype();
+    }
+  }
+
+  // Return the dtype of the Tensor. For references, return the underlying type.
+  // This variation on the dtype() acquires the lock for references.
+  //
+  // TODO(b/133843385): Disallow dtype modifications
+  DataType dtype_safe() const {
+    if (is_ref()) {
+      tf_shared_lock ml(*mutex_if_ref);
+      return MakeRefType(tensor->dtype());
+    } else {
+      return tensor->dtype();
+    }
+  }
+
+  mutex* mutex_if_ref;  // nullptr if not a ref, != nullptr if a ref
+  Tensor* tensor;
+};
+
+// Used to store partitioned graphs from function-calling ops.
+struct GraphCollector {
+  mutex mu;
+  std::vector<GraphDef> partitioned_graphs TF_GUARDED_BY(mu);
+  GraphDef raw_graph TF_GUARDED_BY(mu);
+  GraphDef optimized_graph TF_GUARDED_BY(mu);
+
+  bool dirty TF_GUARDED_BY(mu);
+
+  GraphCollector() : dirty(false) {}
+
+  void CollectRawGraph(const GraphDef& graph) {
+    mutex_lock ml(mu);
+    raw_graph.MergeFrom(graph);
+    dirty = true;
+  }
+
+  void CollectOptimizedGraph(const GraphDef& graph) {
+    mutex_lock ml(mu);
+    optimized_graph.MergeFrom(graph);
+    dirty = true;
+  }
+
+  void CollectPartitionedGraph(const GraphDef& graph) {
+    mutex_lock ml(mu);
+    partitioned_graphs.push_back(graph);
+    dirty = true;
+  }
+
+  void ClearGraphs() TF_EXCLUSIVE_LOCKS_REQUIRED(mu) {
+    raw_graph.Clear();
+    optimized_graph.Clear();
+    partitioned_graphs.clear();
+    dirty = false;
+  }
+
+  bool HasUpdatedGraphs() {
+    mutex_lock ml(mu);
+    return dirty;
+  }
+};
+
+class OpKernelContext {
+ public:
+  // The first element of a WrappedAllocator is a "base" Allocator and
+  // the second element is that Allocator wrapped by a
+  // TrackingAllocator
+  typedef std::pair<Allocator*, TrackingAllocator*> WrappedAllocator;
+
+  // TODO(zhifengc): Do some cleanup of Params.
+  // The Params struct is passed in to initialize an OpKernelContext,
+  // and must outlive the OpKernelContext.
+  struct Params {
+    ~Params() { delete eigen_gpu_device; }
+
+    // The step being executed.
+    int64_t step_id = 0;
+
+    // Timestamp for the start of graph execution. Used for latency metrics.
+    int64_t start_time_usecs = 0;
+
+    // The deadline for the session to complete by. Empty if unspecified.
+    absl::optional<absl::Time> deadline;
+
+    // The op kernel being computed.
+    OpKernel* op_kernel = nullptr;
+
+    // The device on which the kernel is running.
+    DeviceBase* device = nullptr;
+
+    // The Eigen GPU device wrapper, which may include a per-op
+    // wrapped allocator. The concrete type of this object depends on
+    // the type of this->device, so eigen_gpu_device can't be an
+    // inline member and must be heap allocated. However, we don't
+    // want to allocate a new eigen_gpu_device for every Op that is
+    // executed. Instead this member is allocated on first use using
+    // ensure_eigen_gpu_device, and then if the Params structure is
+    // re-used for subsequent Ops, the eigen_gpu_device is
+    // ReInitialized in the OpKernelContext constructor. Unlike the
+    // other pointers in Params, this one is owned by Params.
+    PerOpGpuDevice* eigen_gpu_device = nullptr;
+
+    inline void ensure_eigen_gpu_device() {
+      DCHECK(device);
+      if (nullptr == eigen_gpu_device) {
+        // Surprisingly, MakeGpuDevice will return nullptr if the
+        // device is not a GPU device. This is ok, since those devices
+        // will never use eigen_gpu_device. It seems better to have
+        // ensure_eigen_gpu_device fall through and regenerate the
+        // nullptr every time an OpKernelContext is instantiated, than
+        // to do an unnecessary allocation of a dummy eigen GPU
+        // device for CPU device Ops.
+        eigen_gpu_device = device->MakeGpuDevice();
+      }
+    }
+
+    bool track_allocations = false;
+    bool log_memory = false;
+
+    // Array indexed by output number for this node
+    const AllocatorAttributes* output_attr_array = nullptr;
+
+    // Shared resources accessible by this op kernel invocation.
+    ResourceMgr* resource_manager = nullptr;
+
+    // Per-step resources accessible by this op kernel invocation should be
+    // stored in this container..
+    ScopedStepContainer* step_container = nullptr;
+
+    // Mechanism used by this op kernel invocation to communicate with
+    // computations running on other devices.
+    RendezvousInterface* rendezvous = nullptr;
+
+    // Mechanism for executing a collective op that needs to coordinate
+    // with parallel instances running on other devices.
+    CollectiveExecutor* collective_executor = nullptr;
+
+    // The session state for this op.
+    SessionState* session_state = nullptr;
+
+    // Unique session identifier. Can be empty.
+    std::string session_handle;
+
+    // Metadata about the session. Can be nullptr.
+    const SessionMetadata* session_metadata = nullptr;
+
+    // The tensor store for this op.
+    TensorStore* tensor_store = nullptr;
+
+    // Mechanism used by this op kernel invocation to register a callback
+    // for its cancellation.
+    CancellationManager* cancellation_manager = nullptr;
+
+    // Inputs to this op kernel.
+    absl::Span<const TensorValue> inputs;
+    bool is_input_dead = false;
+
+    absl::Span<const AllocatorAttributes> input_alloc_attrs;
+
+    // Device context.
+    DeviceContext* op_device_context = nullptr;
+
+    // Control-flow op supports.
+    FrameAndIter frame_iter;
+
+    // Function call supports.
+    CallFrameInterface* call_frame = nullptr;
+    FunctionLibraryRuntime* function_library = nullptr;
+    std::function<void(std::function<void()>)>* runner = nullptr;
+    StepStatsCollectorInterface* stats_collector = nullptr;
+    GraphCollector* graph_collector = nullptr;
+    bool run_all_kernels_inline = false;
+    const std::string* executor_type = nullptr;
+
+    // TensorSliceReaderCache support.
+    checkpoint::TensorSliceReaderCacheWrapper* slice_reader_cache = nullptr;
+
+    // Support for forwarding reservations (used by ScopedAllocator).
+    static constexpr int kNeverForward = -2;
+    static constexpr int kNoReservation = -1;
+    // Values in [0,...) represent reservations for the indexed output.
+    const int* forward_from_array = nullptr;
+
+    // For tracking actively running deferred ops.
+    std::function<void()> inc_num_deferred_ops_function;
+    std::function<void()> dec_num_deferred_ops_function;
+
+    absl::optional<ManagedStackTrace> stack_trace = {};
+
+    // For implementing `OpKernelContext::output_required()`. If null, all
+    // outputs are required.
+    bool* outputs_required_array = nullptr;
+
+    // For access to distributed coordination service.
+    tsl::CoordinationServiceAgent* coordination_service_agent = nullptr;
+  };
+
+  // params must outlive the OpKernelContext.
+  explicit OpKernelContext(Params* params);
+  OpKernelContext(Params* params, int num_outputs);
+  ~OpKernelContext();
+
+  Env* env() const { return params_->device->env(); }
+
+  int64_t step_id() const { return params_->step_id; }
+
+  int64_t start_time_usecs() const { return params_->start_time_usecs; }
+
+  // The deadline for the session to complete by. Empty if unspecified in
+  // RunOptions.
+  absl::optional<absl::Time> deadline() const { return params_->deadline; }
+
+  const OpKernel& op_kernel() const { return *params_->op_kernel; }
+
+  // Stack trace of where the op was defined (if defined in eager mode).
+  const absl::optional<ManagedStackTrace>& stack_trace() const {
+    return params_->stack_trace;
+  }
+
+  // Input/output signature.
+
+  int num_inputs() const { return params_->inputs.size(); }
+  DataType input_dtype(int index) const;
+  Status input_dtype(StringPiece name, DataType* dtype) const;
+  MemoryType input_memory_type(int index) const;
+
+  int num_outputs() const { return outputs_.size(); }
+  DataType expected_output_dtype(int index) const;
+  MemoryType output_memory_type(int index) const;
+
+  // Input
+
+  // Returns an immutable input tensor by index. May only be used for non-Ref
+  // inputs. For Ref inputs use mutable_input below.
+  // REQUIRES: !IsRefType(input_dtype(index))
+  // TODO(mrry): Convert this to return Status.
+  const Tensor& input(int index) const;
+
+  // Returns an immutable input tensor in "tensor" by index. May only be used
+  // for non-Ref inputs. For Ref inputs use mutable_input below.
+  // REQUIRES: !IsRefType(input_dtype(index))
+  StatusOr<const Tensor*> get_input(int index) const;
+
+  // Returns the named immutable input tensor in "tensor", as defined
+  // in the OpDef. May only be used for non-Ref inputs. For Ref inputs
+  // use mutable_input below.
+  // REQUIRES: !IsRefType(input_dtype(index))
+  // REQUIRES: the named input must not be a list.
+  Status input(StringPiece name, const Tensor** tensor);
+
+  // Returns the named list-valued immutable input in "list", as
+  // defined in the OpDef.  If the named output is not list-valued,
+  // returns a one-element list. May only be used for non-Ref
+  // inputs. For Ref inputs use mutable_input below.
+  // REQUIRES: !IsRefType(input_dtype(index))
+  Status input_list(StringPiece name, OpInputList* list);
+
+  // For mutable inputs, use the following together to make sure there
+  // is no concurrent access to mutable_input(), e.g.:
+  // {
+  //   Tensor& t = context->mutable_input(index);
+  //   mutex_lock lock(*context->input_ref_mutex(index));
+  //   // modify the values in t
+  // }
+  // REQUIRES: IsRefType(input_dtype(index))
+  Status input_ref_mutex(StringPiece name, mutex** out_mutex);
+
+  // Returns a mutable input tensor. Must be used to access Ref
+  // inputs.  REQUIRES: IsRefType(input_dtype(index)). The caller may
+  // modify the values stored in the Tensor buffer, and modifications
+  // will be visible to other Ops reading the same ref tensor. If
+  // !lock_held the input mutex will be acquired before returning the
+  // Tensor.
+  // TODO(mrry): Convert this to return Status.
+  Tensor mutable_input(int index, bool lock_held);
+
+  // Returns the named mutable input tensor in "tensor", as defined in
+  // the OpDef. Must be used to access Ref inputs. The values stored
+  // in the Tensor buffer may be modified, and modifications will be
+  // visible to other Ops reading the same ref tensor. If !lock_held
+  // the input mutex will be acquired before returning the Tensor.
+  // REQUIRES: the named input must not be a list.
+  // REQUIRES: the named input must be a ref tensor.
+  Status mutable_input(StringPiece name, Tensor* tensor, bool lock_held);
+
+  // Returns the named list-valued mutable input in "list", as defined
+  // in the OpDef.  If the named input is not list-valued, returns a
+  // one-element list. Must be used to access Ref inputs. The values
+  // stored in the Tensor buffer may be modified, and modifications
+  // will be visible to other Ops reading the same ref tensor.
+  // REQUIRES: the named input must be a ref tensor.
+  Status mutable_input_list(StringPiece name, OpMutableInputList* list);
+
+  // Replace the corresponding Ref Input to use the storage buffer
+  // used by tensor. If !lock_held the input mutex will be acquired
+  // before returning the Tensor.
+  // REQUIRES: IsRefType(input_dtype(index)).
+  void replace_ref_input(int index, const Tensor& tensor, bool lock_held);
+
+  // Replace the corresponding named Ref Input to use the storage
+  // buffer used by tensor. If !lock_held the input mutex will be
+  // acquired before returning the Tensor.
+  // REQUIRES: IsRefType(input_dtype(index)).
+  Status replace_ref_input(StringPiece name, const Tensor& tensor,
+                           bool lock_held);
+
+  // Deletes the Tensor object used as the Ref Input at
+  // input_index. This is not usually necessary and should be used
+  // with caution. If !lock_held the input mutex will be acquired
+  // before returning the Tensor.
+  // REQUIRES: IsRefType(input_dtype(input_index)).
+  void delete_ref_input(int input_index, bool lock_held);
+
+  // Return true if there is input at the given index. An operator has no
+  // input at index if its tensor is null. This is primarily used by the
+  // merge operator.
+  // TODO(mrry): Convert this to return Status.
+  bool has_input(int index) const;
+
+  // Returns true if all inputs are the same shape, otherwise sets the
+  // status to a non-OK value and returns false.
+  // Usage: if (!context->ValidateInputsAreSameShape(this)) return;
+  bool ValidateInputsAreSameShape(OpKernel* op);
+
+  // If non-null, kernels should populate with any partition subgraphs created.
+  GraphCollector* graph_collector() { return params_->graph_collector; }
+
+  // If True, hint that all kernels in functions called by this kernel, should
+  // be treated as "inexpensive", and hence executed on the scheduling thread.
+  bool run_all_kernels_inline() const {
+    return params_->run_all_kernels_inline;
+  }
+
+  // Returns the registered name for the executor type that is executing the
+  // current kernel. If empty, the default executor is used.
+  const std::string& executor_type() const;
+
+  // Input to output forwarding.
+
+  // Set the output Ref Tensor at output_index to be an alias of the
+  // input Ref Tensor at input_index.
+  // REQUIRES: IsRefType(input_dtype(input_index)).
+  // REQUIRES: IsRefType(output_dtype(output_index)).
+  void forward_ref_input_to_ref_output(int input_index, int output_index);
+
+  // Returns true when an alias to input[input_index], reshaped to output_shape,
+  // which is safe to use for in-place computation was written to *output.
+  // Returns false if input[input_index] has a refcount greater than one, or if
+  // its type does not match the expected output type of output[output_index],
+  // or the number of elements in input[input_index] does not equal the number
+  // of elements in output_shape.
+  bool forward_input_to_output_with_shape(int input_index, int output_index,
+                                          const TensorShape& output_shape,
+                                          Tensor** output) TF_MUST_USE_RESULT;
+  Status forward_input_to_output_with_shape(StringPiece input_name,
+                                            StringPiece output_name,
+                                            const TensorShape& output_shape,
+                                            Tensor** output) TF_MUST_USE_RESULT;
+
+  // Returns a pointer to a Tensor aliasing the underlying buffer backing
+  // input[input_index] iff
+  //   * input[input_index] is not a ref,
+  //   * the data type, shape, memory type, and allocator attributes of
+  //     input[input_index] are compatible with those given in dtype, shape,
+  //     memory_type, and attr,
+  //   * refcount on the underlying buffer is one.
+  //   * Either there is no forwarding reservation for either input_index
+  //     or output_index or the specified input is reserved for the specified
+  //     output. More precisely:
+  //
+  //     These cases mean neither input nor output has a reservation:
+  //        forward_from_array = nullptr
+  //     OR (input_index is not in forward_from_array AND
+  //         (output_index == kNoReservation OR
+  //          forward_from_array[output_index] == kNoReservation))
+  //
+  //     This case means that input_index is reserved for output_index:
+  //        forward_from_array[output_index] == input_index
+  //
+  //     This case means the output is reserved to always be allocated,
+  //     never assigned a forwarded input:
+  //        forward_from_array[output_index] == kNeverForward
+  //
+  // Otherwise returns nullptr.
+  // NOTE: For Cuda kernels that read inputs using the __ldg() intrinsic,
+  // forwarding is only safe if there are no reads via __ldg() after writes
+  // to the same address.
+  std::unique_ptr<Tensor> forward_input(
+      int input_index, int output_index, DataType output_dtype,
+      const TensorShape& output_shape, MemoryType output_memory_type,
+      const AllocatorAttributes& output_attr) TF_MUST_USE_RESULT;
+
+  // Tries to forward one of the inputs given in input_indices to
+  // output[output_index]. If none of the given inputs can be forwarded, calls
+  // allocate_output() to allocate a new output buffer. The index of the
+  // forwarded input will be assign to output argument forwarded_input (if it's
+  // not nullptr). If no inputs are forwarded, forwarded_input will be assigned
+  // -1.
+  Status forward_input_or_allocate_output(
+      gtl::ArraySlice<int> candidate_input_indices, int output_index,
+      const TensorShape& output_shape, Tensor** output,
+      int* forwarded_input = nullptr) TF_MUST_USE_RESULT;
+  Status forward_input_or_allocate_output(
+      gtl::ArraySlice<StringPiece> candidate_input_names,
+      StringPiece output_name, const TensorShape& output_shape,
+      Tensor** output) TF_MUST_USE_RESULT;
+
+  // Tries to reuse one of the inputs given in input_indices as a temporary.
+  // If none of the given inputs can be forwarded, calls
+  // allocate_temp() to allocate a new temporary buffer.
+  Status forward_input_or_allocate_temp(
+      gtl::ArraySlice<int> candidate_input_indices, DataType type,
+      const TensorShape& shape, const AllocatorAttributes& allocator_attr,
+      Tensor* out_temp) TF_MUST_USE_RESULT;
+
+  Status forward_input_or_allocate_temp(
+      gtl::ArraySlice<int> candidate_input_indices, DataType type,
+      const TensorShape& shape, Tensor* out_temp) TF_MUST_USE_RESULT {
+    return forward_input_or_allocate_temp(candidate_input_indices, type, shape,
+                                          AllocatorAttributes(), out_temp);
+  }
+
+  // Output
+
+  // Returns the named list-valued output in "list", as defined in the OpDef.
+  // If the named output is not list-valued, returns a one-element list.
+  Status output_list(StringPiece name, OpOutputList* list);
+
+  // If output_required(index) returns true, the OpKernel's Compute() method
+  // should call allocate_output(index, ...), set_output(index, ...),
+  // set_output_ref(index, ...), or set the status to a non-ok value.
+  // If it returns false, it may output, but is not required to do so.
+  bool output_required(int index) const {
+    return !params_->outputs_required_array ||
+           params_->outputs_required_array[index];
+  }
+
+  // If output_expects_forwarding returns true, the OpKernel's Compute() method
+  // should not allocate the output with allocate_output but instead needs to
+  // use forward_input.
+  bool output_expects_forwarding(int index) const {
+    return params_->forward_from_array != nullptr &&
+           params_->forward_from_array[index] >= 0;
+  }
+
+  // Allocation of tensors during kernel execution inside the Compute
+  // method:
+  //
+  // There are two methods to allocate Tensors when an Op kernel
+  // executes.
+  //
+  // 1) allocate_output. This should be used to allocate any tensor
+  // that is going to be used as an output from the Op at the end of
+  // the current execution. The caller indicates which output the
+  // Tensor will be assigned to, and the call returns the
+  // newly-allocated Tensor. The Tensor can subsequently be assigned
+  // to during kernel execution, and will be used as the designated
+  // output when the kernel execution completes.
+  //
+  // 2) allocate_temp. This should be used to allocate any scratch
+  // storage that is needed while the kernel is executing, and will
+  // not be retained by the Op.
+  //
+  // In some cases a Tensor needs to be used as an output even though
+  // it was previously allocated elsewhere. The Tensor may have been
+  // passed as an input, or stored in a Tensor during a
+  // previous kernel execution, or allocated earlier in the kernel
+  // execution at a time when it was not known which output it would
+  // be assigned to. In this case the kernel can use set_output or
+  // set_output_ref to indicate that the tensor should be used as the
+  // designated output. It is legal to use any previously-allocated
+  // Tensor as an argument to set_output or set_output_ref, including
+  // Tensors allocated via allocate_temp. There may be a performance
+  // penalty to using a Tensor that was not allocated using
+  // allocate_output. This is because allocate_output uses the
+  // AllocatorAttributes stored in output_attr_array for the
+  // designated output. In some cases, using the wrong attributes may
+  // cause an extra copy of the Tensor's buffer.
+
+  // Allocates output for the specified output index with shape.
+  // OpKernelContext retains ownership of the returned pointer. See
+  // comment above.
+  //
+  // If memory allocation fails, returns an error status.
+  //
+  // REQUIRES: !IsRefType(expected_output_dtype(index))
+  Status allocate_output(int index, const TensorShape& shape,
+                         Tensor** tensor) TF_MUST_USE_RESULT;
+  Status allocate_output(StringPiece name, const TensorShape& shape,
+                         Tensor** tensor) TF_MUST_USE_RESULT;
+  // The following methods use the supplied attributes instead of
+  // those in output_attr_array. The caller is responsible for
+  // ensuring that the attributes are "compatible" with the
+  // output_attr_array, e.g. the tensor is allocated on the correct
+  // device. See comment above.
+  Status allocate_output(int index, const TensorShape& shape, Tensor** tensor,
+                         AllocatorAttributes attr) TF_MUST_USE_RESULT;
+  Status allocate_output(StringPiece name, const TensorShape& shape,
+                         Tensor** tensor,
+                         AllocatorAttributes attr) TF_MUST_USE_RESULT;
+
+  // Allocates a temporary Tensor of the specified type and
+  // shape. Devices such as GPUs that enqueue Ops for lazy execution
+  // may retain references to the temporary tensors after the Op's
+  // Compute method has run. See comment above.
+  Status allocate_temp(DataType type, const TensorShape& shape,
+                       Tensor* out_temp, AllocatorAttributes allocator_attr,
+                       const AllocationAttributes& allocation_attr);
+  Status allocate_temp(DataType type, const TensorShape& shape,
+                       Tensor* out_temp, AllocatorAttributes allocator_attr);
+  Status allocate_temp(DataType type, const TensorShape& shape,
+                       Tensor* out_temp);
+
+  // Copies a tensor (allocated by the caller) to the specified output
+  // index.  REQUIRES: !IsRefType(expected_output_dtype(index))
+  // REQUIRES: 'tensor' must have the same MemoryType as
+  // output_memory_types[index]. See comment above.
+  Status set_output(StringPiece name, const Tensor& tensor);
+  Status set_output(StringPiece name, Tensor&& tensor);
+  void set_output(int index, const Tensor& tensor);
+  void set_output(int index, Tensor&& tensor);
+
+  // To output a reference.  Caller retains ownership of mu and tensor_for_ref,
+  // and they must outlive all uses within the step. See comment above.
+  // REQUIRES: IsRefType(expected_output_dtype(index))
+  Status set_output_ref(StringPiece name, mutex* mu, Tensor* tensor_for_ref);
+
+  // Returns nullptr if allocate_output() or set_output() have not been called.
+  Status mutable_output(StringPiece name, Tensor** tensor);
+
+  // Return the DeviceContext that should be used for this Op.
+  //
+  // If using the templated function, the type must be a subclass
+  // of DeviceContext.
+  //
+  // Returns nullptr if the device did not provide one.
+  template <typename T>
+  T* op_device_context();
+  DeviceContext* op_device_context() {
+    DeviceContext* ret = params_->op_device_context;
+    if (ret == nullptr) {
+      auto* dev_info = device()->tensorflow_accelerator_device_info();
+      if (dev_info) ret = dev_info->default_context;
+    }
+    return ret;
+  }
+
+  AllocatorAttributes input_alloc_attr(int index) const {
+    if (params_->input_alloc_attrs.empty()) {
+      return AllocatorAttributes();
+    } else {
+      DCHECK_GE(index, 0);
+      DCHECK_LT(index, params_->input_alloc_attrs.size());
+      return params_->input_alloc_attrs[index];
+    }
+  }
+
+  AllocatorAttributes output_alloc_attr(int index) const {
+    return params_->output_attr_array[index];
+  }
+
+  gtl::InlinedVector<WrappedAllocator, 4> ConsumeWrappedAllocators() {
+    gtl::InlinedVector<WrappedAllocator, 4> retrieved;
+    if (tracking_state_) {
+      mutex_lock lock(tracking_state_->mu);
+      retrieved.swap(tracking_state_->wrapped_allocators);
+    }
+    return retrieved;
+  }
+
+  // Communication.
+  //
+  // An op kernel communicates with outside environment through
+  // Rendezvous Send() and Recv().
+  RendezvousInterface* rendezvous() const { return params_->rendezvous; }
+
+  CollectiveExecutor* collective_executor() const {
+    return params_->collective_executor;
+  }
+
+  // An op kernel can access the session state it belongs to.
+  SessionState* session_state() const { return params_->session_state; }
+
+  // Unique identifier of the session it belongs to. Can be empty.
+  std::string session_handle() const { return params_->session_handle; }
+
+  // Metadata about the session. Can be nullptr.
+  const SessionMetadata* session_metadata() const {
+    return params_->session_metadata;
+  }
+
+  // An op kernel can access the tensor store of the run it belongs to.
+  TensorStore* tensor_store() const { return params_->tensor_store; }
+
+  // Function call support.
+  //
+  // If this kernel invocation is within a function execution,
+  // call_frame() returns the call frame for the function call.
+  CallFrameInterface* call_frame() const { return params_->call_frame; }
+
+  // If not nullptr, the kernel invoke functions defined in the
+  // library. E.g., CHECK_NOTNULL(function_library())->Run("Foo", ...).
+  FunctionLibraryRuntime* function_library() const {
+    return params_->function_library;
+  }
+
+  std::function<void(std::function<void()>)>* runner() const {
+    return params_->runner;
+  }
+  StepStatsCollectorInterface* stats_collector() const {
+    return params_->stats_collector;
+  }
+
+  // Shared resources accessible to this kernel.
+  ResourceMgr* resource_manager() const { return params_->resource_manager; }
+
+  checkpoint::TensorSliceReaderCacheWrapper* slice_reader_cache() const {
+    return params_->slice_reader_cache;
+  }
+
+  // Execution.
+  //
+  // OpKernels can use these eigen devices to carry out their
+  // numerical computation.
+  const Eigen::ThreadPoolDevice& eigen_cpu_device() const {
+    return *device()->eigen_cpu_device();
+  }
+  const Eigen::GpuDevice& eigen_gpu_device() const {
+    return params_->eigen_gpu_device->device();
+  }
+  template <typename EigenDeviceType>
+  const EigenDeviceType& eigen_device() const;
+
+  // Error handling.
+
+  // If expected_inputs == inputs() and expected_outputs == output_types(),
+  // returns OK, else returns INVALID_ARGUMENT with an error message.
+  // Recommended for Ops with dynamic signatures, where validation can only
+  // be performed at runtime.
+  Status MatchSignature(const DataTypeSlice expected_inputs,
+                        const DataTypeSlice expected_outputs);
+
+  // An OpKernel should call SetStatus() if Compute() encounters an
+  // error.
+  void SetStatus(const Status& status);
+  const Status& status() const { return status_; }
+
+  // Cancellation.
+  //
+  // EXPERIMENTAL. See the implementation in tensorflow::FIFOQueue for an
+  // example of how to use this API.
+  CancellationManager* cancellation_manager() const {
+    return params_->cancellation_manager;
+  }
+
+  // Other accessors.
+
+  // For control flow.
+  FrameAndIter frame_iter() const { return params_->frame_iter; }
+  bool is_input_dead() const { return params_->is_input_dead; }
+
+  // May be used, e.g., to get GPU handles, etc.
+  // TODO(tucker): Add example usage.
+  DeviceBase* device() const { return params_->device; }
+
+  // Per-step container for use by white-listed internal ops.
+  ScopedStepContainer* step_container() const {
+    return params_->step_container;
+  }
+
+  // Access to distributed coordination service.
+  tsl::CoordinationServiceAgent* coordination_service_agent() const {
+    return params_->coordination_service_agent;
+  }
+
+  // Helper routines for the OP_REQUIRES macros
+  void CtxFailure(const Status& s);
+  void CtxFailureWithWarning(const Status& s);
+  void CtxFailure(const char* file, int line, const Status& s);
+  void CtxFailureWithWarning(const char* file, int line, const Status& s);
+
+  // Unrecommended functions: these are functions that have some
+  // current uses but are not recommended for use, and may go away at
+  // some future major version release.
+  //
+  // The following functions all have versions that return Status
+  // to capture error conditions, and are strongly preferred.
+  Tensor* mutable_output(int index);
+  mutex* input_ref_mutex(int index);
+  void set_output_ref(int index, mutex* mu, Tensor* tensor_for_ref);
+  TensorValue release_output(int index);
+
+  bool track_allocations() const { return params_->track_allocations; }
+
+  // Records temp memory allocation. Tensor object is recorded to identify the
+  // case where temp memory is used as output memory.
+  void record_temp_memory_allocation(int64_t size, const Tensor& t)
+      TF_LOCKS_EXCLUDED(tracking_state_->stats_mu);
+
+  // Returns recorded size of temporary memory;
+  int64_t temp_memory_allocated() const
+      TF_LOCKS_EXCLUDED(tracking_state_->stats_mu);
+
+  // Records persistent memory allocation, size can be negative indicating
+  // deallocation.
+  void record_persistent_memory_allocation(int64_t size, int64_t alloc_id = -1)
+      TF_LOCKS_EXCLUDED(tracking_state_->stats_mu);
+
+  // Returns recorded size and ids of persistent memory.
+  int64_t persistent_memory_allocated() const
+      TF_LOCKS_EXCLUDED(tracking_state_->stats_mu);
+
+  std::vector<int64_t> persistent_alloc_ids() const
+      TF_LOCKS_EXCLUDED(tracking_state_->stats_mu);
+
+  // Resets counters for temp and persistent memory and recorded ids.
+  void clear_recorded_memory() TF_LOCKS_EXCLUDED(tracking_state_->stats_mu);
+
+  bool input_is_ref(int index) const;
+
+  void set_record_memory_consumption(bool v);
+
+  // Used by OpKernel implementations to track actively running deferred ops.
+  //
+  // A deferred op is one whose Compute method returns (or whose ComputeAsync
+  // method invokes the callback) when work is scheduled onto a device. At that
+  // point, we don't know when the work will actually complete (or if it has
+  // already completed) on the device. These functions allow the executor to
+  // track the status of deferred ops and act accordingly.
+  //
+  // Deferred OpKernel implementations must use these methods to get two
+  // functions. It then must call these two functions in pairs, before and after
+  // device execution, respectively.
+  TF_MUST_USE_RESULT std::function<void()> inc_num_deferred_ops_function() {
+    DCHECK(params_->op_kernel->is_deferred());
+    return params_->inc_num_deferred_ops_function
+               ? params_->inc_num_deferred_ops_function
+               : []() {};
+  }
+  TF_MUST_USE_RESULT std::function<void()> dec_num_deferred_ops_function() {
+    DCHECK(params_->op_kernel->is_deferred());
+    return params_->dec_num_deferred_ops_function
+               ? params_->dec_num_deferred_ops_function
+               : []() {};
+  }
+
+  Allocator* get_allocator(AllocatorAttributes attr);
+
+  Params* params() const { return params_; }
+  void set_params(Params* params) { params_ = params; }
+
+  void ResetOutputs(int num_outputs = 0) {
+    for (TensorValue& value : outputs_) {
+      DCHECK(!value.is_ref());
+      delete value.tensor;
+      value.tensor = nullptr;
+    }
+    outputs_.resize(num_outputs);
+  }
+
+ private:
+  bool record_memory_consumption_ = false;
+
+  // Internal common method used when allocating tensor memory
+  Status allocate_tensor(DataType type, const TensorShape& shape,
+                         Tensor* out_tensor,
+                         AllocatorAttributes allocator_attr) {
+    return allocate_tensor(type, shape, out_tensor, allocator_attr,
+                           AllocationAttributes());
+  }
+
+  Status allocate_tensor(DataType type, const TensorShape& shape,
+                         Tensor* out_tensor, AllocatorAttributes allocator_attr,
+                         const AllocationAttributes& allocation_attr);
+
+  // Helpers for `set_output()`.
+
+  // Returns `true` if the tensor was copied into an allocated output.
+  bool maybe_set_output_by_allocate_and_copy(int index, const Tensor& tensor);
+
+  void maybe_track_allocations_for_set_output(const Tensor& tensor);
+
+  Status get_input_index(StringPiece name, int* out_index) const;
+  Status get_output_index(StringPiece name, int* out_index) const;
+
+  // Initialize the allocated_scope_ids_ set the first time this method is
+  // called.
+  void maybe_initialize_scope_id_set();
+
+  Status status_;
+  friend class CollectiveExecutor;  // for access to params_
+  Params* params_;                  // not owned
+  gtl::InlinedVector<TensorValue, 4> outputs_;
+
+  // Keep track of calls to ScopedAllocator.
+  // TODO(ayushd): change to absl::flat_hash_set.
+  std::unique_ptr<std::unordered_set<int32>> allocated_scope_ids_;
+
+  // The following data members are only used when allocation tracking is
+  // enabled, memory consumption is being recorded, or tensor access is being
+  // recorded.
+  struct TrackingState {
+    mutable mutex mu;
+    gtl::InlinedVector<WrappedAllocator, 4> wrapped_allocators
+        TF_GUARDED_BY(mu);
+
+    mutable mutex stats_mu;
+    int64_t temp_memory_allocated TF_GUARDED_BY(stats_mu) = 0;
+
+    int64_t persistent_memory_allocated TF_GUARDED_BY(stats_mu) = 0;
+    gtl::InlinedVector<std::pair<const void*, int64_t>, 2>
+        temp_tensor_buffer_and_size TF_GUARDED_BY(stats_mu);
+    gtl::InlinedVector<int64_t, 2> persistent_alloc_ids TF_GUARDED_BY(stats_mu);
+  };
+  std::unique_ptr<TrackingState> tracking_state_;
+
+  // For access to `params_->op_kernel`.
+  friend void CheckNotInComputeAsync(OpKernelContext* ctx,
+                                     const char* correct_macro_name);
+
+  OpKernelContext(const OpKernelContext&) = delete;
+  void operator=(const OpKernelContext&) = delete;
+};
+
+template <>
+const Eigen::ThreadPoolDevice& OpKernelContext::eigen_device() const;
+
+template <>
+const Eigen::GpuDevice& OpKernelContext::eigen_device() const;
+
+// Register your OpKernel by specifying the Op's name, the device the
+// kernel runs on, any type attr constraints for this kernel, any
+// host-memory args, and the class to instantiate.  Examples:
+//
+//  // A kernel that supports all types.
+//  REGISTER_KERNEL_BUILDER(Name("Save").Device(DEVICE_CPU), SaveOp);
+//
+//  // The following are equivalent ways of specifying that the kernel only
+//  // works if the "T" type attr is set to DT_FLOAT.
+//  REGISTER_KERNEL_BUILDER(
+//      Name("Sub").Device(DEVICE_CPU).TypeConstraint<float>("T"),
+//      SubOp<float>);
+//  // (You would then repeat this for every type supported by "Sub".)
+//
+//  // This form allows you to specify a list of types as the constraint.
+//  REGISTER_KERNEL_BUILDER(Name("Sub")
+//                              .Device(DEVICE_CPU)
+//                              .TypeConstraint("T", {DT_FLOAT}),
+//                          SubOp<float>);
+//
+//  // A kernel that expects one of the input tensors in host memory.
+//  REGISTER_KERNEL_BUILDER(
+//      Name("Reshape").Device(DEVICE_GPU).HostMemory("shape"), ReshapeOp);
+//
+//  // A kernel that works on any device. Kernels using DEVICE_DEFAULT
+//  // must aways run on host and all inputs and outputs must use `HostMemory`.
+//  // Kernels for data management, control-flow primitives or working with
+//  // tensor shapes for various devices (including `PluggableDevices`) are
+//  // typical uses.
+//  REGISTER_KERNEL_BUILDER(
+//     Name("TensorListLength").Device(DEVICE_DEFAULT).HostMemory("length"),
+//     TensorListLength);
+//
+// See kernel_def_builder for details.
+
+// Instantiate an OpKernel that has been registered.  Returns nullptr
+// if no operation for that type of device / input signature combination
+// (and a NOT_FOUND *status), or there is an error in construction (and
+// an INVALID_ARGUMENT *status).  Otherwise, the caller takes ownership
+// of the returned pointer.
+// EXPECTED USAGE: unique_ptr<OpKernel> op = CreateOpKernel(...);
+// REQUIRES: def has all attrs specified (e.g. using AddDefaultsToNodeDef()).
+std::unique_ptr<OpKernel> CreateOpKernel(DeviceType device_type,
+                                         DeviceBase* device,
+                                         Allocator* allocator,
+                                         const NodeDef& node_def,
+                                         int graph_def_version, Status* status);
+
+std::unique_ptr<OpKernel> CreateOpKernel(
+    DeviceType device_type, DeviceBase* device, Allocator* allocator,
+    const std::shared_ptr<const NodeProperties>& props, int graph_def_version,
+    Status* status);
+
+Status CreateOpKernel(DeviceType device_type, DeviceBase* device,
+                      Allocator* allocator, FunctionLibraryRuntime* flib,
+                      const std::shared_ptr<const NodeProperties>& props,
+                      int graph_def_version, OpKernel** kernel);
+
+Status CreateOpKernel(DeviceType device_type, DeviceBase* device,
+                      Allocator* allocator, FunctionLibraryRuntime* flib,
+                      ResourceMgr* resource_mgr,
+                      const std::shared_ptr<const NodeProperties>& props,
+                      int graph_def_version, OpKernel** kernel);
+
+// Returns into 'device_types' the subset of prioritized_types that this
+// binary has registered for the given NodeDef.
+//
+// REQUIRES: * 'device_types' is not nullptr.
+//           * def has all attrs specified (e.g. using AddDefaultsToNodeDef()).
+Status SupportedDeviceTypesForNode(
+    const std::vector<DeviceType>& prioritized_types, const NodeDef& def,
+    PrioritizedDeviceTypeVector* device_types,
+    const DeviceNameUtils::ParsedName* local_address_spec = nullptr);
+
+// Returns a message with a description of the kernels registered for op
+// `op_name`.
+std::string KernelsRegisteredForOp(StringPiece op_name);
+
+// Call once after Op registration has completed.
+Status ValidateKernelRegistrations(const OpRegistryInterface& op_registry);
+
+// -----------------------------------------------------------------------------
+// OpKernel registration implementation follows, please ignore.
+
+// Allow the REGISTER_KERNEL_BUILDER(Name("op_name").Device(...)...) syntax.
+namespace register_kernel {
+
+class Name : public KernelDefBuilder {
+ public:
+  explicit Name(const char* op);
+};
+
+}  // namespace register_kernel
+
+// Kernel registration appears as:
+//   REGISTER_KERNEL_BUILDER(Name("OpName").Device(DEVICE_CPU)..., OpImpl)
+// We'd like to have "OpName" as a constant-expression, without requiring that
+// of the overall KernelDefBuilder expression (beginning with the
+// register_kernel::Name constructor above).
+//
+// So, we pull the "OpName" part to a separate macro-level argument. This
+// involves treating Name("OpName") as a macro call, via token-pasting (e.g.
+// M_## =>  M_Name("OpName")), and having it expand to '"OpName",
+// Name("OpName")' which is then usable as two arguments.
+#define TF_EXTRACT_KERNEL_NAME_Name(name_str) \
+  name_str, ::tensorflow::register_kernel::Name(name_str)
+#define TF_EXTRACT_KERNEL_NAME_IMPL(m, ...) m(__VA_ARGS__)
+#define TF_EXTRACT_KERNEL_NAME(m, kernel_builder, ...)                    \
+  TF_EXTRACT_KERNEL_NAME_IMPL(m, TF_EXTRACT_KERNEL_NAME_##kernel_builder, \
+                              __VA_ARGS__)
+
+// REGISTER_KERNEL_BUILDER_IMPL_2, with a unique 'ctr' as the first argument.
+// TODO(dodgen): There are some uses of this macro inside functions, where
+// kernel_builder refers to (non-const) locals (they should be fixed). To
+// accommodate those, kernel_builder.Build() appears as an argument to an
+// immediately-called lambda (not in the lambda itself).
+#define REGISTER_KERNEL_BUILDER_IMPL_3(ctr, op_name, kernel_builder_expr,   \
+                                       is_system_kernel, ...)               \
+  static ::tensorflow::InitOnStartupMarker const register_kernel_##ctr      \
+      TF_ATTRIBUTE_UNUSED =                                                 \
+          TF_INIT_ON_STARTUP_IF(is_system_kernel ||                         \
+                                (SHOULD_REGISTER_OP_KERNEL(#__VA_ARGS__) && \
+                                 SHOULD_REGISTER_OP(op_name)))              \
+          << ([](::tensorflow::KernelDef const* kernel_def) {               \
+               ::tensorflow::kernel_factory::OpKernelRegistrar registrar(   \
+                   kernel_def, #__VA_ARGS__,                                \
+                   [](::tensorflow::OpKernelConstruction* context)          \
+                       -> ::tensorflow::OpKernel* {                         \
+                     return new __VA_ARGS__(context);                       \
+                   });                                                      \
+               (void)registrar;                                             \
+               LOG_KERNEL_SOURCES(op_name)                                  \
+               return ::tensorflow::InitOnStartupMarker{};                  \
+             })(kernel_builder_expr.Build());
+
+// REGISTER_KERNEL_BUILDER_IMPL, but with kernel_builder split to op_name,
+// kernel_builder_expr.
+#define REGISTER_KERNEL_BUILDER_IMPL_2(op_name, kernel_builder_expr, \
+                                       is_system_kernel, ...)        \
+  TF_NEW_ID_FOR_INIT(REGISTER_KERNEL_BUILDER_IMPL_3, op_name,        \
+                     kernel_builder_expr, is_system_kernel, __VA_ARGS__)
+
+// REGISTER_KERNEL_BUILDER, but with is_system_kernel bound.
+#define REGISTER_KERNEL_BUILDER_IMPL(kernel_builder, is_system_kernel, ...) \
+  TF_EXTRACT_KERNEL_NAME(REGISTER_KERNEL_BUILDER_IMPL_2, kernel_builder,    \
+                         is_system_kernel, __VA_ARGS__)
+
+#define REGISTER_KERNEL_BUILDER(kernel_builder, ...) \
+  TF_ATTRIBUTE_ANNOTATE("tf:kernel")                 \
+  REGISTER_KERNEL_BUILDER_IMPL(kernel_builder, false, __VA_ARGS__)
+
+// The `REGISTER_SYSTEM_KERNEL_BUILDER()` macro acts as
+// `REGISTER_KERNEL_BUILDER()` except that the kernel is registered
+// unconditionally even when selective registration is used.
+#define REGISTER_SYSTEM_KERNEL_BUILDER(kernel_builder, ...) \
+  TF_ATTRIBUTE_ANNOTATE("tf:kernel")                        \
+  TF_ATTRIBUTE_ANNOTATE("tf:kernel:system")                 \
+  REGISTER_KERNEL_BUILDER_IMPL(kernel_builder, true, __VA_ARGS__)
+
+// Checks whether a given kernel is registered on device_type.
+bool KernelDefAvailable(const DeviceType& device_type, const NodeDef& node_def);
+
+// If node of node_name, experimental_debug_info, node_op, node_device and
+// node_attrs has a corresponding kernel registered on device_type, returns OK
+// and fill in the kernel def and kernel_class_name. <def> and
+// <kernel_class_name> may be null.
+Status FindKernelDef(
+    const DeviceType& device_type, StringPiece node_name,
+    bool has_experimental_debug_info,
+    const NodeDef_ExperimentalDebugInfo& experimental_debug_info,
+    StringPiece node_op, StringPiece node_device, AttrSlice node_attrs,
+    const KernelDef** def, std::string* kernel_class_name);
+
+// If node_def has a corresponding kernel registered on device_type,
+// returns OK and fill in the kernel def and kernel_class_name. <def> and
+// <kernel_class_name> may be null.
+Status FindKernelDef(const DeviceType& device_type, const NodeDef& node_def,
+                     const KernelDef** def, std::string* kernel_class_name);
+
+// Writes a list of all registered kernels to LOG(INFO), to help users debug
+// missing kernel errors.
+void LogAllRegisteredKernels();
+
+// Gets a list of all registered kernels.
+KernelList GetAllRegisteredKernels();
+
+// Gets a list of all registered kernels for which predicate returns true
+KernelList GetFilteredRegisteredKernels(
+    const std::function<bool(const KernelDef&)>& predicate);
+
+// Gets a list of all registered kernels for a given op
+KernelList GetRegisteredKernelsForOp(StringPiece op_name);
+
+namespace kernel_factory {
+
+// OpKernelFactory is responsible for creating OpKernels when TensorFlow needs
+// them. You register factories with the TensorFlow core by constructing an
+// OpKernelRegistrar and passing the factory as a constructor parameter.
+class OpKernelFactory {
+ public:
+  virtual OpKernel* Create(OpKernelConstruction* context) = 0;
+  virtual ~OpKernelFactory() = default;
+};
+
+class OpKernelRegistrar {
+ public:
+  // Registers the given kernel factory with TensorFlow. TF will call the
+  // factory Create() method when it determines that a kernel matching the given
+  // KernelDef is required.
+  OpKernelRegistrar(const KernelDef* kernel_def, StringPiece kernel_class_name,
+                    std::unique_ptr<OpKernelFactory> factory)
+      TF_ATTRIBUTE_NOINLINE {
+    InitInternal(kernel_def, kernel_class_name, std::move(factory));
+  }
+
+  // Registers the given factory function with TensorFlow. This is equivalent
+  // to registering a factory whose Create function invokes `create_fn`.
+  OpKernelRegistrar(const KernelDef* kernel_def, StringPiece kernel_class_name,
+                    OpKernel* (*create_fn)(OpKernelConstruction*))
+      TF_ATTRIBUTE_NOINLINE {
+    InitInternal(kernel_def, kernel_class_name,
+                 absl::make_unique<PtrOpKernelFactory>(create_fn));
+  }
+
+ private:
+  struct PtrOpKernelFactory : public OpKernelFactory {
+    explicit PtrOpKernelFactory(OpKernel* (*create_func)(OpKernelConstruction*))
+        : create_func_(create_func) {}
+
+    OpKernel* Create(OpKernelConstruction* context) override;
+
+    OpKernel* (*create_func_)(OpKernelConstruction*);
+  };
+
+  void InitInternal(const KernelDef* kernel_def, StringPiece kernel_class_name,
+                    std::unique_ptr<OpKernelFactory> factory);
+};
+
+}  // namespace kernel_factory
+
+// -----------------------------------------------------------------------------
+// Template and inline method implementations, please ignore
+
+template <class T>
+Status OpKernelConstruction::GetAttr(StringPiece attr_name, T* value) const {
+  return GetNodeAttr(def(), attr_name, value);
+}
+
+inline DataType OpKernelContext::input_dtype(int index) const {
+  DCHECK_GE(index, 0);
+  DCHECK_LT(index, num_inputs());
+  const TensorValue& value(params_->inputs[index]);
+  return value.dtype();
+}
+
+inline MemoryType OpKernelContext::input_memory_type(int index) const {
+  DCHECK_GE(index, 0);
+  DCHECK_LT(index, num_inputs());
+  return op_kernel().input_memory_types()[index];
+}
+
+inline DataType OpKernelContext::expected_output_dtype(int index) const {
+  DCHECK_GE(index, 0);
+  DCHECK_LT(index, num_outputs());
+  return params_->op_kernel->output_type(index);
+}
+
+inline MemoryType OpKernelContext::output_memory_type(int index) const {
+  DCHECK_GE(index, 0);
+  DCHECK_LT(index, num_outputs());
+  return op_kernel().output_memory_types()[index];
+}
+
+inline bool OpKernelContext::input_is_ref(int index) const {
+  const TensorValue& value(params_->inputs[index]);
+  return value.is_ref();
+}
+
+// no input if tensor == nullptr.
+inline bool OpKernelContext::has_input(int index) const {
+  DCHECK_GE(index, 0);
+  DCHECK_LT(index, num_inputs());
+  return params_->inputs[index].tensor != nullptr;
+}
+
+inline mutex* OpKernelContext::input_ref_mutex(int index) {
+  DCHECK_GE(index, 0);
+  DCHECK_LT(index, num_inputs());
+  DCHECK(input_is_ref(index));
+  return params_->inputs[index].mutex_if_ref;
+}
+
+inline Tensor* OpKernelContext::mutable_output(int index) {
+  DCHECK_GE(index, 0);
+  DCHECK_LT(index, num_outputs());
+  return outputs_[index].tensor;
+}
+
+inline TensorValue OpKernelContext::release_output(int index) {
+  DCHECK_GE(index, 0);
+  DCHECK_LT(index, num_outputs());
+  TensorValue value = outputs_[index];
+  outputs_[index] = TensorValue();
+  return value;
+}
+
+template <typename T>
+T* OpKernelContext::op_device_context() {
+  static_assert(std::is_base_of<DeviceContext, T>::value,
+                "T is not a subclass of DeviceContext");
+  return static_cast<T*>(op_device_context());
+}
+
+inline const Tensor& OpInputList::operator[](int i) const {
+  DCHECK_GE(i, 0);
+  DCHECK_LT(i, stop_ - start_);
+  return ctx_->input(start_ + i);
+}
+
+inline mutex* OpMutableInputList::ref_mutex(int i) {
+  DCHECK_GE(i, 0);
+  DCHECK_LT(i, stop_ - start_);
+  return ctx_->input_ref_mutex(start_ + i);
+}
+
+inline Tensor OpMutableInputList::at(int i, bool lock_held) {
+  DCHECK_GE(i, 0);
+  DCHECK_LT(i, stop_ - start_);
+  return ctx_->mutable_input(start_ + i, lock_held);
+}
+
+inline Tensor* OpOutputList::operator[](int i) {
+  DCHECK_GE(i, 0);
+  DCHECK_LT(i, stop_ - start_);
+  return ctx_->mutable_output(start_ + i);
+}
+
+inline bool OpOutputList::required(int i) const {
+  DCHECK_GE(i, 0);
+  DCHECK_LT(i, stop_ - start_);
+  return ctx_->output_required(start_ + i);
+}
+
+inline DataType OpOutputList::expected_output_dtype(int i) const {
+  DCHECK_GE(i, 0);
+  DCHECK_LT(i, stop_ - start_);
+  return ctx_->expected_output_dtype(start_ + i);
+}
+
+inline Status OpOutputList::allocate(int i, const TensorShape& shape,
+                                     Tensor** output) {
+  DCHECK_GE(i, 0);
+  DCHECK_LT(i, stop_ - start_);
+  return ctx_->allocate_output(start_ + i, shape, output);
+}
+
+inline void OpOutputList::set(int i, const Tensor& tensor) {
+  DCHECK_GE(i, 0);
+  DCHECK_LT(i, stop_ - start_);
+  ctx_->set_output(start_ + i, tensor);
+}
+
+inline void OpOutputList::set(int i, Tensor&& tensor) {
+  DCHECK_GE(i, 0);
+  DCHECK_LT(i, stop_ - start_);
+  ctx_->set_output(start_ + i, std::move(tensor));
+}
+
+inline void OpOutputList::set_ref(int i, mutex* mu, Tensor* tensor_for_ref) {
+  DCHECK_GE(i, 0);
+  DCHECK_LT(i, stop_ - start_);
+  ctx_->set_output_ref(i, mu, tensor_for_ref);
+}
+
+// Generate a fatal error if OP_REQUIRES or OP_REQUIRES_OK are used in
+// AsyncOpKernel implementations. If these macros are used and the condition
+// does not hold, the `done` callback will never be called and the system will
+// deadlock, so a crash failure is preferable. Since the OP_REQUIRES[_OK] macros
+// are legal to use in AsyncOpKernel constructors, we use overload resolution
+// to distinguish between OpKernelConstruction* and OpKernelContext* context
+// types.
+class XlaOpKernelContext;
+inline void CheckNotInComputeAsync(XlaOpKernelContext*, const char*) {}
+inline void CheckNotInComputeAsync(OpKernelConstruction*, const char*) {}
+void CheckNotInComputeAsync(OpKernelContext* ctx,
+                            const char* correct_macro_name);
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_OP_KERNEL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/op_requires.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/op_requires.h
new file mode 100644
index 0000000000000000000000000000000000000000..c5fb7796ecf6e8ed7d5deb22778c55016e30f07c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/op_requires.h
@@ -0,0 +1,103 @@
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_OP_REQUIRES_H_
+#define TENSORFLOW_CORE_FRAMEWORK_OP_REQUIRES_H_
+
+#include "tensorflow/core/platform/macros.h"
+
+namespace tensorflow {
+
+// Convenience macros for asserting and handling exceptional conditions.
+// Analogous to the CHECK* macros provided by logging.h.
+//
+// Example use:
+// void Compute(OperationContext* context) {
+//   OP_REQUIRES(context, context->num_inputs() == 2,
+//               errors::InvalidArgument("FooOp requires 2 arguments"));
+//   ...
+//   Status status = SomeUncertainMethod();
+//   OP_REQUIRES_OK(context, status);
+//   ...
+// }
+//
+// These macros depend on CheckNotInComputeAsync, which must be defined before
+// invoking the macro. We specifically don't include op_kernel.h from this
+// header to reduce this header's dependencies. These macros may be used with
+// alternative implementations of OpKernelContext with fewer dependencies.
+
+#define OP_REQUIRES(CTX, EXP, STATUS)                     \
+  do {                                                    \
+    if (!TF_PREDICT_TRUE(EXP)) {                          \
+      CheckNotInComputeAsync((CTX), "OP_REQUIRES_ASYNC"); \
+      (CTX)->CtxFailure(__FILE__, __LINE__, (STATUS));    \
+      return;                                             \
+    }                                                     \
+  } while (0)
+
+#define OP_REQUIRES_OK(CTX, ...)                             \
+  do {                                                       \
+    ::tensorflow::Status _s(__VA_ARGS__);                    \
+    if (!TF_PREDICT_TRUE(_s.ok())) {                         \
+      CheckNotInComputeAsync((CTX), "OP_REQUIRES_OK_ASYNC"); \
+      (CTX)->CtxFailureWithWarning(__FILE__, __LINE__, _s);  \
+      return;                                                \
+    }                                                        \
+  } while (0)
+
+#define OP_REQUIRES_OK_OR_SET_PAYLOAD(CTX, PAYLOAD_KEY, PAYLOAD_VALUE, STATUS) \
+  do {                                                                         \
+    if (!TF_PREDICT_TRUE(STATUS.ok())) {                                       \
+      CheckNotInComputeAsync((CTX), "OP_REQUIRES_OK_ASYNC");                   \
+      if (!PAYLOAD_VALUE.empty()) {                                            \
+        STATUS.SetPayload(PAYLOAD_KEY, absl::Cord(PAYLOAD_VALUE));             \
+      }                                                                        \
+      (CTX)->CtxFailureWithWarning(__FILE__, __LINE__, STATUS);                \
+      return;                                                                  \
+    }                                                                          \
+  } while (0)
+
+#define OP_REQUIRES_ASYNC(CTX, EXP, STATUS, CALLBACK)  \
+  do {                                                 \
+    if (!TF_PREDICT_TRUE(EXP)) {                       \
+      (CTX)->CtxFailure(__FILE__, __LINE__, (STATUS)); \
+      (CALLBACK)();                                    \
+      return;                                          \
+    }                                                  \
+  } while (0)
+
+#define OP_REQUIRES_OK_ASYNC(CTX, STATUS, CALLBACK)         \
+  do {                                                      \
+    const ::tensorflow::Status& _s(STATUS);                 \
+    if (!TF_PREDICT_TRUE(_s.ok())) {                        \
+      (CTX)->CtxFailureWithWarning(__FILE__, __LINE__, _s); \
+      (CALLBACK)();                                         \
+      return;                                               \
+    }                                                       \
+  } while (0)
+
+#define OP_REQUIRES_VALUE(lhs, ctx, rexpr)                                   \
+  OP_REQUIRES_VALUE_IMPL(                                                    \
+      TF_STATUS_MACROS_CONCAT_NAME(_status_or_value, __COUNTER__), lhs, ctx, \
+      rexpr)
+
+#define OP_REQUIRES_VALUE_IMPL(statusor, lhs, ctx, rexpr) \
+  auto statusor = (rexpr);                                \
+  OP_REQUIRES_OK(ctx, statusor.status());                 \
+  lhs = std::move(statusor.value())
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_OP_REQUIRES_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/op_segment.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/op_segment.h
new file mode 100644
index 0000000000000000000000000000000000000000..8cbca548cf02df37f77378e4f86d9abe2200080b
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/op_segment.h
@@ -0,0 +1,90 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_OP_SEGMENT_H_
+#define TENSORFLOW_CORE_FRAMEWORK_OP_SEGMENT_H_
+
+#include <string>
+#include <unordered_map>
+
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/platform/macros.h"
+#include "tensorflow/core/platform/mutex.h"
+#include "tensorflow/core/platform/thread_annotations.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+
+// OpSegment keeps track of OpKernels registered for sessions running
+// on a device.
+//
+// The implementation maintains a two-level map. The 1st level maps
+// session handle to the map of registered OpKernels. The 2nd level
+// map maps node names to instantiated OpKernel objects.
+//
+// Each 2-nd level map is reference-counted and the caller can call
+// AddHold to obtain a reference on all kernels of a session and
+// ensure these kernels are alive until a corresponding RemoveHold is
+// called on the same session.
+class OpSegment {
+ public:
+  OpSegment();
+  ~OpSegment();
+
+  // A hold can be placed on a session, preventing all its kernels
+  // from being deleted.
+  void AddHold(const std::string& session_handle);
+  void RemoveHold(const std::string& session_handle);
+
+  // If the kernel for "node_name" has been created in the
+  // "session_handle", returns the existing op kernel in "*kernel".
+  // Otherwise, creates the kernel by calling create_fn(), cache it,
+  // and returns it in "*kernel". If create_fn() fails, returns the
+  // error.
+  //
+  // OpSegment keeps the ownership of the returned "*kernel".
+  typedef std::function<Status(OpKernel**)> CreateKernelFn;
+  Status FindOrCreate(const std::string& session_handle,
+                      const std::string& node_name, OpKernel** kernel,
+                      CreateKernelFn create_fn);
+
+  // Returns true if OpSegment should own the kernel.
+  static bool ShouldOwnKernel(FunctionLibraryRuntime* lib,
+                              const std::string& node_op);
+
+ private:
+  // op name -> OpKernel
+  typedef std::unordered_map<string, OpKernel*> KernelMap;
+  struct Item {
+    int num_holds = 1;      // Num of holds put on the session.
+    KernelMap name_kernel;  // op name -> kernel.
+    ~Item();
+  };
+
+  // session handle -> item.
+  // Session handles are produced by strings::FpToString()
+  typedef std::unordered_map<string, Item*> SessionMap;
+
+  mutable mutex mu_;
+  SessionMap sessions_ TF_GUARDED_BY(mu_);
+
+  OpSegment(const OpSegment&) = delete;
+  void operator=(const OpSegment&) = delete;
+};
+
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_OP_SEGMENT_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/ops_util.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/ops_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..6d6868a4ac63990df8b87ab68211633fda04f24c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/ops_util.h
@@ -0,0 +1,116 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_OPS_UTIL_H_
+#define TENSORFLOW_CORE_FRAMEWORK_OPS_UTIL_H_
+
+// This file contains utilities for various operations.
+
+#include <array>
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/framework/tensor_shape.h"
+#include "tensorflow/core/framework/tensor_types.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/util/padding.h"
+
+namespace tensorflow {
+
+// Calculates broadcast starting index and size.  For SAME padding, addition
+// padding could be applied to right, left, top and bottom.  Depending on the
+// current index, input size, kernel size, stride, padding size, the starting
+// index and size for broadcast for that dimension are different from the
+// current index and kernel size.
+// This is mainly used by gradient algorithms for pooling operations.
+Status GetBroadcastSize(const int index, const int in_size, const int ksize,
+                        const int stride, const int pad_size, int* bindex,
+                        int* bsize);
+
+// Converts Brain's Padding to Eigen's PaddingType.
+Eigen::PaddingType BrainPadding2EigenPadding(Padding padding);
+
+// Given a shape 's' of a tensor of type T. Returns true iff the
+// number of bytes occupied by each dim 0 (i.e., &tensor(i + 1, ...) -
+// &tensor(i, ...)) is multiple of EIGEN_MAX_ALIGN_BYTES.
+template <typename T>
+bool IsInnerDimsSizeAligned(const TensorShape& s) {
+  if (s.dims() == 0) return false;
+  const int64_t dim0_size = s.dim_size(0);
+  if (dim0_size == 0) return false;
+#if EIGEN_MAX_ALIGN_BYTES == 0
+  return true;
+#else
+  const int64_t bytes_per_dim0 = (s.num_elements() / dim0_size) * sizeof(T);
+  return bytes_per_dim0 % EIGEN_MAX_ALIGN_BYTES == 0;
+#endif
+}
+
+// Given a shape 's' of a tensor of type T and the `start` and `end` index of a
+// dim 0 slice, returns true iff slice is aligned with respect to original
+// tensor. Here aligned implies the address is a multiple of
+// EIGEN_MAX_ALIGN_BYTES.
+template <typename T>
+bool IsDim0SliceAligned(const TensorShape& s, int64_t start,
+                        int64_t end_or_size) {
+  if (s.dims() == 1) {
+#if EIGEN_MAX_ALIGN_BYTES == 0
+    return true;
+#else
+    bool start_aligned = (start * sizeof(T)) % EIGEN_MAX_ALIGN_BYTES == 0;
+    // End is aligned if either the explicit end index is passed and is a
+    // a multiple of EIGEN_MAX_ALIGN_BYTES, or the start index is aligned and
+    // the size is aligned. So for convenience we can either pass start and
+    // index, or start and size.
+    bool end_aligned = (end_or_size * sizeof(T)) % EIGEN_MAX_ALIGN_BYTES == 0;
+    return start_aligned && end_aligned;
+#endif
+  } else {
+    return IsInnerDimsSizeAligned<T>(s);
+  }
+}
+
+// Returns <suffix> sanitized to have only [a-zA-Z0-9-_].
+std::string SanitizeThreadSuffix(std::string suffix);
+
+// Helper to compute 'strides' given a tensor 'shape'. I.e.,
+// strides[i] = prod(shape.dim_size[(i+1):])
+template <typename T>
+gtl::InlinedVector<T, 8> ComputeStride(const TensorShape& shape) {
+  const int ndims = shape.dims();
+  gtl::InlinedVector<T, 8> strides(ndims);
+  T stride = 1;
+  for (int i = ndims - 1; i >= 0; --i) {
+    strides[i] = stride;
+    stride *= static_cast<T>(shape.dim_size(i));
+  }
+  return strides;
+}
+
+// Helper to compute 'strides' given an Eigen TensorDimensions
+template <typename T, typename EigenDimensions>
+gtl::InlinedVector<T, 8> ComputeEigenStrides(const EigenDimensions& shape) {
+  const int ndims = shape.rank();
+  gtl::InlinedVector<T, 8> strides(ndims);
+  T stride = 1;
+  for (int i = ndims - 1; i >= 0; --i) {
+    strides[i] = stride;
+    stride *= static_cast<T>(shape[i]);
+  }
+  return strides;
+}
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_OPS_UTIL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/optimized_function_graph.pb.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/optimized_function_graph.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..8bec9df47ee1bf5221f9feaecd00df9342309ad4
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/optimized_function_graph.pb.h
@@ -0,0 +1,733 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: tensorflow/core/framework/optimized_function_graph.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2foptimized_5ffunction_5fgraph_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2foptimized_5ffunction_5fgraph_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3021000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3021009 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/map.h>  // IWYU pragma: export
+#include <google/protobuf/map_entry.h>
+#include <google/protobuf/map_field_inl.h>
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "tensorflow/core/framework/graph.pb.h"
+#include "tensorflow/core/framework/types.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_tensorflow_2fcore_2fframework_2foptimized_5ffunction_5fgraph_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_tensorflow_2fcore_2fframework_2foptimized_5ffunction_5fgraph_2eproto {
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_tensorflow_2fcore_2fframework_2foptimized_5ffunction_5fgraph_2eproto;
+namespace tensorflow {
+class OptimizedFunctionGraph;
+struct OptimizedFunctionGraphDefaultTypeInternal;
+extern OptimizedFunctionGraphDefaultTypeInternal _OptimizedFunctionGraph_default_instance_;
+class OptimizedFunctionGraph_NodeNameToControlRetEntry_DoNotUse;
+struct OptimizedFunctionGraph_NodeNameToControlRetEntry_DoNotUseDefaultTypeInternal;
+extern OptimizedFunctionGraph_NodeNameToControlRetEntry_DoNotUseDefaultTypeInternal _OptimizedFunctionGraph_NodeNameToControlRetEntry_DoNotUse_default_instance_;
+}  // namespace tensorflow
+PROTOBUF_NAMESPACE_OPEN
+template<> ::tensorflow::OptimizedFunctionGraph* Arena::CreateMaybeMessage<::tensorflow::OptimizedFunctionGraph>(Arena*);
+template<> ::tensorflow::OptimizedFunctionGraph_NodeNameToControlRetEntry_DoNotUse* Arena::CreateMaybeMessage<::tensorflow::OptimizedFunctionGraph_NodeNameToControlRetEntry_DoNotUse>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace tensorflow {
+
+enum OptimizedFunctionGraph_OptimizationSource : int {
+  OptimizedFunctionGraph_OptimizationSource_SOURCE_UNSPECIFIED = 0,
+  OptimizedFunctionGraph_OptimizationSource_AOT = 1,
+  OptimizedFunctionGraph_OptimizationSource_JIT = 2,
+  OptimizedFunctionGraph_OptimizationSource_OptimizedFunctionGraph_OptimizationSource_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
+  OptimizedFunctionGraph_OptimizationSource_OptimizedFunctionGraph_OptimizationSource_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
+};
+bool OptimizedFunctionGraph_OptimizationSource_IsValid(int value);
+constexpr OptimizedFunctionGraph_OptimizationSource OptimizedFunctionGraph_OptimizationSource_OptimizationSource_MIN = OptimizedFunctionGraph_OptimizationSource_SOURCE_UNSPECIFIED;
+constexpr OptimizedFunctionGraph_OptimizationSource OptimizedFunctionGraph_OptimizationSource_OptimizationSource_MAX = OptimizedFunctionGraph_OptimizationSource_JIT;
+constexpr int OptimizedFunctionGraph_OptimizationSource_OptimizationSource_ARRAYSIZE = OptimizedFunctionGraph_OptimizationSource_OptimizationSource_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* OptimizedFunctionGraph_OptimizationSource_descriptor();
+template<typename T>
+inline const std::string& OptimizedFunctionGraph_OptimizationSource_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, OptimizedFunctionGraph_OptimizationSource>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function OptimizedFunctionGraph_OptimizationSource_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    OptimizedFunctionGraph_OptimizationSource_descriptor(), enum_t_value);
+}
+inline bool OptimizedFunctionGraph_OptimizationSource_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, OptimizedFunctionGraph_OptimizationSource* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<OptimizedFunctionGraph_OptimizationSource>(
+    OptimizedFunctionGraph_OptimizationSource_descriptor(), name, value);
+}
+// ===================================================================
+
+class OptimizedFunctionGraph_NodeNameToControlRetEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<OptimizedFunctionGraph_NodeNameToControlRetEntry_DoNotUse, 
+    std::string, std::string,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING> {
+public:
+  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<OptimizedFunctionGraph_NodeNameToControlRetEntry_DoNotUse, 
+    std::string, std::string,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING> SuperType;
+  OptimizedFunctionGraph_NodeNameToControlRetEntry_DoNotUse();
+  explicit PROTOBUF_CONSTEXPR OptimizedFunctionGraph_NodeNameToControlRetEntry_DoNotUse(
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+  explicit OptimizedFunctionGraph_NodeNameToControlRetEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  void MergeFrom(const OptimizedFunctionGraph_NodeNameToControlRetEntry_DoNotUse& other);
+  static const OptimizedFunctionGraph_NodeNameToControlRetEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const OptimizedFunctionGraph_NodeNameToControlRetEntry_DoNotUse*>(&_OptimizedFunctionGraph_NodeNameToControlRetEntry_DoNotUse_default_instance_); }
+  static bool ValidateKey(std::string* s) {
+    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "tensorflow.OptimizedFunctionGraph.NodeNameToControlRetEntry.key");
+ }
+  static bool ValidateValue(std::string* s) {
+    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "tensorflow.OptimizedFunctionGraph.NodeNameToControlRetEntry.value");
+ }
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2foptimized_5ffunction_5fgraph_2eproto;
+};
+
+// -------------------------------------------------------------------
+
+class OptimizedFunctionGraph final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.OptimizedFunctionGraph) */ {
+ public:
+  inline OptimizedFunctionGraph() : OptimizedFunctionGraph(nullptr) {}
+  ~OptimizedFunctionGraph() override;
+  explicit PROTOBUF_CONSTEXPR OptimizedFunctionGraph(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  OptimizedFunctionGraph(const OptimizedFunctionGraph& from);
+  OptimizedFunctionGraph(OptimizedFunctionGraph&& from) noexcept
+    : OptimizedFunctionGraph() {
+    *this = ::std::move(from);
+  }
+
+  inline OptimizedFunctionGraph& operator=(const OptimizedFunctionGraph& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline OptimizedFunctionGraph& operator=(OptimizedFunctionGraph&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const OptimizedFunctionGraph& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const OptimizedFunctionGraph* internal_default_instance() {
+    return reinterpret_cast<const OptimizedFunctionGraph*>(
+               &_OptimizedFunctionGraph_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(OptimizedFunctionGraph& a, OptimizedFunctionGraph& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(OptimizedFunctionGraph* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(OptimizedFunctionGraph* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  OptimizedFunctionGraph* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<OptimizedFunctionGraph>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const OptimizedFunctionGraph& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const OptimizedFunctionGraph& from) {
+    OptimizedFunctionGraph::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(OptimizedFunctionGraph* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.OptimizedFunctionGraph";
+  }
+  protected:
+  explicit OptimizedFunctionGraph(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+
+  typedef OptimizedFunctionGraph_OptimizationSource OptimizationSource;
+  static constexpr OptimizationSource SOURCE_UNSPECIFIED =
+    OptimizedFunctionGraph_OptimizationSource_SOURCE_UNSPECIFIED;
+  static constexpr OptimizationSource AOT =
+    OptimizedFunctionGraph_OptimizationSource_AOT;
+  static constexpr OptimizationSource JIT =
+    OptimizedFunctionGraph_OptimizationSource_JIT;
+  static inline bool OptimizationSource_IsValid(int value) {
+    return OptimizedFunctionGraph_OptimizationSource_IsValid(value);
+  }
+  static constexpr OptimizationSource OptimizationSource_MIN =
+    OptimizedFunctionGraph_OptimizationSource_OptimizationSource_MIN;
+  static constexpr OptimizationSource OptimizationSource_MAX =
+    OptimizedFunctionGraph_OptimizationSource_OptimizationSource_MAX;
+  static constexpr int OptimizationSource_ARRAYSIZE =
+    OptimizedFunctionGraph_OptimizationSource_OptimizationSource_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  OptimizationSource_descriptor() {
+    return OptimizedFunctionGraph_OptimizationSource_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& OptimizationSource_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, OptimizationSource>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function OptimizationSource_Name.");
+    return OptimizedFunctionGraph_OptimizationSource_Name(enum_t_value);
+  }
+  static inline bool OptimizationSource_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      OptimizationSource* value) {
+    return OptimizedFunctionGraph_OptimizationSource_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNodeNameToControlRetFieldNumber = 3,
+    kRetTypesFieldNumber = 4,
+    kNameFieldNumber = 1,
+    kFunctionGraphFieldNumber = 2,
+    kNumReturnNodesFieldNumber = 5,
+    kSourceFieldNumber = 7,
+    kOptimizationTimeUsecsFieldNumber = 8,
+  };
+  // map<string, string> node_name_to_control_ret = 3;
+  int node_name_to_control_ret_size() const;
+  private:
+  int _internal_node_name_to_control_ret_size() const;
+  public:
+  void clear_node_name_to_control_ret();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
+      _internal_node_name_to_control_ret() const;
+  ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
+      _internal_mutable_node_name_to_control_ret();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
+      node_name_to_control_ret() const;
+  ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
+      mutable_node_name_to_control_ret();
+
+  // repeated .tensorflow.DataType ret_types = 4;
+  int ret_types_size() const;
+  private:
+  int _internal_ret_types_size() const;
+  public:
+  void clear_ret_types();
+  private:
+  ::tensorflow::DataType _internal_ret_types(int index) const;
+  void _internal_add_ret_types(::tensorflow::DataType value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_ret_types();
+  public:
+  ::tensorflow::DataType ret_types(int index) const;
+  void set_ret_types(int index, ::tensorflow::DataType value);
+  void add_ret_types(::tensorflow::DataType value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& ret_types() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_ret_types();
+
+  // string name = 1;
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // .tensorflow.GraphDef function_graph = 2;
+  bool has_function_graph() const;
+  private:
+  bool _internal_has_function_graph() const;
+  public:
+  void clear_function_graph();
+  const ::tensorflow::GraphDef& function_graph() const;
+  PROTOBUF_NODISCARD ::tensorflow::GraphDef* release_function_graph();
+  ::tensorflow::GraphDef* mutable_function_graph();
+  void set_allocated_function_graph(::tensorflow::GraphDef* function_graph);
+  private:
+  const ::tensorflow::GraphDef& _internal_function_graph() const;
+  ::tensorflow::GraphDef* _internal_mutable_function_graph();
+  public:
+  void unsafe_arena_set_allocated_function_graph(
+      ::tensorflow::GraphDef* function_graph);
+  ::tensorflow::GraphDef* unsafe_arena_release_function_graph();
+
+  // uint32 num_return_nodes = 5;
+  void clear_num_return_nodes();
+  uint32_t num_return_nodes() const;
+  void set_num_return_nodes(uint32_t value);
+  private:
+  uint32_t _internal_num_return_nodes() const;
+  void _internal_set_num_return_nodes(uint32_t value);
+  public:
+
+  // optional .tensorflow.OptimizedFunctionGraph.OptimizationSource source = 7;
+  bool has_source() const;
+  private:
+  bool _internal_has_source() const;
+  public:
+  void clear_source();
+  ::tensorflow::OptimizedFunctionGraph_OptimizationSource source() const;
+  void set_source(::tensorflow::OptimizedFunctionGraph_OptimizationSource value);
+  private:
+  ::tensorflow::OptimizedFunctionGraph_OptimizationSource _internal_source() const;
+  void _internal_set_source(::tensorflow::OptimizedFunctionGraph_OptimizationSource value);
+  public:
+
+  // optional uint64 optimization_time_usecs = 8;
+  bool has_optimization_time_usecs() const;
+  private:
+  bool _internal_has_optimization_time_usecs() const;
+  public:
+  void clear_optimization_time_usecs();
+  uint64_t optimization_time_usecs() const;
+  void set_optimization_time_usecs(uint64_t value);
+  private:
+  uint64_t _internal_optimization_time_usecs() const;
+  void _internal_set_optimization_time_usecs(uint64_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.OptimizedFunctionGraph)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::MapField<
+        OptimizedFunctionGraph_NodeNameToControlRetEntry_DoNotUse,
+        std::string, std::string,
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING> node_name_to_control_ret_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField<int> ret_types_;
+    mutable std::atomic<int> _ret_types_cached_byte_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+    ::tensorflow::GraphDef* function_graph_;
+    uint32_t num_return_nodes_;
+    int source_;
+    uint64_t optimization_time_usecs_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2foptimized_5ffunction_5fgraph_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// OptimizedFunctionGraph
+
+// string name = 1;
+inline void OptimizedFunctionGraph::clear_name() {
+  _impl_.name_.ClearToEmpty();
+}
+inline const std::string& OptimizedFunctionGraph::name() const {
+  // @@protoc_insertion_point(field_get:tensorflow.OptimizedFunctionGraph.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void OptimizedFunctionGraph::set_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.OptimizedFunctionGraph.name)
+}
+inline std::string* OptimizedFunctionGraph::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:tensorflow.OptimizedFunctionGraph.name)
+  return _s;
+}
+inline const std::string& OptimizedFunctionGraph::_internal_name() const {
+  return _impl_.name_.Get();
+}
+inline void OptimizedFunctionGraph::_internal_set_name(const std::string& value) {
+  
+  _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* OptimizedFunctionGraph::_internal_mutable_name() {
+  
+  return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* OptimizedFunctionGraph::release_name() {
+  // @@protoc_insertion_point(field_release:tensorflow.OptimizedFunctionGraph.name)
+  return _impl_.name_.Release();
+}
+inline void OptimizedFunctionGraph::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.OptimizedFunctionGraph.name)
+}
+
+// .tensorflow.GraphDef function_graph = 2;
+inline bool OptimizedFunctionGraph::_internal_has_function_graph() const {
+  return this != internal_default_instance() && _impl_.function_graph_ != nullptr;
+}
+inline bool OptimizedFunctionGraph::has_function_graph() const {
+  return _internal_has_function_graph();
+}
+inline const ::tensorflow::GraphDef& OptimizedFunctionGraph::_internal_function_graph() const {
+  const ::tensorflow::GraphDef* p = _impl_.function_graph_;
+  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::GraphDef&>(
+      ::tensorflow::_GraphDef_default_instance_);
+}
+inline const ::tensorflow::GraphDef& OptimizedFunctionGraph::function_graph() const {
+  // @@protoc_insertion_point(field_get:tensorflow.OptimizedFunctionGraph.function_graph)
+  return _internal_function_graph();
+}
+inline void OptimizedFunctionGraph::unsafe_arena_set_allocated_function_graph(
+    ::tensorflow::GraphDef* function_graph) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.function_graph_);
+  }
+  _impl_.function_graph_ = function_graph;
+  if (function_graph) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.OptimizedFunctionGraph.function_graph)
+}
+inline ::tensorflow::GraphDef* OptimizedFunctionGraph::release_function_graph() {
+  
+  ::tensorflow::GraphDef* temp = _impl_.function_graph_;
+  _impl_.function_graph_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::tensorflow::GraphDef* OptimizedFunctionGraph::unsafe_arena_release_function_graph() {
+  // @@protoc_insertion_point(field_release:tensorflow.OptimizedFunctionGraph.function_graph)
+  
+  ::tensorflow::GraphDef* temp = _impl_.function_graph_;
+  _impl_.function_graph_ = nullptr;
+  return temp;
+}
+inline ::tensorflow::GraphDef* OptimizedFunctionGraph::_internal_mutable_function_graph() {
+  
+  if (_impl_.function_graph_ == nullptr) {
+    auto* p = CreateMaybeMessage<::tensorflow::GraphDef>(GetArenaForAllocation());
+    _impl_.function_graph_ = p;
+  }
+  return _impl_.function_graph_;
+}
+inline ::tensorflow::GraphDef* OptimizedFunctionGraph::mutable_function_graph() {
+  ::tensorflow::GraphDef* _msg = _internal_mutable_function_graph();
+  // @@protoc_insertion_point(field_mutable:tensorflow.OptimizedFunctionGraph.function_graph)
+  return _msg;
+}
+inline void OptimizedFunctionGraph::set_allocated_function_graph(::tensorflow::GraphDef* function_graph) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.function_graph_);
+  }
+  if (function_graph) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(function_graph));
+    if (message_arena != submessage_arena) {
+      function_graph = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, function_graph, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.function_graph_ = function_graph;
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.OptimizedFunctionGraph.function_graph)
+}
+
+// map<string, string> node_name_to_control_ret = 3;
+inline int OptimizedFunctionGraph::_internal_node_name_to_control_ret_size() const {
+  return _impl_.node_name_to_control_ret_.size();
+}
+inline int OptimizedFunctionGraph::node_name_to_control_ret_size() const {
+  return _internal_node_name_to_control_ret_size();
+}
+inline void OptimizedFunctionGraph::clear_node_name_to_control_ret() {
+  _impl_.node_name_to_control_ret_.Clear();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
+OptimizedFunctionGraph::_internal_node_name_to_control_ret() const {
+  return _impl_.node_name_to_control_ret_.GetMap();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
+OptimizedFunctionGraph::node_name_to_control_ret() const {
+  // @@protoc_insertion_point(field_map:tensorflow.OptimizedFunctionGraph.node_name_to_control_ret)
+  return _internal_node_name_to_control_ret();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
+OptimizedFunctionGraph::_internal_mutable_node_name_to_control_ret() {
+  return _impl_.node_name_to_control_ret_.MutableMap();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
+OptimizedFunctionGraph::mutable_node_name_to_control_ret() {
+  // @@protoc_insertion_point(field_mutable_map:tensorflow.OptimizedFunctionGraph.node_name_to_control_ret)
+  return _internal_mutable_node_name_to_control_ret();
+}
+
+// repeated .tensorflow.DataType ret_types = 4;
+inline int OptimizedFunctionGraph::_internal_ret_types_size() const {
+  return _impl_.ret_types_.size();
+}
+inline int OptimizedFunctionGraph::ret_types_size() const {
+  return _internal_ret_types_size();
+}
+inline void OptimizedFunctionGraph::clear_ret_types() {
+  _impl_.ret_types_.Clear();
+}
+inline ::tensorflow::DataType OptimizedFunctionGraph::_internal_ret_types(int index) const {
+  return static_cast< ::tensorflow::DataType >(_impl_.ret_types_.Get(index));
+}
+inline ::tensorflow::DataType OptimizedFunctionGraph::ret_types(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.OptimizedFunctionGraph.ret_types)
+  return _internal_ret_types(index);
+}
+inline void OptimizedFunctionGraph::set_ret_types(int index, ::tensorflow::DataType value) {
+  _impl_.ret_types_.Set(index, value);
+  // @@protoc_insertion_point(field_set:tensorflow.OptimizedFunctionGraph.ret_types)
+}
+inline void OptimizedFunctionGraph::_internal_add_ret_types(::tensorflow::DataType value) {
+  _impl_.ret_types_.Add(value);
+}
+inline void OptimizedFunctionGraph::add_ret_types(::tensorflow::DataType value) {
+  _internal_add_ret_types(value);
+  // @@protoc_insertion_point(field_add:tensorflow.OptimizedFunctionGraph.ret_types)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
+OptimizedFunctionGraph::ret_types() const {
+  // @@protoc_insertion_point(field_list:tensorflow.OptimizedFunctionGraph.ret_types)
+  return _impl_.ret_types_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
+OptimizedFunctionGraph::_internal_mutable_ret_types() {
+  return &_impl_.ret_types_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
+OptimizedFunctionGraph::mutable_ret_types() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.OptimizedFunctionGraph.ret_types)
+  return _internal_mutable_ret_types();
+}
+
+// uint32 num_return_nodes = 5;
+inline void OptimizedFunctionGraph::clear_num_return_nodes() {
+  _impl_.num_return_nodes_ = 0u;
+}
+inline uint32_t OptimizedFunctionGraph::_internal_num_return_nodes() const {
+  return _impl_.num_return_nodes_;
+}
+inline uint32_t OptimizedFunctionGraph::num_return_nodes() const {
+  // @@protoc_insertion_point(field_get:tensorflow.OptimizedFunctionGraph.num_return_nodes)
+  return _internal_num_return_nodes();
+}
+inline void OptimizedFunctionGraph::_internal_set_num_return_nodes(uint32_t value) {
+  
+  _impl_.num_return_nodes_ = value;
+}
+inline void OptimizedFunctionGraph::set_num_return_nodes(uint32_t value) {
+  _internal_set_num_return_nodes(value);
+  // @@protoc_insertion_point(field_set:tensorflow.OptimizedFunctionGraph.num_return_nodes)
+}
+
+// optional .tensorflow.OptimizedFunctionGraph.OptimizationSource source = 7;
+inline bool OptimizedFunctionGraph::_internal_has_source() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool OptimizedFunctionGraph::has_source() const {
+  return _internal_has_source();
+}
+inline void OptimizedFunctionGraph::clear_source() {
+  _impl_.source_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline ::tensorflow::OptimizedFunctionGraph_OptimizationSource OptimizedFunctionGraph::_internal_source() const {
+  return static_cast< ::tensorflow::OptimizedFunctionGraph_OptimizationSource >(_impl_.source_);
+}
+inline ::tensorflow::OptimizedFunctionGraph_OptimizationSource OptimizedFunctionGraph::source() const {
+  // @@protoc_insertion_point(field_get:tensorflow.OptimizedFunctionGraph.source)
+  return _internal_source();
+}
+inline void OptimizedFunctionGraph::_internal_set_source(::tensorflow::OptimizedFunctionGraph_OptimizationSource value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.source_ = value;
+}
+inline void OptimizedFunctionGraph::set_source(::tensorflow::OptimizedFunctionGraph_OptimizationSource value) {
+  _internal_set_source(value);
+  // @@protoc_insertion_point(field_set:tensorflow.OptimizedFunctionGraph.source)
+}
+
+// optional uint64 optimization_time_usecs = 8;
+inline bool OptimizedFunctionGraph::_internal_has_optimization_time_usecs() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool OptimizedFunctionGraph::has_optimization_time_usecs() const {
+  return _internal_has_optimization_time_usecs();
+}
+inline void OptimizedFunctionGraph::clear_optimization_time_usecs() {
+  _impl_.optimization_time_usecs_ = uint64_t{0u};
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline uint64_t OptimizedFunctionGraph::_internal_optimization_time_usecs() const {
+  return _impl_.optimization_time_usecs_;
+}
+inline uint64_t OptimizedFunctionGraph::optimization_time_usecs() const {
+  // @@protoc_insertion_point(field_get:tensorflow.OptimizedFunctionGraph.optimization_time_usecs)
+  return _internal_optimization_time_usecs();
+}
+inline void OptimizedFunctionGraph::_internal_set_optimization_time_usecs(uint64_t value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.optimization_time_usecs_ = value;
+}
+inline void OptimizedFunctionGraph::set_optimization_time_usecs(uint64_t value) {
+  _internal_set_optimization_time_usecs(value);
+  // @@protoc_insertion_point(field_set:tensorflow.OptimizedFunctionGraph.optimization_time_usecs)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace tensorflow
+
+PROTOBUF_NAMESPACE_OPEN
+
+template <> struct is_proto_enum< ::tensorflow::OptimizedFunctionGraph_OptimizationSource> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::tensorflow::OptimizedFunctionGraph_OptimizationSource>() {
+  return ::tensorflow::OptimizedFunctionGraph_OptimizationSource_descriptor();
+}
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2foptimized_5ffunction_5fgraph_2eproto
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/optimized_function_graph.proto b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/optimized_function_graph.proto
new file mode 100644
index 0000000000000000000000000000000000000000..25008f0ead2aaca72d649cf3fc7da8ece1aea633
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/optimized_function_graph.proto
@@ -0,0 +1,48 @@
+syntax = "proto3";
+
+package tensorflow;
+
+import "tensorflow/core/framework/graph.proto";
+import "tensorflow/core/framework/types.proto";
+
+// Optimized function graph after instantiation-related graph optimization
+// passes (up till before graph partitioning). The first half of the proto is
+// representing a GraphDef and the rest of the fields are extra information from
+// graph optimizations.
+message OptimizedFunctionGraph {
+  // Function name. It can be a human-readable SignatureDef's method name, or a
+  // FunctionDef name.
+  string name = 1;
+  // Optimized function graph.
+  GraphDef function_graph = 2;
+  // Maps from node name to control ret. This is an output from running TF/XLA
+  // bridge.
+  map<string, string> node_name_to_control_ret = 3;
+  // Return node types of the function. This is an output of graph
+  // preprocessing.
+  repeated DataType ret_types = 4;
+  // Number of return nodes. This is an output of graph preprocessing.
+  uint32 num_return_nodes = 5;
+
+  reserved 6;
+
+  // Enum for distinguishing the origin where the proto is created.
+  //
+  // AOT: proto is created in ahead-of-time environment, which can be different
+  // from the environment where the graph is actually executed.
+  //
+  // JIT: proto is created in just-in-time execution, which has the same
+  // environment as the one the graph is actually executed.
+  enum OptimizationSource {
+    SOURCE_UNSPECIFIED = 0;
+    AOT = 1;
+    JIT = 2;
+  }
+
+  // Indicates the source environment where this proto is generated.
+  optional OptimizationSource source = 7;
+
+  // Time (in microseconds) spent on running the graph optimization passes for
+  // this function.
+  optional uint64 optimization_time_usecs = 8;
+}
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/partial_tensor_shape.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/partial_tensor_shape.h
new file mode 100644
index 0000000000000000000000000000000000000000..fa1ce07dd43a462fbe856aca1032a88259248b21
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/partial_tensor_shape.h
@@ -0,0 +1,22 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_PARTIAL_TENSOR_SHAPE_H_
+#define TENSORFLOW_CORE_FRAMEWORK_PARTIAL_TENSOR_SHAPE_H_
+
+// TODO(irving): Remove this forwarding header
+#include "tensorflow/core/framework/tensor_shape.h"
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_PARTIAL_TENSOR_SHAPE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/queue_interface.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/queue_interface.h
new file mode 100644
index 0000000000000000000000000000000000000000..9395cce1644f7e8fd09cf40a48b2d7a5abb30bb2
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/queue_interface.h
@@ -0,0 +1,102 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_QUEUE_INTERFACE_H_
+#define TENSORFLOW_CORE_FRAMEWORK_QUEUE_INTERFACE_H_
+
+#include <string>
+#include <vector>
+
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/resource_mgr.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+
+// All implementations must be thread-safe.
+class QueueInterface : public ResourceBase {
+ public:
+  typedef std::vector<Tensor> Tuple;
+  typedef AsyncOpKernel::DoneCallback DoneCallback;
+  typedef std::function<void(const Tuple&)> CallbackWithTuple;
+
+  virtual Status ValidateTuple(const Tuple& tuple) = 0;
+  virtual Status ValidateManyTuple(const Tuple& tuple) = 0;
+
+  // Stashes a function object for future execution, that will eventually
+  // enqueue the tuple of tensors into the queue, and returns immediately. The
+  // function object is guaranteed to call 'callback'.
+  virtual void TryEnqueue(const Tuple& tuple, OpKernelContext* ctx,
+                          DoneCallback callback) = 0;
+
+  // Same as above, but the component tensors are sliced along the 0th dimension
+  // to make multiple queue-element components.
+  virtual void TryEnqueueMany(const Tuple& tuple, OpKernelContext* ctx,
+                              DoneCallback callback) = 0;
+
+  // Stashes a function object for future execution, that will eventually
+  // dequeue an element from the queue and call 'callback' with that tuple
+  // element as argument.
+  virtual void TryDequeue(OpKernelContext* ctx, CallbackWithTuple callback) = 0;
+
+  // Same as above, but the stashed function object will attempt to dequeue
+  // num_elements items.  If allow_small_batch is true, and the Queue is
+  // closed but at least 1 element is available, there is no blocking
+  // and between 1 and num_elements items are immediately returned.
+  // If the queue does not support the allow_small_batch flag will
+  // return an Unimplemented error.
+  virtual void TryDequeueMany(int num_elements, OpKernelContext* ctx,
+                              bool allow_small_batch,
+                              CallbackWithTuple callback) = 0;
+
+  // Signals that no more elements will be enqueued, and optionally
+  // cancels pending Enqueue(Many) operations.
+  //
+  // After calling this function, subsequent calls to Enqueue(Many)
+  // will fail. If `cancel_pending_enqueues` is true, all pending
+  // calls to Enqueue(Many) will fail as well.
+  //
+  // After calling this function, all current and subsequent calls to
+  // Dequeue(Many) will fail instead of blocking (though they may
+  // succeed if they can be satisfied by the elements in the queue at
+  // the time it was closed).
+  virtual void Close(OpKernelContext* ctx, bool cancel_pending_enqueues,
+                     DoneCallback callback) = 0;
+
+  // Returns true if a given queue is closed and false if it is open.
+  virtual bool is_closed() const = 0;
+
+  // Assuming *this represents a shared queue, verify that it matches
+  // another instantiation indicated by node_def.
+  virtual Status MatchesNodeDef(const NodeDef& node_def) = 0;
+
+  // Returns the number of elements in the queue.
+  virtual int32 size() const = 0;
+
+  virtual const DataTypeVector& component_dtypes() const = 0;
+
+  string DebugString() const override {
+    return strings::StrCat("A Queue of size: ", size());
+  }
+
+ protected:
+  virtual ~QueueInterface() {}
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_QUEUE_INTERFACE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/reader_base.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/reader_base.h
new file mode 100644
index 0000000000000000000000000000000000000000..8f4e347e09aa99fcdb9f645f238ae6ce9e4c88bc
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/reader_base.h
@@ -0,0 +1,138 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_READER_BASE_H_
+#define TENSORFLOW_CORE_FRAMEWORK_READER_BASE_H_
+
+#include <memory>
+#include <string>
+#include "tensorflow/core/framework/queue_interface.h"
+#include "tensorflow/core/framework/reader_interface.h"
+#include "tensorflow/core/lib/core/stringpiece.h"
+
+namespace tensorflow {
+
+class ReaderBaseState;
+
+// Default implementation of ReaderInterface.
+class ReaderBase : public ReaderInterface {
+ public:
+  // name: For use in error messages, should mention both the name of
+  // the op and the node.
+  explicit ReaderBase(const string& name);
+
+  // Note that methods with names ending in "Locked" are called while
+  // the ReaderBase's mutex is held.
+
+  // Implement this function in descendants -----------------------------------
+
+  // Produce the next key/value pair from the current work item.
+  // This is called "Locked" since it is executed under a mutex
+  // that serializes all Reader calls.
+  // Usage:
+  //  a) If a record was successfully produced, set *produced = true,
+  //  and fill in *key and *value.
+  //  b) If no more records will be produced for this work item, set
+  //  *at_end = true.
+  //  c) If a record was produced, but no more will be produced, you
+  //     may either do both (a) and (b), or do (a) in this call and do (b) in
+  //     the next call to ReadLocked().
+  //  d) If there was an error producing (e.g. an error reading the file,
+  //     data corruption), return a non-OK() status.  ReadLocked may be
+  //     called again if the user reruns this part of the graph.
+  virtual Status ReadLocked(tstring* key, tstring* value, bool* produced,
+                            bool* at_end) = 0;
+
+  // Descendants may optionally implement these -------------------------------
+
+  // Produce up to num_records next key/value pairs from the current
+  // work item, in the same manner of ReadLocked.
+  virtual Status ReadUpToLocked(int64_t num_records, std::vector<tstring>* keys,
+                                std::vector<tstring>* values, int64_t* num_read,
+                                bool* at_end);
+
+  // Called when work starts / finishes.
+  virtual Status OnWorkStartedLocked() { return OkStatus(); }
+  virtual Status OnWorkFinishedLocked() { return OkStatus(); }
+
+  // Called to reset the Reader to a newly constructed state.
+  virtual Status ResetLocked();
+
+  // Default implementation generates an Unimplemented error.
+  // See the protected helper methods below.
+  virtual Status SerializeStateLocked(tstring* state);
+  virtual Status RestoreStateLocked(const tstring& state);
+
+  // Accessors ----------------------------------------------------------------
+
+  // Always true during a call to ReadLocked().
+  bool work_in_progress() const { return work_finished_ < work_started_; }
+
+  // Returns the name of the current work item (valid if
+  // work_in_progress() returns true).  May change between calls to
+  // ReadLocked().
+  const tstring& current_work() const { return work_; }
+
+  // What was passed to the constructor.
+  const string& name() const { return name_; }
+
+  // Produce the key name (from current_work and the actual key).
+  tstring KeyName(const tstring& key) const;
+
+ protected:
+  // For descendants wishing to implement serialize & restore state.
+
+  // Writes ReaderBase state to *state.
+  void SaveBaseState(ReaderBaseState* state) const;
+
+  // Restores ReaderBase state from state. Assumes state was filled
+  // using SaveBaseState() above.
+  Status RestoreBaseState(const ReaderBaseState& state);
+
+ private:
+  // For descendants that wish to obtain the next work item in a different way.
+  // For implementing Read().  Dequeues the next work item from
+  // *queue, and if successful returns "work" (a string). May block.
+  virtual string GetNextWorkLocked(QueueInterface* queue,
+                                   OpKernelContext* context) const;
+
+  // Implementations of ReaderInterface methods.  These ensure thread-safety
+  // and call the methods above to do the work.
+  void Read(QueueInterface* queue, tstring* key, tstring* value,
+            OpKernelContext* context) override;
+
+  // Produces up to num_records.
+  // In this implementation all the records come from the same work unit.
+  int64_t ReadUpTo(const int64_t num_records, QueueInterface* queue,
+                   std::vector<tstring>* keys, std::vector<tstring>* value,
+                   OpKernelContext* context) override;
+
+  Status Reset() override;
+  int64_t NumRecordsProduced() override;
+  int64_t NumWorkUnitsCompleted() override;
+  Status SerializeState(tstring* state) override;
+  Status RestoreState(const tstring& state) override;
+
+  mutable mutex mu_;
+  const string name_;
+  int64_t work_started_ = 0;
+  int64_t work_finished_ = 0;
+  int64_t num_records_produced_ = 0;
+  tstring work_;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_READER_BASE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/reader_base.pb.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/reader_base.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..e6681d56eaff04699ce016dbab3c51456de805c8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/reader_base.pb.h
@@ -0,0 +1,375 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: tensorflow/core/framework/reader_base.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2freader_5fbase_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2freader_5fbase_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3021000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3021009 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_tensorflow_2fcore_2fframework_2freader_5fbase_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_tensorflow_2fcore_2fframework_2freader_5fbase_2eproto {
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_tensorflow_2fcore_2fframework_2freader_5fbase_2eproto;
+namespace tensorflow {
+class ReaderBaseState;
+struct ReaderBaseStateDefaultTypeInternal;
+extern ReaderBaseStateDefaultTypeInternal _ReaderBaseState_default_instance_;
+}  // namespace tensorflow
+PROTOBUF_NAMESPACE_OPEN
+template<> ::tensorflow::ReaderBaseState* Arena::CreateMaybeMessage<::tensorflow::ReaderBaseState>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace tensorflow {
+
+// ===================================================================
+
+class ReaderBaseState final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.ReaderBaseState) */ {
+ public:
+  inline ReaderBaseState() : ReaderBaseState(nullptr) {}
+  ~ReaderBaseState() override;
+  explicit PROTOBUF_CONSTEXPR ReaderBaseState(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ReaderBaseState(const ReaderBaseState& from);
+  ReaderBaseState(ReaderBaseState&& from) noexcept
+    : ReaderBaseState() {
+    *this = ::std::move(from);
+  }
+
+  inline ReaderBaseState& operator=(const ReaderBaseState& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ReaderBaseState& operator=(ReaderBaseState&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ReaderBaseState& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ReaderBaseState* internal_default_instance() {
+    return reinterpret_cast<const ReaderBaseState*>(
+               &_ReaderBaseState_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(ReaderBaseState& a, ReaderBaseState& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ReaderBaseState* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ReaderBaseState* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ReaderBaseState* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ReaderBaseState>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ReaderBaseState& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const ReaderBaseState& from) {
+    ReaderBaseState::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ReaderBaseState* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.ReaderBaseState";
+  }
+  protected:
+  explicit ReaderBaseState(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kCurrentWorkFieldNumber = 4,
+    kWorkStartedFieldNumber = 1,
+    kWorkFinishedFieldNumber = 2,
+    kNumRecordsProducedFieldNumber = 3,
+  };
+  // bytes current_work = 4;
+  void clear_current_work();
+  const std::string& current_work() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_current_work(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_current_work();
+  PROTOBUF_NODISCARD std::string* release_current_work();
+  void set_allocated_current_work(std::string* current_work);
+  private:
+  const std::string& _internal_current_work() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_current_work(const std::string& value);
+  std::string* _internal_mutable_current_work();
+  public:
+
+  // int64 work_started = 1;
+  void clear_work_started();
+  int64_t work_started() const;
+  void set_work_started(int64_t value);
+  private:
+  int64_t _internal_work_started() const;
+  void _internal_set_work_started(int64_t value);
+  public:
+
+  // int64 work_finished = 2;
+  void clear_work_finished();
+  int64_t work_finished() const;
+  void set_work_finished(int64_t value);
+  private:
+  int64_t _internal_work_finished() const;
+  void _internal_set_work_finished(int64_t value);
+  public:
+
+  // int64 num_records_produced = 3;
+  void clear_num_records_produced();
+  int64_t num_records_produced() const;
+  void set_num_records_produced(int64_t value);
+  private:
+  int64_t _internal_num_records_produced() const;
+  void _internal_set_num_records_produced(int64_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.ReaderBaseState)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr current_work_;
+    int64_t work_started_;
+    int64_t work_finished_;
+    int64_t num_records_produced_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2freader_5fbase_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// ReaderBaseState
+
+// int64 work_started = 1;
+inline void ReaderBaseState::clear_work_started() {
+  _impl_.work_started_ = int64_t{0};
+}
+inline int64_t ReaderBaseState::_internal_work_started() const {
+  return _impl_.work_started_;
+}
+inline int64_t ReaderBaseState::work_started() const {
+  // @@protoc_insertion_point(field_get:tensorflow.ReaderBaseState.work_started)
+  return _internal_work_started();
+}
+inline void ReaderBaseState::_internal_set_work_started(int64_t value) {
+  
+  _impl_.work_started_ = value;
+}
+inline void ReaderBaseState::set_work_started(int64_t value) {
+  _internal_set_work_started(value);
+  // @@protoc_insertion_point(field_set:tensorflow.ReaderBaseState.work_started)
+}
+
+// int64 work_finished = 2;
+inline void ReaderBaseState::clear_work_finished() {
+  _impl_.work_finished_ = int64_t{0};
+}
+inline int64_t ReaderBaseState::_internal_work_finished() const {
+  return _impl_.work_finished_;
+}
+inline int64_t ReaderBaseState::work_finished() const {
+  // @@protoc_insertion_point(field_get:tensorflow.ReaderBaseState.work_finished)
+  return _internal_work_finished();
+}
+inline void ReaderBaseState::_internal_set_work_finished(int64_t value) {
+  
+  _impl_.work_finished_ = value;
+}
+inline void ReaderBaseState::set_work_finished(int64_t value) {
+  _internal_set_work_finished(value);
+  // @@protoc_insertion_point(field_set:tensorflow.ReaderBaseState.work_finished)
+}
+
+// int64 num_records_produced = 3;
+inline void ReaderBaseState::clear_num_records_produced() {
+  _impl_.num_records_produced_ = int64_t{0};
+}
+inline int64_t ReaderBaseState::_internal_num_records_produced() const {
+  return _impl_.num_records_produced_;
+}
+inline int64_t ReaderBaseState::num_records_produced() const {
+  // @@protoc_insertion_point(field_get:tensorflow.ReaderBaseState.num_records_produced)
+  return _internal_num_records_produced();
+}
+inline void ReaderBaseState::_internal_set_num_records_produced(int64_t value) {
+  
+  _impl_.num_records_produced_ = value;
+}
+inline void ReaderBaseState::set_num_records_produced(int64_t value) {
+  _internal_set_num_records_produced(value);
+  // @@protoc_insertion_point(field_set:tensorflow.ReaderBaseState.num_records_produced)
+}
+
+// bytes current_work = 4;
+inline void ReaderBaseState::clear_current_work() {
+  _impl_.current_work_.ClearToEmpty();
+}
+inline const std::string& ReaderBaseState::current_work() const {
+  // @@protoc_insertion_point(field_get:tensorflow.ReaderBaseState.current_work)
+  return _internal_current_work();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ReaderBaseState::set_current_work(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.current_work_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.ReaderBaseState.current_work)
+}
+inline std::string* ReaderBaseState::mutable_current_work() {
+  std::string* _s = _internal_mutable_current_work();
+  // @@protoc_insertion_point(field_mutable:tensorflow.ReaderBaseState.current_work)
+  return _s;
+}
+inline const std::string& ReaderBaseState::_internal_current_work() const {
+  return _impl_.current_work_.Get();
+}
+inline void ReaderBaseState::_internal_set_current_work(const std::string& value) {
+  
+  _impl_.current_work_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ReaderBaseState::_internal_mutable_current_work() {
+  
+  return _impl_.current_work_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ReaderBaseState::release_current_work() {
+  // @@protoc_insertion_point(field_release:tensorflow.ReaderBaseState.current_work)
+  return _impl_.current_work_.Release();
+}
+inline void ReaderBaseState::set_allocated_current_work(std::string* current_work) {
+  if (current_work != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.current_work_.SetAllocated(current_work, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.current_work_.IsDefault()) {
+    _impl_.current_work_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.ReaderBaseState.current_work)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace tensorflow
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2freader_5fbase_2eproto
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/reader_base.proto b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/reader_base.proto
new file mode 100644
index 0000000000000000000000000000000000000000..6fae310248dd4017bb372af27cc807133222ecc9
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/reader_base.proto
@@ -0,0 +1,18 @@
+syntax = "proto3";
+
+package tensorflow;
+
+option cc_enable_arenas = true;
+option java_outer_classname = "ReaderBaseProtos";
+option java_multiple_files = true;
+option java_package = "org.tensorflow.framework";
+option go_package = "github.com/tensorflow/tensorflow/tensorflow/go/core/framework/reader_base_go_proto";
+
+// For serializing and restoring the state of ReaderBase, see
+// reader_base.h for details.
+message ReaderBaseState {
+  int64 work_started = 1;
+  int64 work_finished = 2;
+  int64 num_records_produced = 3;
+  bytes current_work = 4;
+}
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/reader_interface.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/reader_interface.h
new file mode 100644
index 0000000000000000000000000000000000000000..e3d7e7e62ade5096db292e4e83970e576bb829dd
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/reader_interface.h
@@ -0,0 +1,88 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_READER_INTERFACE_H_
+#define TENSORFLOW_CORE_FRAMEWORK_READER_INTERFACE_H_
+
+#include <memory>
+#include <string>
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/resource_mgr.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+
+class QueueInterface;
+class ReaderInterface;
+
+// Readers are the mechanism for reading records from files in
+// TensorFlow graphs.  Each supported file format has a corresponding
+// ReaderInterface descendant and a corresponding Op & OpKernel
+// (implemented using ReaderOpKernel from reader_op_kernel.h).
+//
+// To use a Reader, you first encode "work" (some string, typically a
+// filename) in the Reader's "work queue".  It then processes the
+// "work" (reading records from the file), to produce key/value
+// strings.  The methods of this class are called by ReaderFoo ops,
+// so see ../ops/io_ops.cc for detailed descriptions.
+//
+// All descendants of this class must be thread-safe.
+class ReaderInterface : public ResourceBase {
+ public:
+  // Read a single record into *key / *value.  May get more work from
+  // *queue if the current work is complete.  Sets the status on
+  // *context with an OutOfRange Status if the current work is
+  // complete and the queue is done (closed and empty).
+  // This method may block.
+  virtual void Read(QueueInterface* queue, tstring* key, tstring* value,
+                    OpKernelContext* context) = 0;
+
+  // Read up to num_records records into keys / values. May get more work from
+  // *queue if the current work is complete.  Sets the status on
+  // *context with an OutOfRange Status if the current work is
+  // complete and the queue is done (closed and empty).
+  // This method may block.
+  // The std::vector keys/value pointers are assumed to point to empty
+  // structures (that have most likely been reserve(num_records)).
+  // Returns how many records were actually read.
+  virtual int64_t ReadUpTo(const int64_t num_records, QueueInterface* queue,
+                           std::vector<tstring>* keys,
+                           std::vector<tstring>* value,
+                           OpKernelContext* context) = 0;
+
+  // Restore this reader to its newly-constructed state.
+  virtual Status Reset() = 0;
+
+  // Accessors
+  virtual int64_t NumRecordsProduced() = 0;
+  virtual int64_t NumWorkUnitsCompleted() = 0;
+
+  // -- Serialization/Restoration support --
+  // Not all readers will support saving and restoring state.
+  virtual Status SerializeState(tstring* state) = 0;
+  // Note: Must Reset on error.
+  virtual Status RestoreState(const tstring& state) = 0;
+
+  string DebugString() const override { return "a reader"; }
+
+ protected:
+  virtual ~ReaderInterface() {}
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_READER_INTERFACE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/reader_op_kernel.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/reader_op_kernel.h
new file mode 100644
index 0000000000000000000000000000000000000000..36f59717e0e9dbca6e84058c11a4ad5cb55658d9
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/reader_op_kernel.h
@@ -0,0 +1,87 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_READER_OP_KERNEL_H_
+#define TENSORFLOW_CORE_FRAMEWORK_READER_OP_KERNEL_H_
+
+#include <functional>
+#include <string>
+
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/reader_interface.h"
+#include "tensorflow/core/framework/resource_mgr.h"
+#include "tensorflow/core/framework/resource_op_kernel.h"
+#include "tensorflow/core/platform/mutex.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+
+// NOTE: This is now a very thin layer over ResourceOpKernel.
+// TODO(sjhwang): Remove dependencies to this class, then delete this.
+
+// Implementation for ops providing a Reader.
+class ReaderOpKernel : public ResourceOpKernel<ReaderInterface> {
+ public:
+  using ResourceOpKernel::ResourceOpKernel;
+
+  // Must be called by descendants before the first call to Compute() (typically
+  // called during construction).  factory must return a ReaderInterface
+  // descendant allocated with new that ReaderOpKernel will take ownership of.
+  void SetReaderFactory(std::function<ReaderInterface*()> factory)
+      TF_LOCKS_EXCLUDED(mu_) {
+    DCHECK(get_resource() == nullptr);
+    mutex_lock l(mu_);
+    factory_ = factory;
+  }
+
+  void Compute(OpKernelContext* context) override {
+    if (!IsCancellable()) {
+      ResourceOpKernel<ReaderInterface>::Compute(context);
+    } else {
+      // Install cancellation
+      CancellationManager* cm = context->cancellation_manager();
+      CancellationToken token = cm->get_cancellation_token();
+      bool already_cancelled =
+          !cm->RegisterCallback(token, [this]() { this->Cancel(); });
+
+      if (!already_cancelled) {
+        ResourceOpKernel<ReaderInterface>::Compute(context);
+      } else {
+        context->SetStatus(errors::Cancelled("read operation was cancelled"));
+      }
+    }
+  }
+
+ private:
+  virtual bool IsCancellable() const { return false; }
+  virtual void Cancel() {}
+
+  Status CreateResource(ReaderInterface** reader)
+      TF_EXCLUSIVE_LOCKS_REQUIRED(mu_) override {
+    *reader = factory_();
+    if (*reader == nullptr) {
+      return errors::ResourceExhausted("Failed to allocate reader");
+    }
+    std::function<ReaderInterface*()> temp = nullptr;
+    factory_.swap(temp);
+    return OkStatus();
+  }
+
+  std::function<ReaderInterface*()> factory_ TF_GUARDED_BY(mu_);
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_READER_OP_KERNEL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/ref_var.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/ref_var.h
new file mode 100644
index 0000000000000000000000000000000000000000..8e423e81c6523359de06209968ef587cd266d4d2
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/ref_var.h
@@ -0,0 +1,31 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_REF_VAR_H_
+#define TENSORFLOW_CORE_FRAMEWORK_REF_VAR_H_
+
+#include <functional>
+
+namespace tensorflow {
+class OpKernelContext;
+
+void AssignRefVariable(
+    OpKernelContext* context, int input_ref_index, int output_ref_index,
+    int value_index, bool use_locking, bool validate_shape,
+    bool relax_constraints,
+    std::function<void(OpKernelContext*, Tensor*, const Tensor&)> copy);
+}  //  end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_REF_VAR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/register_types.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/register_types.h
new file mode 100644
index 0000000000000000000000000000000000000000..eba2ae88c9490dd9e768b1c638b8f893dc29197a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/register_types.h
@@ -0,0 +1,233 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_REGISTER_TYPES_H_
+#define TENSORFLOW_CORE_FRAMEWORK_REGISTER_TYPES_H_
+// This file is used by cuda code and must remain compilable by nvcc.
+
+#include "tensorflow/core/framework/numeric_types.h"
+#include "tensorflow/core/framework/resource_handle.h"
+#include "tensorflow/core/framework/variant.h"
+#include "tensorflow/core/platform/types.h"
+
+// Two sets of macros:
+// - TF_CALL_float, TF_CALL_double, etc. which call the given macro with
+//   the type name as the only parameter - except on platforms for which
+//   the type should not be included.
+// - Macros to apply another macro to lists of supported types. These also call
+//   into TF_CALL_float, TF_CALL_double, etc. so they filter by target platform
+//   as well.
+// If you change the lists of types, please also update the list in types.cc.
+//
+// See example uses of these macros in core/ops.
+//
+//
+// Each of these TF_CALL_XXX_TYPES(m) macros invokes the macro "m" multiple
+// times by passing each invocation a data type supported by TensorFlow.
+//
+// The different variations pass different subsets of the types.
+// TF_CALL_ALL_TYPES(m) applied "m" to all types supported by TensorFlow.
+// The set of types depends on the compilation platform.
+//.
+// This can be used to register a different template instantiation of
+// an OpKernel for different signatures, e.g.:
+/*
+   #define REGISTER_PARTITION(type)                                      \
+     REGISTER_KERNEL_BUILDER(                                            \
+         Name("Partition").Device(DEVICE_CPU).TypeConstraint<type>("T"), \
+         PartitionOp<type>);
+   TF_CALL_ALL_TYPES(REGISTER_PARTITION)
+   #undef REGISTER_PARTITION
+*/
+
+#if !defined(IS_MOBILE_PLATFORM) || defined(SUPPORT_SELECTIVE_REGISTRATION) || \
+    defined(ANDROID_TEGRA)
+
+// All types are supported, so all macros are invoked.
+//
+// Note: macros are defined in same order as types in types.proto, for
+// readability.
+#define TF_CALL_float(m) m(float)
+#define TF_CALL_double(m) m(double)
+#define TF_CALL_int32(m) m(::tensorflow::int32)
+#define TF_CALL_uint32(m) m(::tensorflow::uint32)
+#define TF_CALL_uint8(m) m(::tensorflow::uint8)
+#define TF_CALL_int16(m) m(::tensorflow::int16)
+
+#define TF_CALL_int8(m) m(::tensorflow::int8)
+#define TF_CALL_string(m) m(::tensorflow::tstring)
+#define TF_CALL_tstring(m) m(::tensorflow::tstring)
+#define TF_CALL_resource(m) m(::tensorflow::ResourceHandle)
+#define TF_CALL_variant(m) m(::tensorflow::Variant)
+#define TF_CALL_complex64(m) m(::tensorflow::complex64)
+#define TF_CALL_int64(m) m(::int64_t)
+#define TF_CALL_uint64(m) m(::tensorflow::uint64)
+#define TF_CALL_bool(m) m(bool)
+
+#define TF_CALL_qint8(m) m(::tensorflow::qint8)
+#define TF_CALL_quint8(m) m(::tensorflow::quint8)
+#define TF_CALL_qint32(m) m(::tensorflow::qint32)
+#define TF_CALL_bfloat16(m) m(::tensorflow::bfloat16)
+#define TF_CALL_qint16(m) m(::tensorflow::qint16)
+
+#define TF_CALL_quint16(m) m(::tensorflow::quint16)
+#define TF_CALL_uint16(m) m(::tensorflow::uint16)
+#define TF_CALL_complex128(m) m(::tensorflow::complex128)
+#define TF_CALL_half(m) m(Eigen::half)
+
+#define TF_CALL_float8_e5m2(m) m(::tensorflow::float8_e5m2)
+#define TF_CALL_float8_e4m3fn(m) m(::tensorflow::float8_e4m3fn)
+
+#define TF_CALL_int4(m) m(::tensorflow::int4)
+#define TF_CALL_uint4(m) m(::tensorflow::uint4)
+
+#elif defined(__ANDROID_TYPES_FULL__)
+
+// Only string, half, float, int32, int64, bool, and quantized types
+// supported.
+#define TF_CALL_float(m) m(float)
+#define TF_CALL_double(m)
+#define TF_CALL_int32(m) m(::tensorflow::int32)
+#define TF_CALL_uint32(m)
+#define TF_CALL_uint8(m)
+#define TF_CALL_int16(m)
+
+#define TF_CALL_int8(m)
+#define TF_CALL_string(m) m(::tensorflow::tstring)
+#define TF_CALL_tstring(m) m(::tensorflow::tstring)
+#define TF_CALL_resource(m)
+#define TF_CALL_variant(m)
+#define TF_CALL_complex64(m)
+#define TF_CALL_int64(m) m(::int64_t)
+#define TF_CALL_uint64(m)
+#define TF_CALL_bool(m) m(bool)
+
+#define TF_CALL_qint8(m) m(::tensorflow::qint8)
+#define TF_CALL_quint8(m) m(::tensorflow::quint8)
+#define TF_CALL_qint32(m) m(::tensorflow::qint32)
+#define TF_CALL_bfloat16(m)
+#define TF_CALL_qint16(m) m(::tensorflow::qint16)
+
+#define TF_CALL_quint16(m) m(::tensorflow::quint16)
+#define TF_CALL_uint16(m)
+#define TF_CALL_complex128(m)
+#define TF_CALL_half(m) m(Eigen::half)
+
+#define TF_CALL_float8_e5m2(m)
+#define TF_CALL_float8_e4m3fn(m)
+
+#define TF_CALL_int4(m)
+#define TF_CALL_uint4(m)
+
+#else  // defined(IS_MOBILE_PLATFORM) && !defined(__ANDROID_TYPES_FULL__)
+
+// Only float, int32, and bool are supported.
+#define TF_CALL_float(m) m(float)
+#define TF_CALL_double(m)
+#define TF_CALL_int32(m) m(::tensorflow::int32)
+#define TF_CALL_uint32(m)
+#define TF_CALL_uint8(m)
+#define TF_CALL_int16(m)
+
+#define TF_CALL_int8(m)
+#define TF_CALL_string(m)
+#define TF_CALL_tstring(m)
+#define TF_CALL_resource(m)
+#define TF_CALL_variant(m)
+#define TF_CALL_complex64(m)
+#define TF_CALL_int64(m)
+#define TF_CALL_uint64(m)
+#define TF_CALL_bool(m) m(bool)
+
+#define TF_CALL_qint8(m)
+#define TF_CALL_quint8(m)
+#define TF_CALL_qint32(m)
+#define TF_CALL_bfloat16(m)
+#define TF_CALL_qint16(m)
+
+#define TF_CALL_quint16(m)
+#define TF_CALL_uint16(m)
+#define TF_CALL_complex128(m)
+#define TF_CALL_half(m)
+
+#define TF_CALL_float8_e5m2(m)
+#define TF_CALL_float8_e4m3fn(m)
+
+#define TF_CALL_int4(m)
+#define TF_CALL_uint4(m)
+
+#endif  // defined(IS_MOBILE_PLATFORM)  - end of TF_CALL_type defines
+
+// Defines for sets of types.
+#define TF_CALL_INTEGRAL_TYPES_NO_INT32(m)                               \
+  TF_CALL_uint64(m) TF_CALL_int64(m) TF_CALL_uint32(m) TF_CALL_uint16(m) \
+      TF_CALL_int16(m) TF_CALL_uint8(m) TF_CALL_int8(m)
+
+#define TF_CALL_INTEGRAL_TYPES(m) \
+  TF_CALL_INTEGRAL_TYPES_NO_INT32(m) TF_CALL_int32(m)
+
+#define TF_CALL_FLOAT_TYPES(m) \
+  TF_CALL_half(m) TF_CALL_bfloat16(m) TF_CALL_float(m) TF_CALL_double(m)
+
+#define TF_CALL_REAL_NUMBER_TYPES(m) \
+  TF_CALL_INTEGRAL_TYPES(m) TF_CALL_FLOAT_TYPES(m)
+
+#define TF_CALL_REAL_NUMBER_TYPES_NO_BFLOAT16(m) \
+  TF_CALL_INTEGRAL_TYPES(m) TF_CALL_half(m) TF_CALL_float(m) TF_CALL_double(m)
+
+#define TF_CALL_REAL_NUMBER_TYPES_NO_INT32(m)                            \
+  TF_CALL_half(m) TF_CALL_bfloat16(m) TF_CALL_float(m) TF_CALL_double(m) \
+      TF_CALL_INTEGRAL_TYPES_NO_INT32(m)
+
+#define TF_CALL_COMPLEX_TYPES(m) TF_CALL_complex64(m) TF_CALL_complex128(m)
+
+// Call "m" for all number types, including complex types
+#define TF_CALL_NUMBER_TYPES(m) \
+  TF_CALL_REAL_NUMBER_TYPES(m) TF_CALL_COMPLEX_TYPES(m)
+
+#define TF_CALL_NUMBER_TYPES_NO_INT32(m) \
+  TF_CALL_REAL_NUMBER_TYPES_NO_INT32(m) TF_CALL_COMPLEX_TYPES(m)
+
+#define TF_CALL_POD_TYPES(m) TF_CALL_NUMBER_TYPES(m) TF_CALL_bool(m)
+
+// Call "m" on all types.
+#define TF_CALL_ALL_TYPES(m) \
+  TF_CALL_POD_TYPES(m) TF_CALL_tstring(m) TF_CALL_resource(m) TF_CALL_variant(m)
+
+// Call "m" on POD and string types.
+#define TF_CALL_POD_STRING_TYPES(m) TF_CALL_POD_TYPES(m) TF_CALL_tstring(m)
+
+// Call "m" on all number types supported on GPU.
+#define TF_CALL_GPU_NUMBER_TYPES(m) \
+  TF_CALL_half(m) TF_CALL_bfloat16(m) TF_CALL_float(m) TF_CALL_double(m)
+
+// Call "m" on all types supported on GPU.
+#define TF_CALL_GPU_ALL_TYPES(m) \
+  TF_CALL_GPU_NUMBER_TYPES(m) TF_CALL_COMPLEX_TYPES(m) TF_CALL_bool(m)
+
+#define TF_CALL_GPU_NUMBER_TYPES_NO_HALF(m) TF_CALL_float(m) TF_CALL_double(m)
+
+// Call "m" on all quantized types.
+// TODO(cwhipkey): include TF_CALL_qint16(m) TF_CALL_quint16(m)
+#define TF_CALL_QUANTIZED_TYPES(m) \
+  TF_CALL_qint8(m) TF_CALL_quint8(m) TF_CALL_qint32(m)
+
+// Types used for save and restore ops.
+#define TF_CALL_SAVE_RESTORE_TYPES(m)      \
+  TF_CALL_REAL_NUMBER_TYPES_NO_BFLOAT16(m) \
+  TF_CALL_COMPLEX_TYPES(m)                 \
+  TF_CALL_QUANTIZED_TYPES(m) TF_CALL_bool(m) TF_CALL_tstring(m)
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_REGISTER_TYPES_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/register_types_traits.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/register_types_traits.h
new file mode 100644
index 0000000000000000000000000000000000000000..b2847d844e1aea3e9304c1f430317ae49a31798b
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/register_types_traits.h
@@ -0,0 +1,93 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_REGISTER_TYPES_TRAITS_H_
+#define TENSORFLOW_CORE_FRAMEWORK_REGISTER_TYPES_TRAITS_H_
+// This file is used by cuda code and must remain compilable by nvcc.
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+typedef Eigen::ThreadPoolDevice CPUDevice;
+typedef Eigen::GpuDevice GPUDevice;
+
+
+#include "tensorflow/core/framework/numeric_types.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+
+// Remap POD types by size to equivalent proxy types. This works
+// since all we are doing is copying data around.
+struct UnusableProxyType;
+template <typename Device, int size>
+struct proxy_type_pod {
+  typedef UnusableProxyType type;
+};
+template <>
+struct proxy_type_pod<CPUDevice, 16> {
+  typedef ::tensorflow::complex128 type;
+};
+template <>
+struct proxy_type_pod<CPUDevice, 8> {
+  typedef ::int64_t type;
+};
+template <>
+struct proxy_type_pod<CPUDevice, 4> {
+  typedef ::tensorflow::int32 type;
+};
+template <>
+struct proxy_type_pod<CPUDevice, 2> {
+  typedef ::tensorflow::int16 type;
+};
+template <>
+struct proxy_type_pod<CPUDevice, 1> {
+  typedef ::tensorflow::int8 type;
+};
+template <>
+struct proxy_type_pod<GPUDevice, 8> {
+  typedef double type;
+};
+template <>
+struct proxy_type_pod<GPUDevice, 4> {
+  typedef float type;
+};
+template <>
+struct proxy_type_pod<GPUDevice, 2> {
+  typedef Eigen::half type;
+};
+template <>
+struct proxy_type_pod<GPUDevice, 1> {
+  typedef ::tensorflow::int8 type;
+};
+
+
+/// If POD we use proxy_type_pod, otherwise this maps to identity.
+template <typename Device, typename T>
+struct proxy_type {
+  typedef typename std::conditional<
+      std::is_arithmetic<T>::value,
+      typename proxy_type_pod<Device, sizeof(T)>::type, T>::type type;
+  static_assert(sizeof(type) == sizeof(T), "proxy_type_pod is not valid");
+};
+
+/// The active proxy types
+#define TF_CALL_CPU_PROXY_TYPES(m)                                     \
+  TF_CALL_int64(m) TF_CALL_int32(m) TF_CALL_uint16(m) TF_CALL_int16(m) \
+      TF_CALL_int8(m) TF_CALL_complex128(m)
+#define TF_CALL_GPU_PROXY_TYPES(m)                                       \
+  TF_CALL_double(m) TF_CALL_float(m) TF_CALL_half(m) TF_CALL_bfloat16(m) \
+      TF_CALL_int32(m) TF_CALL_int8(m)
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_REGISTER_TYPES_TRAITS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/registration/options.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/registration/options.h
new file mode 100644
index 0000000000000000000000000000000000000000..6b8f1a59d51f7f08de8892ac863875a6473bc08a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/registration/options.h
@@ -0,0 +1,26 @@
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_REGISTRATION_OPTIONS_TMPL_H_
+#define TENSORFLOW_CORE_FRAMEWORK_REGISTRATION_OPTIONS_TMPL_H_
+
+// This header is generated from a template; see the tf_gen_options_header()
+// build rule. Template placeholders of the form '#define_option X' result in
+// macros of the form 'TF_OPTION_X()'.
+
+// @//tensorflow:enable_registration_v2
+#define TF_OPTION_REGISTRATION_V2() false
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_REGISTRATION_OPTIONS_TMPL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/registration/registration.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/registration/registration.h
new file mode 100644
index 0000000000000000000000000000000000000000..27f2ec2bde9efb5766c722c8303c51b54d3e29e1
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/registration/registration.h
@@ -0,0 +1,152 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// This file provides some common support for 'registration' of e.g. ops and
+// kernels. In particular, it relates to the REGISTER_OP (op registration) and
+// REGISTER_KERNEL_BUILDER (kernel registration) macros.
+//
+// Note that there are two sides to 'registration':
+//   - Definition (compile-time): making op and kernel definitions _available_.
+//   - Usage (run-time): adding particular (available) definitions of ops and
+//     kernels to the global OpRegistry / KernelRegistry, to be found when
+//     constructing and executing graphs.
+//
+// Currently, definition and usage happen to be coupled together: all
+// 'available' definitions (from the REGISTER_*' macros) are added to the global
+// registries on startup / library load.
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_REGISTRATION_REGISTRATION_H_
+#define TENSORFLOW_CORE_FRAMEWORK_REGISTRATION_REGISTRATION_H_
+
+#include <string.h>
+
+#include <type_traits>
+#include <utility>
+
+#include "tensorflow/core/framework/registration/options.h"
+
+#if !TF_OPTION_REGISTRATION_V2()
+
+#ifdef SELECTIVE_REGISTRATION
+
+// Experimental selective registration support to reduce binary size.
+//
+// To use selective registration, when building:
+// 1. define SELECTIVE_REGISTRATION, e.g. in gcc by passing
+//    -DSELECTIVE_REGISTRATION to compilation.
+// 2. Provide ops_to_register.h. This file is not included in the repo and must
+//    be placed by the user or a tool where the compiler can find it.  It must
+//    define the constants and functions used in the macros below. The
+//    functions should be defined as valid constexpr functions, so that they are
+//    evaluated at compile time: this is needed to make symbols referenced by
+//    un-registered objects unused, and therefore allow the linker to strip them
+//    out.  See python/tools/print_selective_registration_header.py for a tool
+//    that can be used to generate ops_to_register.h.
+//
+// ops_to_register.h should define macros for:
+//   // Ops for which this is false will not be registered.
+//   SHOULD_REGISTER_OP(op)
+//   // If this is false, then no gradient ops are registered.
+//   SHOULD_REGISTER_OP_GRADIENT
+//   // Op kernel classes where this is false won't be registered.
+//   SHOULD_REGISTER_OP_KERNEL(clz)
+// The macros should be defined using constexprs.
+
+#include "ops_to_register.h"
+
+#if (!defined(SHOULD_REGISTER_OP) || !defined(SHOULD_REGISTER_OP_GRADIENT) || \
+     !defined(SHOULD_REGISTER_OP_KERNEL))
+static_assert(false, "ops_to_register.h must define SHOULD_REGISTER macros");
+#endif
+#else  // SELECTIVE_REGISTRATION
+#define SHOULD_REGISTER_OP(op) true
+#define SHOULD_REGISTER_OP_GRADIENT true
+#define SHOULD_REGISTER_OP_KERNEL(clz) true
+#endif  // SELECTIVE_REGISTRATION
+
+#else  // ! TF_OPTION_REGISTRATION_V2()
+
+#ifdef SELECTIVE_REGISTRATION
+#error TF_OPTION_REGISTRATION_V2(): Compile-time selective registration is not supported
+#endif
+
+#endif  // ! TF_OPTION_REGISTRATION_V2()
+
+namespace tensorflow {
+
+// An InitOnStartupMarker is 'initialized' on program startup, purely for the
+// side-effects of that initialization - the struct itself is empty. (The type
+// is expected to be used to define globals.)
+//
+// The '<<' operator should be used in initializer expressions to specify what
+// to run on startup. The following values are accepted:
+//   - An InitOnStartupMarker. Example:
+//      InitOnStartupMarker F();
+//      InitOnStartupMarker const kInitF =
+//        InitOnStartupMarker{} << F();
+//   - Something to call, which returns an InitOnStartupMarker. Example:
+//      InitOnStartupMarker const kInit =
+//        InitOnStartupMarker{} << []() { G(); return
+//
+// See also: TF_INIT_ON_STARTUP_IF
+struct InitOnStartupMarker {
+  constexpr InitOnStartupMarker operator<<(InitOnStartupMarker) const {
+    return *this;
+  }
+
+  template <typename T>
+  constexpr InitOnStartupMarker operator<<(T&& v) const {
+    return std::forward<T>(v)();
+  }
+};
+
+// Conditional initializer expressions for InitOnStartupMarker:
+//   TF_INIT_ON_STARTUP_IF(cond) << f
+// If 'cond' is true, 'f' is evaluated (and called, if applicable) on startup.
+// Otherwise, 'f' is *not evaluated*. Note that 'cond' is required to be a
+// constant-expression, and so this approximates #ifdef.
+//
+// The implementation uses the ?: operator (!cond prevents evaluation of 'f').
+// The relative precedence of ?: and << is significant; this effectively expands
+// to (see extra parens):
+//   !cond ? InitOnStartupMarker{} : (InitOnStartupMarker{} << f)
+//
+// Note that although forcing 'cond' to be a constant-expression should not
+// affect binary size (i.e. the same optimizations should apply if it 'happens'
+// to be one), it was found to be necessary (for a recent version of clang;
+// perhaps an optimizer bug).
+//
+// The parens are necessary to hide the ',' from the preprocessor; it could
+// otherwise act as a macro argument separator.
+#define TF_INIT_ON_STARTUP_IF(cond)                \
+  (::std::integral_constant<bool, !(cond)>::value) \
+      ? ::tensorflow::InitOnStartupMarker{}        \
+      : ::tensorflow::InitOnStartupMarker {}
+
+// Wrapper for generating unique IDs (for 'anonymous' InitOnStartup definitions)
+// using __COUNTER__. The new ID (__COUNTER__ already expanded) is provided as a
+// macro argument.
+//
+// Usage:
+//   #define M_IMPL(id, a, b) ...
+//   #define M(a, b) TF_NEW_ID_FOR_INIT(M_IMPL, a, b)
+#define TF_NEW_ID_FOR_INIT_2(m, c, ...) m(c, __VA_ARGS__)
+#define TF_NEW_ID_FOR_INIT_1(m, c, ...) TF_NEW_ID_FOR_INIT_2(m, c, __VA_ARGS__)
+#define TF_NEW_ID_FOR_INIT(m, ...) \
+  TF_NEW_ID_FOR_INIT_1(m, __COUNTER__, __VA_ARGS__)
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_REGISTRATION_REGISTRATION_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/rendezvous.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/rendezvous.h
new file mode 100644
index 0000000000000000000000000000000000000000..c4b5b99ec51ba071f2cc90831dd53305e8bcc035
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/rendezvous.h
@@ -0,0 +1,176 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_RENDEZVOUS_H_
+#define TENSORFLOW_CORE_FRAMEWORK_RENDEZVOUS_H_
+
+#include <string>
+#include <utility>
+
+#include "tensorflow/core/framework/cancellation.h"
+#include "tensorflow/core/framework/control_flow.h"
+#include "tensorflow/core/framework/device_base.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/lib/core/refcount.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/util/device_name_utils.h"
+
+namespace tensorflow {
+
+class DeviceMgr;
+
+// A Rendezvous is an abstraction for passing tensors from producers
+// to consumers. A rendezvous is a table of channels. Each channel is
+// keyed by a rendezvous key. The key encodes a pair of <producer,
+// consumer>, where the producer and the consumer are tensorflow
+// devices.
+//
+// The producer calls the Send() method to send one tensor over one
+// named channel. The consumer calls the Recv() method to receive one
+// tensor from a named channel. A sequence of tensors can be passed
+// from the producer to the consumer.  The consumer receives them in
+// the order as the producer sends them.
+//
+// A consumer may safely request the tensor before or after it has
+// been produced.  A consumer has the choice of making a blocking call
+// or providing a callback: in either case, the consumer receives the
+// Tensor as soon as it is available.  A producer never blocks.
+class RendezvousInterface {
+ public:
+  struct Args {
+    DeviceContext* device_context = nullptr;
+    AllocatorAttributes alloc_attrs;
+    CancellationManager* cancellation_manager = nullptr;  // not owned.
+  };
+
+  // Parses the key constructed by CreateKey and parse src/dst device
+  // names into structures respectively.
+  struct ParsedKey {
+    StringPiece src_device;
+    DeviceNameUtils::ParsedName src;
+    uint64 src_incarnation = 0;
+    StringPiece dst_device;
+    DeviceNameUtils::ParsedName dst;
+    StringPiece edge_name;
+
+    ParsedKey() {}
+    ParsedKey(const ParsedKey& b) { *this = b; }
+
+    ParsedKey& operator=(const ParsedKey& b);
+    StringPiece FullKey() const { return buf_; }
+
+   private:
+    friend class Rendezvous;
+    friend class SendOp;
+    friend class RecvOp;
+    std::string buf_;
+  };
+
+  // The caller is a tensor producer and it sends a message (a tensor
+  // "val" and a bool "is_dead") under the given "key".
+  //
+  // {val, is_dead} is bundled as a message sent and received.
+  // Typically, is_dead is set by some control flow nodes
+  // (e.g., a not-taken branch).  args is passed by Send to the
+  // Recv function to communicate any information that the Recv
+  // function might need.  This is typically only necessary for
+  // Send/Recv on the same worker.
+  //
+  // Send() never blocks.
+  virtual Status Send(const ParsedKey& key, const Args& args, const Tensor& val,
+                      const bool is_dead) = 0;
+
+  // Callback provided by a tensor consumer waiting on the rendezvous.
+  // It will be invoked when the tensor is available, or when a non-OK
+  // status arises in the production of that tensor.  It also gets
+  // two Rendezvous::Args, one provided by the sender, the other by the
+  // receiver, which may be needed when a non-CPU device is in use
+  // by either side.
+  typedef std::function<void(const Status&, const Args&, const Args&,
+                             const Tensor&, const bool)>
+      DoneCallback;
+
+  virtual void RecvAsync(const ParsedKey& key, const Args& args,
+                         DoneCallback done) = 0;
+
+  // Synchronous wrapper for RecvAsync.
+  Status Recv(const ParsedKey& key, const Args& args, Tensor* val,
+              bool* is_dead, int64_t timeout_ms);
+  Status Recv(const ParsedKey& key, const Args& args, Tensor* val,
+              bool* is_dead);
+
+  // Aborts all pending and future Send/Recv with the given "status".
+  //
+  // StartAbort() does not wait for ongoing calls to finish.
+  // REQUIRES: !status.ok()
+  virtual void StartAbort(const Status& status) = 0;
+
+  virtual ~RendezvousInterface();
+
+ protected:
+  virtual bool is_cross_process() { return false; }
+  friend class ProcessFunctionLibraryRuntime;
+};
+
+// A reference-counted implementation of RendezvousInterface.
+//
+// This class is used in cases where a rendezvous may be shared between multiple
+// threads with no clear owner.
+class Rendezvous : public RendezvousInterface, public core::WeakRefCounted {
+ public:
+  class Factory {
+   public:
+    // Default to a factory that evaluates to false.
+    Factory() : valid_(false) {}
+
+    explicit Factory(std::function<Status(const int64_t, const DeviceMgr*,
+                                          tsl::core::RefCountPtr<Rendezvous>*)>
+                         create_fn)
+        : valid_(true), create_fn_(std::move(create_fn)) {}
+
+    explicit operator bool() const { return valid_; }
+
+    Status operator()(const int64_t step_id, const DeviceMgr* device_mgr,
+                      tsl::core::RefCountPtr<Rendezvous>* rendez) const {
+      return create_fn_(step_id, device_mgr, rendez);
+    }
+
+   private:
+    bool valid_;
+    std::function<Status(const int64_t, const DeviceMgr*,
+                         tsl::core::RefCountPtr<Rendezvous>*)>
+        create_fn_;
+  };
+
+  // Constructs a rendezvous key for the tensor of "name" sent from
+  // "src_device" to "dst_device". The tensor is generated in the frame
+  // and iteration specified by "frame_iter".
+  static std::string CreateKey(const std::string& src_device,
+                               uint64 src_incarnation,
+                               const std::string& dst_device,
+                               const std::string& name,
+                               const FrameAndIter& frame_iter);
+
+  static Status ParseKey(StringPiece key, ParsedKey* out);
+};
+
+// Returns a Rendezvous instance that is limited to use only by
+// producers and consumers in the local process.  The caller assumes
+// ownership of one Ref() on the returned object.
+Rendezvous* NewLocalRendezvous(int num_shards = 1);
+
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_RENDEZVOUS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/resource_base.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/resource_base.h
new file mode 100644
index 0000000000000000000000000000000000000000..46a76ea094ce17dcae56ffa4a3f386c0e5f302f5
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/resource_base.h
@@ -0,0 +1,62 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_RESOURCE_BASE_H_
+#define TENSORFLOW_CORE_FRAMEWORK_RESOURCE_BASE_H_
+
+#include <cstdint>
+#include <string>
+
+#include "absl/strings/str_format.h"
+#include "tensorflow/core/lib/core/refcount.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/platform/errors.h"
+
+namespace tensorflow {
+
+// Forward declaration to avoid introducing a dependency on headers in
+// "tensorflow/core/graph/...".
+class GraphDefBuilder;
+class Node;
+
+// This is the base class of all resource classes. Each resource must be
+// represented as a sub-class of ResourceBase (which is reference counted) to be
+// able to work with resource facilities such ResourceHandle and ResourceMgr.
+class ResourceBase : public core::WeakRefCounted {
+ public:
+  // Returns a debug string for *this.
+  virtual std::string DebugString() const = 0;
+
+  // Returns a name for ref-counting handles.
+  virtual std::string MakeRefCountingHandleName(int64_t resource_id) const {
+    return absl::StrFormat("Resource-%d-at-%p", resource_id, this);
+  }
+
+  // Returns memory used by this resource.
+  virtual int64_t MemoryUsed() const { return 0; }
+
+  // Writes a representation of this resource into `builder`, so that executing
+  // `*out` will recreate this resource. The lifetime of the created resource
+  // should not be tied to the graph that created it, since the graph may be
+  // destroyed before the resource is used. To avoid this lifetime issue, you
+  // can usually set a unique `shared_name` attribute for the resource.
+  virtual Status AsGraphDef(GraphDefBuilder* builder, Node** out) const {
+    return errors::Unimplemented("AsGraphDef not implemented for resource ",
+                                 DebugString());
+  }
+};
+}  //  end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_RESOURCE_BASE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/resource_handle.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/resource_handle.h
new file mode 100644
index 0000000000000000000000000000000000000000..97392eea61e8d7e6974e4eeeec0391b62604ca59
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/resource_handle.h
@@ -0,0 +1,205 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_RESOURCE_HANDLE_H_
+#define TENSORFLOW_CORE_FRAMEWORK_RESOURCE_HANDLE_H_
+
+#include <string>
+
+#include "tensorflow/core/framework/resource_base.h"
+#include "tensorflow/core/framework/tensor_shape.h"
+#include "tensorflow/core/framework/type_index.h"
+#include "tensorflow/core/framework/types.pb.h"
+#include "tensorflow/core/platform/casts.h"
+#include "tensorflow/core/platform/intrusive_ptr.h"
+#include "tensorflow/core/platform/statusor.h"
+#include "tensorflow/core/platform/tensor_coding.h"
+#include "tensorflow/core/platform/types.h"
+#include "tensorflow/core/util/managed_stack_trace.h"
+
+namespace tensorflow {
+
+class ResourceHandleProto;
+
+// Class representing a handle to a tensorflow resource. Handles are
+// not valid across executions, but can be serialized back and forth from within
+// a single run (except for those created from MakeRefCountingHandle i.e. whose
+// resource_ field is not empty).
+//
+// This is the native C++ class equivalent of ResourceHandleProto.  They are
+// separate so that kernels do not need to depend on protos.
+class ResourceHandle {
+ public:
+  ResourceHandle();
+  ResourceHandle(const ResourceHandleProto& proto);
+  ~ResourceHandle();
+
+  // Use this factory method if the `proto` comes from user controlled input, to
+  // prevent a denial of service.
+  static Status BuildResourceHandle(const ResourceHandleProto& proto,
+                                    ResourceHandle* out);
+
+  // Unique name for the device containing the resource.
+  const std::string& device() const { return device_; }
+
+  void set_device(const std::string& device) { device_ = device; }
+
+  // Container in which this resource is placed.
+  const std::string& container() const { return container_; }
+  void set_container(const std::string& container) { container_ = container; }
+
+  // Unique name of this resource.
+  const std::string& name() const { return name_; }
+  void set_name(const std::string& name) { name_ = name; }
+
+  // Hash code for the type of the resource. Is only valid in the same device
+  // and in the same execution.
+  uint64 hash_code() const { return hash_code_; }
+  void set_hash_code(uint64 hash_code) { hash_code_ = hash_code; }
+
+  // For debug-only, the name of the type pointed to by this handle, if
+  // available.
+  const std::string& maybe_type_name() const { return maybe_type_name_; }
+  void set_maybe_type_name(const std::string& value) {
+    maybe_type_name_ = value;
+  }
+
+  // Data types and shapes for the underlying resource.
+  std::vector<DtypeAndPartialTensorShape> dtypes_and_shapes() const {
+    return dtypes_and_shapes_;
+  }
+  void set_dtypes_and_shapes(
+      const std::vector<DtypeAndPartialTensorShape>& dtypes_and_shapes) {
+    dtypes_and_shapes_ = dtypes_and_shapes;
+  }
+
+  void set_definition_stack_trace(
+      const absl::optional<ManagedStackTrace>& definition_stack_trace) {
+    definition_stack_trace_ = definition_stack_trace;
+  }
+
+  const absl::optional<ManagedStackTrace>& definition_stack_trace() const {
+    return definition_stack_trace_;
+  }
+
+  // Conversion to and from ResourceHandleProto
+  void AsProto(ResourceHandleProto* proto) const;
+  Status FromProto(const ResourceHandleProto& proto);
+
+  // Serialization via ResourceHandleProto
+  std::string SerializeAsString() const;
+  bool ParseFromString(const std::string& s);
+
+  std::string DebugString() const;
+
+  std::string SummarizeValue() const;
+
+  // GUID for anonymous resources. Resources with this shared_name will have
+  // their shared_name replaced with a GUID at creation time
+  static constexpr const char* ANONYMOUS_NAME =
+      "cd2c89b7-88b7-44c8-ad83-06c2a9158347";
+
+  // Creates a `ResourceHandle` that holds a pointer to a resource and takes
+  // ownership of it. Normally a `ResourceHandle` only contains the name (and
+  // some other metadata) of the resource. When created via this function,
+  // the handle will own the resource, in the sense that it will destroy the
+  // resource automatically when the resource is no longer needed. It does this
+  // via automatic ref-counting on the resource: when the handle is copied, it
+  // will call `Ref` on the resource (remember that all resources inherit from
+  // `ResourceBase` which inherits from `RefCounted`), and when the handle is
+  // destroyed, it will call `Unref` on the resource. When the last handle goes
+  // out of scope, the resource's ref-count will go down to zero and the
+  // resource will be destroyed. When calling this function, the `resource`
+  // argument should have a ref-count of one (which is the case when the
+  // resource is newly created).
+  //
+  // For those familiar with `ResourceMgr`, when you create a handle by the
+  // `MakeResourceHandle` function in resource_mgr.h, the handle doesn't hold a
+  // strong reference to the resource, and the resource is owned by the
+  // resource manager whose strong reference must be manually deleted by
+  // calling `ResourceMgr::Delete`. In contrast, a handle created by this
+  // function holds a strong reference to the resource. The resource manager
+  // does not hold a strong reference to the resource.
+  template <typename T>
+  static ResourceHandle MakeRefCountingHandle(
+      T* resource, const string& device_name,
+      const std::vector<DtypeAndPartialTensorShape>& dtypes_and_shapes = {},
+      const absl::optional<ManagedStackTrace>& definition_stack_trace = {}) {
+    return MakeRefCountingHandle(resource, device_name, TypeIndex::Make<T>(),
+                                 dtypes_and_shapes, definition_stack_trace);
+  }
+
+  static ResourceHandle MakeRefCountingHandle(
+      ResourceBase* resource, const string& device_name,
+      const TypeIndex& type_index,
+      const std::vector<DtypeAndPartialTensorShape>& dtypes_and_shapes = {},
+      const absl::optional<ManagedStackTrace>& definition_stack_trace = {});
+
+  // Pointer to the resource.
+  const core::IntrusivePtr<ResourceBase>& resource() const { return resource_; }
+
+  // Gets the resource pointer in `handle` as `T*`, or an error if the actual
+  // resource type is not `T`.
+  template <typename T>
+  StatusOr<T*> GetResource() const {
+    TF_RETURN_IF_ERROR(ValidateType<T>());
+    return down_cast<T*>(resource_.get());
+  }
+
+  // Returns True if the resource handle is ref-counting.
+  // See MakeRefCountingHandle.
+  bool IsRefCounting() const { return resource_.get() != nullptr; }
+
+  // Validates that the resource type in `handle` is `T`.
+  template <typename T>
+  Status ValidateType() const {
+    return ValidateType(TypeIndex::Make<T>());
+  }
+
+  Status ValidateType(const TypeIndex& type_index) const;
+
+  // Generates unique IDs (e.g. for names of anonymous variables)
+  static int64_t GenerateUniqueId();
+
+ private:
+  std::string device_;
+  std::string container_;
+  std::string name_;
+  uint64 hash_code_ = 0;
+  std::string maybe_type_name_;
+  std::vector<DtypeAndPartialTensorShape> dtypes_and_shapes_;
+  absl::optional<ManagedStackTrace> definition_stack_trace_;
+  // A smart pointer to the actual resource. When this field is not empty, the
+  // handle is in a "ref-counting" mode, owning the resource; otherwise it's in
+  // a "weak-ref" mode, only containing the name of the resource (conceptually a
+  // weak reference).
+  core::IntrusivePtr<ResourceBase> resource_;
+  static std::atomic<int64_t> current_id_;
+};
+
+// For backwards compatibility for when this was a proto
+std::string ProtoDebugString(const ResourceHandle& handle);
+
+// Encodes a list of ResourceHandle protos in the given StringListEncoder.
+void EncodeResourceHandleList(const ResourceHandle* p, int64_t n,
+                              std::unique_ptr<port::StringListEncoder> e);
+
+// Decodes a list of ResourceHandle protos from the given StringListDecoder.
+bool DecodeResourceHandleList(std::unique_ptr<port::StringListDecoder> d,
+                              ResourceHandle* ps, int64_t n);
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_RESOURCE_HANDLE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/resource_handle.pb.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/resource_handle.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..7deab8b4a82818ce35564f050a649e4a876b76b8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/resource_handle.pb.h
@@ -0,0 +1,858 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: tensorflow/core/framework/resource_handle.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fresource_5fhandle_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fresource_5fhandle_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3021000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3021009 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+#include "tensorflow/core/framework/tensor_shape.pb.h"
+#include "tensorflow/core/framework/types.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_tensorflow_2fcore_2fframework_2fresource_5fhandle_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_tensorflow_2fcore_2fframework_2fresource_5fhandle_2eproto {
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_tensorflow_2fcore_2fframework_2fresource_5fhandle_2eproto;
+namespace tensorflow {
+class ResourceHandleProto;
+struct ResourceHandleProtoDefaultTypeInternal;
+extern ResourceHandleProtoDefaultTypeInternal _ResourceHandleProto_default_instance_;
+class ResourceHandleProto_DtypeAndShape;
+struct ResourceHandleProto_DtypeAndShapeDefaultTypeInternal;
+extern ResourceHandleProto_DtypeAndShapeDefaultTypeInternal _ResourceHandleProto_DtypeAndShape_default_instance_;
+}  // namespace tensorflow
+PROTOBUF_NAMESPACE_OPEN
+template<> ::tensorflow::ResourceHandleProto* Arena::CreateMaybeMessage<::tensorflow::ResourceHandleProto>(Arena*);
+template<> ::tensorflow::ResourceHandleProto_DtypeAndShape* Arena::CreateMaybeMessage<::tensorflow::ResourceHandleProto_DtypeAndShape>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace tensorflow {
+
+// ===================================================================
+
+class ResourceHandleProto_DtypeAndShape final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.ResourceHandleProto.DtypeAndShape) */ {
+ public:
+  inline ResourceHandleProto_DtypeAndShape() : ResourceHandleProto_DtypeAndShape(nullptr) {}
+  ~ResourceHandleProto_DtypeAndShape() override;
+  explicit PROTOBUF_CONSTEXPR ResourceHandleProto_DtypeAndShape(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ResourceHandleProto_DtypeAndShape(const ResourceHandleProto_DtypeAndShape& from);
+  ResourceHandleProto_DtypeAndShape(ResourceHandleProto_DtypeAndShape&& from) noexcept
+    : ResourceHandleProto_DtypeAndShape() {
+    *this = ::std::move(from);
+  }
+
+  inline ResourceHandleProto_DtypeAndShape& operator=(const ResourceHandleProto_DtypeAndShape& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ResourceHandleProto_DtypeAndShape& operator=(ResourceHandleProto_DtypeAndShape&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ResourceHandleProto_DtypeAndShape& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ResourceHandleProto_DtypeAndShape* internal_default_instance() {
+    return reinterpret_cast<const ResourceHandleProto_DtypeAndShape*>(
+               &_ResourceHandleProto_DtypeAndShape_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(ResourceHandleProto_DtypeAndShape& a, ResourceHandleProto_DtypeAndShape& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ResourceHandleProto_DtypeAndShape* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ResourceHandleProto_DtypeAndShape* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ResourceHandleProto_DtypeAndShape* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ResourceHandleProto_DtypeAndShape>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ResourceHandleProto_DtypeAndShape& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const ResourceHandleProto_DtypeAndShape& from) {
+    ResourceHandleProto_DtypeAndShape::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ResourceHandleProto_DtypeAndShape* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.ResourceHandleProto.DtypeAndShape";
+  }
+  protected:
+  explicit ResourceHandleProto_DtypeAndShape(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kShapeFieldNumber = 2,
+    kDtypeFieldNumber = 1,
+  };
+  // .tensorflow.TensorShapeProto shape = 2;
+  bool has_shape() const;
+  private:
+  bool _internal_has_shape() const;
+  public:
+  void clear_shape();
+  const ::tensorflow::TensorShapeProto& shape() const;
+  PROTOBUF_NODISCARD ::tensorflow::TensorShapeProto* release_shape();
+  ::tensorflow::TensorShapeProto* mutable_shape();
+  void set_allocated_shape(::tensorflow::TensorShapeProto* shape);
+  private:
+  const ::tensorflow::TensorShapeProto& _internal_shape() const;
+  ::tensorflow::TensorShapeProto* _internal_mutable_shape();
+  public:
+  void unsafe_arena_set_allocated_shape(
+      ::tensorflow::TensorShapeProto* shape);
+  ::tensorflow::TensorShapeProto* unsafe_arena_release_shape();
+
+  // .tensorflow.DataType dtype = 1;
+  void clear_dtype();
+  ::tensorflow::DataType dtype() const;
+  void set_dtype(::tensorflow::DataType value);
+  private:
+  ::tensorflow::DataType _internal_dtype() const;
+  void _internal_set_dtype(::tensorflow::DataType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.ResourceHandleProto.DtypeAndShape)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::tensorflow::TensorShapeProto* shape_;
+    int dtype_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fresource_5fhandle_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ResourceHandleProto final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.ResourceHandleProto) */ {
+ public:
+  inline ResourceHandleProto() : ResourceHandleProto(nullptr) {}
+  ~ResourceHandleProto() override;
+  explicit PROTOBUF_CONSTEXPR ResourceHandleProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ResourceHandleProto(const ResourceHandleProto& from);
+  ResourceHandleProto(ResourceHandleProto&& from) noexcept
+    : ResourceHandleProto() {
+    *this = ::std::move(from);
+  }
+
+  inline ResourceHandleProto& operator=(const ResourceHandleProto& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ResourceHandleProto& operator=(ResourceHandleProto&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ResourceHandleProto& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ResourceHandleProto* internal_default_instance() {
+    return reinterpret_cast<const ResourceHandleProto*>(
+               &_ResourceHandleProto_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(ResourceHandleProto& a, ResourceHandleProto& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ResourceHandleProto* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ResourceHandleProto* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ResourceHandleProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ResourceHandleProto>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ResourceHandleProto& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const ResourceHandleProto& from) {
+    ResourceHandleProto::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ResourceHandleProto* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.ResourceHandleProto";
+  }
+  protected:
+  explicit ResourceHandleProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ResourceHandleProto_DtypeAndShape DtypeAndShape;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDtypesAndShapesFieldNumber = 6,
+    kDeviceFieldNumber = 1,
+    kContainerFieldNumber = 2,
+    kNameFieldNumber = 3,
+    kMaybeTypeNameFieldNumber = 5,
+    kHashCodeFieldNumber = 4,
+  };
+  // repeated .tensorflow.ResourceHandleProto.DtypeAndShape dtypes_and_shapes = 6;
+  int dtypes_and_shapes_size() const;
+  private:
+  int _internal_dtypes_and_shapes_size() const;
+  public:
+  void clear_dtypes_and_shapes();
+  ::tensorflow::ResourceHandleProto_DtypeAndShape* mutable_dtypes_and_shapes(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::ResourceHandleProto_DtypeAndShape >*
+      mutable_dtypes_and_shapes();
+  private:
+  const ::tensorflow::ResourceHandleProto_DtypeAndShape& _internal_dtypes_and_shapes(int index) const;
+  ::tensorflow::ResourceHandleProto_DtypeAndShape* _internal_add_dtypes_and_shapes();
+  public:
+  const ::tensorflow::ResourceHandleProto_DtypeAndShape& dtypes_and_shapes(int index) const;
+  ::tensorflow::ResourceHandleProto_DtypeAndShape* add_dtypes_and_shapes();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::ResourceHandleProto_DtypeAndShape >&
+      dtypes_and_shapes() const;
+
+  // string device = 1;
+  void clear_device();
+  const std::string& device() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_device(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_device();
+  PROTOBUF_NODISCARD std::string* release_device();
+  void set_allocated_device(std::string* device);
+  private:
+  const std::string& _internal_device() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_device(const std::string& value);
+  std::string* _internal_mutable_device();
+  public:
+
+  // string container = 2;
+  void clear_container();
+  const std::string& container() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_container(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_container();
+  PROTOBUF_NODISCARD std::string* release_container();
+  void set_allocated_container(std::string* container);
+  private:
+  const std::string& _internal_container() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_container(const std::string& value);
+  std::string* _internal_mutable_container();
+  public:
+
+  // string name = 3;
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // string maybe_type_name = 5;
+  void clear_maybe_type_name();
+  const std::string& maybe_type_name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_maybe_type_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_maybe_type_name();
+  PROTOBUF_NODISCARD std::string* release_maybe_type_name();
+  void set_allocated_maybe_type_name(std::string* maybe_type_name);
+  private:
+  const std::string& _internal_maybe_type_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_maybe_type_name(const std::string& value);
+  std::string* _internal_mutable_maybe_type_name();
+  public:
+
+  // uint64 hash_code = 4;
+  void clear_hash_code();
+  uint64_t hash_code() const;
+  void set_hash_code(uint64_t value);
+  private:
+  uint64_t _internal_hash_code() const;
+  void _internal_set_hash_code(uint64_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.ResourceHandleProto)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::ResourceHandleProto_DtypeAndShape > dtypes_and_shapes_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr container_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr maybe_type_name_;
+    uint64_t hash_code_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fresource_5fhandle_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// ResourceHandleProto_DtypeAndShape
+
+// .tensorflow.DataType dtype = 1;
+inline void ResourceHandleProto_DtypeAndShape::clear_dtype() {
+  _impl_.dtype_ = 0;
+}
+inline ::tensorflow::DataType ResourceHandleProto_DtypeAndShape::_internal_dtype() const {
+  return static_cast< ::tensorflow::DataType >(_impl_.dtype_);
+}
+inline ::tensorflow::DataType ResourceHandleProto_DtypeAndShape::dtype() const {
+  // @@protoc_insertion_point(field_get:tensorflow.ResourceHandleProto.DtypeAndShape.dtype)
+  return _internal_dtype();
+}
+inline void ResourceHandleProto_DtypeAndShape::_internal_set_dtype(::tensorflow::DataType value) {
+  
+  _impl_.dtype_ = value;
+}
+inline void ResourceHandleProto_DtypeAndShape::set_dtype(::tensorflow::DataType value) {
+  _internal_set_dtype(value);
+  // @@protoc_insertion_point(field_set:tensorflow.ResourceHandleProto.DtypeAndShape.dtype)
+}
+
+// .tensorflow.TensorShapeProto shape = 2;
+inline bool ResourceHandleProto_DtypeAndShape::_internal_has_shape() const {
+  return this != internal_default_instance() && _impl_.shape_ != nullptr;
+}
+inline bool ResourceHandleProto_DtypeAndShape::has_shape() const {
+  return _internal_has_shape();
+}
+inline const ::tensorflow::TensorShapeProto& ResourceHandleProto_DtypeAndShape::_internal_shape() const {
+  const ::tensorflow::TensorShapeProto* p = _impl_.shape_;
+  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::TensorShapeProto&>(
+      ::tensorflow::_TensorShapeProto_default_instance_);
+}
+inline const ::tensorflow::TensorShapeProto& ResourceHandleProto_DtypeAndShape::shape() const {
+  // @@protoc_insertion_point(field_get:tensorflow.ResourceHandleProto.DtypeAndShape.shape)
+  return _internal_shape();
+}
+inline void ResourceHandleProto_DtypeAndShape::unsafe_arena_set_allocated_shape(
+    ::tensorflow::TensorShapeProto* shape) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.shape_);
+  }
+  _impl_.shape_ = shape;
+  if (shape) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.ResourceHandleProto.DtypeAndShape.shape)
+}
+inline ::tensorflow::TensorShapeProto* ResourceHandleProto_DtypeAndShape::release_shape() {
+  
+  ::tensorflow::TensorShapeProto* temp = _impl_.shape_;
+  _impl_.shape_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::tensorflow::TensorShapeProto* ResourceHandleProto_DtypeAndShape::unsafe_arena_release_shape() {
+  // @@protoc_insertion_point(field_release:tensorflow.ResourceHandleProto.DtypeAndShape.shape)
+  
+  ::tensorflow::TensorShapeProto* temp = _impl_.shape_;
+  _impl_.shape_ = nullptr;
+  return temp;
+}
+inline ::tensorflow::TensorShapeProto* ResourceHandleProto_DtypeAndShape::_internal_mutable_shape() {
+  
+  if (_impl_.shape_ == nullptr) {
+    auto* p = CreateMaybeMessage<::tensorflow::TensorShapeProto>(GetArenaForAllocation());
+    _impl_.shape_ = p;
+  }
+  return _impl_.shape_;
+}
+inline ::tensorflow::TensorShapeProto* ResourceHandleProto_DtypeAndShape::mutable_shape() {
+  ::tensorflow::TensorShapeProto* _msg = _internal_mutable_shape();
+  // @@protoc_insertion_point(field_mutable:tensorflow.ResourceHandleProto.DtypeAndShape.shape)
+  return _msg;
+}
+inline void ResourceHandleProto_DtypeAndShape::set_allocated_shape(::tensorflow::TensorShapeProto* shape) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.shape_);
+  }
+  if (shape) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(shape));
+    if (message_arena != submessage_arena) {
+      shape = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, shape, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.shape_ = shape;
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.ResourceHandleProto.DtypeAndShape.shape)
+}
+
+// -------------------------------------------------------------------
+
+// ResourceHandleProto
+
+// string device = 1;
+inline void ResourceHandleProto::clear_device() {
+  _impl_.device_.ClearToEmpty();
+}
+inline const std::string& ResourceHandleProto::device() const {
+  // @@protoc_insertion_point(field_get:tensorflow.ResourceHandleProto.device)
+  return _internal_device();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ResourceHandleProto::set_device(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.device_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.ResourceHandleProto.device)
+}
+inline std::string* ResourceHandleProto::mutable_device() {
+  std::string* _s = _internal_mutable_device();
+  // @@protoc_insertion_point(field_mutable:tensorflow.ResourceHandleProto.device)
+  return _s;
+}
+inline const std::string& ResourceHandleProto::_internal_device() const {
+  return _impl_.device_.Get();
+}
+inline void ResourceHandleProto::_internal_set_device(const std::string& value) {
+  
+  _impl_.device_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ResourceHandleProto::_internal_mutable_device() {
+  
+  return _impl_.device_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ResourceHandleProto::release_device() {
+  // @@protoc_insertion_point(field_release:tensorflow.ResourceHandleProto.device)
+  return _impl_.device_.Release();
+}
+inline void ResourceHandleProto::set_allocated_device(std::string* device) {
+  if (device != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.device_.SetAllocated(device, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.device_.IsDefault()) {
+    _impl_.device_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.ResourceHandleProto.device)
+}
+
+// string container = 2;
+inline void ResourceHandleProto::clear_container() {
+  _impl_.container_.ClearToEmpty();
+}
+inline const std::string& ResourceHandleProto::container() const {
+  // @@protoc_insertion_point(field_get:tensorflow.ResourceHandleProto.container)
+  return _internal_container();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ResourceHandleProto::set_container(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.container_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.ResourceHandleProto.container)
+}
+inline std::string* ResourceHandleProto::mutable_container() {
+  std::string* _s = _internal_mutable_container();
+  // @@protoc_insertion_point(field_mutable:tensorflow.ResourceHandleProto.container)
+  return _s;
+}
+inline const std::string& ResourceHandleProto::_internal_container() const {
+  return _impl_.container_.Get();
+}
+inline void ResourceHandleProto::_internal_set_container(const std::string& value) {
+  
+  _impl_.container_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ResourceHandleProto::_internal_mutable_container() {
+  
+  return _impl_.container_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ResourceHandleProto::release_container() {
+  // @@protoc_insertion_point(field_release:tensorflow.ResourceHandleProto.container)
+  return _impl_.container_.Release();
+}
+inline void ResourceHandleProto::set_allocated_container(std::string* container) {
+  if (container != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.container_.SetAllocated(container, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.container_.IsDefault()) {
+    _impl_.container_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.ResourceHandleProto.container)
+}
+
+// string name = 3;
+inline void ResourceHandleProto::clear_name() {
+  _impl_.name_.ClearToEmpty();
+}
+inline const std::string& ResourceHandleProto::name() const {
+  // @@protoc_insertion_point(field_get:tensorflow.ResourceHandleProto.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ResourceHandleProto::set_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.ResourceHandleProto.name)
+}
+inline std::string* ResourceHandleProto::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:tensorflow.ResourceHandleProto.name)
+  return _s;
+}
+inline const std::string& ResourceHandleProto::_internal_name() const {
+  return _impl_.name_.Get();
+}
+inline void ResourceHandleProto::_internal_set_name(const std::string& value) {
+  
+  _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ResourceHandleProto::_internal_mutable_name() {
+  
+  return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ResourceHandleProto::release_name() {
+  // @@protoc_insertion_point(field_release:tensorflow.ResourceHandleProto.name)
+  return _impl_.name_.Release();
+}
+inline void ResourceHandleProto::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.ResourceHandleProto.name)
+}
+
+// uint64 hash_code = 4;
+inline void ResourceHandleProto::clear_hash_code() {
+  _impl_.hash_code_ = uint64_t{0u};
+}
+inline uint64_t ResourceHandleProto::_internal_hash_code() const {
+  return _impl_.hash_code_;
+}
+inline uint64_t ResourceHandleProto::hash_code() const {
+  // @@protoc_insertion_point(field_get:tensorflow.ResourceHandleProto.hash_code)
+  return _internal_hash_code();
+}
+inline void ResourceHandleProto::_internal_set_hash_code(uint64_t value) {
+  
+  _impl_.hash_code_ = value;
+}
+inline void ResourceHandleProto::set_hash_code(uint64_t value) {
+  _internal_set_hash_code(value);
+  // @@protoc_insertion_point(field_set:tensorflow.ResourceHandleProto.hash_code)
+}
+
+// string maybe_type_name = 5;
+inline void ResourceHandleProto::clear_maybe_type_name() {
+  _impl_.maybe_type_name_.ClearToEmpty();
+}
+inline const std::string& ResourceHandleProto::maybe_type_name() const {
+  // @@protoc_insertion_point(field_get:tensorflow.ResourceHandleProto.maybe_type_name)
+  return _internal_maybe_type_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ResourceHandleProto::set_maybe_type_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.maybe_type_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.ResourceHandleProto.maybe_type_name)
+}
+inline std::string* ResourceHandleProto::mutable_maybe_type_name() {
+  std::string* _s = _internal_mutable_maybe_type_name();
+  // @@protoc_insertion_point(field_mutable:tensorflow.ResourceHandleProto.maybe_type_name)
+  return _s;
+}
+inline const std::string& ResourceHandleProto::_internal_maybe_type_name() const {
+  return _impl_.maybe_type_name_.Get();
+}
+inline void ResourceHandleProto::_internal_set_maybe_type_name(const std::string& value) {
+  
+  _impl_.maybe_type_name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ResourceHandleProto::_internal_mutable_maybe_type_name() {
+  
+  return _impl_.maybe_type_name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ResourceHandleProto::release_maybe_type_name() {
+  // @@protoc_insertion_point(field_release:tensorflow.ResourceHandleProto.maybe_type_name)
+  return _impl_.maybe_type_name_.Release();
+}
+inline void ResourceHandleProto::set_allocated_maybe_type_name(std::string* maybe_type_name) {
+  if (maybe_type_name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.maybe_type_name_.SetAllocated(maybe_type_name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.maybe_type_name_.IsDefault()) {
+    _impl_.maybe_type_name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.ResourceHandleProto.maybe_type_name)
+}
+
+// repeated .tensorflow.ResourceHandleProto.DtypeAndShape dtypes_and_shapes = 6;
+inline int ResourceHandleProto::_internal_dtypes_and_shapes_size() const {
+  return _impl_.dtypes_and_shapes_.size();
+}
+inline int ResourceHandleProto::dtypes_and_shapes_size() const {
+  return _internal_dtypes_and_shapes_size();
+}
+inline void ResourceHandleProto::clear_dtypes_and_shapes() {
+  _impl_.dtypes_and_shapes_.Clear();
+}
+inline ::tensorflow::ResourceHandleProto_DtypeAndShape* ResourceHandleProto::mutable_dtypes_and_shapes(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.ResourceHandleProto.dtypes_and_shapes)
+  return _impl_.dtypes_and_shapes_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::ResourceHandleProto_DtypeAndShape >*
+ResourceHandleProto::mutable_dtypes_and_shapes() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.ResourceHandleProto.dtypes_and_shapes)
+  return &_impl_.dtypes_and_shapes_;
+}
+inline const ::tensorflow::ResourceHandleProto_DtypeAndShape& ResourceHandleProto::_internal_dtypes_and_shapes(int index) const {
+  return _impl_.dtypes_and_shapes_.Get(index);
+}
+inline const ::tensorflow::ResourceHandleProto_DtypeAndShape& ResourceHandleProto::dtypes_and_shapes(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.ResourceHandleProto.dtypes_and_shapes)
+  return _internal_dtypes_and_shapes(index);
+}
+inline ::tensorflow::ResourceHandleProto_DtypeAndShape* ResourceHandleProto::_internal_add_dtypes_and_shapes() {
+  return _impl_.dtypes_and_shapes_.Add();
+}
+inline ::tensorflow::ResourceHandleProto_DtypeAndShape* ResourceHandleProto::add_dtypes_and_shapes() {
+  ::tensorflow::ResourceHandleProto_DtypeAndShape* _add = _internal_add_dtypes_and_shapes();
+  // @@protoc_insertion_point(field_add:tensorflow.ResourceHandleProto.dtypes_and_shapes)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::ResourceHandleProto_DtypeAndShape >&
+ResourceHandleProto::dtypes_and_shapes() const {
+  // @@protoc_insertion_point(field_list:tensorflow.ResourceHandleProto.dtypes_and_shapes)
+  return _impl_.dtypes_and_shapes_;
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace tensorflow
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fresource_5fhandle_2eproto
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/resource_handle.proto b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/resource_handle.proto
new file mode 100644
index 0000000000000000000000000000000000000000..5a41750475d6121a266418d83c69ac7d150ade85
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/resource_handle.proto
@@ -0,0 +1,45 @@
+syntax = "proto3";
+
+package tensorflow;
+
+import "tensorflow/core/framework/tensor_shape.proto";
+import "tensorflow/core/framework/types.proto";
+
+option cc_enable_arenas = true;
+option java_outer_classname = "ResourceHandle";
+option java_multiple_files = true;
+option java_package = "org.tensorflow.framework";
+option go_package = "github.com/tensorflow/tensorflow/tensorflow/go/core/framework/resource_handle_go_proto";
+
+// Protocol buffer representing a handle to a tensorflow resource. Handles are
+// not valid across executions, but can be serialized back and forth from within
+// a single run.
+message ResourceHandleProto {
+  // Unique name for the device containing the resource.
+  string device = 1;
+
+  // Container in which this resource is placed.
+  string container = 2;
+
+  // Unique name of this resource.
+  string name = 3;
+
+  // Hash code for the type of the resource. Is only valid in the same device
+  // and in the same execution.
+  uint64 hash_code = 4;
+
+  // For debug-only, the name of the type pointed to by this handle, if
+  // available.
+  string maybe_type_name = 5;
+
+  // Protocol buffer representing a pair of (data type, tensor shape).
+  message DtypeAndShape {
+    DataType dtype = 1;
+    TensorShapeProto shape = 2;
+  }
+
+  // Data types and shapes for the underlying resource.
+  repeated DtypeAndShape dtypes_and_shapes = 6;
+
+  reserved 7;
+}
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/resource_mgr.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/resource_mgr.h
new file mode 100644
index 0000000000000000000000000000000000000000..7a4a1047bc59bba6a126cf3b7d05fd6d67c88266
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/resource_mgr.h
@@ -0,0 +1,1026 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_RESOURCE_MGR_H_
+#define TENSORFLOW_CORE_FRAMEWORK_RESOURCE_MGR_H_
+
+#include <memory>
+#include <string>
+#include <typeindex>
+#include <typeinfo>
+#include <unordered_map>
+
+#include "absl/container/flat_hash_map.h"
+#include "absl/types/variant.h"
+#include "tensorflow/core/framework/common_shape_fns.h"
+#include "tensorflow/core/framework/device_attributes.pb.h"
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/resource_base.h"
+#include "tensorflow/core/framework/resource_handle.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/tensor_shape.h"
+#include "tensorflow/core/framework/tensor_types.h"
+#include "tensorflow/core/framework/type_index.h"
+#include "tensorflow/core/framework/variant_tensor_data.h"
+#include "tensorflow/core/lib/core/errors.h"
+#include "tensorflow/core/lib/hash/hash.h"
+#include "tensorflow/core/platform/logging.h"
+#include "tensorflow/core/platform/macros.h"
+#include "tensorflow/core/platform/mutex.h"
+#include "tensorflow/core/platform/thread_annotations.h"
+
+namespace tensorflow {
+
+// A ResourceMgr instance keeps track of named and typed resources
+// grouped into containers.
+//
+// Each named resource is
+// registered with ResourceMgr under a named "container" name. At any
+// time, there is at most one instance of a resource given the container
+// name, the resource type and the resource name.
+//
+// All resources for a given container can be dropped by one call of
+// Cleanup().
+//
+// E.g.,
+//   struct MyVar : public ResourceBase {
+//     mutex mu;
+//     Tensor val;
+//   }
+//
+//   ResourceMgr rm;
+//
+//   // Create a var.
+//   MyVar* my_var = new MyVar;
+//   my_var->val = Tensor(DT_FLOAT, my_shape);
+//   my_var->val.flat<float>().setZeros();   // 0 initialized.
+//   ctx->SetStatus(rm.Create("my_container", "my_name", my_var));
+//
+//   // += a variable.
+//   MyVar* my_var = nullptr;
+//   Status s = rm.Lookup("my_container", "my_name", &my_var);
+//   if (s.ok()) {
+//     my_var->val.flat<float>() += grad;
+//   }
+//   my_var->Unref();   // Or use ScopedUnref().
+//   ctx->SetStatus(s);
+
+// Container used for per-step resources.
+class ScopedStepContainer {
+ public:
+  // step_id: the unique ID of this step. Doesn't have to be sequential, just
+  // has to be unique.
+  // cleanup: callback to delete a container of this name.
+  // prefix: optional string prefix to disambiguate step containers.
+  ScopedStepContainer(const int64_t step_id,
+                      std::function<void(const string&)> cleanup)
+      : step_id_(step_id),
+        container_(strings::StrCat("__per_step_", step_id)),
+        cleanup_(cleanup),
+        dirty_(false) {}
+
+  ScopedStepContainer(const int64_t step_id,
+                      std::function<void(const string&)> cleanup,
+                      const std::string& prefix)
+      : step_id_(step_id),
+        container_(strings::StrCat("__", prefix, "_per_step_", step_id)),
+        cleanup_(cleanup),
+        dirty_(false) {}
+
+  ~ScopedStepContainer() { CleanUp(); }
+
+  void CleanUp() TF_NO_THREAD_SAFETY_ANALYSIS {
+    // NOTE(mrry): Avoid acquiring the mutex in the case that the container is
+    // clean.
+    if (dirty_) {
+      mutex_lock ml(mu_);
+      cleanup_(container_);
+      dirty_ = false;
+    }
+  }
+
+  // Pass through functions for resource lookup and creation. We do this to
+  // ensure that we can appropriately set the dirty_ bit in the
+  // ScopedStepContainer if the name of the container is used to create
+  // resources.
+
+  // Pass through to MakeResourceHandle with the container name
+  template <typename T>
+  ResourceHandle MakeResourceHandle(
+      const std::string& name, const DeviceBase& device) TF_MUST_USE_RESULT;
+  // Pass through to ResourceMgr::Create with the container name
+  template <typename T>
+  Status Create(ResourceMgr* rm, const std::string& name,
+                T* resource) TF_MUST_USE_RESULT;
+  // Pass through to ResourceMgr::Delete with the container name
+  template <typename T>
+  Status Delete(ResourceMgr* rm, const std::string& name) TF_MUST_USE_RESULT;
+  // Pass through to ResourceMgr::Lookup with the container name
+  template <typename T>
+  Status Lookup(ResourceMgr* rm, const std::string& name,
+                T** resource) const TF_MUST_USE_RESULT;
+  // Pass through to ResourceMgr::LookupOrCreate with the container name
+  template <typename T>
+  Status LookupOrCreate(ResourceMgr* rm, const std::string& name, T** resource,
+                        std::function<Status(T**)> creator) TF_MUST_USE_RESULT;
+  int64_t StepId() const { return step_id_; }
+
+ private:
+  const int64_t step_id_;
+  const std::string container_;
+  const std::function<void(const string&)> cleanup_;
+  mutex mu_;
+  mutable std::atomic<bool> dirty_ TF_GUARDED_BY(mu_);
+};
+
+class ResourceMgr {
+ public:
+  ResourceMgr();
+  explicit ResourceMgr(const std::string& default_container);
+  ~ResourceMgr();
+
+  // Returns the default container name for *this.
+  const std::string& default_container() const { return default_container_; }
+
+  // Creates a resource "name" in the "container".  The caller transfers
+  // the ownership of one ref on "resource" to *this, regardless of whether this
+  // operation succeeds or fails.
+  //
+  // REQUIRES: std::is_base_of<ResourceBase, T>
+  // REQUIRES: resource != nullptr.
+  template <typename T>
+  Status Create(const std::string& container, const std::string& name,
+                T* resource) TF_MUST_USE_RESULT;
+
+  // Creates a unowned resource "name" in the "container".  The caller does NOT
+  // transfer the ownership of any ref on "resource" to *this, regardless of
+  // whether this operation succeeds or fails.
+  //
+  // After the resource is destroyed, lookups from the manager fail.
+  // The caller must call this->Delete() on the name to free up the memory
+  // entry of the name.
+  //
+  // REQUIRES: std::is_base_of<ResourceBase, T>
+  // REQUIRES: resource != nullptr.
+  template <typename T>
+  Status CreateUnowned(const std::string& container, const std::string& name,
+                       T* resource) TF_MUST_USE_RESULT;
+
+  // If "container" has a resource "name", returns it in "*resource" and
+  // the caller takes the ownership of one ref on "*resource".
+  //
+  // REQUIRES: std::is_base_of<ResourceBase, T>
+  // REQUIRES: resource != nullptr
+  template <typename T, bool use_dynamic_cast = false>
+  Status Lookup(const std::string& container, const std::string& name,
+                T** resource) const TF_MUST_USE_RESULT;
+
+  // If the resource manager has a resource matching "handle", returns it in
+  // "*resource" and the caller takes the ownership of one ref on "*resource".
+  //
+  // REQUIRES: resource != nullptr
+  Status Lookup(const ResourceHandle& handle,
+                ResourceBase** resource) const TF_MUST_USE_RESULT;
+
+  // Similar to Lookup, but looks up multiple resources at once, with only a
+  // single lock acquisition.  If containers_and_names[i] is uninitialized
+  // then this function does not modify resources[i].
+  template <typename T, bool use_dynamic_cast = false>
+  Status LookupMany(absl::Span<std::pair<const string*, const string*> const>
+                        containers_and_names,
+                    std::vector<core::RefCountPtr<T>>* resources) const
+      TF_MUST_USE_RESULT;
+
+  // If "container" has a resource "name", returns it in
+  // "*resource". Otherwise, invokes creator() to create the resource.
+  // The caller takes the ownership of one ref on "*resource".
+  //
+  // WARNING: creator() must not call any methods on ResourceMgr during its
+  // execution, because a non-reentrant lock is held during the creator() call
+  // in order to guarantee atomicity of LookupOrCreate().
+  //
+  // REQUIRES: std::is_base_of<ResourceBase, T>
+  // REQUIRES: resource != nullptr
+  template <typename T, bool use_dynamic_cast = false>
+  Status LookupOrCreate(const std::string& container, const std::string& name,
+                        T** resource,
+                        std::function<Status(T**)> creator) TF_MUST_USE_RESULT;
+
+  // Deletes the resource "name" from the "container".
+  //
+  // REQUIRES: std::is_base_of<ResourceBase, T>
+  template <typename T>
+  Status Delete(const std::string& container,
+                const std::string& name) TF_MUST_USE_RESULT;
+
+  // Deletes the resource pointed by "handle".
+  Status Delete(const ResourceHandle& handle) TF_MUST_USE_RESULT;
+
+  // Deletes all resources from the "container" and removes the container.
+  Status Cleanup(const std::string& container) TF_MUST_USE_RESULT;
+
+  // Deletes all resources in all containers.
+  void Clear();
+
+  // Returns a text description for all resources.
+  std::string DebugString() const;
+
+ private:
+  typedef std::pair<uint64, StringPiece> Key;
+  struct KeyHash {
+    std::size_t operator()(const Key& k) const {
+      return Hash64(k.second.data(), k.second.size(), k.first);
+    }
+  };
+  struct KeyEqual {
+    bool operator()(const Key& x, const Key& y) const {
+      return (x.second == y.second) && (x.first == y.first);
+    }
+  };
+  struct ResourceAndName {
+    absl::variant<core::RefCountPtr<ResourceBase>, core::WeakPtr<ResourceBase>>
+        resource;
+    std::unique_ptr<std::string> name;
+
+    ResourceAndName();
+    explicit ResourceAndName(const string& name);
+    ResourceAndName(ResourceAndName&& other) noexcept;
+    ~ResourceAndName();
+
+    ResourceAndName& operator=(ResourceAndName&&) noexcept;
+
+    // Returns a strong reference to resource, or nullptr if the resource is
+    // no longer valid.
+    core::RefCountPtr<ResourceBase> GetResource() const;
+
+   private:
+    ResourceAndName(const ResourceAndName&) = delete;
+    void operator=(const ResourceAndName&) = delete;
+  };
+  typedef absl::flat_hash_map<Key, ResourceAndName, KeyHash, KeyEqual>
+      Container;
+
+  const std::string default_container_;
+  mutable mutex mu_;
+  absl::flat_hash_map<string, Container*> containers_ TF_GUARDED_BY(mu_);
+
+  template <typename T, bool use_dynamic_cast = false>
+  Status LookupInternal(const std::string& container, const std::string& name,
+                        T** resource) const
+      TF_SHARED_LOCKS_REQUIRED(mu_) TF_MUST_USE_RESULT;
+  Status LookupInternal(const std::string& container, uint64 type_hash_code,
+                        const std::string& name, ResourceBase** resource) const
+      TF_SHARED_LOCKS_REQUIRED(mu_) TF_MUST_USE_RESULT;
+
+  Status DoCreate(const std::string& container, TypeIndex type,
+                  const std::string& name, ResourceBase* resource,
+                  bool owns_resource)
+      TF_EXCLUSIVE_LOCKS_REQUIRED(mu_) TF_MUST_USE_RESULT;
+
+  Status DoLookup(const std::string& container, TypeIndex type,
+                  const std::string& name, ResourceBase** resource) const
+      TF_SHARED_LOCKS_REQUIRED(mu_) TF_MUST_USE_RESULT;
+  Status DoLookup(const std::string& container, uint64 type_hash_code,
+                  const std::string& type_name,
+                  const std::string& resource_name,
+                  ResourceBase** resource) const
+      TF_SHARED_LOCKS_REQUIRED(mu_) TF_MUST_USE_RESULT;
+
+  Status DoDelete(const std::string& container, uint64 type_hash_code,
+                  const std::string& resource_name,
+                  const std::string& type_name) TF_MUST_USE_RESULT;
+  Status DoDelete(const std::string& container, TypeIndex type,
+                  const std::string& resource_name) TF_MUST_USE_RESULT;
+
+  // Pops the ResourceAndName entry. The entry is moved from the list to
+  // the output argument `resource_and_name`.
+  Status PopResourceAndName(
+      const std::string& container, uint64 type_hash_code,
+      const std::string& resource_name, const std::string& type_name,
+      ResourceAndName& resource_and_name) TF_MUST_USE_RESULT;
+  // Inserts the type name for 'hash_code' into the hash_code to type name map.
+  Status InsertDebugTypeName(uint64 hash_code, const std::string& type_name)
+      TF_EXCLUSIVE_LOCKS_REQUIRED(mu_) TF_MUST_USE_RESULT;
+
+  // Returns the type name for the 'hash_code'.
+  // Returns "<unknown>" if a resource with such a type was never inserted into
+  // the container.
+  const char* DebugTypeName(uint64 hash_code) const
+      TF_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+
+  // Map from type hash_code to type name.
+  std::unordered_map<uint64, string> debug_type_names_ TF_GUARDED_BY(mu_);
+
+  ResourceMgr(const ResourceMgr&) = delete;
+  void operator=(const ResourceMgr&) = delete;
+};
+
+// Makes a resource handle with the specified type for a given container /
+// name.
+ResourceHandle MakeResourceHandle(
+    const std::string& container, const std::string& name,
+    const DeviceBase& device, const TypeIndex& type_index,
+    const std::vector<DtypeAndPartialTensorShape>& dtypes_and_shapes = {},
+    const absl::optional<ManagedStackTrace>& definition_stack_trace = {})
+    TF_MUST_USE_RESULT;
+
+template <typename T>
+ResourceHandle MakeResourceHandle(
+    OpKernelContext* ctx, const std::string& container, const std::string& name,
+    const std::vector<DtypeAndPartialTensorShape>& dtypes_and_shapes = {},
+    const absl::optional<ManagedStackTrace>& definition_stack_trace = {}) {
+  return MakeResourceHandle(container.empty()
+                                ? ctx->resource_manager()->default_container()
+                                : container,
+                            name, *ctx->device(), TypeIndex::Make<T>(),
+                            dtypes_and_shapes, definition_stack_trace);
+}
+
+template <typename T>
+ResourceHandle MakeResourceHandle(
+    OpKernelConstruction* ctx, const std::string& container,
+    const std::string& name,
+    const std::vector<DtypeAndPartialTensorShape>& dtypes_and_shapes = {},
+    const absl::optional<ManagedStackTrace>& definition_stack_trace = {}) {
+  return MakeResourceHandle(container.empty()
+                                ? ctx->resource_manager()->default_container()
+                                : container,
+                            name, *ctx->device(), TypeIndex::Make<T>(),
+                            dtypes_and_shapes, definition_stack_trace);
+}
+
+Status MakeResourceHandleToOutput(OpKernelContext* context, int output_index,
+                                  const std::string& container,
+                                  const std::string& name,
+                                  const TypeIndex& type_index);
+
+// Returns a resource handle from a numbered op input.
+const ResourceHandle& HandleFromInput(OpKernelContext* ctx, int input);
+
+// Safely returns a resource handle from a numbered op input.
+// Prevents segfault by checking for empty resource handle.
+Status HandleFromInput(OpKernelContext* ctx, int input, ResourceHandle* handle);
+// Returns a resource handle by name, as defined in the OpDef.
+// Also prevents segfault by checking for empty resource handle.
+Status HandleFromInput(OpKernelContext* ctx, StringPiece input,
+                       ResourceHandle* handle);
+
+// Create a resource pointed by a given resource handle.
+//
+// If successful, the caller transfers the ownership of one ref on `resource` to
+// `ctx->resource_mgr()`.
+template <typename T>
+Status CreateResource(OpKernelContext* ctx, const ResourceHandle& p, T* value);
+
+// Looks up a resource pointed by a given resource handle.
+//
+// If the lookup is successful, the caller takes the ownership of one ref on
+// `*value`, and must call its `Unref()` method when it has finished using it.
+template <typename T, bool use_dynamic_cast = false>
+Status LookupResource(OpKernelContext* ctx, const ResourceHandle& p, T** value);
+
+// Looks up a resource pointed by a given resource handle.
+//
+// Prefer usage of LookupResource taking `core::RefCountPtr` to avoid
+// requiring the caller to explicitly call `Unref()`.
+template <typename T>
+Status LookupResource(OpKernelContext* ctx, const ResourceHandle& p,
+                      core::RefCountPtr<T>* value);
+
+// Looks up multiple resources pointed by a sequence of resource handles.  If
+// p[i] is uninitialized then values[i] is unmodified.
+template <typename T>
+Status LookupResources(OpKernelContext* ctx, absl::Span<ResourceHandle const> p,
+                       std::vector<core::RefCountPtr<T>>* values);
+
+// Looks up or creates a resource.
+//
+// If successful, the caller takes the ownership of one ref on `*value`, and
+// must call its `Unref()` method when it has finished using it. If the
+// `creator` is invoked, its reference on the created resource is transferred
+// to `ctx->resource_mgr()`.
+//
+// Prefer usage of LookupOrCreateResource taking `core::RefCountPtr` to avoid
+// requiring the caller to explicitly call `Unref()`.
+template <typename T>
+Status LookupOrCreateResource(OpKernelContext* ctx, const ResourceHandle& p,
+                              T** value, std::function<Status(T**)> creator);
+
+// Looks up or creates a resource.
+template <typename T>
+Status LookupOrCreateResource(OpKernelContext* ctx, const ResourceHandle& p,
+                              core::RefCountPtr<T>* value,
+                              std::function<Status(T**)> creator);
+
+// Destroys a resource pointed by a given resource handle.
+template <typename T>
+Status DeleteResource(OpKernelContext* ctx, const ResourceHandle& p);
+
+// Same as above, but uses the hash code of the type directly.
+// The type name information will be missing in the debug output when the
+// resource is not present in the container.
+Status DeleteResource(OpKernelContext* ctx, const ResourceHandle& p);
+
+// Policy helper to decide which container/shared_name to use for a
+// stateful kernel that accesses shared resource.
+class ContainerInfo {
+ public:
+  // Analyze the node attribute of 'ndef' and decides the container and
+  // resource name the kernel should use for accessing the shared
+  // resource.
+  //
+  // 'ndef' is expected to have node attribute "container" and
+  // "shared_name". Returns non-OK if they are not provided or they are
+  // invalid.
+  //
+  // The policy is as following:
+  // * If the attribute "container" is non-empty, it is used as is.
+  //   Otherwise, uses the resource manager's default container.
+  // * If the attribute "shared_name" is non-empty, it is used as is.
+  //   Otherwise, if "use_node_name_as_default" is true, the kernel's
+  //   node name is used as the resource name. Otherwise, a string
+  //   unique to this process is used.
+  Status Init(ResourceMgr* rmgr, const NodeDef& ndef,
+              bool use_node_name_as_default);
+  Status Init(ResourceMgr* rmgr, const NodeDef& ndef) {
+    return Init(rmgr, ndef, false);
+  }
+
+  // The policy decides that the kernel should access the resource in
+  // resource_manager(), the resource is in the container() and its
+  // name is name().  If resource_is_private_to_kernel() is true, the
+  // kernel should delete the resource when the kernel is deleted.
+  ResourceMgr* resource_manager() const { return rmgr_; }
+  const std::string& container() const { return container_; }
+  const std::string& name() const { return name_; }
+  bool resource_is_private_to_kernel() const {
+    return resource_is_private_to_kernel_;
+  }
+
+  // Returns a readable string for *this.
+  std::string DebugString() const;
+
+ private:
+  ResourceMgr* rmgr_ = nullptr;
+  std::string container_;
+  std::string name_;
+  bool resource_is_private_to_kernel_ = false;
+};
+
+// Helper for kernels to obtain 'resource' from the
+// ctx->resource_manager().
+//
+// "input_name" specifies the kernel's ref input which gives a string
+// tensor with two elements, which specifies the container and
+// resource name.
+//
+// Returns OK if the resource is found and transfers one ref of
+// *resource to the caller. Otherwise, returns an error.
+template <typename T>
+Status GetResourceFromContext(OpKernelContext* ctx,
+                              const std::string& input_name, T** resource);
+
+// Utility op kernel to check if a handle to resource type T is initialized.
+template <typename T>
+class IsResourceInitialized : public OpKernel {
+ public:
+  explicit IsResourceInitialized(OpKernelConstruction* c) : OpKernel(c) {}
+
+  void Compute(OpKernelContext* ctx) override;
+};
+
+// Registers an op which produces just a resource handle to a resource of the
+// specified type. The type will be a part of the generated op name.
+// TODO(apassos): figure out how to get non-cpu-allocated tensors to work
+// through constant folding so this doesn't have to be marked as stateful.
+#define REGISTER_RESOURCE_HANDLE_OP(Type) \
+  REGISTER_OP(#Type "HandleOp")           \
+      .Attr("container: string = ''")     \
+      .Attr("shared_name: string = ''")   \
+      .Output("resource: resource")       \
+      .SetIsStateful()                    \
+      .SetShapeFn(tensorflow::shape_inference::ScalarShape)
+
+// Utility op kernel to produce a handle to a resource of type T.
+template <typename T>
+class ResourceHandleOp : public OpKernel {
+ public:
+  explicit ResourceHandleOp(OpKernelConstruction* context);
+
+  void Compute(OpKernelContext* ctx) override;
+
+  bool IsExpensive() override { return false; }
+
+ private:
+  std::string container_;
+  std::string name_;
+  mutex mutex_;
+  Tensor resource_;
+  std::atomic<bool> initialized_{false};
+};
+
+// Utility op kernel to produce a handle to a resource of type T.
+template <typename T>
+class ResourceHandlesOp : public OpKernel {
+ public:
+  explicit ResourceHandlesOp(OpKernelConstruction* context);
+
+  void Compute(OpKernelContext* ctx) override;
+
+  bool IsExpensive() override { return false; }
+
+ private:
+  std::vector<string> containers_;
+  std::vector<string> names_;
+  mutex mutex_;
+  std::vector<Tensor> resources_;
+  std::atomic<bool> initialized_{false};
+};
+
+// Registers a kernel for an op which produces a handle to a resource of the
+// specified type.
+#define REGISTER_RESOURCE_HANDLE_KERNEL(Type)                        \
+  REGISTER_KERNEL_BUILDER(Name(#Type "HandleOp").Device(DEVICE_CPU), \
+                          ResourceHandleOp<Type>)
+
+// This class is used to guarantee that an anonymous resource is deleted
+// (irrespective of whether a resource deleter op is called explicitly or
+// the execution encounters an error before the op runs).
+//
+// This is achieved by wrapping an instance of this class into a variant
+// tensor which is passed as an input to a resource deleter op. If the
+// execution encounters an error before the op runs, the tensor will be
+// destroyed, essentially triggering the iterator deletion.
+// NOTE: This is not a feature-complete implementation of the DT_VARIANT
+// specification. In particular, we cannot serialize the `ResourceMgr`
+// object, so the `Encode()` and `Decode()` methods are not implemented.
+class ResourceDeleter {
+ public:
+  ResourceDeleter() : deleter_() {}
+
+  ResourceDeleter(ResourceHandle handle, ResourceMgr* resource_manager)
+      : deleter_(std::make_shared<Helper>(handle, resource_manager)) {}
+
+  ResourceDeleter(ResourceDeleter&& rhs) : deleter_(std::move(rhs.deleter_)) {
+    VLOG(3) << "ResourceDeleter move constructor called.";
+  }
+
+  ResourceDeleter(const ResourceDeleter& rhs) : deleter_(rhs.deleter_) {
+    VLOG(3) << "ResourceDeleter copy constructor called.";
+  }
+
+  ResourceDeleter& operator=(const ResourceDeleter& rhs) = delete;
+
+  ResourceDeleter& operator=(ResourceDeleter&& rhs) = default;
+
+  virtual ~ResourceDeleter() {
+    VLOG(3) << "ResourceDeleter destructor called.";
+  }
+
+  void Encode(VariantTensorData*) const {
+    LOG(ERROR) << "The Encode() method is not implemented for ResourceDeleter "
+                  "objects.";
+  }
+
+  bool Decode(const VariantTensorData&) {
+    LOG(ERROR) << "The Decode() method is not implemented for ResourceDeleter "
+                  "objects";
+    return false;  // Not supported.
+  }
+
+ private:
+  // Helper that performs reference counting for the parent class and deletes
+  // the iterator resource when the refcount goes to zero.
+  //
+  // NOTE: The object is borrowing a pointer to the resource manager.
+  // Consequently, the tensor containing this object should not escape the
+  // function in which was created (so that it is guaranteed that the resource
+  // manager will outlive it).
+  struct Helper {
+    Helper(ResourceHandle handle, ResourceMgr* resource_manager)
+        : handle(handle), resource_manager(resource_manager) {}
+
+    Helper(const Helper& rhs) = delete;
+    Helper(Helper&& rhs) = delete;
+
+    ~Helper() {
+      VLOG(3) << "Deleting Resource: " << handle.DebugString();
+      resource_manager->Delete(handle).IgnoreError();
+    }
+
+    ResourceHandle handle;
+    ResourceMgr* resource_manager;  // not owned
+  };
+
+  std::shared_ptr<Helper> deleter_;
+};
+
+// Implementation details below.
+
+template <typename T>
+void CheckDeriveFromResourceBase() {
+  static_assert(std::is_base_of<ResourceBase, T>::value,
+                "T must derive from ResourceBase");
+}
+
+template <typename T>
+Status ResourceMgr::Create(const std::string& container,
+                           const std::string& name, T* resource) {
+  CheckDeriveFromResourceBase<T>();
+  CHECK(resource != nullptr);
+  mutex_lock l(mu_);
+  return DoCreate(container, TypeIndex::Make<T>(), name, resource,
+                  /* owns_resource */ true);
+}
+
+template <typename T>
+Status ResourceMgr::CreateUnowned(const std::string& container,
+                                  const std::string& name, T* resource) {
+  CheckDeriveFromResourceBase<T>();
+  mutex_lock l(mu_);
+  return DoCreate(container, TypeIndex::Make<T>(), name, resource,
+                  /* owns_resource */ false);
+}
+
+template <typename T, bool use_dynamic_cast>
+Status ResourceMgr::Lookup(const std::string& container,
+                           const std::string& name, T** resource) const {
+  CheckDeriveFromResourceBase<T>();
+  tf_shared_lock l(mu_);
+  return LookupInternal<T, use_dynamic_cast>(container, name, resource);
+}
+
+template <typename T, bool use_dynamic_cast>
+Status ResourceMgr::LookupMany(
+    absl::Span<std::pair<const string*, const string*> const>
+        containers_and_names,
+    std::vector<core::RefCountPtr<T>>* resources) const {
+  CheckDeriveFromResourceBase<T>();
+  tf_shared_lock l(mu_);
+  resources->resize(containers_and_names.size());
+  for (size_t i = 0; i < containers_and_names.size(); ++i) {
+    T* resource;
+    Status s = LookupInternal<T, use_dynamic_cast>(
+        *containers_and_names[i].first, *containers_and_names[i].second,
+        &resource);
+    if (s.ok()) {
+      (*resources)[i].reset(resource);
+    }
+  }
+  return OkStatus();
+}
+
+// Simple wrapper to allow conditional dynamic / static casts.
+template <typename T, bool use_dynamic_cast>
+struct TypeCastFunctor {
+  static T* Cast(ResourceBase* r) { return static_cast<T*>(r); }
+};
+
+template <typename T>
+struct TypeCastFunctor<T, true> {
+  static T* Cast(ResourceBase* r) { return dynamic_cast<T*>(r); }
+};
+
+template <typename T, bool use_dynamic_cast>
+Status ResourceMgr::LookupInternal(const std::string& container,
+                                   const std::string& name,
+                                   T** resource) const {
+  ResourceBase* found = nullptr;
+  Status s = DoLookup(container, TypeIndex::Make<T>(), name, &found);
+  if (s.ok()) {
+    // It's safe to down cast 'found' to T* since
+    // typeid(T).hash_code() is part of the map key.
+    *resource = TypeCastFunctor<T, use_dynamic_cast>::Cast(found);
+  }
+  return s;
+}
+
+template <typename T, bool use_dynamic_cast>
+Status ResourceMgr::LookupOrCreate(const std::string& container,
+                                   const std::string& name, T** resource,
+                                   std::function<Status(T**)> creator) {
+  CheckDeriveFromResourceBase<T>();
+  *resource = nullptr;
+  Status s;
+  {
+    tf_shared_lock l(mu_);
+    s = LookupInternal<T, use_dynamic_cast>(container, name, resource);
+    if (s.ok()) return s;
+  }
+  mutex_lock l(mu_);
+  s = LookupInternal<T, use_dynamic_cast>(container, name, resource);
+  if (s.ok()) return s;
+  TF_RETURN_IF_ERROR(creator(resource));
+  s = DoCreate(container, TypeIndex::Make<T>(), name, *resource,
+               /* owns_resource */ true);
+  if (!s.ok()) {
+    return errors::Internal("LookupOrCreate failed unexpectedly");
+  }
+  (*resource)->Ref();
+  return s;
+}
+
+template <typename T>
+Status ResourceMgr::Delete(const std::string& container,
+                           const std::string& name) {
+  CheckDeriveFromResourceBase<T>();
+  return DoDelete(container, TypeIndex::Make<T>(), name);
+}
+
+template <typename T>
+Status GetResourceFromContext(OpKernelContext* ctx,
+                              const std::string& input_name, T** resource) {
+  DataType dtype;
+  TF_RETURN_IF_ERROR(ctx->input_dtype(input_name, &dtype));
+  if (dtype == DT_RESOURCE) {
+    const Tensor* handle;
+    TF_RETURN_IF_ERROR(ctx->input(input_name, &handle));
+    return LookupResource(ctx, handle->scalar<ResourceHandle>()(), resource);
+  }
+  std::string container;
+  std::string shared_name;
+  {
+    mutex* mu;
+    TF_RETURN_IF_ERROR(ctx->input_ref_mutex(input_name, &mu));
+    mutex_lock l(*mu);
+    Tensor tensor;
+    TF_RETURN_IF_ERROR(ctx->mutable_input(input_name, &tensor, true));
+    if (tensor.NumElements() != 2) {
+      return errors::InvalidArgument(
+          "Resource handle must have 2 elements, but had shape: ",
+          tensor.shape().DebugString());
+    }
+    container = tensor.flat<tstring>()(0);
+    shared_name = tensor.flat<tstring>()(1);
+  }
+  return ctx->resource_manager()->Lookup(container, shared_name, resource);
+}
+
+namespace internal {
+
+Status ValidateDevice(OpKernelContext* ctx, const ResourceHandle& p);
+
+template <typename T>
+Status ValidateDeviceAndType(OpKernelContext* ctx, const ResourceHandle& p) {
+  TF_RETURN_IF_ERROR(internal::ValidateDevice(ctx, p));
+  TF_RETURN_IF_ERROR(p.ValidateType<T>());
+  return OkStatus();
+}
+
+}  // namespace internal
+
+// Creates the resource pointed at by "p". The caller transfers the ownership of
+// one ref on "*value" to the resource manager in "ctx", regardless of whether
+// this operation succeeds or fails.
+template <typename T>
+Status CreateResource(OpKernelContext* ctx, const ResourceHandle& p, T* value) {
+  TF_RETURN_IF_ERROR(internal::ValidateDeviceAndType<T>(ctx, p));
+  return ctx->resource_manager()->Create(p.container(), p.name(), value);
+}
+
+// Finds the resource as "*value" from the handle. If the handle is
+// ref-counting, returns the resource owned by the handle. Otherwise, looks up
+// the resource matching "p" from resource manager associated with ctx.
+// Always returns a new reference to the resource in "*value". The caller shall
+// call (*value)->Unref().
+template <typename T, bool use_dynamic_cast>
+Status LookupResource(OpKernelContext* ctx, const ResourceHandle& p,
+                      T** value) {
+  TF_RETURN_IF_ERROR(internal::ValidateDeviceAndType<T>(ctx, p));
+  if (p.IsRefCounting()) {
+    TF_ASSIGN_OR_RETURN(*value, p.GetResource<T>());
+    // Transfers out a new reference.
+    (*value)->Ref();
+    return OkStatus();
+  }
+
+  return ctx->resource_manager()->Lookup<T, use_dynamic_cast>(p.container(),
+                                                              p.name(), value);
+}
+
+// Finds the resource as "*value" from the handle. This is a type-erased
+// variant of LookupResource above.
+Status LookupResource(OpKernelContext* ctx, const ResourceHandle& p,
+                      ResourceBase** value);
+
+// If the resource manager in "ctx" has a resource matching "p", returns it in
+// "*value".
+template <typename T>
+Status LookupResource(OpKernelContext* ctx, const ResourceHandle& p,
+                      core::RefCountPtr<T>* value) {
+  T* raw_ptr = nullptr;
+  TF_RETURN_IF_ERROR(LookupResource<T, false>(ctx, p, &raw_ptr));
+  value->reset(raw_ptr);
+
+  return OkStatus();
+}
+
+// Similar to Lookup, but looks up multiple resources at once, with only a
+// single lock acquisition.
+template <typename T>
+Status LookupResources(OpKernelContext* ctx,
+                       absl::Span<ResourceHandle const* const> p,
+                       std::vector<core::RefCountPtr<T>>* values) {
+  std::vector<std::pair<const string*, const string*>> containers_and_names(
+      p.size());
+  for (size_t i = 0; i < p.size(); ++i) {
+    TF_RETURN_IF_ERROR(internal::ValidateDeviceAndType<T>(ctx, *p[i]));
+    containers_and_names[i] = {&p[i]->container(), &p[i]->name()};
+  }
+  return ctx->resource_manager()->LookupMany(containers_and_names, values);
+}
+
+// If the resource manager in "ctx" has a resource pointed at by "p", returns
+// it in "*value". Otherwise, invokes creator() to create the resource.
+// The caller takes the ownership of one ref on "*value".
+//
+// WARNING: creator() must not call any methods on the resource manager during
+// its execution, because a non-reentrant lock is held during the creator() call
+// in order to guarantee atomicity of LookupOrCreateResource().
+template <typename T>
+Status LookupOrCreateResource(OpKernelContext* ctx, const ResourceHandle& p,
+                              T** value, std::function<Status(T**)> creator) {
+  TF_RETURN_IF_ERROR(internal::ValidateDeviceAndType<T>(ctx, p));
+  return ctx->resource_manager()->LookupOrCreate(p.container(), p.name(), value,
+                                                 creator);
+}
+
+// If the resource manager in "ctx" has a resource pointed at by "p", returns
+// it in "*value". Otherwise, invokes creator() to create the resource.
+//
+// WARNING: creator() must not call any methods on the resource manager during
+// its execution, because a non-reentrant lock is held during the creator() call
+// in order to guarantee atomicity of LookupOrCreateResource().
+template <typename T>
+Status LookupOrCreateResource(OpKernelContext* ctx, const ResourceHandle& p,
+                              core::RefCountPtr<T>* value,
+                              std::function<Status(T**)> creator) {
+  T* raw_ptr = nullptr;
+  TF_RETURN_IF_ERROR(LookupOrCreateResource<T>(ctx, p, &raw_ptr, creator));
+  value->reset(raw_ptr);
+
+  return OkStatus();
+}
+
+// Deletes the resource pointed by "p", using the resource manager in "ctx".
+template <typename T>
+Status DeleteResource(OpKernelContext* ctx, const ResourceHandle& p) {
+  TF_RETURN_IF_ERROR(internal::ValidateDeviceAndType<T>(ctx, p));
+  // This is a noop because ResourceMgr does not hold a reference.
+  // NOTE(feyu): if we can convert all resources handle to ref-counting, then
+  // DeleteResource can be removed.
+  if (p.IsRefCounting()) {
+    return OkStatus();
+  }
+  return ctx->resource_manager()->Delete<T>(p.container(), p.name());
+}
+
+// Deletes the resource pointed by "p", using the resource manager in "ctx".
+Status DeleteResource(OpKernelContext* ctx, const ResourceHandle& p);
+
+template <typename T>
+void IsResourceInitialized<T>::Compute(OpKernelContext* ctx) {
+  Tensor* output;
+  OP_REQUIRES_OK(ctx, ctx->allocate_output(0, {}, &output));
+  T* object;
+  bool found;
+  if (LookupResource(ctx, HandleFromInput(ctx, 0), &object).ok()) {
+    found = true;
+    object->Unref();
+  } else {
+    found = false;
+  }
+
+  output->flat<bool>()(0) = found;
+}
+
+template <typename T>
+ResourceHandleOp<T>::ResourceHandleOp(OpKernelConstruction* context)
+    : OpKernel(context) {
+  OP_REQUIRES_OK(context, context->GetAttr("container", &container_));
+  OP_REQUIRES_OK(context, context->GetAttr("shared_name", &name_));
+}
+
+template <typename T>
+void ResourceHandleOp<T>::Compute(OpKernelContext* ctx) {
+  if (name_ == ResourceHandle::ANONYMOUS_NAME) {
+    AllocatorAttributes attr;
+    attr.set_on_host(true);
+    Tensor handle;
+    OP_REQUIRES_OK(
+        ctx, ctx->allocate_temp(DT_RESOURCE, TensorShape({}), &handle, attr));
+    handle.scalar<ResourceHandle>()() = MakeResourceHandle<T>(
+        ctx, container_, name_, /*dtypes_and_shapes=*/{}, ctx->stack_trace());
+    ctx->set_output(0, handle);
+  } else {
+    if (!initialized_.load()) {
+      mutex_lock ml(mutex_);
+      // Checking again to see if another thread has initialized the resource.
+      if (!initialized_.load()) {
+        AllocatorAttributes attr;
+        attr.set_on_host(true);
+        OP_REQUIRES_OK(ctx, ctx->allocate_temp(DT_RESOURCE, TensorShape({}),
+                                               &resource_, attr));
+        resource_.scalar<ResourceHandle>()() =
+            MakeResourceHandle<T>(ctx, container_, name_,
+                                  /*dtypes_and_shapes=*/{}, ctx->stack_trace());
+        initialized_.store(true);
+      }
+    }
+    ctx->set_output(0, resource_);
+  }
+}
+
+template <typename T>
+ResourceHandlesOp<T>::ResourceHandlesOp(OpKernelConstruction* context)
+    : OpKernel(context) {
+  int n;
+  OP_REQUIRES_OK(context, context->GetAttr("N", &n));
+  OP_REQUIRES_OK(context, context->GetAttr("containers", &containers_));
+  OP_REQUIRES_OK(context, context->GetAttr("shared_names", &names_));
+  OP_REQUIRES(
+      context, containers_.size() == n,
+      errors::InvalidArgument("Number of containers (", containers_.size(),
+                              ") must be equal to N (", n, ")"));
+  OP_REQUIRES(context, names_.size() == n,
+              errors::InvalidArgument("Number of names (", containers_.size(),
+                                      ") must be equal to N (", n, ")"));
+  resources_.resize(n);
+}
+
+template <typename T>
+void ResourceHandlesOp<T>::Compute(OpKernelContext* ctx) {
+  if (!initialized_.load()) {
+    mutex_lock ml(mutex_);
+    // Checking again to see if another thread has initialized the resource.
+    if (!initialized_.load()) {
+      AllocatorAttributes attr;
+      attr.set_on_host(true);
+      for (size_t i = 0; i < resources_.size(); ++i) {
+        OP_REQUIRES_OK(ctx, ctx->allocate_temp(DT_RESOURCE, TensorShape({}),
+                                               &resources_[i], attr));
+        ResourceHandle h =
+            MakeResourceHandle<T>(ctx, containers_[i], names_[i]);
+        resources_[i].template scalar<ResourceHandle>()() = h;
+      }
+      initialized_.store(true);
+    }
+  }
+  for (size_t i = 0; i < resources_.size(); ++i) {
+    ctx->set_output(i, resources_[i]);
+  }
+}
+
+template <typename T>
+ResourceHandle ScopedStepContainer::MakeResourceHandle(
+    const std::string& name, const DeviceBase& device) {
+  mutex_lock ml(mu_);
+  dirty_ = true;
+  return tensorflow::MakeResourceHandle(container_, name, device,
+                                        TypeIndex::Make<T>(), {});
+}
+
+template <typename T>
+Status ScopedStepContainer::Lookup(ResourceMgr* rm, const std::string& name,
+                                   T** resource) const {
+  return rm->Lookup<T>(container_, name, resource);
+}
+
+template <typename T>
+Status ScopedStepContainer::LookupOrCreate(ResourceMgr* rm,
+                                           const std::string& name,
+                                           T** resource,
+                                           std::function<Status(T**)> creator) {
+  mutex_lock ml(mu_);
+  dirty_ = true;
+  return rm->LookupOrCreate<T>(container_, name, resource, creator);
+}
+
+template <typename T>
+Status ScopedStepContainer::Create(ResourceMgr* rm, const std::string& name,
+                                   T* resource) {
+  mutex_lock ml(mu_);
+  dirty_ = true;
+  return rm->Create<T>(container_, name, resource);
+}
+
+template <typename T>
+Status ScopedStepContainer::Delete(ResourceMgr* rm, const std::string& name) {
+  return rm->Delete<T>(container_, name);
+}
+
+}  //  end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_RESOURCE_MGR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/resource_op_kernel.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/resource_op_kernel.h
new file mode 100644
index 0000000000000000000000000000000000000000..a7f20cc33524b828bf700bff2edb9bbac7c78b41
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/resource_op_kernel.h
@@ -0,0 +1,153 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_RESOURCE_OP_KERNEL_H_
+#define TENSORFLOW_CORE_FRAMEWORK_RESOURCE_OP_KERNEL_H_
+
+#include <string>
+
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/op_requires.h"
+#include "tensorflow/core/framework/resource_mgr.h"
+#include "tensorflow/core/framework/tensor_shape.h"
+#include "tensorflow/core/platform/logging.h"
+#include "tensorflow/core/platform/mutex.h"
+#include "tensorflow/core/platform/refcount.h"
+#include "tensorflow/core/platform/thread_annotations.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+
+// ResourceOpKernel<T> is a virtual base class for resource op implementing
+// interface type T. The inherited op looks up the resource name (determined by
+// ContainerInfo), and creates a new resource if necessary.
+//
+// Requirements:
+//  - Op must be marked as stateful.
+//  - Op must have `container` and `shared_name` attributes. Empty `container`
+//  means using the default container. Empty `shared_name` means private
+//  resource.
+//  - Subclass must override CreateResource().
+//  - Subclass is encouraged to override VerifyResource().
+template <typename T>
+class ResourceOpKernel : public OpKernel {
+ public:
+  explicit ResourceOpKernel(OpKernelConstruction* context) : OpKernel(context) {
+    has_resource_type_ = (context->output_type(0) == DT_RESOURCE);
+    if (!has_resource_type_) {
+      // The resource variant of the op may be placed on non-CPU devices, but
+      // this allocation is always on the host. Fortunately we don't need it in
+      // the resource case.
+      OP_REQUIRES_OK(context, context->allocate_temp(
+                                  DT_STRING, TensorShape({2}), &tensor_));
+    }
+  }
+
+  // The resource is deleted from the resource manager only when it is private
+  // to kernel. Ideally the resource should be deleted when it is no longer held
+  // by anyone, but it would break backward compatibility.
+  ~ResourceOpKernel() override {
+    if (cinfo_.resource_is_private_to_kernel()) {
+      if (!cinfo_.resource_manager()
+               ->template Delete<T>(cinfo_.container(), cinfo_.name())
+               .ok()) {
+        // Do nothing; the resource can have been deleted by session resets.
+      }
+    }
+  }
+
+  void Compute(OpKernelContext* context) override TF_LOCKS_EXCLUDED(mu_) {
+    mutex_lock l(mu_);
+    core::RefCountPtr<T> resource_ref_ptr = weak_resource_.GetNewRef();
+    if (resource_ref_ptr == nullptr) {
+      ResourceMgr* mgr = context->resource_manager();
+      OP_REQUIRES_OK(context, cinfo_.Init(mgr, def()));
+
+      T* resource;
+      OP_REQUIRES_OK(context,
+                     mgr->LookupOrCreate<T>(
+                         cinfo_.container(), cinfo_.name(), &resource,
+                         [this](T** ret) TF_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
+                           Status s = CreateResource(ret);
+                           if (!s.ok() && *ret != nullptr) {
+                             CHECK((*ret)->Unref());
+                           }
+                           return s;
+                         }));
+      // Here the code releases the reference to the resource created by this op
+      // and only holds a WeakPtr to the resource. This way the lifetime of the
+      // resource is owned by the container; otherwise the container may be
+      // cleared (e.g. a Session::Reset()) but the resource lives on inside this
+      // op, causing later lookups in the container by handle to fail.
+      core::ScopedUnref resource_unref(resource);
+      OP_REQUIRES_OK(context, VerifyResource(resource));
+      weak_resource_ = core::WeakPtr<T>(resource);
+      // TODO(b/243544755): delete after scam migrates ResourceKernelOp
+      // subclasses to get_resource() in TF 2.11.
+      resource_ = resource;
+
+      if (!has_resource_type_) {
+        auto h = tensor_.template flat<tstring>();
+        h(0) = cinfo_.container();
+        h(1) = cinfo_.name();
+      }
+    }
+    if (has_resource_type_) {
+      OP_REQUIRES_OK(context, MakeResourceHandleToOutput(
+                                  context, 0, cinfo_.container(), cinfo_.name(),
+                                  TypeIndex::Make<T>()));
+    } else {
+      context->set_output_ref(0, &mu_, &tensor_);
+    }
+  }
+
+ protected:
+  // Variables accessible from subclasses.
+  mutex mu_;
+  ContainerInfo cinfo_ TF_GUARDED_BY(mu_);
+  // TODO(b/243544755): delete after scam migrates ResourceKernelOp subclasses
+  // to get_resource() in TF 2.11.
+  ABSL_DEPRECATED("Use get_resource() instead.")
+  T* resource_ TF_GUARDED_BY(mu_) = nullptr;
+
+  core::RefCountPtr<T> get_resource() TF_LOCKS_EXCLUDED(mu_) {
+    mutex_lock lock(mu_);
+    return weak_resource_.GetNewRef();
+  }
+
+ private:
+  core::WeakPtr<T> weak_resource_ TF_GUARDED_BY(mu_) =
+      core::WeakPtr<T>(nullptr);
+
+  // Must return a T descendant allocated with new that ResourceOpKernel will
+  // take ownership of.
+  virtual Status CreateResource(T** resource)
+      TF_EXCLUSIVE_LOCKS_REQUIRED(mu_) = 0;
+
+  // During the first Compute(), resource is either created or looked up using
+  // shared_name. In the latter case, the resource found should be verified if
+  // it is compatible with this op's configuration. The verification may fail in
+  // cases such as two graphs asking queues of the same shared name to have
+  // inconsistent capacities.
+  virtual Status VerifyResource(T* resource) { return OkStatus(); }
+
+  Tensor tensor_ TF_GUARDED_BY(mu_);
+
+  // Is the output of the operator of type DT_RESOURCE?
+  bool has_resource_type_;
+};
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_RESOURCE_OP_KERNEL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/resource_var.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/resource_var.h
new file mode 100644
index 0000000000000000000000000000000000000000..d74435d33f54061ccb6b2633594840a57e7f591b
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/resource_var.h
@@ -0,0 +1,153 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_RESOURCE_VAR_H_
+#define TENSORFLOW_CORE_FRAMEWORK_RESOURCE_VAR_H_
+
+#include <string>
+
+#include "tensorflow/core/framework/resource_base.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/lib/core/status.h"
+
+// Forward declarations to avoid introducing a dependency on headers in
+// "tensorflow/core/graph/...".
+class GraphDefBuilder;
+
+namespace tensorflow {
+
+// Resource stored by variables in the resource manager (new, resource-style
+// version).
+//
+// These variables have a mixed access mode: they can operate on copy-on-write
+// mode (the default) or copy-on-read mode (used only for sparse access).
+//
+// When copy-on-write mode is enabled reading the value of the variable involves
+// grabbing its mutex in shared mode and aliasing the internal tensor as the
+// output of the read operation, increasing its reference count. Writing,
+// conversely, works by, under an exclusive lock, detecting whether there are
+// outstanding aliases of the tensor, using the reference count, copying the
+// tensor if they exist, and writing to either the original or a copy with no
+// outstanding aliases. Sparse operations are not supported in copy-on-write
+// mode.
+//
+// When a variable is accessed sparsely it switches to copy-on-read mode. To
+// switch we need to grab an exclusive lock and might (if there are aliases)
+// need to copy the entire tensor. Once copy-on-read mode is enabled, no tensor
+// is allowed to alias the variable's internal tensor. This means dense reads
+// must return a copy of the variable, done while holding a shared lock. Dense
+// writes do not need to check whether aliases exist, and can always write
+// directly to the buffer without making a copy, while holding an exclusive
+// lock. Sparse reads and sparse writes, on the other hand, can be done under a
+// shared or exclusive mutex (the damage from writes under a shared mutex is
+// limited since no other buffer is allowed to alias the variable's
+// buffer). Using an exclusive mutex disallows concurrent writes and concurrent
+// sparse reads, providing some extra safety at the expense of performance,
+// while shared mutex allow for "hogwild" behavior. Doing sparse writes under a
+// shared mutex prevents them from overlapping with dense writes, which is
+// necessary as dense writes can change the shape the of the tensor.
+//
+// Transitioning a variable from copy-on-read mode to copy-on-write mode is
+// currently not supported. To upgrade a variable from copy-on-write to
+// copy-on-read use `EnsureSparseVariableAccess()`, and then grab the variable's
+// mutex as desired. To access the variable in dense mode grab the mutex either
+// directly or via `MaybeLockVariableInputMutexesInOrder` on all variables being
+// modified and then call `PrepareToUpdateVariable` on them in any order.
+class Var : public ResourceBase {
+ public:
+  explicit Var(DataType dtype) : tensor_(dtype) {}
+  explicit Var(DataType dtype, std::string& debug_name) : tensor_(dtype) {
+    debug_name_ = debug_name;
+  }
+
+  // When locking multiple variables, the locks must be acquired in order of
+  // increasing mu() address.
+  // TODO(ebrevdo): Use LockSet instead of exposing mu.
+  mutex* mu() { return &mu_; }
+  Tensor* tensor() { return &tensor_; }
+
+  // Uninitializes the variable, by reverting the state of the tensor to
+  // the state when the variable is first created.
+  void Uninitialize() {
+    // move frees the buffer of the tensor after unused goes out of scope.
+    Tensor unused = std::move(tensor_);
+    is_initialized = false;
+  }
+
+  Status AsGraphDef(GraphDefBuilder* builder, Node** out) const override;
+
+  std::string DebugString() const override {
+    return strings::StrCat(DataTypeString(tensor_.dtype()), "/",
+                           tensor_.shape().DebugString());
+  }
+
+  std::string MakeRefCountingHandleName(int64_t resource_id) const override;
+
+  // Only used in the resource variable path. In resource variables,
+  // tensor.IsInitialized() can be true (i.e. have memory allocated to it) while
+  // there is not a good value there due to a race condition, and it's possible
+  // to stumble upon this during variable.initialized_value(). So it's best to
+  // just store directly whether the variable is initialized.
+  bool is_initialized = false;  // TF_GUARDED_BY(mu_) but annotalysis doesn't
+                                // like it.
+
+  // Also fake-guarded by mu_. Should be set to True whenever any sparse
+  // operation uses the variable. Once this is true no tensor is allowed to
+  // alias the memory of the variable, and we always copy the variable on
+  // reads. This allows sparse operations to happen with only a shared lock if
+  // so desired.
+  std::atomic<bool> copy_on_read_mode{false};
+
+ private:
+  mutex mu_;
+  Tensor tensor_;
+  std::string debug_name_;
+
+  ~Var() override {}
+  Var(const Var&) = delete;
+  void operator=(const Var&) = delete;
+};
+
+// Does unlock and unref automatically when going out of scope, and also
+// supports early manual release.
+class TF_SCOPED_LOCKABLE ScopedUnlockUnrefVar {
+ public:
+  explicit ScopedUnlockUnrefVar(Var* var) TF_EXCLUSIVE_LOCK_FUNCTION(var_->mu())
+      : var_(var) {
+    if (var_) {
+      var_->mu()->lock();
+    }
+  }
+  void Release() TF_UNLOCK_FUNCTION() {
+    if (var_) {
+      var_->mu()->unlock();
+      var_->Unref();
+      var_ = nullptr;
+    }
+  }
+  ~ScopedUnlockUnrefVar() TF_UNLOCK_FUNCTION() { Release(); }
+
+ private:
+  Var* var_;
+
+  ScopedUnlockUnrefVar(const ScopedUnlockUnrefVar&) = delete;
+  ScopedUnlockUnrefVar(ScopedUnlockUnrefVar&&) = delete;
+  ScopedUnlockUnrefVar& operator=(const ScopedUnlockUnrefVar&) = delete;
+  ScopedUnlockUnrefVar& operator=(ScopedUnlockUnrefVar&&) = delete;
+};
+
+}  //  end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_RESOURCE_VAR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/rng_alg.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/rng_alg.h
new file mode 100644
index 0000000000000000000000000000000000000000..fd756c871559724719fabcefe6d52fd21e0f6fee
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/rng_alg.h
@@ -0,0 +1,63 @@
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_RNG_ALG_H_
+#define TENSORFLOW_CORE_FRAMEWORK_RNG_ALG_H_
+
+#include "tensorflow/core/platform/logging.h"
+
+namespace tensorflow {
+
+enum Algorithm {
+  // The Philox algorithm, as described in paper
+  // ['Parallel Random Numbers: As Easy as 1, 2, 3']
+  // (https://www.thesalmons.org/john/random123/papers/random123sc11.pdf)
+  RNG_ALG_PHILOX = 1,
+  // The ThreeFry algorithm, as described in paper
+  // ['Parallel Random Numbers: As Easy as 1, 2, 3']
+  // (https://www.thesalmons.org/john/random123/papers/random123sc11.pdf)
+  RNG_ALG_THREEFRY = 2,
+  // An algorithm auto-selected by the system according to device type.
+  RNG_ALG_AUTO_SELECT = 3
+};
+
+// Same as `Algorithm`, but without AUTO_SELECT. We use C++ compiler's -Wswitch
+// and -Werror to check that `switch` covers all cases. When the algorithm
+// auto-selection has been resolved, we use this type so that
+// we don't need to (unnecessarily) handle the AUTO_SELECT case.
+enum class ConcreteRngAlgorithm {
+  RNG_ALG_PHILOX = 1,
+  RNG_ALG_THREEFRY = 2,
+};
+
+// Gets the counter size (in unit of uint64) for a counter-based RNG
+// algorithm `alg`. Callers of this function must ensure that `alg` doesn't have
+// non-enumerator values.
+inline int GetCounterSize(ConcreteRngAlgorithm alg) {
+  switch (alg) {
+    case ConcreteRngAlgorithm::RNG_ALG_PHILOX:
+      return 2;
+    case ConcreteRngAlgorithm::RNG_ALG_THREEFRY:
+      return 1;
+  }
+  LOG(ERROR) << "This point shouldn't have been reached.";
+}
+static constexpr int RNG_MAX_COUNTER_SIZE = 2;
+
+static constexpr int RNG_KEY_SIZE = 1;
+
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_RNG_ALG_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/run_handler.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/run_handler.h
new file mode 100644
index 0000000000000000000000000000000000000000..148378bc0e9c6fd6b640cebb31510a60a2c1655f
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/run_handler.h
@@ -0,0 +1,315 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_RUN_HANDLER_H_
+#define TENSORFLOW_CORE_FRAMEWORK_RUN_HANDLER_H_
+
+#include "tensorflow/core/lib/core/threadpool.h"
+#include "tensorflow/core/lib/histogram/histogram.h"
+#include "tensorflow/core/platform/context.h"
+#include "tensorflow/core/platform/mutex.h"
+#include "tensorflow/core/platform/thread_annotations.h"
+#include "tensorflow/core/protobuf/config.pb.h"
+
+namespace Eigen {
+struct ThreadPoolDevice;
+}
+
+namespace tensorflow {
+
+class RunHandler;
+
+// RunHandlerPool is a fixed size pool of pre-allocated RunHandlers
+// that can be used for tracking inter-op work for a given Session::Run().
+// RunHandler(s) in the pool are initially 'inactive'. A RunHandler becomes
+// 'active' when its unique_ptr is returned by Get() and is being used by a
+// client. It becomes 'inactive' once more when its unique_ptr gets destroyed.
+//
+// Expected usage:
+//
+// * Create a single RunHandlerPool (say run_handler_pool_).
+//
+// * When a Session::Run() is invoked, obtain a handler by:
+// auto handler = run_handler_pool_->Get();
+//
+// * Use handler for scheduling all inter-op work by:
+// handler->ScheduleInterOpClosure(closure);
+//
+// This class is thread safe.
+class RunHandlerPool {
+ public:
+  explicit RunHandlerPool(int num_inter_op_threads);
+
+  RunHandlerPool(int num_inter_op_threads, int num_intra_op_threads);
+  ~RunHandlerPool();
+
+  // Returns an inactive RunHandler from the pool.
+  //
+  // RunHandlers in RunHandlerPool are initially 'inactive'.
+  // A RunHandler becomes 'active' when its unique_ptr its returned by Get()
+  // and is being used by a client.  It becomes 'inactive' once more when the
+  // unique_ptr is destroyed.
+  //
+  // Will block unless there is an inactive handler.
+  std::unique_ptr<RunHandler> Get(
+      int64_t step_id = 0, int64_t timeout_in_ms = 0,
+      const RunOptions::Experimental::RunHandlerPoolOptions& options =
+          RunOptions::Experimental::RunHandlerPoolOptions());
+
+  // Get the priorities for active handlers. The return result is with the same
+  // order of the active handler list.
+  std::vector<int64_t> GetActiveHandlerPrioritiesForTesting() const;
+
+ private:
+  class Impl;
+  friend class RunHandler;
+
+  std::unique_ptr<Impl> impl_;
+};
+
+// RunHandler can be used to schedule inter/intra-op closures to run on a global
+// pool shared across all Session::Run(s). The closures are enqueued to a
+// handler specific queue, from which the work is stolen in a priority order
+// (time of the Get() call).
+//
+// It can only be created via RunHandlerPool::Get().
+//
+// This class can be used instead of directly scheduling closures on a global
+// pool since it maintains a global view across all sessions and optimizes pool
+// scheduling to improve (median and tail) latency.
+//
+// This class is thread safe.
+class RunHandler {
+ public:
+  void ScheduleInterOpClosure(std::function<void()> fn);
+  thread::ThreadPoolInterface* AsIntraThreadPoolInterface();
+
+  ~RunHandler();
+
+ private:
+  class Impl;
+  friend class RunHandlerPool::Impl;
+
+  explicit RunHandler(Impl* impl);
+
+  Impl* impl_;  // NOT OWNED.
+};
+
+namespace internal {
+
+// TODO(azaks): Refactor with thread:ThreadPool
+class RunHandlerEnvironment {
+  typedef Thread EnvThread;
+  struct TaskImpl {
+    std::function<void()> f;
+    Context context;
+    uint64 trace_id;
+  };
+  Env* const env_;
+  const ThreadOptions thread_options_;
+  const string name_;
+
+ public:
+  struct Task {
+    std::unique_ptr<TaskImpl> f;
+  };
+
+  RunHandlerEnvironment(Env* env, const ThreadOptions& thread_options,
+                        const string& name);
+
+  EnvThread* CreateThread(std::function<void()> f,
+                          const std::string& thread_name);
+
+  Task CreateTask(std::function<void()> f);
+
+  void ExecuteTask(const Task& t);
+};
+
+typedef typename RunHandlerEnvironment::Task Task;
+typedef Eigen::RunQueue<Task, 1024> Queue;
+
+// To reduce cache misses, we use a doubly-linked list of Waiter structs and
+// queue them in LIFO order rather than the FIFO order used by a single
+// condition variable.
+struct Waiter {
+  Waiter() {
+    next = this;
+    prev = this;
+  }
+  condition_variable cv;
+  mutex mu;
+  Waiter* next;
+  Waiter* prev;
+};
+
+class ThreadWorkSource {
+ public:
+  ThreadWorkSource();
+
+  ~ThreadWorkSource();
+
+  Task EnqueueTask(Task t, bool is_blocking);
+
+  Task PopBlockingTask();
+
+  Task PopNonBlockingTask(int start_index, bool search_from_all_queue);
+
+  void WaitForWork(int max_sleep_micros);
+
+  int TaskQueueSize(bool is_blocking);
+
+  int64_t GetTracemeId();
+
+  void SetTracemeId(int64_t value);
+
+  void SetWaiter(uint64 version, Waiter* waiter, mutex* mutex);
+
+  int64_t GetInflightTaskCount(bool is_blocking);
+
+  void IncrementInflightTaskCount(bool is_blocking);
+
+  void DecrementInflightTaskCount(bool is_blocking);
+
+  unsigned NonBlockingWorkShardingFactor();
+
+  std::string ToString();
+
+ private:
+  struct NonBlockingQueue {
+    mutex queue_op_mu;
+    char pad[128];
+    Queue queue;
+  };
+
+  int32 non_blocking_work_sharding_factor_;
+  Eigen::MaxSizeVector<NonBlockingQueue*> non_blocking_work_queues_;
+
+  std::atomic<int64_t> blocking_inflight_;
+  std::atomic<int64_t> non_blocking_inflight_;
+
+  Queue blocking_work_queue_;
+  mutex blocking_queue_op_mu_;
+  char pad_[128];
+  mutex waiters_mu_;
+  Waiter queue_waiters_ TF_GUARDED_BY(waiters_mu_);
+  std::atomic<int64_t> traceme_id_;
+
+  mutex run_handler_waiter_mu_;
+  uint64 version_ TF_GUARDED_BY(run_handler_waiter_mu_);
+  mutex* sub_thread_pool_waiter_mu_ TF_GUARDED_BY(run_handler_waiter_mu_);
+  Waiter* sub_thread_pool_waiter_ TF_GUARDED_BY(run_handler_waiter_mu_);
+};
+
+class RunHandlerThreadPool {
+ public:
+  struct PerThread {
+    constexpr PerThread() : pool(nullptr), thread_id(-1) {}
+    RunHandlerThreadPool* pool;  // Parent pool, or null for normal threads.
+    int thread_id;               // Worker thread index in pool.
+  };
+
+  RunHandlerThreadPool(int num_blocking_threads, int num_non_blocking_threads,
+                       Env* env, const ThreadOptions& thread_options,
+                       const string& name,
+                       Eigen::MaxSizeVector<mutex>* waiters_mu,
+                       Eigen::MaxSizeVector<Waiter>* queue_waiters);
+
+  ~RunHandlerThreadPool();
+
+  void Start();
+
+  void StartOneThreadForTesting();
+
+  void AddWorkToQueue(ThreadWorkSource* tws, bool is_blocking,
+                      std::function<void()> fn);
+
+  // Set work queues from which the thread 'tid' can steal its work.
+  // The request with start_request_idx will be attempted first. Other requests
+  // will be attempted in FIFO order based on their arrival time.
+  void SetThreadWorkSources(
+      int tid, int start_request_idx, uint64 version,
+      const Eigen::MaxSizeVector<ThreadWorkSource*>& thread_work_sources);
+
+  PerThread* GetPerThread();
+
+  int CurrentThreadId() const;
+
+  int NumThreads() const;
+
+  int NumBlockingThreads() const;
+
+  int NumNonBlockingThreads() const;
+
+  void WorkerLoop(int thread_id, bool may_steal_blocking_work);
+
+  // Search tasks from Requets range searching_range_start to
+  // searching_range_end. If there is no tasks in the search range and
+  // may_steal_blocking_work is true, then search from all requests.
+  Task FindTask(
+      int searching_range_start, int searching_range_end, int thread_id,
+      int sub_thread_pool_id, int max_blocking_inflight,
+      bool may_steal_blocking_work,
+      const Eigen::MaxSizeVector<ThreadWorkSource*>& thread_work_sources,
+      bool* task_from_blocking_queue, ThreadWorkSource** tws);
+
+  void WaitForWork(bool is_blocking, int thread_id,
+                   int32_t max_blocking_inflight);
+
+  void WaitForWorkInSubThreadPool(bool is_blocking, int sub_thread_pool_id);
+
+ private:
+  struct ThreadData {
+    ThreadData();
+    mutex mu;
+    uint64 new_version;
+    condition_variable sources_not_empty;
+    std::unique_ptr<Thread> thread;
+    int current_index;
+    std::unique_ptr<Eigen::MaxSizeVector<ThreadWorkSource*>>
+        new_thread_work_sources TF_GUARDED_BY(mu);
+
+    uint64 current_version;
+    // Should only be accessed by one thread.
+    std::unique_ptr<Eigen::MaxSizeVector<ThreadWorkSource*>>
+        current_thread_work_sources;
+
+    int sub_thread_pool_id;
+  };
+
+  const int num_threads_;
+  const int num_blocking_threads_;
+  const int num_non_blocking_threads_;
+  Eigen::MaxSizeVector<ThreadData> thread_data_;
+  internal::RunHandlerEnvironment env_;
+  std::atomic<bool> cancelled_;
+  string name_;
+  Eigen::MaxSizeVector<mutex>* waiters_mu_;
+  Eigen::MaxSizeVector<Waiter>* queue_waiters_;
+
+  bool use_sub_thread_pool_;
+  std::vector<int> num_threads_in_sub_thread_pool_;
+
+  // Threads in each sub thread pool will search tasks from the given
+  // start_request_percentage to end_request_percentage in a round robin
+  // fashion.
+  std::vector<double> sub_thread_pool_start_request_percentage_;
+  std::vector<double> sub_thread_pool_end_request_percentage_;
+};
+
+}  // namespace internal
+
+}  // end namespace tensorflow.
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_RUN_HANDLER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/run_handler_util.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/run_handler_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..c63583da9a0a671d3b6dce7e46fbc40db9c75fa9
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/run_handler_util.h
@@ -0,0 +1,78 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_RUN_HANDLER_UTIL_H_
+#define TENSORFLOW_CORE_FRAMEWORK_RUN_HANDLER_UTIL_H_
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+namespace tensorflow {
+
+// Assign thread ranges to requests.
+// Requests are numbered 0...num_active_requests-1, and
+// threads are numbered 0...num_threads-1.
+// On return, the range [start_vec->at(i), end_vec->at(i))
+// indicates the subrange of the threads available to request i.
+// The ranges given to different requests may overlap.
+// Lower numbered requests will tend to be assigned more threads.
+// Thus, a client might associate older requests with lower
+// array indices so they receive access to more threads.
+// However, the routine ensures that each request is given access
+// to at least min(min_threads_per_request, num_threads)  threads.
+// Every thread will be assigned to at least one request range,
+// assuming there is at least one request.
+void ComputeInterOpSchedulingRanges(int num_active_requests, int num_threads,
+                                    int min_threads_per_request,
+                                    std::vector<std::uint_fast32_t>* start_vec,
+                                    std::vector<std::uint_fast32_t>* end_vec);
+
+// Assign thread steal ranges to threads.Threads are numbered 0...num_threads-1.
+// On return, the range [start_vec->at(i), end_vec->at(i)) indicates the steal
+// range of the thread i. The ranges given to different threads may overlap.
+void ComputeInterOpStealingRanges(int num_threads, int min_threads_per_domain,
+                                  std::vector<std::uint_fast32_t>* start_vec,
+                                  std::vector<std::uint_fast32_t>* end_vec);
+
+// For each of the num_threads determine the index of the active_request whose
+// work queue should be attempted first by that the thread. Return a vector of
+// size num_threads which represents how threads should be distributed across
+// requests.
+std::vector<int> ChooseRequestsWithExponentialDistribution(
+    int num_active_requests, int num_threads);
+
+// Look up environment variable named 'var_name' and return the value if it
+// exist and can be parsed. Return 'default_value' otherwise.
+double ParamFromEnvWithDefault(const char* var_name, double default_value);
+
+// Look up environment variable named 'var_name' and return the value if it
+// exist and can be parsed. The value must be in format val1,val2... Return
+// 'default_value' otherwise.
+std::vector<double> ParamFromEnvWithDefault(const char* var_name,
+                                            std::vector<double> default_value);
+
+// Look up environment variable named 'var_name' and return the value if it
+// exist and can be parsed. The value must be in format val1,val2... Return
+// 'default_value' otherwise.
+std::vector<int> ParamFromEnvWithDefault(const char* var_name,
+                                         std::vector<int> default_value);
+
+// Look up environment variable named 'var_name' and return the value if it
+// exist and can be parsed. Return 'default_value' otherwise.
+bool ParamFromEnvBoolWithDefault(const char* var_name, bool default_value);
+
+}  // end namespace tensorflow
+#endif  // TENSORFLOW_CORE_FRAMEWORK_RUN_HANDLER_UTIL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/session_state.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/session_state.h
new file mode 100644
index 0000000000000000000000000000000000000000..9d49951870d4f0228c408714e80ba34d363fa5c0
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/session_state.h
@@ -0,0 +1,91 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_SESSION_STATE_H_
+#define TENSORFLOW_CORE_FRAMEWORK_SESSION_STATE_H_
+
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/lib/core/errors.h"
+#include "tensorflow/core/platform/mutex.h"
+
+namespace tensorflow {
+
+// The session state remembers the tensors we choose to keep across
+// multiple run calls.
+class SessionState {
+ public:
+  // Get a tensor from the session state.
+  Status GetTensor(const std::string& handle, Tensor* tensor);
+
+  // Store a tensor in the session state.
+  Status AddTensor(const std::string& handle, const Tensor& tensor);
+
+  // Delete a tensor from the session state.
+  Status DeleteTensor(const std::string& handle);
+
+  int64_t GetNewId();
+
+  static const char* kTensorHandleResourceTypeName;
+
+ private:
+  mutex state_lock_;
+
+  // For generating unique ids for tensors stored in the session.
+  int64_t tensor_id_ = 0;
+
+  // The live tensors in the session. A map from tensor handle to tensor.
+  std::unordered_map<string, Tensor> tensors_;
+};
+
+// The tensor store remembers the tensors we choose to keep for the
+// current run call. It is available to every op kernel.
+class TensorStore {
+ public:
+  struct TensorAndKey {
+    Tensor tensor;
+    int64_t id;
+    std::string device_name;
+
+    std::string GetHandle(const std::string& tensor_name) {
+      return strings::StrCat(tensor_name, ";", id, ";", device_name);
+    }
+  };
+
+  // Add the named tensor to the tensor store for this run.
+  Status AddTensor(const std::string& name, const TensorAndKey& tk);
+
+  // Save the tensors in the tensor store of this run to the session.
+  Status SaveTensors(const std::vector<string>& output_names,
+                     SessionState* session_state);
+
+  // Returns true if no tensors have been added to this store.
+  bool empty() TF_NO_THREAD_SAFETY_ANALYSIS { return !dirty_; }
+
+ private:
+  mutex lock_;
+  std::atomic<bool> dirty_ TF_GUARDED_BY(lock_){false};
+
+  // The tensors that will be saved to session state when this run completes.
+  // A map from tensor string name to tensor.
+  std::unordered_map<string, TensorAndKey> tensors_ TF_GUARDED_BY(lock_);
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_SESSION_STATE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/shape_inference.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/shape_inference.h
new file mode 100644
index 0000000000000000000000000000000000000000..658bf494a6d56f78e4c323e7d4ee0bb7aeb353a6
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/shape_inference.h
@@ -0,0 +1,905 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_FRAMEWORK_SHAPE_INFERENCE_H_
+#define TENSORFLOW_CORE_FRAMEWORK_SHAPE_INFERENCE_H_
+
+#include <vector>
+
+#include "absl/memory/memory.h"
+#include "tensorflow/core/framework/full_type.pb.h"
+#include "tensorflow/core/framework/node_def_util.h"
+#include "tensorflow/core/lib/core/errors.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/platform/macros.h"
+
+namespace tensorflow {
+
+namespace grappler {
+class GraphProperties;
+class SymbolicShapeManager;
+}  // namespace grappler
+
+namespace shape_inference {
+
+struct DimensionOrConstant;
+class InferenceContext;
+
+// This header contains the InferenceContext that is used to infer the shape of
+// the results of an operation or flag an operation with invalid inputs (e.g.,
+// mismatched shapes for elementwise operation) by ShapeRefiner. The shape of an
+// operation is computed using the OpShapeInferenceFn set via SetShapeFn in op
+// registration. The OpShapeInferenceFn uses a per op InferenceContext populated
+// with input shapes to compute resultant shape (including resource shapes).
+//
+// The shapes created in the InferenceContext are bound to the lifetime of the
+// InferenceContext in which it was created. E.g., in
+//
+// ```c++
+//  InferenceContext c;
+//  // Below a ShapeHandle is returned by MakeShape, while UnknownDim returns a
+//  // DimensionHandle.
+//  ShapeHandle in0 = c.MakeShape({10, c.UnknownDim()});
+// ```
+//
+// the ShapeHandle `in0` (and the nested unknown dim inside) is only valid while
+// `c` is in scope, as ShapeHandle and DimensionHandle are effectively
+// wrappers around pointers stored inside the context with the lifetime of the
+// value pointed to managed by the context. The result from one operation's
+// inference context will be passed as input to the inference of consumer
+// operations. Hence it is possible for ShapeHandles produced by inference on a
+// node to consist of ShapeHandles owned by different InferenceContexts. While
+// inferring the shapes of a Graph, the InferenceContext of all nodes/operations
+// in the Graph remain resident for the lifetime of the Graph (e.g, there is a
+// map from each node to its InferenceContext, technically its
+// ExtendedInferencContext which additionally stores the element types of inputs
+// & outputs, which remains resident).
+//
+// For functions, the body of the function is instantiated as a Graph while
+// inferring the result shapes of a function call node. The rules above apply
+// while the function's shape is being inferred, but the contexts associated
+// with nodes in the function body are released once the function call's
+// resultant shapes are inferred. The shapes of results returned by a function
+// are propagated to the InferenceContext of the function call's op (which is
+// associated with a Graph of nodes whose shape is being inferred) as the return
+// values of a function call node are the inputs of its consumer, but the return
+// values are produced by nodes inside the function whose InferenceContexts
+// (which owns the values pointed to by ShapeHandle and DimensionHandle) are
+// reclaimed after inferring function result shapes. Recursive user-defined
+// function are not supported hence inference of functions are fully nested with
+// the InferenceContext's of function calls forming a stack.
+//
+// For example, consider the following call and function:
+//
+// ```python
+// @tf.function
+// def g(st):
+//   d = tf.add(st, st)
+//   return d
+//
+// @tf.function
+// def f():
+//   st = tf.A()
+//   result = g(st)
+//   return h(result)
+// ```
+//
+// During inference of f, the shape of `A` will be inferred and the results from
+// its InferenceContext used as inputs to function call `g(st)`. The call node
+// will have an InferenceContext created (call it outer context) and the graph
+// corresponding to function `g` will be instantiated. The result shape of the
+// Arg nodes of the function will be associated with input from outer context.
+// During inference of `g` (for the callsite `g(st)` in `f`), the
+// InferenceContext of all nodes inside `g` will remain alive. Thus, when shape
+// of `tf.add` is computed it may rely on all inputs. Once the RetVal nodes of a
+// function is reached, we know the shape of its input may correspond to a shape
+// queried in the outer context and it is explicitly copied to outer context. In
+// this case that means that the shape of `d` is copied to the InferenceContext
+// of `g(st)` and so when `h(result)` is executed this shape may be queried.
+// Furthermore, no shapes computed due to call `g(st)` can be queried post this
+// point and, as the RetVal shapes have been coppied into outer context, all
+// InferenceContexts associated with nodes in function `g` instantiated for
+// `g(st)` may be and are released.
+
+// Dimension values are accessed through InferenceContext.
+class Dimension {
+ private:
+  Dimension();
+  Dimension(int64_t value);
+  ~Dimension() {}
+
+  const int64_t value_;
+
+  friend class InferenceContext;
+  friend class ShapeManager;
+  Dimension(const Dimension&) = delete;
+  void operator=(const Dimension&) = delete;
+};
+
+class DimensionHandle {
+ public:
+  DimensionHandle() {}
+  bool SameHandle(DimensionHandle d) const { return ptr_ == d.ptr_; }
+  std::size_t Handle() const { return reinterpret_cast<std::size_t>(ptr_); }
+
+ private:
+  DimensionHandle(const Dimension* dim) { ptr_ = dim; }
+
+  const Dimension* operator->() const { return ptr_; }
+  bool IsSet() const { return ptr_ != nullptr; }
+
+  const Dimension* ptr_ = nullptr;
+
+  friend struct DimensionOrConstant;
+  friend class InferenceContext;
+  friend class ShapeInferenceTest;
+  friend class ShapeInferenceTestutil;
+  friend class ::tensorflow::grappler::GraphProperties;
+  friend class ::tensorflow::grappler::SymbolicShapeManager;
+
+  // Intentionally copyable.
+};
+
+// Shape rank and dimensions are accessed through InferenceContext.
+class Shape {
+ private:
+  Shape();
+  Shape(const std::vector<DimensionHandle>& dims);
+  ~Shape() {}
+
+  const int32 rank_;
+  const std::vector<DimensionHandle> dims_;
+
+  friend class InferenceContext;
+  friend class ::tensorflow::grappler::SymbolicShapeManager;
+
+  Shape(const Shape&) = delete;
+  void operator=(const Shape&) = delete;
+};
+
+class ShapeHandle {
+ public:
+  ShapeHandle() {}
+  bool SameHandle(ShapeHandle s) const { return ptr_ == s.ptr_; }
+  std::size_t Handle() const { return reinterpret_cast<std::size_t>(ptr_); }
+
+ private:
+  ShapeHandle(const Shape* shape) { ptr_ = shape; }
+  const Shape* operator->() const { return ptr_; }
+  bool IsSet() const { return ptr_ != nullptr; }
+
+  const Shape* ptr_ = nullptr;
+
+  friend class InferenceContext;
+  friend class ShapeInferenceTest;
+  friend class ShapeInferenceTestutil;
+  friend class ::tensorflow::grappler::SymbolicShapeManager;
+
+  // Intentionally copyable.
+};
+
+// Struct used to allow functions to take DimensionHandle or a dimension value.
+// Not meant to be constructed directly.
+struct DimensionOrConstant {
+ public:
+  // Intentionally not explicit.
+  DimensionOrConstant(DimensionHandle dim);
+
+  // val must be non-negative or InferenceContext::kUnknownDim.
+  DimensionOrConstant(int64_t val);
+
+  // dim takes precedence. If dim != nullptr, val is ignored.
+  DimensionHandle dim;
+  int64_t val;
+
+ private:
+  DimensionOrConstant();
+};
+
+struct ShapeAndType {
+  ShapeAndType() {}
+  ShapeAndType(ShapeHandle s, DataType t) : shape(s), dtype(t) {}
+  // TODO(mdan): Remove dtype from constructor, and use type_ instead.
+  // dtype is kept here for backward compatibiity. Its information should
+  // be redundant to that in type;
+  ShapeAndType(ShapeHandle s, DataType t, FullTypeDef type_)
+      : shape(s), dtype(t), type(type_) {}
+
+  ShapeHandle shape;
+  DataType dtype = DT_INVALID;
+  FullTypeDef type;
+};
+
+// Shape inference functions registered on ops in REGISTER_OP implement
+// their shape functions in terms of this InferenceContext.  An InferenceContext
+// is created by the framework and passed to a shape inference function.  The
+// shape inference function calls functions on the context, and should call
+// set_output() to set the shape on all outputs.
+//
+// To infer shapes for user-defined functions see ShapeRefiner.
+//
+// All Shape* and Dimension* returned by functions of InferenceContext are owned
+// by the InferenceContext.
+class InferenceContext {
+ public:
+  static constexpr int64_t kUnknownDim = -1;
+  static constexpr int32_t kUnknownRank = -1;
+
+  // <input_tensors> is NULL-padded to be the same size as <input_shapes>.
+  //
+  // Elements of <input_tensors_as_shapes> are used for when a shape function
+  // makes a call to MakeShapeFromShapeTensor; in particular, when the
+  // input_tensors[i] is nullptr but the shape represented by it is partially
+  // known from analysis of the graph.
+  // <input_tensors_as_shapes> can have fewer elements than <input_shapes>.
+  // Values of <input_tensors_as_shapes> do not need to outlive the context.
+  InferenceContext(int graph_def_version, const AttrSlice& attrs,
+                   const OpDef& op_def,
+                   const std::vector<ShapeHandle>& input_shapes,
+                   const std::vector<const Tensor*>& input_tensors,
+                   const std::vector<ShapeHandle>& input_tensors_as_shapes,
+                   std::vector<std::unique_ptr<std::vector<ShapeAndType>>>
+                       input_handle_shapes_and_types);
+
+  // <input_tensors> is NULL-padded to be the same size as <input_shapes>.
+  //
+  // Elements of <input_tensors_as_shapes> are used for when a shape
+  // function makes a call to MakeShapeFromShapeTensor; in particular, when
+  // the input_tensors[i] is nullptr but the shape represented by it is
+  // partially known from analysis of the graph. <input_tensors_as_shapes>
+  // can have fewer elements than <input_shapes>. Values of
+  // <input_tensors_as_shapes> do not need to outlive the context.
+  InferenceContext(
+      int graph_def_version, const AttrSlice& attrs, const OpDef& op_def,
+      const std::vector<PartialTensorShape>& input_shapes,
+      const std::vector<const Tensor*>& input_tensors,
+      const std::vector<PartialTensorShape>& input_tensors_as_shapes,
+      const std::vector<std::unique_ptr<
+          std::vector<std::pair<PartialTensorShape, DataType>>>>&
+          input_handle_shapes_and_types);
+
+  ~InferenceContext();
+
+  // Runs the shape inference function 'fn' with 'this' as the
+  // argument, returns the status of the inference.
+  //
+  // On error, additional context is provided in the error message.
+  Status Run(
+      const std::function<Status(shape_inference::InferenceContext* c)>& fn);
+
+  // Merge the stored shape of the input in position idx with <shape> according
+  // to the following rules:
+  //
+  // - If the ShapeHandles are the same or <shape> is unknown, there will be no
+  //   change. Otherwise if the stored shape is unknown, the new shape will be
+  //   <shape>.
+  // - If both shapes are known, then they must have the same rank.
+  // - For any one dimension, if the values for that dimension in both shapes
+  //   are known, then the values must match.
+  // - If one shape has equal or more information than the other shape in every
+  //   dimension, the new shape will become the shape with more information.
+  // - Example: merging [2,?] and [?,2] results in [2,2]
+  // - Example: [2,2] cannot be merged with [1,2]
+  //
+  // This requires idx to be in the [0, num_inputs) range. If the merge is
+  // successful, return true. Return false otherwise.
+  bool MergeInput(int idx, ShapeHandle shape) {
+    ShapeHandle new_shape;
+    if (!Merge(inputs_[idx], shape, &new_shape).ok()) return false;
+    inputs_[idx] = new_shape;
+    return true;
+  }
+
+  // Relax the stored shape of the input in position idx with <shape> according
+  // to the following rules:
+  //
+  // - If the ShapeHandles are the same then the stored shape will be returned.
+  // - If either of the ShapeHandles are unknown, then a new UnknownShape will
+  //   be returned. A new shape must be returned because we cannot claim that
+  //   the resulting shape is necessarily the same as either of the input
+  //   shapes.
+  // - If the shapes both have known ranks but their ranks are different, a new
+  //   UnknownShape will be returned.
+  // - For any one dimension, if the value for that dimension in either of the
+  //   shapes is unknown, a new shape will be returned with a new UnknownDim in
+  //   that dimension.
+  // - For any one dimension, if the values for that dimension in both shapes
+  //   are known but do not match, a new shape will be returned with a new
+  //   UnknownDim in that dimension.
+  // - If both shapes have the same known rank and match in every dimension,
+  //   the stored shape will be returned.
+  // - Example: relaxing [2,?] and [?,2] results in [?,?]
+  // - Example: relaxing [2,2] and [3,2] results in [?,2]
+  // - Example: relaxing [2,2] with [1,2,3] results in ?
+  //
+  // This requires idx to be in the [0, num_inputs) range. If the relax is
+  // successful and the new shape differs from the old one, store the new
+  // shape and return true. Return false otherwise.
+  bool RelaxInput(int idx, ShapeHandle shape) {
+    ShapeHandle new_shape;
+    Relax(inputs_[idx], shape, &new_shape);
+    if (inputs_[idx].SameHandle(new_shape)) {
+      return false;
+    }
+    inputs_[idx] = new_shape;
+    return true;
+  }
+
+  void SetInput(int idx, ShapeHandle shape) { inputs_[idx] = shape; }
+
+  ShapeHandle input(int64_t idx) const { return inputs_[idx]; }
+  Status input(StringPiece input_name, std::vector<ShapeHandle>* output) const;
+  int num_inputs() const { return inputs_.size(); }
+
+  // Returns the input tensor at index <idx>, or nullptr if the input tensor is
+  // not available at the time of shape inference.
+  const Tensor* input_tensor(int idx) {
+    // Mark that this idx was requested.
+    request_input_tensor(idx);
+    return input_tensors_[idx];
+  }
+
+  // Notifies the shape refiner that the value of the tensor at index <idx>
+  // is needed. The shape refiner tries to statically compute this tensor,
+  // and if successful re-runs the  shape function with this tensor available
+  // in the call to 'input_tensor(idx)'.
+  void request_input_tensor(int idx) { requested_input_tensor_[idx] = true; }
+
+  // Returns true iff input_tensor(idx) was called by the shape function.
+  bool requested_input_tensor(int idx) const {
+    return requested_input_tensor_[idx];
+  }
+
+  // Notifies the shape refiner that the value of the tensor at index <idx>
+  // as a partial shape is needed. The shape refiner tries to statically compute
+  // this, and if successful re-runs the  shape function with the
+  // computed PartialTensorShape available in the call to
+  // 'MakeShapeFromShapeTensor(idx, handle)' or
+  // 'MakeShapeFromShapeTensorTreatScalarAsUnknownShape(idx, handle)'.
+  void request_input_tensor_as_partial_shape(int idx) {
+    requested_input_tensor_as_partial_shape_[idx] = true;
+  }
+
+  // Returns true if MakeShapeFromInputTensor was called but the constant
+  // input_tensor was not present.
+  bool requested_input_tensor_as_partial_shape(int idx) const {
+    return requested_input_tensor_as_partial_shape_[idx];
+  }
+
+  void set_input_tensors(const std::vector<const Tensor*>& input_tensors) {
+    input_tensors_ = input_tensors;
+  }
+
+  void set_input_tensors_as_shapes(
+      const std::vector<ShapeHandle>& input_tensors_as_shapes) {
+    input_tensors_as_shapes_ = input_tensors_as_shapes;
+  }
+
+  const std::vector<ShapeHandle>& input_tensors_as_shapes() const {
+    return input_tensors_as_shapes_;
+  }
+
+  ShapeHandle output(int64_t idx) const { return outputs_.at(idx); }
+  void set_output(int idx, ShapeHandle shape) { outputs_.at(idx) = shape; }
+  Status set_output(StringPiece output_name,
+                    const std::vector<ShapeHandle>& shapes);
+
+  int num_outputs() const { return outputs_.size(); }
+  ShapeHandle output(int idx) const { return outputs_.at(idx); }
+  Status output(StringPiece output_name,
+                std::vector<ShapeHandle>* output) const;
+
+  // Returns the value for attribute named `attr_name`.
+  Status GetAttr(StringPiece attr_name, const AttrValue** attr_value) const {
+    return attrs_.Find(attr_name, attr_value);
+  }
+  const AttrValue* GetAttr(StringPiece attr_name) const {
+    return attrs_.Find(attr_name);
+  }
+
+  const FullTypeDef& ret_types() const { return ret_types_; }
+
+  // idx can be negative for an offset from end of dimensions.
+  // idx must be in the range [-1 * s.rank, s.rank).
+  DimensionHandle Dim(ShapeHandle s, int64_t idx) {
+    if (!s.Handle() || s->rank_ == kUnknownRank) {
+      return UnknownDim();
+    }
+    return DimKnownRank(s, idx);
+  }
+  // As above, but asserts that the rank of the shape is known.
+  static DimensionHandle DimKnownRank(ShapeHandle s, int64_t idx) {
+    CHECK_NE(s->rank_, kUnknownRank);
+    if (idx < 0) {
+      return s->dims_[s->dims_.size() + idx];
+    }
+    return s->dims_[idx];
+  }
+
+  static int32 Rank(ShapeHandle s) {
+    return s.IsSet() ? s->rank_ : kUnknownRank;
+  }
+  static bool RankKnown(ShapeHandle s) {
+    return (s.IsSet() && (Rank(s) != kUnknownRank));
+  }
+  static inline int64_t Value(DimensionOrConstant d) {
+    return d.dim.IsSet() ? d.dim->value_ : d.val;
+  }
+  static inline bool ValueKnown(DimensionOrConstant d) {
+    return Value(d) != kUnknownDim;
+  }
+
+  // Fills the output proto with the shape defined by the handle.
+  // "proto" is expected to be empty prior to the call.
+  void ShapeHandleToProto(ShapeHandle handle, TensorShapeProto* proto);
+  TensorShapeProto ShapeHandleToProto(ShapeHandle handle);
+
+  // Returns true if the rank and all dimensions of the Shape are known.
+  bool FullyDefined(ShapeHandle s);
+
+  // Returns the total number of elements, or an unknown dimension for an
+  // incomplete shape.
+  DimensionHandle NumElements(ShapeHandle s);
+
+  std::string DebugString(ShapeHandle s);
+  std::string DebugString(DimensionHandle d);
+  std::string DebugString(const ShapeAndType& shape_and_type);
+  std::string DebugString(gtl::ArraySlice<ShapeAndType> shape_and_types);
+
+  // Describes the whole context, for debugging purposes.
+  std::string DebugString() const;
+
+  // If <shape> has rank <rank>, or its rank is unknown, return OK and return
+  // the shape with asserted rank in <*out>. Otherwise return an error.
+  //
+  // Note that <*out> may be set to <shape>.
+  Status WithRank(ShapeHandle shape, int64_t rank,
+                  ShapeHandle* out) TF_MUST_USE_RESULT;
+  Status WithRankAtLeast(ShapeHandle shape, int64_t rank,
+                         ShapeHandle* out) TF_MUST_USE_RESULT;
+  Status WithRankAtMost(ShapeHandle shape, int64_t rank,
+                        ShapeHandle* out) TF_MUST_USE_RESULT;
+
+  // If <dim> has value <value>, or its value is unknown, returns OK and returns
+  // the dimension with asserted value in <*out>. Otherwise returns an error.
+  //
+  // Note that <*out> may be set to <dim>.
+  Status WithValue(DimensionHandle dim, int64_t value,
+                   DimensionHandle* out) TF_MUST_USE_RESULT;
+
+  // Merges <s0> and <s1> and returns the merged shape in <*out>. See
+  // 'MergeInput' function for full details and examples.
+  Status Merge(ShapeHandle s0, ShapeHandle s1,
+               ShapeHandle* out) TF_MUST_USE_RESULT;
+
+  // Asserts that <s>'s rank >= <prefix>'s rank, and the first
+  // <prefix.rank> dimensions of <s> are compatible with the dimensions of
+  // <prefix>.
+  // Returns the merged results in <*s_out> and <*prefix_out>.
+  Status MergePrefix(ShapeHandle s, ShapeHandle prefix, ShapeHandle* s_out,
+                     ShapeHandle* prefix_out) TF_MUST_USE_RESULT;
+
+  // Merges <d0> and <d1> and returns the merged dimension in <*out>. If <d0>
+  // and <d1> have incompatible values, returns an error.
+  //
+  // Note that <*out> may be set to <d0> or <d1>.
+  Status Merge(DimensionHandle d0, DimensionHandle d1,
+               DimensionHandle* out) TF_MUST_USE_RESULT;
+
+  // Returns in <*out> a sub-shape of <s> with dimensions [start:].
+  // <start> can be negative to index from the end of the shape. If <start> >
+  // rank of <s>, then an empty subshape is returned.
+  Status Subshape(ShapeHandle s, int64_t start,
+                  ShapeHandle* out) TF_MUST_USE_RESULT;
+
+  // Returns in <*out> a sub-shape of <s>, with dimensions [start:end].
+  // <start> and <end> can be negative, to index from the end of the shape.
+  // <start> and <end> are set to the rank of <s> if > rank of <s>.
+  Status Subshape(ShapeHandle s, int64_t start, int64_t end,
+                  ShapeHandle* out) TF_MUST_USE_RESULT;
+
+  // Returns in <*out> a sub-shape of <s>, with dimensions [start:end:stride].
+  // <start> and <end> can be negative, to index from the end of the shape.
+  // <start> and <end> are set to the rank of <s> if > rank of <s>.
+  // <stride> can be negative, to reverse the <s>.
+  Status Subshape(ShapeHandle s, int64_t start, int64_t end, int64_t stride,
+                  ShapeHandle* out) TF_MUST_USE_RESULT;
+
+  // Returns in <*out> the result of appending the dimensions of <s2> to those
+  // of <s1>.
+  Status Concatenate(ShapeHandle s1, ShapeHandle s2,
+                     ShapeHandle* out) TF_MUST_USE_RESULT;
+
+  // Returns in <out> the shape from replacing <s.dim[dim_index]> with
+  // <new_dim>.
+  Status ReplaceDim(ShapeHandle s, int64_t dim_index, DimensionHandle new_dim,
+                    ShapeHandle* out) TF_MUST_USE_RESULT;
+
+  // Returns a new shape with the given dims. The returned value is owned by
+  // this context.
+  ShapeHandle MakeShape(const std::vector<DimensionHandle>& dims);
+  ShapeHandle MakeShape(std::initializer_list<DimensionOrConstant> dims);
+
+  // Returns a new unknown shape.
+  ShapeHandle UnknownShape();
+
+  // Returns a shape with specified rank but unknown dims.
+  ShapeHandle UnknownShapeOfRank(int64_t rank);
+
+  // Returns a new shape of zero dimensions.
+  ShapeHandle Scalar();
+
+  // Returns a new shape of one dimension.
+  ShapeHandle Vector(DimensionOrConstant dim);
+
+  // Returns a new shape of two dimensions.
+  ShapeHandle Matrix(DimensionOrConstant dim1, DimensionOrConstant dim2);
+
+  // Returns in <out> a new shape whose dimension sizes come from input tensor
+  // <input_idx>. The tensor must be a 1-dimensional int32 or int64 tensor.  If
+  // the input tensor is NULL, then an unknown shape is returned.
+  Status MakeShapeFromShapeTensor(int input_idx, ShapeHandle* out);
+
+  // Like the function above, but treats scalar values as unknown
+  // shapes.  **NOTE** If the scalar is statically known, its value
+  // must be -1 or an error is returned.
+  Status MakeShapeFromShapeTensorTreatScalarAsUnknownShape(int input_idx,
+                                                           ShapeHandle* out);
+
+  // Returns in <out> a new shape corresponding to <proto>.
+  Status MakeShapeFromShapeProto(const TensorShapeProto& proto,
+                                 ShapeHandle* out);
+
+  // Returns in <out> a new shape corresponding to <partial_shape>.
+  Status MakeShapeFromPartialTensorShape(
+      const PartialTensorShape& partial_shape, ShapeHandle* out);
+
+  // Returns in <out> a new shape corresponding to <shape>.
+  Status MakeShapeFromTensorShape(const TensorShape& shape, ShapeHandle* out);
+  StatusOr<ShapeHandle> MakeShapeFromShapeTensor(const TensorShape& shape);
+
+  // Returns a new dimension of the given size.  The returned value is owned by
+  // this context.
+  inline DimensionHandle MakeDim(DimensionOrConstant d) {
+    return shape_manager_.MakeDim(d);
+  }
+
+  inline DimensionHandle UnknownDim() { return MakeDim(kUnknownDim); }
+
+  // Returns in <val> a scalar value from an input tensor <t>.  The input tensor
+  // must be a 0-dimensional int32 or int64 tensor.  Caller must ensure that the
+  // input tensor is not NULL.
+  Status GetScalarFromTensor(const Tensor* t, int64_t* val);
+
+  // Returns in <val> a scalar value from a 1D input tensor <t> with int32 or
+  // int64 elements. Caller must ensure that the input tensor is not NULL.
+  Status GetScalarFromTensor(const Tensor* t, int64_t idx, int64_t* val);
+
+  // Returns a new dimension whose value is given by a scalar input tensor.
+  // The input tensor must be in host memory, since it is dereferenced to get
+  // the value.
+  Status MakeDimForScalarInput(int idx, DimensionHandle* out);
+
+  // Returns a new dimension whose value is given by a scalar input tensor.
+  // This allows for a negative input dimension given the rank of a separate
+  // tensor.  This rank can be negative if unknown.
+  // The input tensor must be in host memory, since it is dereferenced to get
+  // the value.
+  Status MakeDimForScalarInputWithNegativeIndexing(int idx, int input_rank,
+                                                   DimensionHandle* out);
+
+  // Look up the attr being evaluated with name attr_name and set *value to its
+  // value. If no attr with attr_name is found in def(), or the attr does not
+  // have a matching type, a non-ok status will be returned.
+  template <class T>
+  Status GetAttr(StringPiece attr_name, T* value) const;
+
+  // Returns in <out> the result of dividing <dividend> by <divisor>.
+  // Returns an error if <divisor>  is not positive or if <evenly_divisible>
+  // and <divisor> does not evenly divide <dividend>.
+  Status Divide(DimensionHandle dividend, DimensionOrConstant divisor,
+                bool evenly_divisible, DimensionHandle* out);
+
+  // Returns in <out> the sum of <first> and <second>.
+  Status Add(DimensionHandle first, DimensionOrConstant second,
+             DimensionHandle* out);
+
+  // Returns in <out> the dimension that is <first> minus <second>.
+  Status Subtract(DimensionHandle first, DimensionOrConstant second,
+                  DimensionHandle* out);
+
+  // Returns in <out> the product of <first> and <second>.
+  Status Multiply(DimensionHandle first, DimensionOrConstant second,
+                  DimensionHandle* out);
+
+  // Returns in <out> the minimum of <first> and <second>. If either <first> or
+  // <second> is zero the results is zero. Otherwise, if either <first> or
+  // <second> is unknown the results is unknown.
+  Status Min(DimensionHandle first, DimensionOrConstant second,
+             DimensionHandle* out);
+
+  // Returns in <out> the maximum of <first> and <second>. If either <first> or
+  // <second> is unknown the results is unknown.
+  Status Max(DimensionHandle first, DimensionOrConstant second,
+             DimensionHandle* out);
+
+  Status construction_status() const { return construction_status_; }
+
+  // Methods to propagate shape and dtype on edges of handles. Handles are the
+  // dtype DT_RESOURCE which can be used to access state stored in a
+  // ResourceManager. When ops (such as variables) consume these handles to
+  // produce tensors they might need to know side-information about the shapes
+  // and dtypes of tensors which can be accessed via the handle. These methods
+  // propagate that information. Output handle dtypes and shapes are ignored if
+  // the output tensor is not of type DT_RESOURCE.
+
+  // Merge the stored shapes and types corresponding to the input handle in
+  // position idx with the specified shapes and types. This requires idx to be
+  // in the [0, num_inputs) range.
+  //
+  // If the merge is successful and any of the new shapes differs from the old
+  // one, or any of the old dtypes was DT_INVALID, store the new shapes and
+  // return true.  Return false otherwise.
+  //
+  // See 'MergeInput' function for full details and examples.
+  bool MergeInputHandleShapesAndTypes(
+      int idx,
+      const std::vector<ShapeAndType>& shapes_and_types) TF_MUST_USE_RESULT;
+
+  // As MergeInputHandleShapesAndTypes, but for an output.
+  bool MergeOutputHandleShapesAndTypes(
+      int idx,
+      const std::vector<ShapeAndType>& shapes_and_types) TF_MUST_USE_RESULT;
+
+  // Relaxes the stored shapes and types corresponding to the input handle in
+  // position idx with the specified shapes and types. This requires idx to be
+  // in the [0, num_inputs) range.
+  //
+  // If the relax is successful (sizes are the same, old dtypes match new ones
+  // or are DT_INVALID), then store the relaxed shapes and return true.
+  // Return false otherwise.
+  //
+  // See 'RelaxInput' function for full details and examples.
+  bool RelaxInputHandleShapesAndMergeTypes(
+      int idx,
+      const std::vector<ShapeAndType>& shapes_and_types) TF_MUST_USE_RESULT;
+
+  // As RelaxInputHandleShapesAndTypes, but for an output.
+  bool RelaxOutputHandleShapesAndMergeTypes(
+      int idx,
+      const std::vector<ShapeAndType>& shapes_and_types) TF_MUST_USE_RESULT;
+
+  void set_input_handle_shapes_and_types(
+      int idx, const std::vector<ShapeAndType>& shapes_and_types) {
+    input_handle_shapes_and_types_[idx] =
+        absl::make_unique<std::vector<ShapeAndType>>(shapes_and_types);
+  }
+
+  // Returns the output handle shapes and types, for the resource tensor output
+  // at index <idx>. Returns NULL if the shape and types were never set.
+  const std::vector<ShapeAndType>* output_handle_shapes_and_types(int idx) {
+    return output_handle_shapes_and_types_[idx].get();
+  }
+
+  // Returns the inputs handle shapes and types, for the resource tensor input
+  // at index <idx>. Returns NULL if the shape and types were not available.
+  const std::vector<ShapeAndType>* input_handle_shapes_and_types(int idx) {
+    return input_handle_shapes_and_types_[idx].get();
+  }
+
+  void set_output_handle_shapes_and_types(
+      int idx, const std::vector<ShapeAndType>& shapes_and_types) {
+    output_handle_shapes_and_types_[idx] =
+        absl::make_unique<std::vector<ShapeAndType>>(shapes_and_types);
+  }
+
+  // Note that shape functions should usually call MakeShapeFromShapeTensor,
+  // as it does more analysis to provide partial shapes.
+  //
+  // Returns in <out> a new shape whose dimension sizes come from tensor <t>.
+  // The tensor must be a 1-dimensional int32 or int64 tensor.  If <t> is NULL,
+  // then an unknown shape is returned.
+  Status MakeShapeFromTensor(const Tensor* t, ShapeHandle tensor_shape,
+                             ShapeHandle* out);
+
+  int graph_def_version() const { return graph_def_version_; }
+
+  const std::vector<std::pair<ShapeHandle, ShapeHandle>>& MergedShapes() const {
+    return merged_shapes_;
+  }
+  const std::vector<std::pair<DimensionHandle, DimensionHandle>>& MergedDims()
+      const {
+    return merged_dims_;
+  }
+
+  // Adds new outputs; useful when mutating the graph.
+  Status ExpandOutputs(int new_output_size);
+
+ private:
+  // Creates and stores shapes for use in InferenceContext.
+  class ShapeManager {
+   public:
+    ShapeManager();
+    ~ShapeManager();
+
+    // Returns a new shape with the given dims. The returned value is owned by
+    // this class.
+    ShapeHandle MakeShape(const std::vector<DimensionHandle>& dims);
+
+    // Returns a new unknown shape.
+    ShapeHandle UnknownShape();
+
+    // Returns a new dimension of the given size.  The returned value
+    // is owned by this class.
+    inline DimensionHandle MakeDim(DimensionOrConstant d) {
+      if (d.dim.IsSet()) {
+        return d.dim;
+      } else {
+        all_dims_.push_back(new Dimension(d.val));
+        return all_dims_.back();
+      }
+    }
+
+   private:
+    std::vector<Shape*> all_shapes_;    // values are owned.
+    std::vector<Dimension*> all_dims_;  // values are owned.
+  };
+
+  friend class ::tensorflow::grappler::GraphProperties;
+
+  friend class ShapeInferenceTest;      // For testing Relax functions.
+  friend class ShapeInferenceTestutil;  // For testing shapes.
+
+  // Shared initialization across the two constructors.  Remove
+  // once we get rid of one of them.
+  void PreInputInit(const OpDef& op_def,
+                    const std::vector<const Tensor*>& input_tensors,
+                    const std::vector<ShapeHandle>& input_tensors_as_shapes);
+  void PostInputInit(std::vector<std::unique_ptr<std::vector<ShapeAndType>>>
+                         input_handle_data);
+
+  Status ReturnUnknownShape(ShapeHandle* out) {
+    *out = UnknownShape();
+    return OkStatus();
+  }
+  Status ReturnCreatedShape(const std::vector<DimensionHandle>& dims,
+                            ShapeHandle* out) {
+    *out = MakeShape(dims);
+    return OkStatus();
+  }
+
+  // Adds additional context to the given status.
+  Status AttachContext(const Status& status);
+
+  // Relaxes an existing value <d_old> with a new value <d_new> and returns the
+  // relaxed dimension in <*out>. If <d_old> and <d_new> have incompatible
+  // values, returns an error.
+  //
+  // Note that <*out> may be set to <d_old> or <d_new>.
+  void Relax(DimensionHandle d_old, DimensionHandle d_new,
+             DimensionHandle* out);
+  // Relaxes an existing shape <s_old> with a new shape <s_new> and returns the
+  // relaxed shape in <*out>. See 'RelaxInput' function for full details and
+  // examples.
+  void Relax(ShapeHandle s_old, ShapeHandle s_new, ShapeHandle* out);
+
+  // Used to implement MergeInputHandleShapesAndTypes and
+  // MergeOutputHandleShapesAndTypes.
+  bool MergeHandleShapesAndTypes(
+      const std::vector<ShapeAndType>& shapes_and_types,
+      std::vector<ShapeAndType>* to_update) TF_MUST_USE_RESULT;
+  // Used to implement RelaxInputHandleShapesAndMergeTypes and
+  // RelaxOutputHandleShapesAndMergeTypes.
+  bool RelaxHandleShapesAndMergeTypes(
+      const std::vector<ShapeAndType>& shapes_and_types,
+      std::vector<ShapeAndType>* to_update) TF_MUST_USE_RESULT;
+
+  // Forget all the previous merged shapes and dims.
+  void ForgetMerges() {
+    merged_shapes_.clear();
+    merged_dims_.clear();
+  }
+
+  // Helper method for MakeShapeFromTensor and MakeShapeFromShapeTensor.
+  Status InternalMakeShapeFromTensor(
+      bool treat_unknown_scalar_tensor_as_unknown_shape, const Tensor* t,
+      ShapeHandle tensor_shape, ShapeHandle* out);
+
+  ShapeManager shape_manager_;
+
+  // inputs_, outputs_, and input_tensors_as_shapes_ refer to values from
+  // `shape_manager_`.
+  std::vector<ShapeHandle> inputs_;
+  std::vector<const Tensor*> input_tensors_;
+  std::vector<bool> requested_input_tensor_;
+  std::vector<ShapeHandle> outputs_;
+  // Can have fewer elements than inputs_.
+  std::vector<ShapeHandle> input_tensors_as_shapes_;
+  std::vector<bool> requested_input_tensor_as_partial_shape_;
+
+  // input_handle_shapes_and_types_[i] is the list of shape/type pairs available
+  // through the resource handle passed along input i of the node.
+  //
+  // Values may be NULL.
+  std::vector<std::unique_ptr<std::vector<ShapeAndType>>>
+      input_handle_shapes_and_types_;
+
+  // output_handle_shapes_and_types_[i] is the list of shape/type pairs
+  // available through the resource handle passed along output i of the node.
+  //
+  // Values may be NULL.
+  std::vector<std::unique_ptr<std::vector<ShapeAndType>>>
+      output_handle_shapes_and_types_;
+
+  // Return types for the node this context is associated with. This information
+  // is to eventually consolidate all the dtype and shape info, allowing for
+  // output_handle_shapes_and_types_ to be removed.
+  FullTypeDef ret_types_;
+
+  const int graph_def_version_;
+  AttrSlice attrs_;
+  NameRangeMap input_name_map_;
+  NameRangeMap output_name_map_;
+
+  // An error set during construction. TODO(cwhipkey): remove when test
+  // constructor is removed.
+  Status construction_status_;
+
+  // Pair of shape or dim handles that are equivalent, ie that represent the
+  // same underlying shape of dimension. Note that for each pair at least one of
+  // the handles must contain an unknown shape, since we don't keep track of
+  // known shapes or dims here.
+  std::vector<std::pair<ShapeHandle, ShapeHandle>> merged_shapes_;
+  std::vector<std::pair<DimensionHandle, DimensionHandle>> merged_dims_;
+
+  InferenceContext(const InferenceContext&) = delete;
+  void operator=(const InferenceContext&) = delete;
+};
+
+// -----------------------------------------------------------------------------
+// Template and inline method implementations, please ignore
+
+inline Dimension::Dimension() : value_(InferenceContext::kUnknownDim) {}
+inline Dimension::Dimension(int64_t value) : value_(value) {
+  DCHECK(value >= 0 || value == InferenceContext::kUnknownDim)
+      << "Dimension must be non-negative or equal to "
+         "InferenceContext::kUnknownDim but got "
+      << value;
+}
+
+inline Shape::Shape() : rank_(InferenceContext::kUnknownRank) {}
+inline Shape::Shape(const std::vector<DimensionHandle>& dims)
+    : rank_(dims.size()), dims_(dims) {}
+
+inline DimensionOrConstant::DimensionOrConstant(DimensionHandle dim)
+    : dim(dim) {
+  DCHECK(dim.IsSet()) << "Internal error: Got nullptr for Dimension.";
+}
+
+inline DimensionOrConstant::DimensionOrConstant(int64_t val) : val(val) {
+  DCHECK(val >= 0 || val == InferenceContext::kUnknownDim)
+      << "Dimension must be non-negative or equal to "
+         "InferenceContext::kUnknownDim but got "
+      << val;
+}
+
+template <class T>
+Status InferenceContext::GetAttr(StringPiece attr_name, T* value) const {
+  return GetNodeAttr(attrs_, attr_name, value);
+}
+
+}  // namespace shape_inference
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_SHAPE_INFERENCE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/shared_ptr_variant.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/shared_ptr_variant.h
new file mode 100644
index 0000000000000000000000000000000000000000..337d51d56c0908f267dce73d988306bb0e1762c2
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/shared_ptr_variant.h
@@ -0,0 +1,75 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_SHARED_PTR_VARIANT_H_
+#define TENSORFLOW_CORE_FRAMEWORK_SHARED_PTR_VARIANT_H_
+
+#include <memory>
+
+#include "tensorflow/core/framework/variant_tensor_data.h"
+#include "tensorflow/core/platform/logging.h"
+
+namespace tensorflow {
+
+template <typename T>
+struct SharedPtrVariant {
+  std::shared_ptr<T> shared_ptr;
+
+  SharedPtrVariant() : shared_ptr() {}
+
+  explicit SharedPtrVariant(std::shared_ptr<T>&& ptr)
+      : shared_ptr(std::forward<decltype(ptr)>(ptr)) {
+    VLOG(3) << "Creating shared_ptr of " << shared_ptr.get()
+            << " count is: " << shared_ptr.use_count();
+  }
+
+  SharedPtrVariant(SharedPtrVariant&& rhs)
+      : shared_ptr(std::move(rhs.shared_ptr)) {
+    VLOG(3) << "Moving SharedPtrVariant of " << shared_ptr.get()
+            << " count is: " << shared_ptr.use_count();
+  }
+
+  SharedPtrVariant& operator=(const SharedPtrVariant& rhs) = delete;
+
+  SharedPtrVariant& operator=(SharedPtrVariant&& rhs) {
+    if (&rhs == this) return *this;
+    std::swap(shared_ptr, rhs.shared_ptr);
+    VLOG(3) << "Move-assign of SharedPtrVariant of " << shared_ptr.get()
+            << " count is: " << shared_ptr.use_count();
+    return *this;
+  }
+
+  SharedPtrVariant(const SharedPtrVariant& rhs) : shared_ptr(rhs.shared_ptr) {
+    VLOG(3) << "Copying SharedPtrVariant of " << shared_ptr.get()
+            << " count is: " << shared_ptr.use_count();
+  }
+
+  ~SharedPtrVariant() {
+    VLOG(3) << "Destroying SharedPtrVariant of " << shared_ptr.get()
+            << " count is: " << shared_ptr.use_count();
+  }
+
+  void Encode(VariantTensorData*) const {
+    // Not supported.
+  }
+
+  bool Decode(const VariantTensorData&) {
+    return false;  // Not supported.
+  }
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_SHARED_PTR_VARIANT_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/stats_aggregator.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/stats_aggregator.h
new file mode 100644
index 0000000000000000000000000000000000000000..9a3cae57664f426820ce7dd1452cf0663cbe6fe4
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/stats_aggregator.h
@@ -0,0 +1,97 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_FRAMEWORK_STATS_AGGREGATOR_H_
+#define TENSORFLOW_CORE_FRAMEWORK_STATS_AGGREGATOR_H_
+
+#include <memory>
+#include <string>
+
+#include "tensorflow/core/framework/resource_mgr.h"
+#include "tensorflow/core/lib/gtl/array_slice.h"
+
+namespace tensorflow {
+
+class Summary;
+class SummaryWriterInterface;
+namespace data {
+
+// A `StatsAggregator` accumulates statistics incrementally. A
+// `StatsAggregator` can accumulate multiple different statistics, distinguished
+// by a string name.
+//
+// The class currently supports accumulating `Histogram`, `scalar` objects and
+// tfstreamz metrics, and we expect to add other methods in future.
+//
+// NOTE(mrry): `StatsAggregator` is a virtual interface because we anticipate
+// that many different implementations will have the same interface. For
+// example, we have different implementations in "stats_aggregator_ops.cc" for
+// simple in-memory implementation that integrates with the pull-based summary
+// API, and for the push-based `SummaryWriterInterface`, and we may add
+// implementations that work well with other custom monitoring services.
+class StatsAggregator {
+ public:
+  virtual ~StatsAggregator() {}
+
+  // Add the given `values` to the histogram with the given `name`. Each
+  // element of `values` will be treated as a separate sample in the histogram.
+  virtual void AddToHistogram(const string& name,
+                              gtl::ArraySlice<double> values,
+                              int64_t global_step) = 0;
+
+  // TODO(shivaniagrawal): consistency in double and float usage.
+  // Add the given `value` as Scalar with the given `name`.
+  virtual void AddScalar(const string& name, float value,
+                         int64_t global_step) = 0;
+
+  // Stores a protocol buffer representation of the aggregator state in the
+  // given `out_summary`.
+  virtual void EncodeToProto(Summary* out_summary) = 0;
+
+  // Sets a `summary_writer` with this stats_aggregator.
+  virtual Status SetSummaryWriter(SummaryWriterInterface* summary_writer) = 0;
+
+  // Increment the `label` cell of metrics mapped with `name` by given `value`.
+  virtual void IncrementCounter(const string& name, const string& label,
+                                int64_t val) = 0;
+};
+
+// A `StatsAggregatorResource` wraps a sharable `StatsAggregator` as a resource
+// in the TensorFlow resource manager.
+//
+// NOTE(mrry): This class is separate from `StatsAggregator` in order to
+// simplify the memory management of the shared object. Most users of
+// `StatsAggregator` interact with a `std::shared_ptr<StatsAggregator>` whereas
+// the `ResourceBase` API requires explicit reference counting.
+class StatsAggregatorResource : public ResourceBase {
+ public:
+  // Creates a new resource from the given `stats_aggregator`.
+  StatsAggregatorResource(std::unique_ptr<StatsAggregator> stats_aggregator)
+      : stats_aggregator_(stats_aggregator.release()) {}
+
+  // Returns the wrapped `StatsAggregator`.
+  std::shared_ptr<StatsAggregator> stats_aggregator() const {
+    return stats_aggregator_;
+  }
+
+  string DebugString() const override { return "StatsAggregatorResource"; }
+
+ private:
+  const std::shared_ptr<StatsAggregator> stats_aggregator_;
+};
+
+}  // namespace data
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_STATS_AGGREGATOR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/step_stats.pb.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/step_stats.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..feba4dafb3f74f7344fc1bbdc4d759098ebefbf3
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/step_stats.pb.h
@@ -0,0 +1,2854 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: tensorflow/core/framework/step_stats.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fstep_5fstats_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fstep_5fstats_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3021000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3021009 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/map.h>  // IWYU pragma: export
+#include <google/protobuf/map_entry.h>
+#include <google/protobuf/map_field_inl.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "tensorflow/core/framework/allocation_description.pb.h"
+#include "tensorflow/core/framework/tensor_description.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_tensorflow_2fcore_2fframework_2fstep_5fstats_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_tensorflow_2fcore_2fframework_2fstep_5fstats_2eproto {
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_tensorflow_2fcore_2fframework_2fstep_5fstats_2eproto;
+namespace tensorflow {
+class AllocationRecord;
+struct AllocationRecordDefaultTypeInternal;
+extern AllocationRecordDefaultTypeInternal _AllocationRecord_default_instance_;
+class AllocatorMemoryUsed;
+struct AllocatorMemoryUsedDefaultTypeInternal;
+extern AllocatorMemoryUsedDefaultTypeInternal _AllocatorMemoryUsed_default_instance_;
+class DeviceStepStats;
+struct DeviceStepStatsDefaultTypeInternal;
+extern DeviceStepStatsDefaultTypeInternal _DeviceStepStats_default_instance_;
+class DeviceStepStats_ThreadNamesEntry_DoNotUse;
+struct DeviceStepStats_ThreadNamesEntry_DoNotUseDefaultTypeInternal;
+extern DeviceStepStats_ThreadNamesEntry_DoNotUseDefaultTypeInternal _DeviceStepStats_ThreadNamesEntry_DoNotUse_default_instance_;
+class MemoryStats;
+struct MemoryStatsDefaultTypeInternal;
+extern MemoryStatsDefaultTypeInternal _MemoryStats_default_instance_;
+class NodeExecStats;
+struct NodeExecStatsDefaultTypeInternal;
+extern NodeExecStatsDefaultTypeInternal _NodeExecStats_default_instance_;
+class NodeOutput;
+struct NodeOutputDefaultTypeInternal;
+extern NodeOutputDefaultTypeInternal _NodeOutput_default_instance_;
+class StepStats;
+struct StepStatsDefaultTypeInternal;
+extern StepStatsDefaultTypeInternal _StepStats_default_instance_;
+}  // namespace tensorflow
+PROTOBUF_NAMESPACE_OPEN
+template<> ::tensorflow::AllocationRecord* Arena::CreateMaybeMessage<::tensorflow::AllocationRecord>(Arena*);
+template<> ::tensorflow::AllocatorMemoryUsed* Arena::CreateMaybeMessage<::tensorflow::AllocatorMemoryUsed>(Arena*);
+template<> ::tensorflow::DeviceStepStats* Arena::CreateMaybeMessage<::tensorflow::DeviceStepStats>(Arena*);
+template<> ::tensorflow::DeviceStepStats_ThreadNamesEntry_DoNotUse* Arena::CreateMaybeMessage<::tensorflow::DeviceStepStats_ThreadNamesEntry_DoNotUse>(Arena*);
+template<> ::tensorflow::MemoryStats* Arena::CreateMaybeMessage<::tensorflow::MemoryStats>(Arena*);
+template<> ::tensorflow::NodeExecStats* Arena::CreateMaybeMessage<::tensorflow::NodeExecStats>(Arena*);
+template<> ::tensorflow::NodeOutput* Arena::CreateMaybeMessage<::tensorflow::NodeOutput>(Arena*);
+template<> ::tensorflow::StepStats* Arena::CreateMaybeMessage<::tensorflow::StepStats>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace tensorflow {
+
+// ===================================================================
+
+class AllocationRecord final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.AllocationRecord) */ {
+ public:
+  inline AllocationRecord() : AllocationRecord(nullptr) {}
+  ~AllocationRecord() override;
+  explicit PROTOBUF_CONSTEXPR AllocationRecord(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  AllocationRecord(const AllocationRecord& from);
+  AllocationRecord(AllocationRecord&& from) noexcept
+    : AllocationRecord() {
+    *this = ::std::move(from);
+  }
+
+  inline AllocationRecord& operator=(const AllocationRecord& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline AllocationRecord& operator=(AllocationRecord&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const AllocationRecord& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const AllocationRecord* internal_default_instance() {
+    return reinterpret_cast<const AllocationRecord*>(
+               &_AllocationRecord_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(AllocationRecord& a, AllocationRecord& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(AllocationRecord* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(AllocationRecord* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  AllocationRecord* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<AllocationRecord>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const AllocationRecord& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const AllocationRecord& from) {
+    AllocationRecord::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(AllocationRecord* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.AllocationRecord";
+  }
+  protected:
+  explicit AllocationRecord(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kAllocMicrosFieldNumber = 1,
+    kAllocBytesFieldNumber = 2,
+  };
+  // int64 alloc_micros = 1;
+  void clear_alloc_micros();
+  int64_t alloc_micros() const;
+  void set_alloc_micros(int64_t value);
+  private:
+  int64_t _internal_alloc_micros() const;
+  void _internal_set_alloc_micros(int64_t value);
+  public:
+
+  // int64 alloc_bytes = 2;
+  void clear_alloc_bytes();
+  int64_t alloc_bytes() const;
+  void set_alloc_bytes(int64_t value);
+  private:
+  int64_t _internal_alloc_bytes() const;
+  void _internal_set_alloc_bytes(int64_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.AllocationRecord)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    int64_t alloc_micros_;
+    int64_t alloc_bytes_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fstep_5fstats_2eproto;
+};
+// -------------------------------------------------------------------
+
+class AllocatorMemoryUsed final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.AllocatorMemoryUsed) */ {
+ public:
+  inline AllocatorMemoryUsed() : AllocatorMemoryUsed(nullptr) {}
+  ~AllocatorMemoryUsed() override;
+  explicit PROTOBUF_CONSTEXPR AllocatorMemoryUsed(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  AllocatorMemoryUsed(const AllocatorMemoryUsed& from);
+  AllocatorMemoryUsed(AllocatorMemoryUsed&& from) noexcept
+    : AllocatorMemoryUsed() {
+    *this = ::std::move(from);
+  }
+
+  inline AllocatorMemoryUsed& operator=(const AllocatorMemoryUsed& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline AllocatorMemoryUsed& operator=(AllocatorMemoryUsed&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const AllocatorMemoryUsed& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const AllocatorMemoryUsed* internal_default_instance() {
+    return reinterpret_cast<const AllocatorMemoryUsed*>(
+               &_AllocatorMemoryUsed_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(AllocatorMemoryUsed& a, AllocatorMemoryUsed& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(AllocatorMemoryUsed* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(AllocatorMemoryUsed* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  AllocatorMemoryUsed* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<AllocatorMemoryUsed>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const AllocatorMemoryUsed& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const AllocatorMemoryUsed& from) {
+    AllocatorMemoryUsed::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(AllocatorMemoryUsed* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.AllocatorMemoryUsed";
+  }
+  protected:
+  explicit AllocatorMemoryUsed(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kAllocationRecordsFieldNumber = 6,
+    kAllocatorNameFieldNumber = 1,
+    kTotalBytesFieldNumber = 2,
+    kPeakBytesFieldNumber = 3,
+    kLiveBytesFieldNumber = 4,
+    kAllocatorBytesInUseFieldNumber = 5,
+  };
+  // repeated .tensorflow.AllocationRecord allocation_records = 6;
+  int allocation_records_size() const;
+  private:
+  int _internal_allocation_records_size() const;
+  public:
+  void clear_allocation_records();
+  ::tensorflow::AllocationRecord* mutable_allocation_records(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::AllocationRecord >*
+      mutable_allocation_records();
+  private:
+  const ::tensorflow::AllocationRecord& _internal_allocation_records(int index) const;
+  ::tensorflow::AllocationRecord* _internal_add_allocation_records();
+  public:
+  const ::tensorflow::AllocationRecord& allocation_records(int index) const;
+  ::tensorflow::AllocationRecord* add_allocation_records();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::AllocationRecord >&
+      allocation_records() const;
+
+  // string allocator_name = 1;
+  void clear_allocator_name();
+  const std::string& allocator_name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_allocator_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_allocator_name();
+  PROTOBUF_NODISCARD std::string* release_allocator_name();
+  void set_allocated_allocator_name(std::string* allocator_name);
+  private:
+  const std::string& _internal_allocator_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_allocator_name(const std::string& value);
+  std::string* _internal_mutable_allocator_name();
+  public:
+
+  // int64 total_bytes = 2;
+  void clear_total_bytes();
+  int64_t total_bytes() const;
+  void set_total_bytes(int64_t value);
+  private:
+  int64_t _internal_total_bytes() const;
+  void _internal_set_total_bytes(int64_t value);
+  public:
+
+  // int64 peak_bytes = 3;
+  void clear_peak_bytes();
+  int64_t peak_bytes() const;
+  void set_peak_bytes(int64_t value);
+  private:
+  int64_t _internal_peak_bytes() const;
+  void _internal_set_peak_bytes(int64_t value);
+  public:
+
+  // int64 live_bytes = 4;
+  void clear_live_bytes();
+  int64_t live_bytes() const;
+  void set_live_bytes(int64_t value);
+  private:
+  int64_t _internal_live_bytes() const;
+  void _internal_set_live_bytes(int64_t value);
+  public:
+
+  // int64 allocator_bytes_in_use = 5;
+  void clear_allocator_bytes_in_use();
+  int64_t allocator_bytes_in_use() const;
+  void set_allocator_bytes_in_use(int64_t value);
+  private:
+  int64_t _internal_allocator_bytes_in_use() const;
+  void _internal_set_allocator_bytes_in_use(int64_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.AllocatorMemoryUsed)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::AllocationRecord > allocation_records_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr allocator_name_;
+    int64_t total_bytes_;
+    int64_t peak_bytes_;
+    int64_t live_bytes_;
+    int64_t allocator_bytes_in_use_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fstep_5fstats_2eproto;
+};
+// -------------------------------------------------------------------
+
+class NodeOutput final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.NodeOutput) */ {
+ public:
+  inline NodeOutput() : NodeOutput(nullptr) {}
+  ~NodeOutput() override;
+  explicit PROTOBUF_CONSTEXPR NodeOutput(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  NodeOutput(const NodeOutput& from);
+  NodeOutput(NodeOutput&& from) noexcept
+    : NodeOutput() {
+    *this = ::std::move(from);
+  }
+
+  inline NodeOutput& operator=(const NodeOutput& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline NodeOutput& operator=(NodeOutput&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const NodeOutput& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const NodeOutput* internal_default_instance() {
+    return reinterpret_cast<const NodeOutput*>(
+               &_NodeOutput_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(NodeOutput& a, NodeOutput& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(NodeOutput* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(NodeOutput* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  NodeOutput* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<NodeOutput>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const NodeOutput& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const NodeOutput& from) {
+    NodeOutput::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(NodeOutput* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.NodeOutput";
+  }
+  protected:
+  explicit NodeOutput(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTensorDescriptionFieldNumber = 3,
+    kSlotFieldNumber = 1,
+  };
+  // .tensorflow.TensorDescription tensor_description = 3;
+  bool has_tensor_description() const;
+  private:
+  bool _internal_has_tensor_description() const;
+  public:
+  void clear_tensor_description();
+  const ::tensorflow::TensorDescription& tensor_description() const;
+  PROTOBUF_NODISCARD ::tensorflow::TensorDescription* release_tensor_description();
+  ::tensorflow::TensorDescription* mutable_tensor_description();
+  void set_allocated_tensor_description(::tensorflow::TensorDescription* tensor_description);
+  private:
+  const ::tensorflow::TensorDescription& _internal_tensor_description() const;
+  ::tensorflow::TensorDescription* _internal_mutable_tensor_description();
+  public:
+  void unsafe_arena_set_allocated_tensor_description(
+      ::tensorflow::TensorDescription* tensor_description);
+  ::tensorflow::TensorDescription* unsafe_arena_release_tensor_description();
+
+  // int32 slot = 1;
+  void clear_slot();
+  int32_t slot() const;
+  void set_slot(int32_t value);
+  private:
+  int32_t _internal_slot() const;
+  void _internal_set_slot(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.NodeOutput)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::tensorflow::TensorDescription* tensor_description_;
+    int32_t slot_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fstep_5fstats_2eproto;
+};
+// -------------------------------------------------------------------
+
+class MemoryStats final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.MemoryStats) */ {
+ public:
+  inline MemoryStats() : MemoryStats(nullptr) {}
+  ~MemoryStats() override;
+  explicit PROTOBUF_CONSTEXPR MemoryStats(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  MemoryStats(const MemoryStats& from);
+  MemoryStats(MemoryStats&& from) noexcept
+    : MemoryStats() {
+    *this = ::std::move(from);
+  }
+
+  inline MemoryStats& operator=(const MemoryStats& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline MemoryStats& operator=(MemoryStats&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const MemoryStats& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const MemoryStats* internal_default_instance() {
+    return reinterpret_cast<const MemoryStats*>(
+               &_MemoryStats_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  friend void swap(MemoryStats& a, MemoryStats& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(MemoryStats* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(MemoryStats* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  MemoryStats* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<MemoryStats>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const MemoryStats& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const MemoryStats& from) {
+    MemoryStats::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(MemoryStats* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.MemoryStats";
+  }
+  protected:
+  explicit MemoryStats(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kPersistentTensorAllocIdsFieldNumber = 5,
+    kDevicePersistentTensorAllocIdsFieldNumber = 6,
+    kTempMemorySizeFieldNumber = 1,
+    kDeviceTempMemorySizeFieldNumber = 2,
+    kPersistentMemorySizeFieldNumber = 3,
+    kDevicePersistentMemorySizeFieldNumber = 4,
+  };
+  // repeated int64 persistent_tensor_alloc_ids = 5;
+  int persistent_tensor_alloc_ids_size() const;
+  private:
+  int _internal_persistent_tensor_alloc_ids_size() const;
+  public:
+  void clear_persistent_tensor_alloc_ids();
+  private:
+  int64_t _internal_persistent_tensor_alloc_ids(int index) const;
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
+      _internal_persistent_tensor_alloc_ids() const;
+  void _internal_add_persistent_tensor_alloc_ids(int64_t value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
+      _internal_mutable_persistent_tensor_alloc_ids();
+  public:
+  int64_t persistent_tensor_alloc_ids(int index) const;
+  void set_persistent_tensor_alloc_ids(int index, int64_t value);
+  void add_persistent_tensor_alloc_ids(int64_t value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
+      persistent_tensor_alloc_ids() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
+      mutable_persistent_tensor_alloc_ids();
+
+  // repeated int64 device_persistent_tensor_alloc_ids = 6 [deprecated = true];
+  PROTOBUF_DEPRECATED int device_persistent_tensor_alloc_ids_size() const;
+  private:
+  int _internal_device_persistent_tensor_alloc_ids_size() const;
+  public:
+  PROTOBUF_DEPRECATED void clear_device_persistent_tensor_alloc_ids();
+  private:
+  int64_t _internal_device_persistent_tensor_alloc_ids(int index) const;
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
+      _internal_device_persistent_tensor_alloc_ids() const;
+  void _internal_add_device_persistent_tensor_alloc_ids(int64_t value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
+      _internal_mutable_device_persistent_tensor_alloc_ids();
+  public:
+  PROTOBUF_DEPRECATED int64_t device_persistent_tensor_alloc_ids(int index) const;
+  PROTOBUF_DEPRECATED void set_device_persistent_tensor_alloc_ids(int index, int64_t value);
+  PROTOBUF_DEPRECATED void add_device_persistent_tensor_alloc_ids(int64_t value);
+  PROTOBUF_DEPRECATED const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
+      device_persistent_tensor_alloc_ids() const;
+  PROTOBUF_DEPRECATED ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
+      mutable_device_persistent_tensor_alloc_ids();
+
+  // int64 temp_memory_size = 1;
+  void clear_temp_memory_size();
+  int64_t temp_memory_size() const;
+  void set_temp_memory_size(int64_t value);
+  private:
+  int64_t _internal_temp_memory_size() const;
+  void _internal_set_temp_memory_size(int64_t value);
+  public:
+
+  // int64 device_temp_memory_size = 2 [deprecated = true];
+  PROTOBUF_DEPRECATED void clear_device_temp_memory_size();
+  PROTOBUF_DEPRECATED int64_t device_temp_memory_size() const;
+  PROTOBUF_DEPRECATED void set_device_temp_memory_size(int64_t value);
+  private:
+  int64_t _internal_device_temp_memory_size() const;
+  void _internal_set_device_temp_memory_size(int64_t value);
+  public:
+
+  // int64 persistent_memory_size = 3;
+  void clear_persistent_memory_size();
+  int64_t persistent_memory_size() const;
+  void set_persistent_memory_size(int64_t value);
+  private:
+  int64_t _internal_persistent_memory_size() const;
+  void _internal_set_persistent_memory_size(int64_t value);
+  public:
+
+  // int64 device_persistent_memory_size = 4 [deprecated = true];
+  PROTOBUF_DEPRECATED void clear_device_persistent_memory_size();
+  PROTOBUF_DEPRECATED int64_t device_persistent_memory_size() const;
+  PROTOBUF_DEPRECATED void set_device_persistent_memory_size(int64_t value);
+  private:
+  int64_t _internal_device_persistent_memory_size() const;
+  void _internal_set_device_persistent_memory_size(int64_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.MemoryStats)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > persistent_tensor_alloc_ids_;
+    mutable std::atomic<int> _persistent_tensor_alloc_ids_cached_byte_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > device_persistent_tensor_alloc_ids_;
+    mutable std::atomic<int> _device_persistent_tensor_alloc_ids_cached_byte_size_;
+    int64_t temp_memory_size_;
+    int64_t device_temp_memory_size_;
+    int64_t persistent_memory_size_;
+    int64_t device_persistent_memory_size_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fstep_5fstats_2eproto;
+};
+// -------------------------------------------------------------------
+
+class NodeExecStats final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.NodeExecStats) */ {
+ public:
+  inline NodeExecStats() : NodeExecStats(nullptr) {}
+  ~NodeExecStats() override;
+  explicit PROTOBUF_CONSTEXPR NodeExecStats(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  NodeExecStats(const NodeExecStats& from);
+  NodeExecStats(NodeExecStats&& from) noexcept
+    : NodeExecStats() {
+    *this = ::std::move(from);
+  }
+
+  inline NodeExecStats& operator=(const NodeExecStats& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline NodeExecStats& operator=(NodeExecStats&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const NodeExecStats& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const NodeExecStats* internal_default_instance() {
+    return reinterpret_cast<const NodeExecStats*>(
+               &_NodeExecStats_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    4;
+
+  friend void swap(NodeExecStats& a, NodeExecStats& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(NodeExecStats* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(NodeExecStats* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  NodeExecStats* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<NodeExecStats>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const NodeExecStats& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const NodeExecStats& from) {
+    NodeExecStats::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(NodeExecStats* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.NodeExecStats";
+  }
+  protected:
+  explicit NodeExecStats(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kMemoryFieldNumber = 6,
+    kOutputFieldNumber = 7,
+    kReferencedTensorFieldNumber = 11,
+    kNodeNameFieldNumber = 1,
+    kTimelineLabelFieldNumber = 8,
+    kMemoryStatsFieldNumber = 12,
+    kAllStartMicrosFieldNumber = 2,
+    kOpStartRelMicrosFieldNumber = 3,
+    kOpEndRelMicrosFieldNumber = 4,
+    kAllEndRelMicrosFieldNumber = 5,
+    kScheduledMicrosFieldNumber = 9,
+    kAllStartNanosFieldNumber = 13,
+    kOpStartRelNanosFieldNumber = 14,
+    kOpEndRelNanosFieldNumber = 15,
+    kAllEndRelNanosFieldNumber = 16,
+    kScheduledNanosFieldNumber = 17,
+    kThreadIdFieldNumber = 10,
+  };
+  // repeated .tensorflow.AllocatorMemoryUsed memory = 6;
+  int memory_size() const;
+  private:
+  int _internal_memory_size() const;
+  public:
+  void clear_memory();
+  ::tensorflow::AllocatorMemoryUsed* mutable_memory(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::AllocatorMemoryUsed >*
+      mutable_memory();
+  private:
+  const ::tensorflow::AllocatorMemoryUsed& _internal_memory(int index) const;
+  ::tensorflow::AllocatorMemoryUsed* _internal_add_memory();
+  public:
+  const ::tensorflow::AllocatorMemoryUsed& memory(int index) const;
+  ::tensorflow::AllocatorMemoryUsed* add_memory();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::AllocatorMemoryUsed >&
+      memory() const;
+
+  // repeated .tensorflow.NodeOutput output = 7;
+  int output_size() const;
+  private:
+  int _internal_output_size() const;
+  public:
+  void clear_output();
+  ::tensorflow::NodeOutput* mutable_output(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::NodeOutput >*
+      mutable_output();
+  private:
+  const ::tensorflow::NodeOutput& _internal_output(int index) const;
+  ::tensorflow::NodeOutput* _internal_add_output();
+  public:
+  const ::tensorflow::NodeOutput& output(int index) const;
+  ::tensorflow::NodeOutput* add_output();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::NodeOutput >&
+      output() const;
+
+  // repeated .tensorflow.AllocationDescription referenced_tensor = 11;
+  int referenced_tensor_size() const;
+  private:
+  int _internal_referenced_tensor_size() const;
+  public:
+  void clear_referenced_tensor();
+  ::tensorflow::AllocationDescription* mutable_referenced_tensor(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::AllocationDescription >*
+      mutable_referenced_tensor();
+  private:
+  const ::tensorflow::AllocationDescription& _internal_referenced_tensor(int index) const;
+  ::tensorflow::AllocationDescription* _internal_add_referenced_tensor();
+  public:
+  const ::tensorflow::AllocationDescription& referenced_tensor(int index) const;
+  ::tensorflow::AllocationDescription* add_referenced_tensor();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::AllocationDescription >&
+      referenced_tensor() const;
+
+  // string node_name = 1;
+  void clear_node_name();
+  const std::string& node_name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_node_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_node_name();
+  PROTOBUF_NODISCARD std::string* release_node_name();
+  void set_allocated_node_name(std::string* node_name);
+  private:
+  const std::string& _internal_node_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_node_name(const std::string& value);
+  std::string* _internal_mutable_node_name();
+  public:
+
+  // string timeline_label = 8;
+  void clear_timeline_label();
+  const std::string& timeline_label() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_timeline_label(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_timeline_label();
+  PROTOBUF_NODISCARD std::string* release_timeline_label();
+  void set_allocated_timeline_label(std::string* timeline_label);
+  private:
+  const std::string& _internal_timeline_label() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_timeline_label(const std::string& value);
+  std::string* _internal_mutable_timeline_label();
+  public:
+
+  // .tensorflow.MemoryStats memory_stats = 12;
+  bool has_memory_stats() const;
+  private:
+  bool _internal_has_memory_stats() const;
+  public:
+  void clear_memory_stats();
+  const ::tensorflow::MemoryStats& memory_stats() const;
+  PROTOBUF_NODISCARD ::tensorflow::MemoryStats* release_memory_stats();
+  ::tensorflow::MemoryStats* mutable_memory_stats();
+  void set_allocated_memory_stats(::tensorflow::MemoryStats* memory_stats);
+  private:
+  const ::tensorflow::MemoryStats& _internal_memory_stats() const;
+  ::tensorflow::MemoryStats* _internal_mutable_memory_stats();
+  public:
+  void unsafe_arena_set_allocated_memory_stats(
+      ::tensorflow::MemoryStats* memory_stats);
+  ::tensorflow::MemoryStats* unsafe_arena_release_memory_stats();
+
+  // int64 all_start_micros = 2;
+  void clear_all_start_micros();
+  int64_t all_start_micros() const;
+  void set_all_start_micros(int64_t value);
+  private:
+  int64_t _internal_all_start_micros() const;
+  void _internal_set_all_start_micros(int64_t value);
+  public:
+
+  // int64 op_start_rel_micros = 3;
+  void clear_op_start_rel_micros();
+  int64_t op_start_rel_micros() const;
+  void set_op_start_rel_micros(int64_t value);
+  private:
+  int64_t _internal_op_start_rel_micros() const;
+  void _internal_set_op_start_rel_micros(int64_t value);
+  public:
+
+  // int64 op_end_rel_micros = 4;
+  void clear_op_end_rel_micros();
+  int64_t op_end_rel_micros() const;
+  void set_op_end_rel_micros(int64_t value);
+  private:
+  int64_t _internal_op_end_rel_micros() const;
+  void _internal_set_op_end_rel_micros(int64_t value);
+  public:
+
+  // int64 all_end_rel_micros = 5;
+  void clear_all_end_rel_micros();
+  int64_t all_end_rel_micros() const;
+  void set_all_end_rel_micros(int64_t value);
+  private:
+  int64_t _internal_all_end_rel_micros() const;
+  void _internal_set_all_end_rel_micros(int64_t value);
+  public:
+
+  // int64 scheduled_micros = 9;
+  void clear_scheduled_micros();
+  int64_t scheduled_micros() const;
+  void set_scheduled_micros(int64_t value);
+  private:
+  int64_t _internal_scheduled_micros() const;
+  void _internal_set_scheduled_micros(int64_t value);
+  public:
+
+  // int64 all_start_nanos = 13;
+  void clear_all_start_nanos();
+  int64_t all_start_nanos() const;
+  void set_all_start_nanos(int64_t value);
+  private:
+  int64_t _internal_all_start_nanos() const;
+  void _internal_set_all_start_nanos(int64_t value);
+  public:
+
+  // int64 op_start_rel_nanos = 14;
+  void clear_op_start_rel_nanos();
+  int64_t op_start_rel_nanos() const;
+  void set_op_start_rel_nanos(int64_t value);
+  private:
+  int64_t _internal_op_start_rel_nanos() const;
+  void _internal_set_op_start_rel_nanos(int64_t value);
+  public:
+
+  // int64 op_end_rel_nanos = 15;
+  void clear_op_end_rel_nanos();
+  int64_t op_end_rel_nanos() const;
+  void set_op_end_rel_nanos(int64_t value);
+  private:
+  int64_t _internal_op_end_rel_nanos() const;
+  void _internal_set_op_end_rel_nanos(int64_t value);
+  public:
+
+  // int64 all_end_rel_nanos = 16;
+  void clear_all_end_rel_nanos();
+  int64_t all_end_rel_nanos() const;
+  void set_all_end_rel_nanos(int64_t value);
+  private:
+  int64_t _internal_all_end_rel_nanos() const;
+  void _internal_set_all_end_rel_nanos(int64_t value);
+  public:
+
+  // int64 scheduled_nanos = 17;
+  void clear_scheduled_nanos();
+  int64_t scheduled_nanos() const;
+  void set_scheduled_nanos(int64_t value);
+  private:
+  int64_t _internal_scheduled_nanos() const;
+  void _internal_set_scheduled_nanos(int64_t value);
+  public:
+
+  // uint32 thread_id = 10;
+  void clear_thread_id();
+  uint32_t thread_id() const;
+  void set_thread_id(uint32_t value);
+  private:
+  uint32_t _internal_thread_id() const;
+  void _internal_set_thread_id(uint32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.NodeExecStats)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::AllocatorMemoryUsed > memory_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::NodeOutput > output_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::AllocationDescription > referenced_tensor_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr node_name_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr timeline_label_;
+    ::tensorflow::MemoryStats* memory_stats_;
+    int64_t all_start_micros_;
+    int64_t op_start_rel_micros_;
+    int64_t op_end_rel_micros_;
+    int64_t all_end_rel_micros_;
+    int64_t scheduled_micros_;
+    int64_t all_start_nanos_;
+    int64_t op_start_rel_nanos_;
+    int64_t op_end_rel_nanos_;
+    int64_t all_end_rel_nanos_;
+    int64_t scheduled_nanos_;
+    uint32_t thread_id_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fstep_5fstats_2eproto;
+};
+// -------------------------------------------------------------------
+
+class DeviceStepStats_ThreadNamesEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<DeviceStepStats_ThreadNamesEntry_DoNotUse, 
+    uint32_t, std::string,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING> {
+public:
+  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<DeviceStepStats_ThreadNamesEntry_DoNotUse, 
+    uint32_t, std::string,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING> SuperType;
+  DeviceStepStats_ThreadNamesEntry_DoNotUse();
+  explicit PROTOBUF_CONSTEXPR DeviceStepStats_ThreadNamesEntry_DoNotUse(
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+  explicit DeviceStepStats_ThreadNamesEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  void MergeFrom(const DeviceStepStats_ThreadNamesEntry_DoNotUse& other);
+  static const DeviceStepStats_ThreadNamesEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const DeviceStepStats_ThreadNamesEntry_DoNotUse*>(&_DeviceStepStats_ThreadNamesEntry_DoNotUse_default_instance_); }
+  static bool ValidateKey(void*) { return true; }
+  static bool ValidateValue(std::string* s) {
+    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "tensorflow.DeviceStepStats.ThreadNamesEntry.value");
+ }
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fstep_5fstats_2eproto;
+};
+
+// -------------------------------------------------------------------
+
+class DeviceStepStats final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.DeviceStepStats) */ {
+ public:
+  inline DeviceStepStats() : DeviceStepStats(nullptr) {}
+  ~DeviceStepStats() override;
+  explicit PROTOBUF_CONSTEXPR DeviceStepStats(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DeviceStepStats(const DeviceStepStats& from);
+  DeviceStepStats(DeviceStepStats&& from) noexcept
+    : DeviceStepStats() {
+    *this = ::std::move(from);
+  }
+
+  inline DeviceStepStats& operator=(const DeviceStepStats& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DeviceStepStats& operator=(DeviceStepStats&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const DeviceStepStats& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const DeviceStepStats* internal_default_instance() {
+    return reinterpret_cast<const DeviceStepStats*>(
+               &_DeviceStepStats_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    6;
+
+  friend void swap(DeviceStepStats& a, DeviceStepStats& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DeviceStepStats* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(DeviceStepStats* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  DeviceStepStats* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<DeviceStepStats>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const DeviceStepStats& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const DeviceStepStats& from) {
+    DeviceStepStats::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(DeviceStepStats* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.DeviceStepStats";
+  }
+  protected:
+  explicit DeviceStepStats(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNodeStatsFieldNumber = 2,
+    kThreadNamesFieldNumber = 3,
+    kDeviceFieldNumber = 1,
+  };
+  // repeated .tensorflow.NodeExecStats node_stats = 2;
+  int node_stats_size() const;
+  private:
+  int _internal_node_stats_size() const;
+  public:
+  void clear_node_stats();
+  ::tensorflow::NodeExecStats* mutable_node_stats(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::NodeExecStats >*
+      mutable_node_stats();
+  private:
+  const ::tensorflow::NodeExecStats& _internal_node_stats(int index) const;
+  ::tensorflow::NodeExecStats* _internal_add_node_stats();
+  public:
+  const ::tensorflow::NodeExecStats& node_stats(int index) const;
+  ::tensorflow::NodeExecStats* add_node_stats();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::NodeExecStats >&
+      node_stats() const;
+
+  // map<uint32, string> thread_names = 3;
+  int thread_names_size() const;
+  private:
+  int _internal_thread_names_size() const;
+  public:
+  void clear_thread_names();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::Map< uint32_t, std::string >&
+      _internal_thread_names() const;
+  ::PROTOBUF_NAMESPACE_ID::Map< uint32_t, std::string >*
+      _internal_mutable_thread_names();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::Map< uint32_t, std::string >&
+      thread_names() const;
+  ::PROTOBUF_NAMESPACE_ID::Map< uint32_t, std::string >*
+      mutable_thread_names();
+
+  // string device = 1;
+  void clear_device();
+  const std::string& device() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_device(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_device();
+  PROTOBUF_NODISCARD std::string* release_device();
+  void set_allocated_device(std::string* device);
+  private:
+  const std::string& _internal_device() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_device(const std::string& value);
+  std::string* _internal_mutable_device();
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.DeviceStepStats)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::NodeExecStats > node_stats_;
+    ::PROTOBUF_NAMESPACE_ID::internal::MapField<
+        DeviceStepStats_ThreadNamesEntry_DoNotUse,
+        uint32_t, std::string,
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32,
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING> thread_names_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fstep_5fstats_2eproto;
+};
+// -------------------------------------------------------------------
+
+class StepStats final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.StepStats) */ {
+ public:
+  inline StepStats() : StepStats(nullptr) {}
+  ~StepStats() override;
+  explicit PROTOBUF_CONSTEXPR StepStats(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  StepStats(const StepStats& from);
+  StepStats(StepStats&& from) noexcept
+    : StepStats() {
+    *this = ::std::move(from);
+  }
+
+  inline StepStats& operator=(const StepStats& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline StepStats& operator=(StepStats&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const StepStats& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const StepStats* internal_default_instance() {
+    return reinterpret_cast<const StepStats*>(
+               &_StepStats_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    7;
+
+  friend void swap(StepStats& a, StepStats& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(StepStats* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(StepStats* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  StepStats* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<StepStats>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const StepStats& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const StepStats& from) {
+    StepStats::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(StepStats* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.StepStats";
+  }
+  protected:
+  explicit StepStats(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDevStatsFieldNumber = 1,
+  };
+  // repeated .tensorflow.DeviceStepStats dev_stats = 1;
+  int dev_stats_size() const;
+  private:
+  int _internal_dev_stats_size() const;
+  public:
+  void clear_dev_stats();
+  ::tensorflow::DeviceStepStats* mutable_dev_stats(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::DeviceStepStats >*
+      mutable_dev_stats();
+  private:
+  const ::tensorflow::DeviceStepStats& _internal_dev_stats(int index) const;
+  ::tensorflow::DeviceStepStats* _internal_add_dev_stats();
+  public:
+  const ::tensorflow::DeviceStepStats& dev_stats(int index) const;
+  ::tensorflow::DeviceStepStats* add_dev_stats();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::DeviceStepStats >&
+      dev_stats() const;
+
+  // @@protoc_insertion_point(class_scope:tensorflow.StepStats)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::DeviceStepStats > dev_stats_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fstep_5fstats_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// AllocationRecord
+
+// int64 alloc_micros = 1;
+inline void AllocationRecord::clear_alloc_micros() {
+  _impl_.alloc_micros_ = int64_t{0};
+}
+inline int64_t AllocationRecord::_internal_alloc_micros() const {
+  return _impl_.alloc_micros_;
+}
+inline int64_t AllocationRecord::alloc_micros() const {
+  // @@protoc_insertion_point(field_get:tensorflow.AllocationRecord.alloc_micros)
+  return _internal_alloc_micros();
+}
+inline void AllocationRecord::_internal_set_alloc_micros(int64_t value) {
+  
+  _impl_.alloc_micros_ = value;
+}
+inline void AllocationRecord::set_alloc_micros(int64_t value) {
+  _internal_set_alloc_micros(value);
+  // @@protoc_insertion_point(field_set:tensorflow.AllocationRecord.alloc_micros)
+}
+
+// int64 alloc_bytes = 2;
+inline void AllocationRecord::clear_alloc_bytes() {
+  _impl_.alloc_bytes_ = int64_t{0};
+}
+inline int64_t AllocationRecord::_internal_alloc_bytes() const {
+  return _impl_.alloc_bytes_;
+}
+inline int64_t AllocationRecord::alloc_bytes() const {
+  // @@protoc_insertion_point(field_get:tensorflow.AllocationRecord.alloc_bytes)
+  return _internal_alloc_bytes();
+}
+inline void AllocationRecord::_internal_set_alloc_bytes(int64_t value) {
+  
+  _impl_.alloc_bytes_ = value;
+}
+inline void AllocationRecord::set_alloc_bytes(int64_t value) {
+  _internal_set_alloc_bytes(value);
+  // @@protoc_insertion_point(field_set:tensorflow.AllocationRecord.alloc_bytes)
+}
+
+// -------------------------------------------------------------------
+
+// AllocatorMemoryUsed
+
+// string allocator_name = 1;
+inline void AllocatorMemoryUsed::clear_allocator_name() {
+  _impl_.allocator_name_.ClearToEmpty();
+}
+inline const std::string& AllocatorMemoryUsed::allocator_name() const {
+  // @@protoc_insertion_point(field_get:tensorflow.AllocatorMemoryUsed.allocator_name)
+  return _internal_allocator_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void AllocatorMemoryUsed::set_allocator_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.allocator_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.AllocatorMemoryUsed.allocator_name)
+}
+inline std::string* AllocatorMemoryUsed::mutable_allocator_name() {
+  std::string* _s = _internal_mutable_allocator_name();
+  // @@protoc_insertion_point(field_mutable:tensorflow.AllocatorMemoryUsed.allocator_name)
+  return _s;
+}
+inline const std::string& AllocatorMemoryUsed::_internal_allocator_name() const {
+  return _impl_.allocator_name_.Get();
+}
+inline void AllocatorMemoryUsed::_internal_set_allocator_name(const std::string& value) {
+  
+  _impl_.allocator_name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* AllocatorMemoryUsed::_internal_mutable_allocator_name() {
+  
+  return _impl_.allocator_name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* AllocatorMemoryUsed::release_allocator_name() {
+  // @@protoc_insertion_point(field_release:tensorflow.AllocatorMemoryUsed.allocator_name)
+  return _impl_.allocator_name_.Release();
+}
+inline void AllocatorMemoryUsed::set_allocated_allocator_name(std::string* allocator_name) {
+  if (allocator_name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.allocator_name_.SetAllocated(allocator_name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.allocator_name_.IsDefault()) {
+    _impl_.allocator_name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.AllocatorMemoryUsed.allocator_name)
+}
+
+// int64 total_bytes = 2;
+inline void AllocatorMemoryUsed::clear_total_bytes() {
+  _impl_.total_bytes_ = int64_t{0};
+}
+inline int64_t AllocatorMemoryUsed::_internal_total_bytes() const {
+  return _impl_.total_bytes_;
+}
+inline int64_t AllocatorMemoryUsed::total_bytes() const {
+  // @@protoc_insertion_point(field_get:tensorflow.AllocatorMemoryUsed.total_bytes)
+  return _internal_total_bytes();
+}
+inline void AllocatorMemoryUsed::_internal_set_total_bytes(int64_t value) {
+  
+  _impl_.total_bytes_ = value;
+}
+inline void AllocatorMemoryUsed::set_total_bytes(int64_t value) {
+  _internal_set_total_bytes(value);
+  // @@protoc_insertion_point(field_set:tensorflow.AllocatorMemoryUsed.total_bytes)
+}
+
+// int64 peak_bytes = 3;
+inline void AllocatorMemoryUsed::clear_peak_bytes() {
+  _impl_.peak_bytes_ = int64_t{0};
+}
+inline int64_t AllocatorMemoryUsed::_internal_peak_bytes() const {
+  return _impl_.peak_bytes_;
+}
+inline int64_t AllocatorMemoryUsed::peak_bytes() const {
+  // @@protoc_insertion_point(field_get:tensorflow.AllocatorMemoryUsed.peak_bytes)
+  return _internal_peak_bytes();
+}
+inline void AllocatorMemoryUsed::_internal_set_peak_bytes(int64_t value) {
+  
+  _impl_.peak_bytes_ = value;
+}
+inline void AllocatorMemoryUsed::set_peak_bytes(int64_t value) {
+  _internal_set_peak_bytes(value);
+  // @@protoc_insertion_point(field_set:tensorflow.AllocatorMemoryUsed.peak_bytes)
+}
+
+// int64 live_bytes = 4;
+inline void AllocatorMemoryUsed::clear_live_bytes() {
+  _impl_.live_bytes_ = int64_t{0};
+}
+inline int64_t AllocatorMemoryUsed::_internal_live_bytes() const {
+  return _impl_.live_bytes_;
+}
+inline int64_t AllocatorMemoryUsed::live_bytes() const {
+  // @@protoc_insertion_point(field_get:tensorflow.AllocatorMemoryUsed.live_bytes)
+  return _internal_live_bytes();
+}
+inline void AllocatorMemoryUsed::_internal_set_live_bytes(int64_t value) {
+  
+  _impl_.live_bytes_ = value;
+}
+inline void AllocatorMemoryUsed::set_live_bytes(int64_t value) {
+  _internal_set_live_bytes(value);
+  // @@protoc_insertion_point(field_set:tensorflow.AllocatorMemoryUsed.live_bytes)
+}
+
+// repeated .tensorflow.AllocationRecord allocation_records = 6;
+inline int AllocatorMemoryUsed::_internal_allocation_records_size() const {
+  return _impl_.allocation_records_.size();
+}
+inline int AllocatorMemoryUsed::allocation_records_size() const {
+  return _internal_allocation_records_size();
+}
+inline void AllocatorMemoryUsed::clear_allocation_records() {
+  _impl_.allocation_records_.Clear();
+}
+inline ::tensorflow::AllocationRecord* AllocatorMemoryUsed::mutable_allocation_records(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.AllocatorMemoryUsed.allocation_records)
+  return _impl_.allocation_records_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::AllocationRecord >*
+AllocatorMemoryUsed::mutable_allocation_records() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.AllocatorMemoryUsed.allocation_records)
+  return &_impl_.allocation_records_;
+}
+inline const ::tensorflow::AllocationRecord& AllocatorMemoryUsed::_internal_allocation_records(int index) const {
+  return _impl_.allocation_records_.Get(index);
+}
+inline const ::tensorflow::AllocationRecord& AllocatorMemoryUsed::allocation_records(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.AllocatorMemoryUsed.allocation_records)
+  return _internal_allocation_records(index);
+}
+inline ::tensorflow::AllocationRecord* AllocatorMemoryUsed::_internal_add_allocation_records() {
+  return _impl_.allocation_records_.Add();
+}
+inline ::tensorflow::AllocationRecord* AllocatorMemoryUsed::add_allocation_records() {
+  ::tensorflow::AllocationRecord* _add = _internal_add_allocation_records();
+  // @@protoc_insertion_point(field_add:tensorflow.AllocatorMemoryUsed.allocation_records)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::AllocationRecord >&
+AllocatorMemoryUsed::allocation_records() const {
+  // @@protoc_insertion_point(field_list:tensorflow.AllocatorMemoryUsed.allocation_records)
+  return _impl_.allocation_records_;
+}
+
+// int64 allocator_bytes_in_use = 5;
+inline void AllocatorMemoryUsed::clear_allocator_bytes_in_use() {
+  _impl_.allocator_bytes_in_use_ = int64_t{0};
+}
+inline int64_t AllocatorMemoryUsed::_internal_allocator_bytes_in_use() const {
+  return _impl_.allocator_bytes_in_use_;
+}
+inline int64_t AllocatorMemoryUsed::allocator_bytes_in_use() const {
+  // @@protoc_insertion_point(field_get:tensorflow.AllocatorMemoryUsed.allocator_bytes_in_use)
+  return _internal_allocator_bytes_in_use();
+}
+inline void AllocatorMemoryUsed::_internal_set_allocator_bytes_in_use(int64_t value) {
+  
+  _impl_.allocator_bytes_in_use_ = value;
+}
+inline void AllocatorMemoryUsed::set_allocator_bytes_in_use(int64_t value) {
+  _internal_set_allocator_bytes_in_use(value);
+  // @@protoc_insertion_point(field_set:tensorflow.AllocatorMemoryUsed.allocator_bytes_in_use)
+}
+
+// -------------------------------------------------------------------
+
+// NodeOutput
+
+// int32 slot = 1;
+inline void NodeOutput::clear_slot() {
+  _impl_.slot_ = 0;
+}
+inline int32_t NodeOutput::_internal_slot() const {
+  return _impl_.slot_;
+}
+inline int32_t NodeOutput::slot() const {
+  // @@protoc_insertion_point(field_get:tensorflow.NodeOutput.slot)
+  return _internal_slot();
+}
+inline void NodeOutput::_internal_set_slot(int32_t value) {
+  
+  _impl_.slot_ = value;
+}
+inline void NodeOutput::set_slot(int32_t value) {
+  _internal_set_slot(value);
+  // @@protoc_insertion_point(field_set:tensorflow.NodeOutput.slot)
+}
+
+// .tensorflow.TensorDescription tensor_description = 3;
+inline bool NodeOutput::_internal_has_tensor_description() const {
+  return this != internal_default_instance() && _impl_.tensor_description_ != nullptr;
+}
+inline bool NodeOutput::has_tensor_description() const {
+  return _internal_has_tensor_description();
+}
+inline const ::tensorflow::TensorDescription& NodeOutput::_internal_tensor_description() const {
+  const ::tensorflow::TensorDescription* p = _impl_.tensor_description_;
+  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::TensorDescription&>(
+      ::tensorflow::_TensorDescription_default_instance_);
+}
+inline const ::tensorflow::TensorDescription& NodeOutput::tensor_description() const {
+  // @@protoc_insertion_point(field_get:tensorflow.NodeOutput.tensor_description)
+  return _internal_tensor_description();
+}
+inline void NodeOutput::unsafe_arena_set_allocated_tensor_description(
+    ::tensorflow::TensorDescription* tensor_description) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.tensor_description_);
+  }
+  _impl_.tensor_description_ = tensor_description;
+  if (tensor_description) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.NodeOutput.tensor_description)
+}
+inline ::tensorflow::TensorDescription* NodeOutput::release_tensor_description() {
+  
+  ::tensorflow::TensorDescription* temp = _impl_.tensor_description_;
+  _impl_.tensor_description_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::tensorflow::TensorDescription* NodeOutput::unsafe_arena_release_tensor_description() {
+  // @@protoc_insertion_point(field_release:tensorflow.NodeOutput.tensor_description)
+  
+  ::tensorflow::TensorDescription* temp = _impl_.tensor_description_;
+  _impl_.tensor_description_ = nullptr;
+  return temp;
+}
+inline ::tensorflow::TensorDescription* NodeOutput::_internal_mutable_tensor_description() {
+  
+  if (_impl_.tensor_description_ == nullptr) {
+    auto* p = CreateMaybeMessage<::tensorflow::TensorDescription>(GetArenaForAllocation());
+    _impl_.tensor_description_ = p;
+  }
+  return _impl_.tensor_description_;
+}
+inline ::tensorflow::TensorDescription* NodeOutput::mutable_tensor_description() {
+  ::tensorflow::TensorDescription* _msg = _internal_mutable_tensor_description();
+  // @@protoc_insertion_point(field_mutable:tensorflow.NodeOutput.tensor_description)
+  return _msg;
+}
+inline void NodeOutput::set_allocated_tensor_description(::tensorflow::TensorDescription* tensor_description) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.tensor_description_);
+  }
+  if (tensor_description) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(tensor_description));
+    if (message_arena != submessage_arena) {
+      tensor_description = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, tensor_description, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.tensor_description_ = tensor_description;
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.NodeOutput.tensor_description)
+}
+
+// -------------------------------------------------------------------
+
+// MemoryStats
+
+// int64 temp_memory_size = 1;
+inline void MemoryStats::clear_temp_memory_size() {
+  _impl_.temp_memory_size_ = int64_t{0};
+}
+inline int64_t MemoryStats::_internal_temp_memory_size() const {
+  return _impl_.temp_memory_size_;
+}
+inline int64_t MemoryStats::temp_memory_size() const {
+  // @@protoc_insertion_point(field_get:tensorflow.MemoryStats.temp_memory_size)
+  return _internal_temp_memory_size();
+}
+inline void MemoryStats::_internal_set_temp_memory_size(int64_t value) {
+  
+  _impl_.temp_memory_size_ = value;
+}
+inline void MemoryStats::set_temp_memory_size(int64_t value) {
+  _internal_set_temp_memory_size(value);
+  // @@protoc_insertion_point(field_set:tensorflow.MemoryStats.temp_memory_size)
+}
+
+// int64 persistent_memory_size = 3;
+inline void MemoryStats::clear_persistent_memory_size() {
+  _impl_.persistent_memory_size_ = int64_t{0};
+}
+inline int64_t MemoryStats::_internal_persistent_memory_size() const {
+  return _impl_.persistent_memory_size_;
+}
+inline int64_t MemoryStats::persistent_memory_size() const {
+  // @@protoc_insertion_point(field_get:tensorflow.MemoryStats.persistent_memory_size)
+  return _internal_persistent_memory_size();
+}
+inline void MemoryStats::_internal_set_persistent_memory_size(int64_t value) {
+  
+  _impl_.persistent_memory_size_ = value;
+}
+inline void MemoryStats::set_persistent_memory_size(int64_t value) {
+  _internal_set_persistent_memory_size(value);
+  // @@protoc_insertion_point(field_set:tensorflow.MemoryStats.persistent_memory_size)
+}
+
+// repeated int64 persistent_tensor_alloc_ids = 5;
+inline int MemoryStats::_internal_persistent_tensor_alloc_ids_size() const {
+  return _impl_.persistent_tensor_alloc_ids_.size();
+}
+inline int MemoryStats::persistent_tensor_alloc_ids_size() const {
+  return _internal_persistent_tensor_alloc_ids_size();
+}
+inline void MemoryStats::clear_persistent_tensor_alloc_ids() {
+  _impl_.persistent_tensor_alloc_ids_.Clear();
+}
+inline int64_t MemoryStats::_internal_persistent_tensor_alloc_ids(int index) const {
+  return _impl_.persistent_tensor_alloc_ids_.Get(index);
+}
+inline int64_t MemoryStats::persistent_tensor_alloc_ids(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.MemoryStats.persistent_tensor_alloc_ids)
+  return _internal_persistent_tensor_alloc_ids(index);
+}
+inline void MemoryStats::set_persistent_tensor_alloc_ids(int index, int64_t value) {
+  _impl_.persistent_tensor_alloc_ids_.Set(index, value);
+  // @@protoc_insertion_point(field_set:tensorflow.MemoryStats.persistent_tensor_alloc_ids)
+}
+inline void MemoryStats::_internal_add_persistent_tensor_alloc_ids(int64_t value) {
+  _impl_.persistent_tensor_alloc_ids_.Add(value);
+}
+inline void MemoryStats::add_persistent_tensor_alloc_ids(int64_t value) {
+  _internal_add_persistent_tensor_alloc_ids(value);
+  // @@protoc_insertion_point(field_add:tensorflow.MemoryStats.persistent_tensor_alloc_ids)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
+MemoryStats::_internal_persistent_tensor_alloc_ids() const {
+  return _impl_.persistent_tensor_alloc_ids_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
+MemoryStats::persistent_tensor_alloc_ids() const {
+  // @@protoc_insertion_point(field_list:tensorflow.MemoryStats.persistent_tensor_alloc_ids)
+  return _internal_persistent_tensor_alloc_ids();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
+MemoryStats::_internal_mutable_persistent_tensor_alloc_ids() {
+  return &_impl_.persistent_tensor_alloc_ids_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
+MemoryStats::mutable_persistent_tensor_alloc_ids() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.MemoryStats.persistent_tensor_alloc_ids)
+  return _internal_mutable_persistent_tensor_alloc_ids();
+}
+
+// int64 device_temp_memory_size = 2 [deprecated = true];
+inline void MemoryStats::clear_device_temp_memory_size() {
+  _impl_.device_temp_memory_size_ = int64_t{0};
+}
+inline int64_t MemoryStats::_internal_device_temp_memory_size() const {
+  return _impl_.device_temp_memory_size_;
+}
+inline int64_t MemoryStats::device_temp_memory_size() const {
+  // @@protoc_insertion_point(field_get:tensorflow.MemoryStats.device_temp_memory_size)
+  return _internal_device_temp_memory_size();
+}
+inline void MemoryStats::_internal_set_device_temp_memory_size(int64_t value) {
+  
+  _impl_.device_temp_memory_size_ = value;
+}
+inline void MemoryStats::set_device_temp_memory_size(int64_t value) {
+  _internal_set_device_temp_memory_size(value);
+  // @@protoc_insertion_point(field_set:tensorflow.MemoryStats.device_temp_memory_size)
+}
+
+// int64 device_persistent_memory_size = 4 [deprecated = true];
+inline void MemoryStats::clear_device_persistent_memory_size() {
+  _impl_.device_persistent_memory_size_ = int64_t{0};
+}
+inline int64_t MemoryStats::_internal_device_persistent_memory_size() const {
+  return _impl_.device_persistent_memory_size_;
+}
+inline int64_t MemoryStats::device_persistent_memory_size() const {
+  // @@protoc_insertion_point(field_get:tensorflow.MemoryStats.device_persistent_memory_size)
+  return _internal_device_persistent_memory_size();
+}
+inline void MemoryStats::_internal_set_device_persistent_memory_size(int64_t value) {
+  
+  _impl_.device_persistent_memory_size_ = value;
+}
+inline void MemoryStats::set_device_persistent_memory_size(int64_t value) {
+  _internal_set_device_persistent_memory_size(value);
+  // @@protoc_insertion_point(field_set:tensorflow.MemoryStats.device_persistent_memory_size)
+}
+
+// repeated int64 device_persistent_tensor_alloc_ids = 6 [deprecated = true];
+inline int MemoryStats::_internal_device_persistent_tensor_alloc_ids_size() const {
+  return _impl_.device_persistent_tensor_alloc_ids_.size();
+}
+inline int MemoryStats::device_persistent_tensor_alloc_ids_size() const {
+  return _internal_device_persistent_tensor_alloc_ids_size();
+}
+inline void MemoryStats::clear_device_persistent_tensor_alloc_ids() {
+  _impl_.device_persistent_tensor_alloc_ids_.Clear();
+}
+inline int64_t MemoryStats::_internal_device_persistent_tensor_alloc_ids(int index) const {
+  return _impl_.device_persistent_tensor_alloc_ids_.Get(index);
+}
+inline int64_t MemoryStats::device_persistent_tensor_alloc_ids(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.MemoryStats.device_persistent_tensor_alloc_ids)
+  return _internal_device_persistent_tensor_alloc_ids(index);
+}
+inline void MemoryStats::set_device_persistent_tensor_alloc_ids(int index, int64_t value) {
+  _impl_.device_persistent_tensor_alloc_ids_.Set(index, value);
+  // @@protoc_insertion_point(field_set:tensorflow.MemoryStats.device_persistent_tensor_alloc_ids)
+}
+inline void MemoryStats::_internal_add_device_persistent_tensor_alloc_ids(int64_t value) {
+  _impl_.device_persistent_tensor_alloc_ids_.Add(value);
+}
+inline void MemoryStats::add_device_persistent_tensor_alloc_ids(int64_t value) {
+  _internal_add_device_persistent_tensor_alloc_ids(value);
+  // @@protoc_insertion_point(field_add:tensorflow.MemoryStats.device_persistent_tensor_alloc_ids)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
+MemoryStats::_internal_device_persistent_tensor_alloc_ids() const {
+  return _impl_.device_persistent_tensor_alloc_ids_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
+MemoryStats::device_persistent_tensor_alloc_ids() const {
+  // @@protoc_insertion_point(field_list:tensorflow.MemoryStats.device_persistent_tensor_alloc_ids)
+  return _internal_device_persistent_tensor_alloc_ids();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
+MemoryStats::_internal_mutable_device_persistent_tensor_alloc_ids() {
+  return &_impl_.device_persistent_tensor_alloc_ids_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
+MemoryStats::mutable_device_persistent_tensor_alloc_ids() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.MemoryStats.device_persistent_tensor_alloc_ids)
+  return _internal_mutable_device_persistent_tensor_alloc_ids();
+}
+
+// -------------------------------------------------------------------
+
+// NodeExecStats
+
+// string node_name = 1;
+inline void NodeExecStats::clear_node_name() {
+  _impl_.node_name_.ClearToEmpty();
+}
+inline const std::string& NodeExecStats::node_name() const {
+  // @@protoc_insertion_point(field_get:tensorflow.NodeExecStats.node_name)
+  return _internal_node_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void NodeExecStats::set_node_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.node_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.NodeExecStats.node_name)
+}
+inline std::string* NodeExecStats::mutable_node_name() {
+  std::string* _s = _internal_mutable_node_name();
+  // @@protoc_insertion_point(field_mutable:tensorflow.NodeExecStats.node_name)
+  return _s;
+}
+inline const std::string& NodeExecStats::_internal_node_name() const {
+  return _impl_.node_name_.Get();
+}
+inline void NodeExecStats::_internal_set_node_name(const std::string& value) {
+  
+  _impl_.node_name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* NodeExecStats::_internal_mutable_node_name() {
+  
+  return _impl_.node_name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* NodeExecStats::release_node_name() {
+  // @@protoc_insertion_point(field_release:tensorflow.NodeExecStats.node_name)
+  return _impl_.node_name_.Release();
+}
+inline void NodeExecStats::set_allocated_node_name(std::string* node_name) {
+  if (node_name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.node_name_.SetAllocated(node_name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.node_name_.IsDefault()) {
+    _impl_.node_name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.NodeExecStats.node_name)
+}
+
+// int64 all_start_micros = 2;
+inline void NodeExecStats::clear_all_start_micros() {
+  _impl_.all_start_micros_ = int64_t{0};
+}
+inline int64_t NodeExecStats::_internal_all_start_micros() const {
+  return _impl_.all_start_micros_;
+}
+inline int64_t NodeExecStats::all_start_micros() const {
+  // @@protoc_insertion_point(field_get:tensorflow.NodeExecStats.all_start_micros)
+  return _internal_all_start_micros();
+}
+inline void NodeExecStats::_internal_set_all_start_micros(int64_t value) {
+  
+  _impl_.all_start_micros_ = value;
+}
+inline void NodeExecStats::set_all_start_micros(int64_t value) {
+  _internal_set_all_start_micros(value);
+  // @@protoc_insertion_point(field_set:tensorflow.NodeExecStats.all_start_micros)
+}
+
+// int64 op_start_rel_micros = 3;
+inline void NodeExecStats::clear_op_start_rel_micros() {
+  _impl_.op_start_rel_micros_ = int64_t{0};
+}
+inline int64_t NodeExecStats::_internal_op_start_rel_micros() const {
+  return _impl_.op_start_rel_micros_;
+}
+inline int64_t NodeExecStats::op_start_rel_micros() const {
+  // @@protoc_insertion_point(field_get:tensorflow.NodeExecStats.op_start_rel_micros)
+  return _internal_op_start_rel_micros();
+}
+inline void NodeExecStats::_internal_set_op_start_rel_micros(int64_t value) {
+  
+  _impl_.op_start_rel_micros_ = value;
+}
+inline void NodeExecStats::set_op_start_rel_micros(int64_t value) {
+  _internal_set_op_start_rel_micros(value);
+  // @@protoc_insertion_point(field_set:tensorflow.NodeExecStats.op_start_rel_micros)
+}
+
+// int64 op_end_rel_micros = 4;
+inline void NodeExecStats::clear_op_end_rel_micros() {
+  _impl_.op_end_rel_micros_ = int64_t{0};
+}
+inline int64_t NodeExecStats::_internal_op_end_rel_micros() const {
+  return _impl_.op_end_rel_micros_;
+}
+inline int64_t NodeExecStats::op_end_rel_micros() const {
+  // @@protoc_insertion_point(field_get:tensorflow.NodeExecStats.op_end_rel_micros)
+  return _internal_op_end_rel_micros();
+}
+inline void NodeExecStats::_internal_set_op_end_rel_micros(int64_t value) {
+  
+  _impl_.op_end_rel_micros_ = value;
+}
+inline void NodeExecStats::set_op_end_rel_micros(int64_t value) {
+  _internal_set_op_end_rel_micros(value);
+  // @@protoc_insertion_point(field_set:tensorflow.NodeExecStats.op_end_rel_micros)
+}
+
+// int64 all_end_rel_micros = 5;
+inline void NodeExecStats::clear_all_end_rel_micros() {
+  _impl_.all_end_rel_micros_ = int64_t{0};
+}
+inline int64_t NodeExecStats::_internal_all_end_rel_micros() const {
+  return _impl_.all_end_rel_micros_;
+}
+inline int64_t NodeExecStats::all_end_rel_micros() const {
+  // @@protoc_insertion_point(field_get:tensorflow.NodeExecStats.all_end_rel_micros)
+  return _internal_all_end_rel_micros();
+}
+inline void NodeExecStats::_internal_set_all_end_rel_micros(int64_t value) {
+  
+  _impl_.all_end_rel_micros_ = value;
+}
+inline void NodeExecStats::set_all_end_rel_micros(int64_t value) {
+  _internal_set_all_end_rel_micros(value);
+  // @@protoc_insertion_point(field_set:tensorflow.NodeExecStats.all_end_rel_micros)
+}
+
+// repeated .tensorflow.AllocatorMemoryUsed memory = 6;
+inline int NodeExecStats::_internal_memory_size() const {
+  return _impl_.memory_.size();
+}
+inline int NodeExecStats::memory_size() const {
+  return _internal_memory_size();
+}
+inline void NodeExecStats::clear_memory() {
+  _impl_.memory_.Clear();
+}
+inline ::tensorflow::AllocatorMemoryUsed* NodeExecStats::mutable_memory(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.NodeExecStats.memory)
+  return _impl_.memory_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::AllocatorMemoryUsed >*
+NodeExecStats::mutable_memory() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.NodeExecStats.memory)
+  return &_impl_.memory_;
+}
+inline const ::tensorflow::AllocatorMemoryUsed& NodeExecStats::_internal_memory(int index) const {
+  return _impl_.memory_.Get(index);
+}
+inline const ::tensorflow::AllocatorMemoryUsed& NodeExecStats::memory(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.NodeExecStats.memory)
+  return _internal_memory(index);
+}
+inline ::tensorflow::AllocatorMemoryUsed* NodeExecStats::_internal_add_memory() {
+  return _impl_.memory_.Add();
+}
+inline ::tensorflow::AllocatorMemoryUsed* NodeExecStats::add_memory() {
+  ::tensorflow::AllocatorMemoryUsed* _add = _internal_add_memory();
+  // @@protoc_insertion_point(field_add:tensorflow.NodeExecStats.memory)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::AllocatorMemoryUsed >&
+NodeExecStats::memory() const {
+  // @@protoc_insertion_point(field_list:tensorflow.NodeExecStats.memory)
+  return _impl_.memory_;
+}
+
+// repeated .tensorflow.NodeOutput output = 7;
+inline int NodeExecStats::_internal_output_size() const {
+  return _impl_.output_.size();
+}
+inline int NodeExecStats::output_size() const {
+  return _internal_output_size();
+}
+inline void NodeExecStats::clear_output() {
+  _impl_.output_.Clear();
+}
+inline ::tensorflow::NodeOutput* NodeExecStats::mutable_output(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.NodeExecStats.output)
+  return _impl_.output_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::NodeOutput >*
+NodeExecStats::mutable_output() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.NodeExecStats.output)
+  return &_impl_.output_;
+}
+inline const ::tensorflow::NodeOutput& NodeExecStats::_internal_output(int index) const {
+  return _impl_.output_.Get(index);
+}
+inline const ::tensorflow::NodeOutput& NodeExecStats::output(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.NodeExecStats.output)
+  return _internal_output(index);
+}
+inline ::tensorflow::NodeOutput* NodeExecStats::_internal_add_output() {
+  return _impl_.output_.Add();
+}
+inline ::tensorflow::NodeOutput* NodeExecStats::add_output() {
+  ::tensorflow::NodeOutput* _add = _internal_add_output();
+  // @@protoc_insertion_point(field_add:tensorflow.NodeExecStats.output)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::NodeOutput >&
+NodeExecStats::output() const {
+  // @@protoc_insertion_point(field_list:tensorflow.NodeExecStats.output)
+  return _impl_.output_;
+}
+
+// string timeline_label = 8;
+inline void NodeExecStats::clear_timeline_label() {
+  _impl_.timeline_label_.ClearToEmpty();
+}
+inline const std::string& NodeExecStats::timeline_label() const {
+  // @@protoc_insertion_point(field_get:tensorflow.NodeExecStats.timeline_label)
+  return _internal_timeline_label();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void NodeExecStats::set_timeline_label(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.timeline_label_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.NodeExecStats.timeline_label)
+}
+inline std::string* NodeExecStats::mutable_timeline_label() {
+  std::string* _s = _internal_mutable_timeline_label();
+  // @@protoc_insertion_point(field_mutable:tensorflow.NodeExecStats.timeline_label)
+  return _s;
+}
+inline const std::string& NodeExecStats::_internal_timeline_label() const {
+  return _impl_.timeline_label_.Get();
+}
+inline void NodeExecStats::_internal_set_timeline_label(const std::string& value) {
+  
+  _impl_.timeline_label_.Set(value, GetArenaForAllocation());
+}
+inline std::string* NodeExecStats::_internal_mutable_timeline_label() {
+  
+  return _impl_.timeline_label_.Mutable(GetArenaForAllocation());
+}
+inline std::string* NodeExecStats::release_timeline_label() {
+  // @@protoc_insertion_point(field_release:tensorflow.NodeExecStats.timeline_label)
+  return _impl_.timeline_label_.Release();
+}
+inline void NodeExecStats::set_allocated_timeline_label(std::string* timeline_label) {
+  if (timeline_label != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.timeline_label_.SetAllocated(timeline_label, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.timeline_label_.IsDefault()) {
+    _impl_.timeline_label_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.NodeExecStats.timeline_label)
+}
+
+// int64 scheduled_micros = 9;
+inline void NodeExecStats::clear_scheduled_micros() {
+  _impl_.scheduled_micros_ = int64_t{0};
+}
+inline int64_t NodeExecStats::_internal_scheduled_micros() const {
+  return _impl_.scheduled_micros_;
+}
+inline int64_t NodeExecStats::scheduled_micros() const {
+  // @@protoc_insertion_point(field_get:tensorflow.NodeExecStats.scheduled_micros)
+  return _internal_scheduled_micros();
+}
+inline void NodeExecStats::_internal_set_scheduled_micros(int64_t value) {
+  
+  _impl_.scheduled_micros_ = value;
+}
+inline void NodeExecStats::set_scheduled_micros(int64_t value) {
+  _internal_set_scheduled_micros(value);
+  // @@protoc_insertion_point(field_set:tensorflow.NodeExecStats.scheduled_micros)
+}
+
+// uint32 thread_id = 10;
+inline void NodeExecStats::clear_thread_id() {
+  _impl_.thread_id_ = 0u;
+}
+inline uint32_t NodeExecStats::_internal_thread_id() const {
+  return _impl_.thread_id_;
+}
+inline uint32_t NodeExecStats::thread_id() const {
+  // @@protoc_insertion_point(field_get:tensorflow.NodeExecStats.thread_id)
+  return _internal_thread_id();
+}
+inline void NodeExecStats::_internal_set_thread_id(uint32_t value) {
+  
+  _impl_.thread_id_ = value;
+}
+inline void NodeExecStats::set_thread_id(uint32_t value) {
+  _internal_set_thread_id(value);
+  // @@protoc_insertion_point(field_set:tensorflow.NodeExecStats.thread_id)
+}
+
+// repeated .tensorflow.AllocationDescription referenced_tensor = 11;
+inline int NodeExecStats::_internal_referenced_tensor_size() const {
+  return _impl_.referenced_tensor_.size();
+}
+inline int NodeExecStats::referenced_tensor_size() const {
+  return _internal_referenced_tensor_size();
+}
+inline ::tensorflow::AllocationDescription* NodeExecStats::mutable_referenced_tensor(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.NodeExecStats.referenced_tensor)
+  return _impl_.referenced_tensor_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::AllocationDescription >*
+NodeExecStats::mutable_referenced_tensor() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.NodeExecStats.referenced_tensor)
+  return &_impl_.referenced_tensor_;
+}
+inline const ::tensorflow::AllocationDescription& NodeExecStats::_internal_referenced_tensor(int index) const {
+  return _impl_.referenced_tensor_.Get(index);
+}
+inline const ::tensorflow::AllocationDescription& NodeExecStats::referenced_tensor(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.NodeExecStats.referenced_tensor)
+  return _internal_referenced_tensor(index);
+}
+inline ::tensorflow::AllocationDescription* NodeExecStats::_internal_add_referenced_tensor() {
+  return _impl_.referenced_tensor_.Add();
+}
+inline ::tensorflow::AllocationDescription* NodeExecStats::add_referenced_tensor() {
+  ::tensorflow::AllocationDescription* _add = _internal_add_referenced_tensor();
+  // @@protoc_insertion_point(field_add:tensorflow.NodeExecStats.referenced_tensor)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::AllocationDescription >&
+NodeExecStats::referenced_tensor() const {
+  // @@protoc_insertion_point(field_list:tensorflow.NodeExecStats.referenced_tensor)
+  return _impl_.referenced_tensor_;
+}
+
+// .tensorflow.MemoryStats memory_stats = 12;
+inline bool NodeExecStats::_internal_has_memory_stats() const {
+  return this != internal_default_instance() && _impl_.memory_stats_ != nullptr;
+}
+inline bool NodeExecStats::has_memory_stats() const {
+  return _internal_has_memory_stats();
+}
+inline void NodeExecStats::clear_memory_stats() {
+  if (GetArenaForAllocation() == nullptr && _impl_.memory_stats_ != nullptr) {
+    delete _impl_.memory_stats_;
+  }
+  _impl_.memory_stats_ = nullptr;
+}
+inline const ::tensorflow::MemoryStats& NodeExecStats::_internal_memory_stats() const {
+  const ::tensorflow::MemoryStats* p = _impl_.memory_stats_;
+  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::MemoryStats&>(
+      ::tensorflow::_MemoryStats_default_instance_);
+}
+inline const ::tensorflow::MemoryStats& NodeExecStats::memory_stats() const {
+  // @@protoc_insertion_point(field_get:tensorflow.NodeExecStats.memory_stats)
+  return _internal_memory_stats();
+}
+inline void NodeExecStats::unsafe_arena_set_allocated_memory_stats(
+    ::tensorflow::MemoryStats* memory_stats) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.memory_stats_);
+  }
+  _impl_.memory_stats_ = memory_stats;
+  if (memory_stats) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.NodeExecStats.memory_stats)
+}
+inline ::tensorflow::MemoryStats* NodeExecStats::release_memory_stats() {
+  
+  ::tensorflow::MemoryStats* temp = _impl_.memory_stats_;
+  _impl_.memory_stats_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::tensorflow::MemoryStats* NodeExecStats::unsafe_arena_release_memory_stats() {
+  // @@protoc_insertion_point(field_release:tensorflow.NodeExecStats.memory_stats)
+  
+  ::tensorflow::MemoryStats* temp = _impl_.memory_stats_;
+  _impl_.memory_stats_ = nullptr;
+  return temp;
+}
+inline ::tensorflow::MemoryStats* NodeExecStats::_internal_mutable_memory_stats() {
+  
+  if (_impl_.memory_stats_ == nullptr) {
+    auto* p = CreateMaybeMessage<::tensorflow::MemoryStats>(GetArenaForAllocation());
+    _impl_.memory_stats_ = p;
+  }
+  return _impl_.memory_stats_;
+}
+inline ::tensorflow::MemoryStats* NodeExecStats::mutable_memory_stats() {
+  ::tensorflow::MemoryStats* _msg = _internal_mutable_memory_stats();
+  // @@protoc_insertion_point(field_mutable:tensorflow.NodeExecStats.memory_stats)
+  return _msg;
+}
+inline void NodeExecStats::set_allocated_memory_stats(::tensorflow::MemoryStats* memory_stats) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.memory_stats_;
+  }
+  if (memory_stats) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(memory_stats);
+    if (message_arena != submessage_arena) {
+      memory_stats = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, memory_stats, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.memory_stats_ = memory_stats;
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.NodeExecStats.memory_stats)
+}
+
+// int64 all_start_nanos = 13;
+inline void NodeExecStats::clear_all_start_nanos() {
+  _impl_.all_start_nanos_ = int64_t{0};
+}
+inline int64_t NodeExecStats::_internal_all_start_nanos() const {
+  return _impl_.all_start_nanos_;
+}
+inline int64_t NodeExecStats::all_start_nanos() const {
+  // @@protoc_insertion_point(field_get:tensorflow.NodeExecStats.all_start_nanos)
+  return _internal_all_start_nanos();
+}
+inline void NodeExecStats::_internal_set_all_start_nanos(int64_t value) {
+  
+  _impl_.all_start_nanos_ = value;
+}
+inline void NodeExecStats::set_all_start_nanos(int64_t value) {
+  _internal_set_all_start_nanos(value);
+  // @@protoc_insertion_point(field_set:tensorflow.NodeExecStats.all_start_nanos)
+}
+
+// int64 op_start_rel_nanos = 14;
+inline void NodeExecStats::clear_op_start_rel_nanos() {
+  _impl_.op_start_rel_nanos_ = int64_t{0};
+}
+inline int64_t NodeExecStats::_internal_op_start_rel_nanos() const {
+  return _impl_.op_start_rel_nanos_;
+}
+inline int64_t NodeExecStats::op_start_rel_nanos() const {
+  // @@protoc_insertion_point(field_get:tensorflow.NodeExecStats.op_start_rel_nanos)
+  return _internal_op_start_rel_nanos();
+}
+inline void NodeExecStats::_internal_set_op_start_rel_nanos(int64_t value) {
+  
+  _impl_.op_start_rel_nanos_ = value;
+}
+inline void NodeExecStats::set_op_start_rel_nanos(int64_t value) {
+  _internal_set_op_start_rel_nanos(value);
+  // @@protoc_insertion_point(field_set:tensorflow.NodeExecStats.op_start_rel_nanos)
+}
+
+// int64 op_end_rel_nanos = 15;
+inline void NodeExecStats::clear_op_end_rel_nanos() {
+  _impl_.op_end_rel_nanos_ = int64_t{0};
+}
+inline int64_t NodeExecStats::_internal_op_end_rel_nanos() const {
+  return _impl_.op_end_rel_nanos_;
+}
+inline int64_t NodeExecStats::op_end_rel_nanos() const {
+  // @@protoc_insertion_point(field_get:tensorflow.NodeExecStats.op_end_rel_nanos)
+  return _internal_op_end_rel_nanos();
+}
+inline void NodeExecStats::_internal_set_op_end_rel_nanos(int64_t value) {
+  
+  _impl_.op_end_rel_nanos_ = value;
+}
+inline void NodeExecStats::set_op_end_rel_nanos(int64_t value) {
+  _internal_set_op_end_rel_nanos(value);
+  // @@protoc_insertion_point(field_set:tensorflow.NodeExecStats.op_end_rel_nanos)
+}
+
+// int64 all_end_rel_nanos = 16;
+inline void NodeExecStats::clear_all_end_rel_nanos() {
+  _impl_.all_end_rel_nanos_ = int64_t{0};
+}
+inline int64_t NodeExecStats::_internal_all_end_rel_nanos() const {
+  return _impl_.all_end_rel_nanos_;
+}
+inline int64_t NodeExecStats::all_end_rel_nanos() const {
+  // @@protoc_insertion_point(field_get:tensorflow.NodeExecStats.all_end_rel_nanos)
+  return _internal_all_end_rel_nanos();
+}
+inline void NodeExecStats::_internal_set_all_end_rel_nanos(int64_t value) {
+  
+  _impl_.all_end_rel_nanos_ = value;
+}
+inline void NodeExecStats::set_all_end_rel_nanos(int64_t value) {
+  _internal_set_all_end_rel_nanos(value);
+  // @@protoc_insertion_point(field_set:tensorflow.NodeExecStats.all_end_rel_nanos)
+}
+
+// int64 scheduled_nanos = 17;
+inline void NodeExecStats::clear_scheduled_nanos() {
+  _impl_.scheduled_nanos_ = int64_t{0};
+}
+inline int64_t NodeExecStats::_internal_scheduled_nanos() const {
+  return _impl_.scheduled_nanos_;
+}
+inline int64_t NodeExecStats::scheduled_nanos() const {
+  // @@protoc_insertion_point(field_get:tensorflow.NodeExecStats.scheduled_nanos)
+  return _internal_scheduled_nanos();
+}
+inline void NodeExecStats::_internal_set_scheduled_nanos(int64_t value) {
+  
+  _impl_.scheduled_nanos_ = value;
+}
+inline void NodeExecStats::set_scheduled_nanos(int64_t value) {
+  _internal_set_scheduled_nanos(value);
+  // @@protoc_insertion_point(field_set:tensorflow.NodeExecStats.scheduled_nanos)
+}
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// DeviceStepStats
+
+// string device = 1;
+inline void DeviceStepStats::clear_device() {
+  _impl_.device_.ClearToEmpty();
+}
+inline const std::string& DeviceStepStats::device() const {
+  // @@protoc_insertion_point(field_get:tensorflow.DeviceStepStats.device)
+  return _internal_device();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void DeviceStepStats::set_device(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.device_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.DeviceStepStats.device)
+}
+inline std::string* DeviceStepStats::mutable_device() {
+  std::string* _s = _internal_mutable_device();
+  // @@protoc_insertion_point(field_mutable:tensorflow.DeviceStepStats.device)
+  return _s;
+}
+inline const std::string& DeviceStepStats::_internal_device() const {
+  return _impl_.device_.Get();
+}
+inline void DeviceStepStats::_internal_set_device(const std::string& value) {
+  
+  _impl_.device_.Set(value, GetArenaForAllocation());
+}
+inline std::string* DeviceStepStats::_internal_mutable_device() {
+  
+  return _impl_.device_.Mutable(GetArenaForAllocation());
+}
+inline std::string* DeviceStepStats::release_device() {
+  // @@protoc_insertion_point(field_release:tensorflow.DeviceStepStats.device)
+  return _impl_.device_.Release();
+}
+inline void DeviceStepStats::set_allocated_device(std::string* device) {
+  if (device != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.device_.SetAllocated(device, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.device_.IsDefault()) {
+    _impl_.device_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.DeviceStepStats.device)
+}
+
+// repeated .tensorflow.NodeExecStats node_stats = 2;
+inline int DeviceStepStats::_internal_node_stats_size() const {
+  return _impl_.node_stats_.size();
+}
+inline int DeviceStepStats::node_stats_size() const {
+  return _internal_node_stats_size();
+}
+inline void DeviceStepStats::clear_node_stats() {
+  _impl_.node_stats_.Clear();
+}
+inline ::tensorflow::NodeExecStats* DeviceStepStats::mutable_node_stats(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.DeviceStepStats.node_stats)
+  return _impl_.node_stats_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::NodeExecStats >*
+DeviceStepStats::mutable_node_stats() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.DeviceStepStats.node_stats)
+  return &_impl_.node_stats_;
+}
+inline const ::tensorflow::NodeExecStats& DeviceStepStats::_internal_node_stats(int index) const {
+  return _impl_.node_stats_.Get(index);
+}
+inline const ::tensorflow::NodeExecStats& DeviceStepStats::node_stats(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.DeviceStepStats.node_stats)
+  return _internal_node_stats(index);
+}
+inline ::tensorflow::NodeExecStats* DeviceStepStats::_internal_add_node_stats() {
+  return _impl_.node_stats_.Add();
+}
+inline ::tensorflow::NodeExecStats* DeviceStepStats::add_node_stats() {
+  ::tensorflow::NodeExecStats* _add = _internal_add_node_stats();
+  // @@protoc_insertion_point(field_add:tensorflow.DeviceStepStats.node_stats)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::NodeExecStats >&
+DeviceStepStats::node_stats() const {
+  // @@protoc_insertion_point(field_list:tensorflow.DeviceStepStats.node_stats)
+  return _impl_.node_stats_;
+}
+
+// map<uint32, string> thread_names = 3;
+inline int DeviceStepStats::_internal_thread_names_size() const {
+  return _impl_.thread_names_.size();
+}
+inline int DeviceStepStats::thread_names_size() const {
+  return _internal_thread_names_size();
+}
+inline void DeviceStepStats::clear_thread_names() {
+  _impl_.thread_names_.Clear();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< uint32_t, std::string >&
+DeviceStepStats::_internal_thread_names() const {
+  return _impl_.thread_names_.GetMap();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< uint32_t, std::string >&
+DeviceStepStats::thread_names() const {
+  // @@protoc_insertion_point(field_map:tensorflow.DeviceStepStats.thread_names)
+  return _internal_thread_names();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< uint32_t, std::string >*
+DeviceStepStats::_internal_mutable_thread_names() {
+  return _impl_.thread_names_.MutableMap();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< uint32_t, std::string >*
+DeviceStepStats::mutable_thread_names() {
+  // @@protoc_insertion_point(field_mutable_map:tensorflow.DeviceStepStats.thread_names)
+  return _internal_mutable_thread_names();
+}
+
+// -------------------------------------------------------------------
+
+// StepStats
+
+// repeated .tensorflow.DeviceStepStats dev_stats = 1;
+inline int StepStats::_internal_dev_stats_size() const {
+  return _impl_.dev_stats_.size();
+}
+inline int StepStats::dev_stats_size() const {
+  return _internal_dev_stats_size();
+}
+inline void StepStats::clear_dev_stats() {
+  _impl_.dev_stats_.Clear();
+}
+inline ::tensorflow::DeviceStepStats* StepStats::mutable_dev_stats(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.StepStats.dev_stats)
+  return _impl_.dev_stats_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::DeviceStepStats >*
+StepStats::mutable_dev_stats() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.StepStats.dev_stats)
+  return &_impl_.dev_stats_;
+}
+inline const ::tensorflow::DeviceStepStats& StepStats::_internal_dev_stats(int index) const {
+  return _impl_.dev_stats_.Get(index);
+}
+inline const ::tensorflow::DeviceStepStats& StepStats::dev_stats(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.StepStats.dev_stats)
+  return _internal_dev_stats(index);
+}
+inline ::tensorflow::DeviceStepStats* StepStats::_internal_add_dev_stats() {
+  return _impl_.dev_stats_.Add();
+}
+inline ::tensorflow::DeviceStepStats* StepStats::add_dev_stats() {
+  ::tensorflow::DeviceStepStats* _add = _internal_add_dev_stats();
+  // @@protoc_insertion_point(field_add:tensorflow.StepStats.dev_stats)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::DeviceStepStats >&
+StepStats::dev_stats() const {
+  // @@protoc_insertion_point(field_list:tensorflow.StepStats.dev_stats)
+  return _impl_.dev_stats_;
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace tensorflow
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fstep_5fstats_2eproto
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/step_stats.proto b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/step_stats.proto
new file mode 100644
index 0000000000000000000000000000000000000000..762487f02545d0a35a0537f3eefb35a9bc48ed5e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/step_stats.proto
@@ -0,0 +1,88 @@
+syntax = "proto3";
+
+package tensorflow;
+
+import "tensorflow/core/framework/allocation_description.proto";
+import "tensorflow/core/framework/tensor_description.proto";
+
+option cc_enable_arenas = true;
+option java_outer_classname = "StepStatsProtos";
+option java_multiple_files = true;
+option java_package = "org.tensorflow.framework";
+option go_package = "github.com/tensorflow/tensorflow/tensorflow/go/core/framework/step_stats_go_proto";
+
+// An allocation/de-allocation operation performed by the allocator.
+message AllocationRecord {
+  // The timestamp of the operation.
+  int64 alloc_micros = 1;
+  // Number of bytes allocated, or de-allocated if negative.
+  int64 alloc_bytes = 2;
+}
+
+message AllocatorMemoryUsed {
+  string allocator_name = 1;
+  // These are per-node allocator memory stats.
+  int64 total_bytes = 2;
+  int64 peak_bytes = 3;
+  // The bytes that are not deallocated.
+  int64 live_bytes = 4;
+  // The allocation and deallocation timeline.
+  repeated AllocationRecord allocation_records = 6;
+
+  // These are snapshots of the overall allocator memory stats.
+  // The number of live bytes currently allocated by the allocator.
+  int64 allocator_bytes_in_use = 5;
+}
+
+// Output sizes recorded for a single execution of a graph node.
+message NodeOutput {
+  int32 slot = 1;
+  TensorDescription tensor_description = 3;
+}
+
+// For memory tracking.
+message MemoryStats {
+  int64 temp_memory_size = 1;
+  int64 persistent_memory_size = 3;
+  repeated int64 persistent_tensor_alloc_ids = 5;
+
+  int64 device_temp_memory_size = 2 [deprecated = true];
+  int64 device_persistent_memory_size = 4 [deprecated = true];
+  repeated int64 device_persistent_tensor_alloc_ids = 6 [deprecated = true];
+}
+
+// Time/size stats recorded for a single execution of a graph node.
+message NodeExecStats {
+  // TODO(tucker): Use some more compact form of node identity than
+  // the full string name.  Either all processes should agree on a
+  // global id (cost_id?) for each node, or we should use a hash of
+  // the name.
+  string node_name = 1;
+  int64 all_start_micros = 2;
+  int64 op_start_rel_micros = 3;
+  int64 op_end_rel_micros = 4;
+  int64 all_end_rel_micros = 5;
+  repeated AllocatorMemoryUsed memory = 6;
+  repeated NodeOutput output = 7;
+  string timeline_label = 8;
+  int64 scheduled_micros = 9;
+  uint32 thread_id = 10;
+  repeated AllocationDescription referenced_tensor = 11;
+  MemoryStats memory_stats = 12;
+  int64 all_start_nanos = 13;
+  int64 op_start_rel_nanos = 14;
+  int64 op_end_rel_nanos = 15;
+  int64 all_end_rel_nanos = 16;
+  int64 scheduled_nanos = 17;
+}
+
+message DeviceStepStats {
+  string device = 1;
+  repeated NodeExecStats node_stats = 2;
+  // Its key is thread id.
+  map<uint32, string> thread_names = 3;
+}
+
+message StepStats {
+  repeated DeviceStepStats dev_stats = 1;
+}
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/summary.pb.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/summary.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..23098125ebd447be199b750a9cce5754b1ad4fca
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/summary.pb.h
@@ -0,0 +1,2847 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: tensorflow/core/framework/summary.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fsummary_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fsummary_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3021000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3021009 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "tsl/protobuf/histogram.pb.h"
+#include "tensorflow/core/framework/tensor.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_tensorflow_2fcore_2fframework_2fsummary_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_tensorflow_2fcore_2fframework_2fsummary_2eproto {
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_tensorflow_2fcore_2fframework_2fsummary_2eproto;
+namespace tensorflow {
+class Summary;
+struct SummaryDefaultTypeInternal;
+extern SummaryDefaultTypeInternal _Summary_default_instance_;
+class SummaryDescription;
+struct SummaryDescriptionDefaultTypeInternal;
+extern SummaryDescriptionDefaultTypeInternal _SummaryDescription_default_instance_;
+class SummaryMetadata;
+struct SummaryMetadataDefaultTypeInternal;
+extern SummaryMetadataDefaultTypeInternal _SummaryMetadata_default_instance_;
+class SummaryMetadata_PluginData;
+struct SummaryMetadata_PluginDataDefaultTypeInternal;
+extern SummaryMetadata_PluginDataDefaultTypeInternal _SummaryMetadata_PluginData_default_instance_;
+class Summary_Audio;
+struct Summary_AudioDefaultTypeInternal;
+extern Summary_AudioDefaultTypeInternal _Summary_Audio_default_instance_;
+class Summary_Image;
+struct Summary_ImageDefaultTypeInternal;
+extern Summary_ImageDefaultTypeInternal _Summary_Image_default_instance_;
+class Summary_Value;
+struct Summary_ValueDefaultTypeInternal;
+extern Summary_ValueDefaultTypeInternal _Summary_Value_default_instance_;
+}  // namespace tensorflow
+PROTOBUF_NAMESPACE_OPEN
+template<> ::tensorflow::Summary* Arena::CreateMaybeMessage<::tensorflow::Summary>(Arena*);
+template<> ::tensorflow::SummaryDescription* Arena::CreateMaybeMessage<::tensorflow::SummaryDescription>(Arena*);
+template<> ::tensorflow::SummaryMetadata* Arena::CreateMaybeMessage<::tensorflow::SummaryMetadata>(Arena*);
+template<> ::tensorflow::SummaryMetadata_PluginData* Arena::CreateMaybeMessage<::tensorflow::SummaryMetadata_PluginData>(Arena*);
+template<> ::tensorflow::Summary_Audio* Arena::CreateMaybeMessage<::tensorflow::Summary_Audio>(Arena*);
+template<> ::tensorflow::Summary_Image* Arena::CreateMaybeMessage<::tensorflow::Summary_Image>(Arena*);
+template<> ::tensorflow::Summary_Value* Arena::CreateMaybeMessage<::tensorflow::Summary_Value>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace tensorflow {
+
+enum DataClass : int {
+  DATA_CLASS_UNKNOWN = 0,
+  DATA_CLASS_SCALAR = 1,
+  DATA_CLASS_TENSOR = 2,
+  DATA_CLASS_BLOB_SEQUENCE = 3,
+  DataClass_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
+  DataClass_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
+};
+bool DataClass_IsValid(int value);
+constexpr DataClass DataClass_MIN = DATA_CLASS_UNKNOWN;
+constexpr DataClass DataClass_MAX = DATA_CLASS_BLOB_SEQUENCE;
+constexpr int DataClass_ARRAYSIZE = DataClass_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DataClass_descriptor();
+template<typename T>
+inline const std::string& DataClass_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, DataClass>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function DataClass_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    DataClass_descriptor(), enum_t_value);
+}
+inline bool DataClass_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DataClass* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DataClass>(
+    DataClass_descriptor(), name, value);
+}
+// ===================================================================
+
+class SummaryDescription final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.SummaryDescription) */ {
+ public:
+  inline SummaryDescription() : SummaryDescription(nullptr) {}
+  ~SummaryDescription() override;
+  explicit PROTOBUF_CONSTEXPR SummaryDescription(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SummaryDescription(const SummaryDescription& from);
+  SummaryDescription(SummaryDescription&& from) noexcept
+    : SummaryDescription() {
+    *this = ::std::move(from);
+  }
+
+  inline SummaryDescription& operator=(const SummaryDescription& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SummaryDescription& operator=(SummaryDescription&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SummaryDescription& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SummaryDescription* internal_default_instance() {
+    return reinterpret_cast<const SummaryDescription*>(
+               &_SummaryDescription_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(SummaryDescription& a, SummaryDescription& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SummaryDescription* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SummaryDescription* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SummaryDescription* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SummaryDescription>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SummaryDescription& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const SummaryDescription& from) {
+    SummaryDescription::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SummaryDescription* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.SummaryDescription";
+  }
+  protected:
+  explicit SummaryDescription(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTypeHintFieldNumber = 1,
+  };
+  // string type_hint = 1;
+  void clear_type_hint();
+  const std::string& type_hint() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_type_hint(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_type_hint();
+  PROTOBUF_NODISCARD std::string* release_type_hint();
+  void set_allocated_type_hint(std::string* type_hint);
+  private:
+  const std::string& _internal_type_hint() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_type_hint(const std::string& value);
+  std::string* _internal_mutable_type_hint();
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.SummaryDescription)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_hint_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fsummary_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SummaryMetadata_PluginData final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.SummaryMetadata.PluginData) */ {
+ public:
+  inline SummaryMetadata_PluginData() : SummaryMetadata_PluginData(nullptr) {}
+  ~SummaryMetadata_PluginData() override;
+  explicit PROTOBUF_CONSTEXPR SummaryMetadata_PluginData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SummaryMetadata_PluginData(const SummaryMetadata_PluginData& from);
+  SummaryMetadata_PluginData(SummaryMetadata_PluginData&& from) noexcept
+    : SummaryMetadata_PluginData() {
+    *this = ::std::move(from);
+  }
+
+  inline SummaryMetadata_PluginData& operator=(const SummaryMetadata_PluginData& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SummaryMetadata_PluginData& operator=(SummaryMetadata_PluginData&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SummaryMetadata_PluginData& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SummaryMetadata_PluginData* internal_default_instance() {
+    return reinterpret_cast<const SummaryMetadata_PluginData*>(
+               &_SummaryMetadata_PluginData_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(SummaryMetadata_PluginData& a, SummaryMetadata_PluginData& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SummaryMetadata_PluginData* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SummaryMetadata_PluginData* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SummaryMetadata_PluginData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SummaryMetadata_PluginData>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SummaryMetadata_PluginData& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const SummaryMetadata_PluginData& from) {
+    SummaryMetadata_PluginData::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SummaryMetadata_PluginData* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.SummaryMetadata.PluginData";
+  }
+  protected:
+  explicit SummaryMetadata_PluginData(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kPluginNameFieldNumber = 1,
+    kContentFieldNumber = 2,
+  };
+  // string plugin_name = 1;
+  void clear_plugin_name();
+  const std::string& plugin_name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_plugin_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_plugin_name();
+  PROTOBUF_NODISCARD std::string* release_plugin_name();
+  void set_allocated_plugin_name(std::string* plugin_name);
+  private:
+  const std::string& _internal_plugin_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_plugin_name(const std::string& value);
+  std::string* _internal_mutable_plugin_name();
+  public:
+
+  // bytes content = 2;
+  void clear_content();
+  const std::string& content() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_content(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_content();
+  PROTOBUF_NODISCARD std::string* release_content();
+  void set_allocated_content(std::string* content);
+  private:
+  const std::string& _internal_content() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_content(const std::string& value);
+  std::string* _internal_mutable_content();
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.SummaryMetadata.PluginData)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr plugin_name_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr content_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fsummary_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SummaryMetadata final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.SummaryMetadata) */ {
+ public:
+  inline SummaryMetadata() : SummaryMetadata(nullptr) {}
+  ~SummaryMetadata() override;
+  explicit PROTOBUF_CONSTEXPR SummaryMetadata(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SummaryMetadata(const SummaryMetadata& from);
+  SummaryMetadata(SummaryMetadata&& from) noexcept
+    : SummaryMetadata() {
+    *this = ::std::move(from);
+  }
+
+  inline SummaryMetadata& operator=(const SummaryMetadata& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SummaryMetadata& operator=(SummaryMetadata&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SummaryMetadata& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SummaryMetadata* internal_default_instance() {
+    return reinterpret_cast<const SummaryMetadata*>(
+               &_SummaryMetadata_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(SummaryMetadata& a, SummaryMetadata& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SummaryMetadata* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SummaryMetadata* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SummaryMetadata* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SummaryMetadata>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SummaryMetadata& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const SummaryMetadata& from) {
+    SummaryMetadata::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SummaryMetadata* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.SummaryMetadata";
+  }
+  protected:
+  explicit SummaryMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef SummaryMetadata_PluginData PluginData;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDisplayNameFieldNumber = 2,
+    kSummaryDescriptionFieldNumber = 3,
+    kPluginDataFieldNumber = 1,
+    kDataClassFieldNumber = 4,
+  };
+  // string display_name = 2;
+  void clear_display_name();
+  const std::string& display_name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_display_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_display_name();
+  PROTOBUF_NODISCARD std::string* release_display_name();
+  void set_allocated_display_name(std::string* display_name);
+  private:
+  const std::string& _internal_display_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_display_name(const std::string& value);
+  std::string* _internal_mutable_display_name();
+  public:
+
+  // string summary_description = 3;
+  void clear_summary_description();
+  const std::string& summary_description() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_summary_description(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_summary_description();
+  PROTOBUF_NODISCARD std::string* release_summary_description();
+  void set_allocated_summary_description(std::string* summary_description);
+  private:
+  const std::string& _internal_summary_description() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_summary_description(const std::string& value);
+  std::string* _internal_mutable_summary_description();
+  public:
+
+  // .tensorflow.SummaryMetadata.PluginData plugin_data = 1;
+  bool has_plugin_data() const;
+  private:
+  bool _internal_has_plugin_data() const;
+  public:
+  void clear_plugin_data();
+  const ::tensorflow::SummaryMetadata_PluginData& plugin_data() const;
+  PROTOBUF_NODISCARD ::tensorflow::SummaryMetadata_PluginData* release_plugin_data();
+  ::tensorflow::SummaryMetadata_PluginData* mutable_plugin_data();
+  void set_allocated_plugin_data(::tensorflow::SummaryMetadata_PluginData* plugin_data);
+  private:
+  const ::tensorflow::SummaryMetadata_PluginData& _internal_plugin_data() const;
+  ::tensorflow::SummaryMetadata_PluginData* _internal_mutable_plugin_data();
+  public:
+  void unsafe_arena_set_allocated_plugin_data(
+      ::tensorflow::SummaryMetadata_PluginData* plugin_data);
+  ::tensorflow::SummaryMetadata_PluginData* unsafe_arena_release_plugin_data();
+
+  // .tensorflow.DataClass data_class = 4;
+  void clear_data_class();
+  ::tensorflow::DataClass data_class() const;
+  void set_data_class(::tensorflow::DataClass value);
+  private:
+  ::tensorflow::DataClass _internal_data_class() const;
+  void _internal_set_data_class(::tensorflow::DataClass value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.SummaryMetadata)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr display_name_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr summary_description_;
+    ::tensorflow::SummaryMetadata_PluginData* plugin_data_;
+    int data_class_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fsummary_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Summary_Image final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.Summary.Image) */ {
+ public:
+  inline Summary_Image() : Summary_Image(nullptr) {}
+  ~Summary_Image() override;
+  explicit PROTOBUF_CONSTEXPR Summary_Image(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Summary_Image(const Summary_Image& from);
+  Summary_Image(Summary_Image&& from) noexcept
+    : Summary_Image() {
+    *this = ::std::move(from);
+  }
+
+  inline Summary_Image& operator=(const Summary_Image& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Summary_Image& operator=(Summary_Image&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Summary_Image& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Summary_Image* internal_default_instance() {
+    return reinterpret_cast<const Summary_Image*>(
+               &_Summary_Image_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  friend void swap(Summary_Image& a, Summary_Image& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Summary_Image* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Summary_Image* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Summary_Image* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Summary_Image>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Summary_Image& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Summary_Image& from) {
+    Summary_Image::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Summary_Image* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.Summary.Image";
+  }
+  protected:
+  explicit Summary_Image(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kEncodedImageStringFieldNumber = 4,
+    kHeightFieldNumber = 1,
+    kWidthFieldNumber = 2,
+    kColorspaceFieldNumber = 3,
+  };
+  // bytes encoded_image_string = 4;
+  void clear_encoded_image_string();
+  const std::string& encoded_image_string() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_encoded_image_string(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_encoded_image_string();
+  PROTOBUF_NODISCARD std::string* release_encoded_image_string();
+  void set_allocated_encoded_image_string(std::string* encoded_image_string);
+  private:
+  const std::string& _internal_encoded_image_string() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_encoded_image_string(const std::string& value);
+  std::string* _internal_mutable_encoded_image_string();
+  public:
+
+  // int32 height = 1;
+  void clear_height();
+  int32_t height() const;
+  void set_height(int32_t value);
+  private:
+  int32_t _internal_height() const;
+  void _internal_set_height(int32_t value);
+  public:
+
+  // int32 width = 2;
+  void clear_width();
+  int32_t width() const;
+  void set_width(int32_t value);
+  private:
+  int32_t _internal_width() const;
+  void _internal_set_width(int32_t value);
+  public:
+
+  // int32 colorspace = 3;
+  void clear_colorspace();
+  int32_t colorspace() const;
+  void set_colorspace(int32_t value);
+  private:
+  int32_t _internal_colorspace() const;
+  void _internal_set_colorspace(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.Summary.Image)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr encoded_image_string_;
+    int32_t height_;
+    int32_t width_;
+    int32_t colorspace_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fsummary_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Summary_Audio final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.Summary.Audio) */ {
+ public:
+  inline Summary_Audio() : Summary_Audio(nullptr) {}
+  ~Summary_Audio() override;
+  explicit PROTOBUF_CONSTEXPR Summary_Audio(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Summary_Audio(const Summary_Audio& from);
+  Summary_Audio(Summary_Audio&& from) noexcept
+    : Summary_Audio() {
+    *this = ::std::move(from);
+  }
+
+  inline Summary_Audio& operator=(const Summary_Audio& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Summary_Audio& operator=(Summary_Audio&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Summary_Audio& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Summary_Audio* internal_default_instance() {
+    return reinterpret_cast<const Summary_Audio*>(
+               &_Summary_Audio_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    4;
+
+  friend void swap(Summary_Audio& a, Summary_Audio& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Summary_Audio* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Summary_Audio* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Summary_Audio* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Summary_Audio>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Summary_Audio& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Summary_Audio& from) {
+    Summary_Audio::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Summary_Audio* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.Summary.Audio";
+  }
+  protected:
+  explicit Summary_Audio(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kEncodedAudioStringFieldNumber = 4,
+    kContentTypeFieldNumber = 5,
+    kNumChannelsFieldNumber = 2,
+    kLengthFramesFieldNumber = 3,
+    kSampleRateFieldNumber = 1,
+  };
+  // bytes encoded_audio_string = 4;
+  void clear_encoded_audio_string();
+  const std::string& encoded_audio_string() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_encoded_audio_string(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_encoded_audio_string();
+  PROTOBUF_NODISCARD std::string* release_encoded_audio_string();
+  void set_allocated_encoded_audio_string(std::string* encoded_audio_string);
+  private:
+  const std::string& _internal_encoded_audio_string() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_encoded_audio_string(const std::string& value);
+  std::string* _internal_mutable_encoded_audio_string();
+  public:
+
+  // string content_type = 5;
+  void clear_content_type();
+  const std::string& content_type() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_content_type(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_content_type();
+  PROTOBUF_NODISCARD std::string* release_content_type();
+  void set_allocated_content_type(std::string* content_type);
+  private:
+  const std::string& _internal_content_type() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_content_type(const std::string& value);
+  std::string* _internal_mutable_content_type();
+  public:
+
+  // int64 num_channels = 2;
+  void clear_num_channels();
+  int64_t num_channels() const;
+  void set_num_channels(int64_t value);
+  private:
+  int64_t _internal_num_channels() const;
+  void _internal_set_num_channels(int64_t value);
+  public:
+
+  // int64 length_frames = 3;
+  void clear_length_frames();
+  int64_t length_frames() const;
+  void set_length_frames(int64_t value);
+  private:
+  int64_t _internal_length_frames() const;
+  void _internal_set_length_frames(int64_t value);
+  public:
+
+  // float sample_rate = 1;
+  void clear_sample_rate();
+  float sample_rate() const;
+  void set_sample_rate(float value);
+  private:
+  float _internal_sample_rate() const;
+  void _internal_set_sample_rate(float value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.Summary.Audio)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr encoded_audio_string_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr content_type_;
+    int64_t num_channels_;
+    int64_t length_frames_;
+    float sample_rate_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fsummary_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Summary_Value final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.Summary.Value) */ {
+ public:
+  inline Summary_Value() : Summary_Value(nullptr) {}
+  ~Summary_Value() override;
+  explicit PROTOBUF_CONSTEXPR Summary_Value(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Summary_Value(const Summary_Value& from);
+  Summary_Value(Summary_Value&& from) noexcept
+    : Summary_Value() {
+    *this = ::std::move(from);
+  }
+
+  inline Summary_Value& operator=(const Summary_Value& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Summary_Value& operator=(Summary_Value&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Summary_Value& default_instance() {
+    return *internal_default_instance();
+  }
+  enum ValueCase {
+    kSimpleValue = 2,
+    kObsoleteOldStyleHistogram = 3,
+    kImage = 4,
+    kHisto = 5,
+    kAudio = 6,
+    kTensor = 8,
+    VALUE_NOT_SET = 0,
+  };
+
+  static inline const Summary_Value* internal_default_instance() {
+    return reinterpret_cast<const Summary_Value*>(
+               &_Summary_Value_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    5;
+
+  friend void swap(Summary_Value& a, Summary_Value& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Summary_Value* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Summary_Value* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Summary_Value* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Summary_Value>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Summary_Value& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Summary_Value& from) {
+    Summary_Value::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Summary_Value* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.Summary.Value";
+  }
+  protected:
+  explicit Summary_Value(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTagFieldNumber = 1,
+    kNodeNameFieldNumber = 7,
+    kMetadataFieldNumber = 9,
+    kSimpleValueFieldNumber = 2,
+    kObsoleteOldStyleHistogramFieldNumber = 3,
+    kImageFieldNumber = 4,
+    kHistoFieldNumber = 5,
+    kAudioFieldNumber = 6,
+    kTensorFieldNumber = 8,
+  };
+  // string tag = 1;
+  void clear_tag();
+  const std::string& tag() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_tag(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_tag();
+  PROTOBUF_NODISCARD std::string* release_tag();
+  void set_allocated_tag(std::string* tag);
+  private:
+  const std::string& _internal_tag() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_tag(const std::string& value);
+  std::string* _internal_mutable_tag();
+  public:
+
+  // string node_name = 7;
+  void clear_node_name();
+  const std::string& node_name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_node_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_node_name();
+  PROTOBUF_NODISCARD std::string* release_node_name();
+  void set_allocated_node_name(std::string* node_name);
+  private:
+  const std::string& _internal_node_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_node_name(const std::string& value);
+  std::string* _internal_mutable_node_name();
+  public:
+
+  // .tensorflow.SummaryMetadata metadata = 9;
+  bool has_metadata() const;
+  private:
+  bool _internal_has_metadata() const;
+  public:
+  void clear_metadata();
+  const ::tensorflow::SummaryMetadata& metadata() const;
+  PROTOBUF_NODISCARD ::tensorflow::SummaryMetadata* release_metadata();
+  ::tensorflow::SummaryMetadata* mutable_metadata();
+  void set_allocated_metadata(::tensorflow::SummaryMetadata* metadata);
+  private:
+  const ::tensorflow::SummaryMetadata& _internal_metadata() const;
+  ::tensorflow::SummaryMetadata* _internal_mutable_metadata();
+  public:
+  void unsafe_arena_set_allocated_metadata(
+      ::tensorflow::SummaryMetadata* metadata);
+  ::tensorflow::SummaryMetadata* unsafe_arena_release_metadata();
+
+  // float simple_value = 2;
+  bool has_simple_value() const;
+  private:
+  bool _internal_has_simple_value() const;
+  public:
+  void clear_simple_value();
+  float simple_value() const;
+  void set_simple_value(float value);
+  private:
+  float _internal_simple_value() const;
+  void _internal_set_simple_value(float value);
+  public:
+
+  // bytes obsolete_old_style_histogram = 3;
+  bool has_obsolete_old_style_histogram() const;
+  private:
+  bool _internal_has_obsolete_old_style_histogram() const;
+  public:
+  void clear_obsolete_old_style_histogram();
+  const std::string& obsolete_old_style_histogram() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_obsolete_old_style_histogram(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_obsolete_old_style_histogram();
+  PROTOBUF_NODISCARD std::string* release_obsolete_old_style_histogram();
+  void set_allocated_obsolete_old_style_histogram(std::string* obsolete_old_style_histogram);
+  private:
+  const std::string& _internal_obsolete_old_style_histogram() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_obsolete_old_style_histogram(const std::string& value);
+  std::string* _internal_mutable_obsolete_old_style_histogram();
+  public:
+
+  // .tensorflow.Summary.Image image = 4;
+  bool has_image() const;
+  private:
+  bool _internal_has_image() const;
+  public:
+  void clear_image();
+  const ::tensorflow::Summary_Image& image() const;
+  PROTOBUF_NODISCARD ::tensorflow::Summary_Image* release_image();
+  ::tensorflow::Summary_Image* mutable_image();
+  void set_allocated_image(::tensorflow::Summary_Image* image);
+  private:
+  const ::tensorflow::Summary_Image& _internal_image() const;
+  ::tensorflow::Summary_Image* _internal_mutable_image();
+  public:
+  void unsafe_arena_set_allocated_image(
+      ::tensorflow::Summary_Image* image);
+  ::tensorflow::Summary_Image* unsafe_arena_release_image();
+
+  // .tensorflow.HistogramProto histo = 5;
+  bool has_histo() const;
+  private:
+  bool _internal_has_histo() const;
+  public:
+  void clear_histo();
+  const ::tensorflow::HistogramProto& histo() const;
+  PROTOBUF_NODISCARD ::tensorflow::HistogramProto* release_histo();
+  ::tensorflow::HistogramProto* mutable_histo();
+  void set_allocated_histo(::tensorflow::HistogramProto* histo);
+  private:
+  const ::tensorflow::HistogramProto& _internal_histo() const;
+  ::tensorflow::HistogramProto* _internal_mutable_histo();
+  public:
+  void unsafe_arena_set_allocated_histo(
+      ::tensorflow::HistogramProto* histo);
+  ::tensorflow::HistogramProto* unsafe_arena_release_histo();
+
+  // .tensorflow.Summary.Audio audio = 6;
+  bool has_audio() const;
+  private:
+  bool _internal_has_audio() const;
+  public:
+  void clear_audio();
+  const ::tensorflow::Summary_Audio& audio() const;
+  PROTOBUF_NODISCARD ::tensorflow::Summary_Audio* release_audio();
+  ::tensorflow::Summary_Audio* mutable_audio();
+  void set_allocated_audio(::tensorflow::Summary_Audio* audio);
+  private:
+  const ::tensorflow::Summary_Audio& _internal_audio() const;
+  ::tensorflow::Summary_Audio* _internal_mutable_audio();
+  public:
+  void unsafe_arena_set_allocated_audio(
+      ::tensorflow::Summary_Audio* audio);
+  ::tensorflow::Summary_Audio* unsafe_arena_release_audio();
+
+  // .tensorflow.TensorProto tensor = 8;
+  bool has_tensor() const;
+  private:
+  bool _internal_has_tensor() const;
+  public:
+  void clear_tensor();
+  const ::tensorflow::TensorProto& tensor() const;
+  PROTOBUF_NODISCARD ::tensorflow::TensorProto* release_tensor();
+  ::tensorflow::TensorProto* mutable_tensor();
+  void set_allocated_tensor(::tensorflow::TensorProto* tensor);
+  private:
+  const ::tensorflow::TensorProto& _internal_tensor() const;
+  ::tensorflow::TensorProto* _internal_mutable_tensor();
+  public:
+  void unsafe_arena_set_allocated_tensor(
+      ::tensorflow::TensorProto* tensor);
+  ::tensorflow::TensorProto* unsafe_arena_release_tensor();
+
+  void clear_value();
+  ValueCase value_case() const;
+  // @@protoc_insertion_point(class_scope:tensorflow.Summary.Value)
+ private:
+  class _Internal;
+  void set_has_simple_value();
+  void set_has_obsolete_old_style_histogram();
+  void set_has_image();
+  void set_has_histo();
+  void set_has_audio();
+  void set_has_tensor();
+
+  inline bool has_value() const;
+  inline void clear_has_value();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr tag_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr node_name_;
+    ::tensorflow::SummaryMetadata* metadata_;
+    union ValueUnion {
+      constexpr ValueUnion() : _constinit_{} {}
+        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+      float simple_value_;
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr obsolete_old_style_histogram_;
+      ::tensorflow::Summary_Image* image_;
+      ::tensorflow::HistogramProto* histo_;
+      ::tensorflow::Summary_Audio* audio_;
+      ::tensorflow::TensorProto* tensor_;
+    } value_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    uint32_t _oneof_case_[1];
+
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fsummary_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Summary final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.Summary) */ {
+ public:
+  inline Summary() : Summary(nullptr) {}
+  ~Summary() override;
+  explicit PROTOBUF_CONSTEXPR Summary(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Summary(const Summary& from);
+  Summary(Summary&& from) noexcept
+    : Summary() {
+    *this = ::std::move(from);
+  }
+
+  inline Summary& operator=(const Summary& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Summary& operator=(Summary&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Summary& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Summary* internal_default_instance() {
+    return reinterpret_cast<const Summary*>(
+               &_Summary_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    6;
+
+  friend void swap(Summary& a, Summary& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Summary* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Summary* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Summary* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Summary>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Summary& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Summary& from) {
+    Summary::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Summary* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.Summary";
+  }
+  protected:
+  explicit Summary(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef Summary_Image Image;
+  typedef Summary_Audio Audio;
+  typedef Summary_Value Value;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kValueFieldNumber = 1,
+  };
+  // repeated .tensorflow.Summary.Value value = 1;
+  int value_size() const;
+  private:
+  int _internal_value_size() const;
+  public:
+  void clear_value();
+  ::tensorflow::Summary_Value* mutable_value(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::Summary_Value >*
+      mutable_value();
+  private:
+  const ::tensorflow::Summary_Value& _internal_value(int index) const;
+  ::tensorflow::Summary_Value* _internal_add_value();
+  public:
+  const ::tensorflow::Summary_Value& value(int index) const;
+  ::tensorflow::Summary_Value* add_value();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::Summary_Value >&
+      value() const;
+
+  // @@protoc_insertion_point(class_scope:tensorflow.Summary)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::Summary_Value > value_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fsummary_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// SummaryDescription
+
+// string type_hint = 1;
+inline void SummaryDescription::clear_type_hint() {
+  _impl_.type_hint_.ClearToEmpty();
+}
+inline const std::string& SummaryDescription::type_hint() const {
+  // @@protoc_insertion_point(field_get:tensorflow.SummaryDescription.type_hint)
+  return _internal_type_hint();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SummaryDescription::set_type_hint(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.type_hint_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.SummaryDescription.type_hint)
+}
+inline std::string* SummaryDescription::mutable_type_hint() {
+  std::string* _s = _internal_mutable_type_hint();
+  // @@protoc_insertion_point(field_mutable:tensorflow.SummaryDescription.type_hint)
+  return _s;
+}
+inline const std::string& SummaryDescription::_internal_type_hint() const {
+  return _impl_.type_hint_.Get();
+}
+inline void SummaryDescription::_internal_set_type_hint(const std::string& value) {
+  
+  _impl_.type_hint_.Set(value, GetArenaForAllocation());
+}
+inline std::string* SummaryDescription::_internal_mutable_type_hint() {
+  
+  return _impl_.type_hint_.Mutable(GetArenaForAllocation());
+}
+inline std::string* SummaryDescription::release_type_hint() {
+  // @@protoc_insertion_point(field_release:tensorflow.SummaryDescription.type_hint)
+  return _impl_.type_hint_.Release();
+}
+inline void SummaryDescription::set_allocated_type_hint(std::string* type_hint) {
+  if (type_hint != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.type_hint_.SetAllocated(type_hint, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.type_hint_.IsDefault()) {
+    _impl_.type_hint_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.SummaryDescription.type_hint)
+}
+
+// -------------------------------------------------------------------
+
+// SummaryMetadata_PluginData
+
+// string plugin_name = 1;
+inline void SummaryMetadata_PluginData::clear_plugin_name() {
+  _impl_.plugin_name_.ClearToEmpty();
+}
+inline const std::string& SummaryMetadata_PluginData::plugin_name() const {
+  // @@protoc_insertion_point(field_get:tensorflow.SummaryMetadata.PluginData.plugin_name)
+  return _internal_plugin_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SummaryMetadata_PluginData::set_plugin_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.plugin_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.SummaryMetadata.PluginData.plugin_name)
+}
+inline std::string* SummaryMetadata_PluginData::mutable_plugin_name() {
+  std::string* _s = _internal_mutable_plugin_name();
+  // @@protoc_insertion_point(field_mutable:tensorflow.SummaryMetadata.PluginData.plugin_name)
+  return _s;
+}
+inline const std::string& SummaryMetadata_PluginData::_internal_plugin_name() const {
+  return _impl_.plugin_name_.Get();
+}
+inline void SummaryMetadata_PluginData::_internal_set_plugin_name(const std::string& value) {
+  
+  _impl_.plugin_name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* SummaryMetadata_PluginData::_internal_mutable_plugin_name() {
+  
+  return _impl_.plugin_name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* SummaryMetadata_PluginData::release_plugin_name() {
+  // @@protoc_insertion_point(field_release:tensorflow.SummaryMetadata.PluginData.plugin_name)
+  return _impl_.plugin_name_.Release();
+}
+inline void SummaryMetadata_PluginData::set_allocated_plugin_name(std::string* plugin_name) {
+  if (plugin_name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.plugin_name_.SetAllocated(plugin_name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.plugin_name_.IsDefault()) {
+    _impl_.plugin_name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.SummaryMetadata.PluginData.plugin_name)
+}
+
+// bytes content = 2;
+inline void SummaryMetadata_PluginData::clear_content() {
+  _impl_.content_.ClearToEmpty();
+}
+inline const std::string& SummaryMetadata_PluginData::content() const {
+  // @@protoc_insertion_point(field_get:tensorflow.SummaryMetadata.PluginData.content)
+  return _internal_content();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SummaryMetadata_PluginData::set_content(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.content_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.SummaryMetadata.PluginData.content)
+}
+inline std::string* SummaryMetadata_PluginData::mutable_content() {
+  std::string* _s = _internal_mutable_content();
+  // @@protoc_insertion_point(field_mutable:tensorflow.SummaryMetadata.PluginData.content)
+  return _s;
+}
+inline const std::string& SummaryMetadata_PluginData::_internal_content() const {
+  return _impl_.content_.Get();
+}
+inline void SummaryMetadata_PluginData::_internal_set_content(const std::string& value) {
+  
+  _impl_.content_.Set(value, GetArenaForAllocation());
+}
+inline std::string* SummaryMetadata_PluginData::_internal_mutable_content() {
+  
+  return _impl_.content_.Mutable(GetArenaForAllocation());
+}
+inline std::string* SummaryMetadata_PluginData::release_content() {
+  // @@protoc_insertion_point(field_release:tensorflow.SummaryMetadata.PluginData.content)
+  return _impl_.content_.Release();
+}
+inline void SummaryMetadata_PluginData::set_allocated_content(std::string* content) {
+  if (content != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.content_.SetAllocated(content, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.content_.IsDefault()) {
+    _impl_.content_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.SummaryMetadata.PluginData.content)
+}
+
+// -------------------------------------------------------------------
+
+// SummaryMetadata
+
+// .tensorflow.SummaryMetadata.PluginData plugin_data = 1;
+inline bool SummaryMetadata::_internal_has_plugin_data() const {
+  return this != internal_default_instance() && _impl_.plugin_data_ != nullptr;
+}
+inline bool SummaryMetadata::has_plugin_data() const {
+  return _internal_has_plugin_data();
+}
+inline void SummaryMetadata::clear_plugin_data() {
+  if (GetArenaForAllocation() == nullptr && _impl_.plugin_data_ != nullptr) {
+    delete _impl_.plugin_data_;
+  }
+  _impl_.plugin_data_ = nullptr;
+}
+inline const ::tensorflow::SummaryMetadata_PluginData& SummaryMetadata::_internal_plugin_data() const {
+  const ::tensorflow::SummaryMetadata_PluginData* p = _impl_.plugin_data_;
+  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::SummaryMetadata_PluginData&>(
+      ::tensorflow::_SummaryMetadata_PluginData_default_instance_);
+}
+inline const ::tensorflow::SummaryMetadata_PluginData& SummaryMetadata::plugin_data() const {
+  // @@protoc_insertion_point(field_get:tensorflow.SummaryMetadata.plugin_data)
+  return _internal_plugin_data();
+}
+inline void SummaryMetadata::unsafe_arena_set_allocated_plugin_data(
+    ::tensorflow::SummaryMetadata_PluginData* plugin_data) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.plugin_data_);
+  }
+  _impl_.plugin_data_ = plugin_data;
+  if (plugin_data) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.SummaryMetadata.plugin_data)
+}
+inline ::tensorflow::SummaryMetadata_PluginData* SummaryMetadata::release_plugin_data() {
+  
+  ::tensorflow::SummaryMetadata_PluginData* temp = _impl_.plugin_data_;
+  _impl_.plugin_data_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::tensorflow::SummaryMetadata_PluginData* SummaryMetadata::unsafe_arena_release_plugin_data() {
+  // @@protoc_insertion_point(field_release:tensorflow.SummaryMetadata.plugin_data)
+  
+  ::tensorflow::SummaryMetadata_PluginData* temp = _impl_.plugin_data_;
+  _impl_.plugin_data_ = nullptr;
+  return temp;
+}
+inline ::tensorflow::SummaryMetadata_PluginData* SummaryMetadata::_internal_mutable_plugin_data() {
+  
+  if (_impl_.plugin_data_ == nullptr) {
+    auto* p = CreateMaybeMessage<::tensorflow::SummaryMetadata_PluginData>(GetArenaForAllocation());
+    _impl_.plugin_data_ = p;
+  }
+  return _impl_.plugin_data_;
+}
+inline ::tensorflow::SummaryMetadata_PluginData* SummaryMetadata::mutable_plugin_data() {
+  ::tensorflow::SummaryMetadata_PluginData* _msg = _internal_mutable_plugin_data();
+  // @@protoc_insertion_point(field_mutable:tensorflow.SummaryMetadata.plugin_data)
+  return _msg;
+}
+inline void SummaryMetadata::set_allocated_plugin_data(::tensorflow::SummaryMetadata_PluginData* plugin_data) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.plugin_data_;
+  }
+  if (plugin_data) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(plugin_data);
+    if (message_arena != submessage_arena) {
+      plugin_data = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, plugin_data, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.plugin_data_ = plugin_data;
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.SummaryMetadata.plugin_data)
+}
+
+// string display_name = 2;
+inline void SummaryMetadata::clear_display_name() {
+  _impl_.display_name_.ClearToEmpty();
+}
+inline const std::string& SummaryMetadata::display_name() const {
+  // @@protoc_insertion_point(field_get:tensorflow.SummaryMetadata.display_name)
+  return _internal_display_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SummaryMetadata::set_display_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.display_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.SummaryMetadata.display_name)
+}
+inline std::string* SummaryMetadata::mutable_display_name() {
+  std::string* _s = _internal_mutable_display_name();
+  // @@protoc_insertion_point(field_mutable:tensorflow.SummaryMetadata.display_name)
+  return _s;
+}
+inline const std::string& SummaryMetadata::_internal_display_name() const {
+  return _impl_.display_name_.Get();
+}
+inline void SummaryMetadata::_internal_set_display_name(const std::string& value) {
+  
+  _impl_.display_name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* SummaryMetadata::_internal_mutable_display_name() {
+  
+  return _impl_.display_name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* SummaryMetadata::release_display_name() {
+  // @@protoc_insertion_point(field_release:tensorflow.SummaryMetadata.display_name)
+  return _impl_.display_name_.Release();
+}
+inline void SummaryMetadata::set_allocated_display_name(std::string* display_name) {
+  if (display_name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.display_name_.SetAllocated(display_name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.display_name_.IsDefault()) {
+    _impl_.display_name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.SummaryMetadata.display_name)
+}
+
+// string summary_description = 3;
+inline void SummaryMetadata::clear_summary_description() {
+  _impl_.summary_description_.ClearToEmpty();
+}
+inline const std::string& SummaryMetadata::summary_description() const {
+  // @@protoc_insertion_point(field_get:tensorflow.SummaryMetadata.summary_description)
+  return _internal_summary_description();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SummaryMetadata::set_summary_description(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.summary_description_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.SummaryMetadata.summary_description)
+}
+inline std::string* SummaryMetadata::mutable_summary_description() {
+  std::string* _s = _internal_mutable_summary_description();
+  // @@protoc_insertion_point(field_mutable:tensorflow.SummaryMetadata.summary_description)
+  return _s;
+}
+inline const std::string& SummaryMetadata::_internal_summary_description() const {
+  return _impl_.summary_description_.Get();
+}
+inline void SummaryMetadata::_internal_set_summary_description(const std::string& value) {
+  
+  _impl_.summary_description_.Set(value, GetArenaForAllocation());
+}
+inline std::string* SummaryMetadata::_internal_mutable_summary_description() {
+  
+  return _impl_.summary_description_.Mutable(GetArenaForAllocation());
+}
+inline std::string* SummaryMetadata::release_summary_description() {
+  // @@protoc_insertion_point(field_release:tensorflow.SummaryMetadata.summary_description)
+  return _impl_.summary_description_.Release();
+}
+inline void SummaryMetadata::set_allocated_summary_description(std::string* summary_description) {
+  if (summary_description != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.summary_description_.SetAllocated(summary_description, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.summary_description_.IsDefault()) {
+    _impl_.summary_description_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.SummaryMetadata.summary_description)
+}
+
+// .tensorflow.DataClass data_class = 4;
+inline void SummaryMetadata::clear_data_class() {
+  _impl_.data_class_ = 0;
+}
+inline ::tensorflow::DataClass SummaryMetadata::_internal_data_class() const {
+  return static_cast< ::tensorflow::DataClass >(_impl_.data_class_);
+}
+inline ::tensorflow::DataClass SummaryMetadata::data_class() const {
+  // @@protoc_insertion_point(field_get:tensorflow.SummaryMetadata.data_class)
+  return _internal_data_class();
+}
+inline void SummaryMetadata::_internal_set_data_class(::tensorflow::DataClass value) {
+  
+  _impl_.data_class_ = value;
+}
+inline void SummaryMetadata::set_data_class(::tensorflow::DataClass value) {
+  _internal_set_data_class(value);
+  // @@protoc_insertion_point(field_set:tensorflow.SummaryMetadata.data_class)
+}
+
+// -------------------------------------------------------------------
+
+// Summary_Image
+
+// int32 height = 1;
+inline void Summary_Image::clear_height() {
+  _impl_.height_ = 0;
+}
+inline int32_t Summary_Image::_internal_height() const {
+  return _impl_.height_;
+}
+inline int32_t Summary_Image::height() const {
+  // @@protoc_insertion_point(field_get:tensorflow.Summary.Image.height)
+  return _internal_height();
+}
+inline void Summary_Image::_internal_set_height(int32_t value) {
+  
+  _impl_.height_ = value;
+}
+inline void Summary_Image::set_height(int32_t value) {
+  _internal_set_height(value);
+  // @@protoc_insertion_point(field_set:tensorflow.Summary.Image.height)
+}
+
+// int32 width = 2;
+inline void Summary_Image::clear_width() {
+  _impl_.width_ = 0;
+}
+inline int32_t Summary_Image::_internal_width() const {
+  return _impl_.width_;
+}
+inline int32_t Summary_Image::width() const {
+  // @@protoc_insertion_point(field_get:tensorflow.Summary.Image.width)
+  return _internal_width();
+}
+inline void Summary_Image::_internal_set_width(int32_t value) {
+  
+  _impl_.width_ = value;
+}
+inline void Summary_Image::set_width(int32_t value) {
+  _internal_set_width(value);
+  // @@protoc_insertion_point(field_set:tensorflow.Summary.Image.width)
+}
+
+// int32 colorspace = 3;
+inline void Summary_Image::clear_colorspace() {
+  _impl_.colorspace_ = 0;
+}
+inline int32_t Summary_Image::_internal_colorspace() const {
+  return _impl_.colorspace_;
+}
+inline int32_t Summary_Image::colorspace() const {
+  // @@protoc_insertion_point(field_get:tensorflow.Summary.Image.colorspace)
+  return _internal_colorspace();
+}
+inline void Summary_Image::_internal_set_colorspace(int32_t value) {
+  
+  _impl_.colorspace_ = value;
+}
+inline void Summary_Image::set_colorspace(int32_t value) {
+  _internal_set_colorspace(value);
+  // @@protoc_insertion_point(field_set:tensorflow.Summary.Image.colorspace)
+}
+
+// bytes encoded_image_string = 4;
+inline void Summary_Image::clear_encoded_image_string() {
+  _impl_.encoded_image_string_.ClearToEmpty();
+}
+inline const std::string& Summary_Image::encoded_image_string() const {
+  // @@protoc_insertion_point(field_get:tensorflow.Summary.Image.encoded_image_string)
+  return _internal_encoded_image_string();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Summary_Image::set_encoded_image_string(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.encoded_image_string_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.Summary.Image.encoded_image_string)
+}
+inline std::string* Summary_Image::mutable_encoded_image_string() {
+  std::string* _s = _internal_mutable_encoded_image_string();
+  // @@protoc_insertion_point(field_mutable:tensorflow.Summary.Image.encoded_image_string)
+  return _s;
+}
+inline const std::string& Summary_Image::_internal_encoded_image_string() const {
+  return _impl_.encoded_image_string_.Get();
+}
+inline void Summary_Image::_internal_set_encoded_image_string(const std::string& value) {
+  
+  _impl_.encoded_image_string_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Summary_Image::_internal_mutable_encoded_image_string() {
+  
+  return _impl_.encoded_image_string_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Summary_Image::release_encoded_image_string() {
+  // @@protoc_insertion_point(field_release:tensorflow.Summary.Image.encoded_image_string)
+  return _impl_.encoded_image_string_.Release();
+}
+inline void Summary_Image::set_allocated_encoded_image_string(std::string* encoded_image_string) {
+  if (encoded_image_string != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.encoded_image_string_.SetAllocated(encoded_image_string, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.encoded_image_string_.IsDefault()) {
+    _impl_.encoded_image_string_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.Summary.Image.encoded_image_string)
+}
+
+// -------------------------------------------------------------------
+
+// Summary_Audio
+
+// float sample_rate = 1;
+inline void Summary_Audio::clear_sample_rate() {
+  _impl_.sample_rate_ = 0;
+}
+inline float Summary_Audio::_internal_sample_rate() const {
+  return _impl_.sample_rate_;
+}
+inline float Summary_Audio::sample_rate() const {
+  // @@protoc_insertion_point(field_get:tensorflow.Summary.Audio.sample_rate)
+  return _internal_sample_rate();
+}
+inline void Summary_Audio::_internal_set_sample_rate(float value) {
+  
+  _impl_.sample_rate_ = value;
+}
+inline void Summary_Audio::set_sample_rate(float value) {
+  _internal_set_sample_rate(value);
+  // @@protoc_insertion_point(field_set:tensorflow.Summary.Audio.sample_rate)
+}
+
+// int64 num_channels = 2;
+inline void Summary_Audio::clear_num_channels() {
+  _impl_.num_channels_ = int64_t{0};
+}
+inline int64_t Summary_Audio::_internal_num_channels() const {
+  return _impl_.num_channels_;
+}
+inline int64_t Summary_Audio::num_channels() const {
+  // @@protoc_insertion_point(field_get:tensorflow.Summary.Audio.num_channels)
+  return _internal_num_channels();
+}
+inline void Summary_Audio::_internal_set_num_channels(int64_t value) {
+  
+  _impl_.num_channels_ = value;
+}
+inline void Summary_Audio::set_num_channels(int64_t value) {
+  _internal_set_num_channels(value);
+  // @@protoc_insertion_point(field_set:tensorflow.Summary.Audio.num_channels)
+}
+
+// int64 length_frames = 3;
+inline void Summary_Audio::clear_length_frames() {
+  _impl_.length_frames_ = int64_t{0};
+}
+inline int64_t Summary_Audio::_internal_length_frames() const {
+  return _impl_.length_frames_;
+}
+inline int64_t Summary_Audio::length_frames() const {
+  // @@protoc_insertion_point(field_get:tensorflow.Summary.Audio.length_frames)
+  return _internal_length_frames();
+}
+inline void Summary_Audio::_internal_set_length_frames(int64_t value) {
+  
+  _impl_.length_frames_ = value;
+}
+inline void Summary_Audio::set_length_frames(int64_t value) {
+  _internal_set_length_frames(value);
+  // @@protoc_insertion_point(field_set:tensorflow.Summary.Audio.length_frames)
+}
+
+// bytes encoded_audio_string = 4;
+inline void Summary_Audio::clear_encoded_audio_string() {
+  _impl_.encoded_audio_string_.ClearToEmpty();
+}
+inline const std::string& Summary_Audio::encoded_audio_string() const {
+  // @@protoc_insertion_point(field_get:tensorflow.Summary.Audio.encoded_audio_string)
+  return _internal_encoded_audio_string();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Summary_Audio::set_encoded_audio_string(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.encoded_audio_string_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.Summary.Audio.encoded_audio_string)
+}
+inline std::string* Summary_Audio::mutable_encoded_audio_string() {
+  std::string* _s = _internal_mutable_encoded_audio_string();
+  // @@protoc_insertion_point(field_mutable:tensorflow.Summary.Audio.encoded_audio_string)
+  return _s;
+}
+inline const std::string& Summary_Audio::_internal_encoded_audio_string() const {
+  return _impl_.encoded_audio_string_.Get();
+}
+inline void Summary_Audio::_internal_set_encoded_audio_string(const std::string& value) {
+  
+  _impl_.encoded_audio_string_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Summary_Audio::_internal_mutable_encoded_audio_string() {
+  
+  return _impl_.encoded_audio_string_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Summary_Audio::release_encoded_audio_string() {
+  // @@protoc_insertion_point(field_release:tensorflow.Summary.Audio.encoded_audio_string)
+  return _impl_.encoded_audio_string_.Release();
+}
+inline void Summary_Audio::set_allocated_encoded_audio_string(std::string* encoded_audio_string) {
+  if (encoded_audio_string != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.encoded_audio_string_.SetAllocated(encoded_audio_string, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.encoded_audio_string_.IsDefault()) {
+    _impl_.encoded_audio_string_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.Summary.Audio.encoded_audio_string)
+}
+
+// string content_type = 5;
+inline void Summary_Audio::clear_content_type() {
+  _impl_.content_type_.ClearToEmpty();
+}
+inline const std::string& Summary_Audio::content_type() const {
+  // @@protoc_insertion_point(field_get:tensorflow.Summary.Audio.content_type)
+  return _internal_content_type();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Summary_Audio::set_content_type(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.content_type_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.Summary.Audio.content_type)
+}
+inline std::string* Summary_Audio::mutable_content_type() {
+  std::string* _s = _internal_mutable_content_type();
+  // @@protoc_insertion_point(field_mutable:tensorflow.Summary.Audio.content_type)
+  return _s;
+}
+inline const std::string& Summary_Audio::_internal_content_type() const {
+  return _impl_.content_type_.Get();
+}
+inline void Summary_Audio::_internal_set_content_type(const std::string& value) {
+  
+  _impl_.content_type_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Summary_Audio::_internal_mutable_content_type() {
+  
+  return _impl_.content_type_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Summary_Audio::release_content_type() {
+  // @@protoc_insertion_point(field_release:tensorflow.Summary.Audio.content_type)
+  return _impl_.content_type_.Release();
+}
+inline void Summary_Audio::set_allocated_content_type(std::string* content_type) {
+  if (content_type != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.content_type_.SetAllocated(content_type, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.content_type_.IsDefault()) {
+    _impl_.content_type_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.Summary.Audio.content_type)
+}
+
+// -------------------------------------------------------------------
+
+// Summary_Value
+
+// string node_name = 7;
+inline void Summary_Value::clear_node_name() {
+  _impl_.node_name_.ClearToEmpty();
+}
+inline const std::string& Summary_Value::node_name() const {
+  // @@protoc_insertion_point(field_get:tensorflow.Summary.Value.node_name)
+  return _internal_node_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Summary_Value::set_node_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.node_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.Summary.Value.node_name)
+}
+inline std::string* Summary_Value::mutable_node_name() {
+  std::string* _s = _internal_mutable_node_name();
+  // @@protoc_insertion_point(field_mutable:tensorflow.Summary.Value.node_name)
+  return _s;
+}
+inline const std::string& Summary_Value::_internal_node_name() const {
+  return _impl_.node_name_.Get();
+}
+inline void Summary_Value::_internal_set_node_name(const std::string& value) {
+  
+  _impl_.node_name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Summary_Value::_internal_mutable_node_name() {
+  
+  return _impl_.node_name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Summary_Value::release_node_name() {
+  // @@protoc_insertion_point(field_release:tensorflow.Summary.Value.node_name)
+  return _impl_.node_name_.Release();
+}
+inline void Summary_Value::set_allocated_node_name(std::string* node_name) {
+  if (node_name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.node_name_.SetAllocated(node_name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.node_name_.IsDefault()) {
+    _impl_.node_name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.Summary.Value.node_name)
+}
+
+// string tag = 1;
+inline void Summary_Value::clear_tag() {
+  _impl_.tag_.ClearToEmpty();
+}
+inline const std::string& Summary_Value::tag() const {
+  // @@protoc_insertion_point(field_get:tensorflow.Summary.Value.tag)
+  return _internal_tag();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Summary_Value::set_tag(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.tag_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.Summary.Value.tag)
+}
+inline std::string* Summary_Value::mutable_tag() {
+  std::string* _s = _internal_mutable_tag();
+  // @@protoc_insertion_point(field_mutable:tensorflow.Summary.Value.tag)
+  return _s;
+}
+inline const std::string& Summary_Value::_internal_tag() const {
+  return _impl_.tag_.Get();
+}
+inline void Summary_Value::_internal_set_tag(const std::string& value) {
+  
+  _impl_.tag_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Summary_Value::_internal_mutable_tag() {
+  
+  return _impl_.tag_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Summary_Value::release_tag() {
+  // @@protoc_insertion_point(field_release:tensorflow.Summary.Value.tag)
+  return _impl_.tag_.Release();
+}
+inline void Summary_Value::set_allocated_tag(std::string* tag) {
+  if (tag != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.tag_.SetAllocated(tag, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.tag_.IsDefault()) {
+    _impl_.tag_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.Summary.Value.tag)
+}
+
+// .tensorflow.SummaryMetadata metadata = 9;
+inline bool Summary_Value::_internal_has_metadata() const {
+  return this != internal_default_instance() && _impl_.metadata_ != nullptr;
+}
+inline bool Summary_Value::has_metadata() const {
+  return _internal_has_metadata();
+}
+inline void Summary_Value::clear_metadata() {
+  if (GetArenaForAllocation() == nullptr && _impl_.metadata_ != nullptr) {
+    delete _impl_.metadata_;
+  }
+  _impl_.metadata_ = nullptr;
+}
+inline const ::tensorflow::SummaryMetadata& Summary_Value::_internal_metadata() const {
+  const ::tensorflow::SummaryMetadata* p = _impl_.metadata_;
+  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::SummaryMetadata&>(
+      ::tensorflow::_SummaryMetadata_default_instance_);
+}
+inline const ::tensorflow::SummaryMetadata& Summary_Value::metadata() const {
+  // @@protoc_insertion_point(field_get:tensorflow.Summary.Value.metadata)
+  return _internal_metadata();
+}
+inline void Summary_Value::unsafe_arena_set_allocated_metadata(
+    ::tensorflow::SummaryMetadata* metadata) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.metadata_);
+  }
+  _impl_.metadata_ = metadata;
+  if (metadata) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.Summary.Value.metadata)
+}
+inline ::tensorflow::SummaryMetadata* Summary_Value::release_metadata() {
+  
+  ::tensorflow::SummaryMetadata* temp = _impl_.metadata_;
+  _impl_.metadata_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::tensorflow::SummaryMetadata* Summary_Value::unsafe_arena_release_metadata() {
+  // @@protoc_insertion_point(field_release:tensorflow.Summary.Value.metadata)
+  
+  ::tensorflow::SummaryMetadata* temp = _impl_.metadata_;
+  _impl_.metadata_ = nullptr;
+  return temp;
+}
+inline ::tensorflow::SummaryMetadata* Summary_Value::_internal_mutable_metadata() {
+  
+  if (_impl_.metadata_ == nullptr) {
+    auto* p = CreateMaybeMessage<::tensorflow::SummaryMetadata>(GetArenaForAllocation());
+    _impl_.metadata_ = p;
+  }
+  return _impl_.metadata_;
+}
+inline ::tensorflow::SummaryMetadata* Summary_Value::mutable_metadata() {
+  ::tensorflow::SummaryMetadata* _msg = _internal_mutable_metadata();
+  // @@protoc_insertion_point(field_mutable:tensorflow.Summary.Value.metadata)
+  return _msg;
+}
+inline void Summary_Value::set_allocated_metadata(::tensorflow::SummaryMetadata* metadata) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.metadata_;
+  }
+  if (metadata) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(metadata);
+    if (message_arena != submessage_arena) {
+      metadata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, metadata, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.metadata_ = metadata;
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.Summary.Value.metadata)
+}
+
+// float simple_value = 2;
+inline bool Summary_Value::_internal_has_simple_value() const {
+  return value_case() == kSimpleValue;
+}
+inline bool Summary_Value::has_simple_value() const {
+  return _internal_has_simple_value();
+}
+inline void Summary_Value::set_has_simple_value() {
+  _impl_._oneof_case_[0] = kSimpleValue;
+}
+inline void Summary_Value::clear_simple_value() {
+  if (_internal_has_simple_value()) {
+    _impl_.value_.simple_value_ = 0;
+    clear_has_value();
+  }
+}
+inline float Summary_Value::_internal_simple_value() const {
+  if (_internal_has_simple_value()) {
+    return _impl_.value_.simple_value_;
+  }
+  return 0;
+}
+inline void Summary_Value::_internal_set_simple_value(float value) {
+  if (!_internal_has_simple_value()) {
+    clear_value();
+    set_has_simple_value();
+  }
+  _impl_.value_.simple_value_ = value;
+}
+inline float Summary_Value::simple_value() const {
+  // @@protoc_insertion_point(field_get:tensorflow.Summary.Value.simple_value)
+  return _internal_simple_value();
+}
+inline void Summary_Value::set_simple_value(float value) {
+  _internal_set_simple_value(value);
+  // @@protoc_insertion_point(field_set:tensorflow.Summary.Value.simple_value)
+}
+
+// bytes obsolete_old_style_histogram = 3;
+inline bool Summary_Value::_internal_has_obsolete_old_style_histogram() const {
+  return value_case() == kObsoleteOldStyleHistogram;
+}
+inline bool Summary_Value::has_obsolete_old_style_histogram() const {
+  return _internal_has_obsolete_old_style_histogram();
+}
+inline void Summary_Value::set_has_obsolete_old_style_histogram() {
+  _impl_._oneof_case_[0] = kObsoleteOldStyleHistogram;
+}
+inline void Summary_Value::clear_obsolete_old_style_histogram() {
+  if (_internal_has_obsolete_old_style_histogram()) {
+    _impl_.value_.obsolete_old_style_histogram_.Destroy();
+    clear_has_value();
+  }
+}
+inline const std::string& Summary_Value::obsolete_old_style_histogram() const {
+  // @@protoc_insertion_point(field_get:tensorflow.Summary.Value.obsolete_old_style_histogram)
+  return _internal_obsolete_old_style_histogram();
+}
+template <typename ArgT0, typename... ArgT>
+inline void Summary_Value::set_obsolete_old_style_histogram(ArgT0&& arg0, ArgT... args) {
+  if (!_internal_has_obsolete_old_style_histogram()) {
+    clear_value();
+    set_has_obsolete_old_style_histogram();
+    _impl_.value_.obsolete_old_style_histogram_.InitDefault();
+  }
+  _impl_.value_.obsolete_old_style_histogram_.SetBytes( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.Summary.Value.obsolete_old_style_histogram)
+}
+inline std::string* Summary_Value::mutable_obsolete_old_style_histogram() {
+  std::string* _s = _internal_mutable_obsolete_old_style_histogram();
+  // @@protoc_insertion_point(field_mutable:tensorflow.Summary.Value.obsolete_old_style_histogram)
+  return _s;
+}
+inline const std::string& Summary_Value::_internal_obsolete_old_style_histogram() const {
+  if (_internal_has_obsolete_old_style_histogram()) {
+    return _impl_.value_.obsolete_old_style_histogram_.Get();
+  }
+  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void Summary_Value::_internal_set_obsolete_old_style_histogram(const std::string& value) {
+  if (!_internal_has_obsolete_old_style_histogram()) {
+    clear_value();
+    set_has_obsolete_old_style_histogram();
+    _impl_.value_.obsolete_old_style_histogram_.InitDefault();
+  }
+  _impl_.value_.obsolete_old_style_histogram_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Summary_Value::_internal_mutable_obsolete_old_style_histogram() {
+  if (!_internal_has_obsolete_old_style_histogram()) {
+    clear_value();
+    set_has_obsolete_old_style_histogram();
+    _impl_.value_.obsolete_old_style_histogram_.InitDefault();
+  }
+  return _impl_.value_.obsolete_old_style_histogram_.Mutable(      GetArenaForAllocation());
+}
+inline std::string* Summary_Value::release_obsolete_old_style_histogram() {
+  // @@protoc_insertion_point(field_release:tensorflow.Summary.Value.obsolete_old_style_histogram)
+  if (_internal_has_obsolete_old_style_histogram()) {
+    clear_has_value();
+    return _impl_.value_.obsolete_old_style_histogram_.Release();
+  } else {
+    return nullptr;
+  }
+}
+inline void Summary_Value::set_allocated_obsolete_old_style_histogram(std::string* obsolete_old_style_histogram) {
+  if (has_value()) {
+    clear_value();
+  }
+  if (obsolete_old_style_histogram != nullptr) {
+    set_has_obsolete_old_style_histogram();
+    _impl_.value_.obsolete_old_style_histogram_.InitAllocated(obsolete_old_style_histogram, GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.Summary.Value.obsolete_old_style_histogram)
+}
+
+// .tensorflow.Summary.Image image = 4;
+inline bool Summary_Value::_internal_has_image() const {
+  return value_case() == kImage;
+}
+inline bool Summary_Value::has_image() const {
+  return _internal_has_image();
+}
+inline void Summary_Value::set_has_image() {
+  _impl_._oneof_case_[0] = kImage;
+}
+inline void Summary_Value::clear_image() {
+  if (_internal_has_image()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete _impl_.value_.image_;
+    }
+    clear_has_value();
+  }
+}
+inline ::tensorflow::Summary_Image* Summary_Value::release_image() {
+  // @@protoc_insertion_point(field_release:tensorflow.Summary.Value.image)
+  if (_internal_has_image()) {
+    clear_has_value();
+    ::tensorflow::Summary_Image* temp = _impl_.value_.image_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    _impl_.value_.image_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::tensorflow::Summary_Image& Summary_Value::_internal_image() const {
+  return _internal_has_image()
+      ? *_impl_.value_.image_
+      : reinterpret_cast< ::tensorflow::Summary_Image&>(::tensorflow::_Summary_Image_default_instance_);
+}
+inline const ::tensorflow::Summary_Image& Summary_Value::image() const {
+  // @@protoc_insertion_point(field_get:tensorflow.Summary.Value.image)
+  return _internal_image();
+}
+inline ::tensorflow::Summary_Image* Summary_Value::unsafe_arena_release_image() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.Summary.Value.image)
+  if (_internal_has_image()) {
+    clear_has_value();
+    ::tensorflow::Summary_Image* temp = _impl_.value_.image_;
+    _impl_.value_.image_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Summary_Value::unsafe_arena_set_allocated_image(::tensorflow::Summary_Image* image) {
+  clear_value();
+  if (image) {
+    set_has_image();
+    _impl_.value_.image_ = image;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.Summary.Value.image)
+}
+inline ::tensorflow::Summary_Image* Summary_Value::_internal_mutable_image() {
+  if (!_internal_has_image()) {
+    clear_value();
+    set_has_image();
+    _impl_.value_.image_ = CreateMaybeMessage< ::tensorflow::Summary_Image >(GetArenaForAllocation());
+  }
+  return _impl_.value_.image_;
+}
+inline ::tensorflow::Summary_Image* Summary_Value::mutable_image() {
+  ::tensorflow::Summary_Image* _msg = _internal_mutable_image();
+  // @@protoc_insertion_point(field_mutable:tensorflow.Summary.Value.image)
+  return _msg;
+}
+
+// .tensorflow.HistogramProto histo = 5;
+inline bool Summary_Value::_internal_has_histo() const {
+  return value_case() == kHisto;
+}
+inline bool Summary_Value::has_histo() const {
+  return _internal_has_histo();
+}
+inline void Summary_Value::set_has_histo() {
+  _impl_._oneof_case_[0] = kHisto;
+}
+inline ::tensorflow::HistogramProto* Summary_Value::release_histo() {
+  // @@protoc_insertion_point(field_release:tensorflow.Summary.Value.histo)
+  if (_internal_has_histo()) {
+    clear_has_value();
+    ::tensorflow::HistogramProto* temp = _impl_.value_.histo_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    _impl_.value_.histo_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::tensorflow::HistogramProto& Summary_Value::_internal_histo() const {
+  return _internal_has_histo()
+      ? *_impl_.value_.histo_
+      : reinterpret_cast< ::tensorflow::HistogramProto&>(::tensorflow::_HistogramProto_default_instance_);
+}
+inline const ::tensorflow::HistogramProto& Summary_Value::histo() const {
+  // @@protoc_insertion_point(field_get:tensorflow.Summary.Value.histo)
+  return _internal_histo();
+}
+inline ::tensorflow::HistogramProto* Summary_Value::unsafe_arena_release_histo() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.Summary.Value.histo)
+  if (_internal_has_histo()) {
+    clear_has_value();
+    ::tensorflow::HistogramProto* temp = _impl_.value_.histo_;
+    _impl_.value_.histo_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Summary_Value::unsafe_arena_set_allocated_histo(::tensorflow::HistogramProto* histo) {
+  clear_value();
+  if (histo) {
+    set_has_histo();
+    _impl_.value_.histo_ = histo;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.Summary.Value.histo)
+}
+inline ::tensorflow::HistogramProto* Summary_Value::_internal_mutable_histo() {
+  if (!_internal_has_histo()) {
+    clear_value();
+    set_has_histo();
+    _impl_.value_.histo_ = CreateMaybeMessage< ::tensorflow::HistogramProto >(GetArenaForAllocation());
+  }
+  return _impl_.value_.histo_;
+}
+inline ::tensorflow::HistogramProto* Summary_Value::mutable_histo() {
+  ::tensorflow::HistogramProto* _msg = _internal_mutable_histo();
+  // @@protoc_insertion_point(field_mutable:tensorflow.Summary.Value.histo)
+  return _msg;
+}
+
+// .tensorflow.Summary.Audio audio = 6;
+inline bool Summary_Value::_internal_has_audio() const {
+  return value_case() == kAudio;
+}
+inline bool Summary_Value::has_audio() const {
+  return _internal_has_audio();
+}
+inline void Summary_Value::set_has_audio() {
+  _impl_._oneof_case_[0] = kAudio;
+}
+inline void Summary_Value::clear_audio() {
+  if (_internal_has_audio()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete _impl_.value_.audio_;
+    }
+    clear_has_value();
+  }
+}
+inline ::tensorflow::Summary_Audio* Summary_Value::release_audio() {
+  // @@protoc_insertion_point(field_release:tensorflow.Summary.Value.audio)
+  if (_internal_has_audio()) {
+    clear_has_value();
+    ::tensorflow::Summary_Audio* temp = _impl_.value_.audio_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    _impl_.value_.audio_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::tensorflow::Summary_Audio& Summary_Value::_internal_audio() const {
+  return _internal_has_audio()
+      ? *_impl_.value_.audio_
+      : reinterpret_cast< ::tensorflow::Summary_Audio&>(::tensorflow::_Summary_Audio_default_instance_);
+}
+inline const ::tensorflow::Summary_Audio& Summary_Value::audio() const {
+  // @@protoc_insertion_point(field_get:tensorflow.Summary.Value.audio)
+  return _internal_audio();
+}
+inline ::tensorflow::Summary_Audio* Summary_Value::unsafe_arena_release_audio() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.Summary.Value.audio)
+  if (_internal_has_audio()) {
+    clear_has_value();
+    ::tensorflow::Summary_Audio* temp = _impl_.value_.audio_;
+    _impl_.value_.audio_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Summary_Value::unsafe_arena_set_allocated_audio(::tensorflow::Summary_Audio* audio) {
+  clear_value();
+  if (audio) {
+    set_has_audio();
+    _impl_.value_.audio_ = audio;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.Summary.Value.audio)
+}
+inline ::tensorflow::Summary_Audio* Summary_Value::_internal_mutable_audio() {
+  if (!_internal_has_audio()) {
+    clear_value();
+    set_has_audio();
+    _impl_.value_.audio_ = CreateMaybeMessage< ::tensorflow::Summary_Audio >(GetArenaForAllocation());
+  }
+  return _impl_.value_.audio_;
+}
+inline ::tensorflow::Summary_Audio* Summary_Value::mutable_audio() {
+  ::tensorflow::Summary_Audio* _msg = _internal_mutable_audio();
+  // @@protoc_insertion_point(field_mutable:tensorflow.Summary.Value.audio)
+  return _msg;
+}
+
+// .tensorflow.TensorProto tensor = 8;
+inline bool Summary_Value::_internal_has_tensor() const {
+  return value_case() == kTensor;
+}
+inline bool Summary_Value::has_tensor() const {
+  return _internal_has_tensor();
+}
+inline void Summary_Value::set_has_tensor() {
+  _impl_._oneof_case_[0] = kTensor;
+}
+inline ::tensorflow::TensorProto* Summary_Value::release_tensor() {
+  // @@protoc_insertion_point(field_release:tensorflow.Summary.Value.tensor)
+  if (_internal_has_tensor()) {
+    clear_has_value();
+    ::tensorflow::TensorProto* temp = _impl_.value_.tensor_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    _impl_.value_.tensor_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::tensorflow::TensorProto& Summary_Value::_internal_tensor() const {
+  return _internal_has_tensor()
+      ? *_impl_.value_.tensor_
+      : reinterpret_cast< ::tensorflow::TensorProto&>(::tensorflow::_TensorProto_default_instance_);
+}
+inline const ::tensorflow::TensorProto& Summary_Value::tensor() const {
+  // @@protoc_insertion_point(field_get:tensorflow.Summary.Value.tensor)
+  return _internal_tensor();
+}
+inline ::tensorflow::TensorProto* Summary_Value::unsafe_arena_release_tensor() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.Summary.Value.tensor)
+  if (_internal_has_tensor()) {
+    clear_has_value();
+    ::tensorflow::TensorProto* temp = _impl_.value_.tensor_;
+    _impl_.value_.tensor_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Summary_Value::unsafe_arena_set_allocated_tensor(::tensorflow::TensorProto* tensor) {
+  clear_value();
+  if (tensor) {
+    set_has_tensor();
+    _impl_.value_.tensor_ = tensor;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.Summary.Value.tensor)
+}
+inline ::tensorflow::TensorProto* Summary_Value::_internal_mutable_tensor() {
+  if (!_internal_has_tensor()) {
+    clear_value();
+    set_has_tensor();
+    _impl_.value_.tensor_ = CreateMaybeMessage< ::tensorflow::TensorProto >(GetArenaForAllocation());
+  }
+  return _impl_.value_.tensor_;
+}
+inline ::tensorflow::TensorProto* Summary_Value::mutable_tensor() {
+  ::tensorflow::TensorProto* _msg = _internal_mutable_tensor();
+  // @@protoc_insertion_point(field_mutable:tensorflow.Summary.Value.tensor)
+  return _msg;
+}
+
+inline bool Summary_Value::has_value() const {
+  return value_case() != VALUE_NOT_SET;
+}
+inline void Summary_Value::clear_has_value() {
+  _impl_._oneof_case_[0] = VALUE_NOT_SET;
+}
+inline Summary_Value::ValueCase Summary_Value::value_case() const {
+  return Summary_Value::ValueCase(_impl_._oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// Summary
+
+// repeated .tensorflow.Summary.Value value = 1;
+inline int Summary::_internal_value_size() const {
+  return _impl_.value_.size();
+}
+inline int Summary::value_size() const {
+  return _internal_value_size();
+}
+inline void Summary::clear_value() {
+  _impl_.value_.Clear();
+}
+inline ::tensorflow::Summary_Value* Summary::mutable_value(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.Summary.value)
+  return _impl_.value_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::Summary_Value >*
+Summary::mutable_value() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.Summary.value)
+  return &_impl_.value_;
+}
+inline const ::tensorflow::Summary_Value& Summary::_internal_value(int index) const {
+  return _impl_.value_.Get(index);
+}
+inline const ::tensorflow::Summary_Value& Summary::value(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.Summary.value)
+  return _internal_value(index);
+}
+inline ::tensorflow::Summary_Value* Summary::_internal_add_value() {
+  return _impl_.value_.Add();
+}
+inline ::tensorflow::Summary_Value* Summary::add_value() {
+  ::tensorflow::Summary_Value* _add = _internal_add_value();
+  // @@protoc_insertion_point(field_add:tensorflow.Summary.value)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::Summary_Value >&
+Summary::value() const {
+  // @@protoc_insertion_point(field_list:tensorflow.Summary.value)
+  return _impl_.value_;
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace tensorflow
+
+PROTOBUF_NAMESPACE_OPEN
+
+template <> struct is_proto_enum< ::tensorflow::DataClass> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::tensorflow::DataClass>() {
+  return ::tensorflow::DataClass_descriptor();
+}
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fsummary_2eproto
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/summary.proto b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/summary.proto
new file mode 100644
index 0000000000000000000000000000000000000000..c6b515abea25177be459eeb91454ff58d06df377
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/summary.proto
@@ -0,0 +1,133 @@
+syntax = "proto3";
+
+package tensorflow;
+
+import public "tsl/protobuf/histogram.proto";
+
+import "tensorflow/core/framework/tensor.proto";
+
+option cc_enable_arenas = true;
+option java_outer_classname = "SummaryProtos";
+option java_multiple_files = true;
+option java_package = "org.tensorflow.framework";
+option go_package = "github.com/tensorflow/tensorflow/tensorflow/go/core/framework/summary_go_proto";
+
+// Metadata associated with a series of Summary data
+message SummaryDescription {
+  // Hint on how plugins should process the data in this series.
+  // Supported values include "scalar", "histogram", "image", "audio"
+  string type_hint = 1;
+}
+
+// A SummaryMetadata encapsulates information on which plugins are able to make
+// use of a certain summary value.
+message SummaryMetadata {
+  message PluginData {
+    // The name of the plugin this data pertains to.
+    string plugin_name = 1;
+
+    // The content to store for the plugin. The best practice is for this to be
+    // a binary serialized protocol buffer.
+    bytes content = 2;
+  }
+
+  // Data that associates a summary with a certain plugin.
+  PluginData plugin_data = 1;
+
+  // Display name for viewing in TensorBoard.
+  string display_name = 2;
+
+  // Longform readable description of the summary sequence. Markdown supported.
+  string summary_description = 3;
+
+  // Class of data stored in this time series. Required for compatibility with
+  // TensorBoard's generic data facilities (`DataProvider`, et al.). This value
+  // imposes constraints on the dtype and shape of the corresponding tensor
+  // values. See `DataClass` docs for details.
+  DataClass data_class = 4;
+}
+
+enum DataClass {
+  // Unknown data class, used (implicitly) for legacy data. Will not be
+  // processed by data ingestion pipelines.
+  DATA_CLASS_UNKNOWN = 0;
+  // Scalar time series. Each `Value` for the corresponding tag must have
+  // `tensor` set to a rank-0 tensor of type `DT_FLOAT` (float32).
+  DATA_CLASS_SCALAR = 1;
+  // Tensor time series. Each `Value` for the corresponding tag must have
+  // `tensor` set. The tensor value is arbitrary, but should be small to
+  // accommodate direct storage in database backends: an upper bound of a few
+  // kilobytes is a reasonable rule of thumb.
+  DATA_CLASS_TENSOR = 2;
+  // Blob sequence time series. Each `Value` for the corresponding tag must
+  // have `tensor` set to a rank-1 tensor of bytestring dtype.
+  DATA_CLASS_BLOB_SEQUENCE = 3;
+}
+
+// A Summary is a set of named values to be displayed by the
+// visualizer.
+//
+// Summaries are produced regularly during training, as controlled by
+// the "summary_interval_secs" attribute of the training operation.
+// Summaries are also produced at the end of an evaluation.
+message Summary {
+  message Image {
+    // Dimensions of the image.
+    int32 height = 1;
+    int32 width = 2;
+    // Valid colorspace values are
+    //   1 - grayscale
+    //   2 - grayscale + alpha
+    //   3 - RGB
+    //   4 - RGBA
+    //   5 - DIGITAL_YUV
+    //   6 - BGRA
+    int32 colorspace = 3;
+    // Image data in encoded format.  All image formats supported by
+    // image_codec::CoderUtil can be stored here.
+    bytes encoded_image_string = 4;
+  }
+
+  message Audio {
+    // Sample rate of the audio in Hz.
+    float sample_rate = 1;
+    // Number of channels of audio.
+    int64 num_channels = 2;
+    // Length of the audio in frames (samples per channel).
+    int64 length_frames = 3;
+    // Encoded audio data and its associated RFC 2045 content type (e.g.
+    // "audio/wav").
+    bytes encoded_audio_string = 4;
+    string content_type = 5;
+  }
+
+  message Value {
+    // This field is deprecated and will not be set.
+    string node_name = 7;
+
+    // Tag name for the data. Used by TensorBoard plugins to organize data. Tags
+    // are often organized by scope (which contains slashes to convey
+    // hierarchy). For example: foo/bar/0
+    string tag = 1;
+
+    // Contains metadata on the summary value such as which plugins may use it.
+    // Take note that many summary values may lack a metadata field. This is
+    // because the FileWriter only keeps a metadata object on the first summary
+    // value with a certain tag for each tag. TensorBoard then remembers which
+    // tags are associated with which plugins. This saves space.
+    SummaryMetadata metadata = 9;
+
+    // Value associated with the tag.
+    oneof value {
+      float simple_value = 2;
+      bytes obsolete_old_style_histogram = 3;
+      Image image = 4;
+      HistogramProto histo = 5;
+      Audio audio = 6;
+      TensorProto tensor = 8;
+    }
+  }
+
+  // Set of values for the summary.
+  repeated Value value = 1;
+}
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/tensor.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/tensor.h
new file mode 100644
index 0000000000000000000000000000000000000000..dbfc314f253fd8fc1b4070b28a36c6fb2321c3cc
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/tensor.h
@@ -0,0 +1,1096 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_TENSOR_H_
+#define TENSORFLOW_CORE_FRAMEWORK_TENSOR_H_
+
+#include <cstdint>
+#include <iosfwd>
+#include <string>
+#include <type_traits>
+#include <utility>
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/framework/allocator.h"
+#include "tensorflow/core/framework/tensor_shape.h"
+#include "tensorflow/core/framework/tensor_types.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/framework/types.pb.h"
+#include "tensorflow/core/lib/core/refcount.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/lib/core/stringpiece.h"
+#include "tensorflow/core/lib/gtl/inlined_vector.h"
+#include "tensorflow/core/platform/mem.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+
+// Forward declarations.  In particular, we forward declare protos so that their
+// symbols can be removed from .so exports.
+class AllocationDescription;
+class OpKernelContext;
+class Tensor;
+class TensorBuffer;
+class TensorCApi;
+class TensorInterface;
+class TensorCord;
+class TensorDescription;
+class TensorProto;
+class Var;
+
+namespace batch_util {
+Status CopyElementToSlice(Tensor element, Tensor* parent, int64_t index);
+Status CopySliceToElement(const Tensor& parent, Tensor* element, int64_t index);
+Status MaybeMoveSliceToElement(Tensor* parent, Tensor* element, int64_t index);
+Status CopyContiguousSlices(const Tensor& src, int64_t src_offset,
+                            int64_t dst_offset, int64_t num_slices,
+                            Tensor* dst);
+}  // namespace batch_util
+
+/// @ingroup core
+
+/// Interface to access the raw ref-counted data buffer.
+class TensorBuffer : public core::RefCounted {
+ public:
+  explicit TensorBuffer(void* data_ptr) : data_(data_ptr) {}
+  ~TensorBuffer() override {}
+
+  /// \brief data() points to a memory region of size() bytes.
+  ///
+  /// NOTE(mrry): The `data()` method is not virtual for performance reasons.
+  /// It can be called multiple times when the contents of a `Tensor` are
+  /// accessed, and so making it non-virtual allows the body to be inlined.
+  void* data() const { return data_; }
+
+  /// \brief Size (in bytes) of the buffer.
+  virtual size_t size() const = 0;
+
+  /// \brief If this TensorBuffer is sub-buffer of another TensorBuffer,
+  /// returns that TensorBuffer. Otherwise, returns this.
+  virtual TensorBuffer* root_buffer() = 0;
+
+  /// \brief Fills metadata about the allocation into the proto.
+  virtual void FillAllocationDescription(
+      AllocationDescription* proto) const = 0;
+
+  virtual bool GetAllocatedBytes(size_t* out_bytes) const;
+
+  /// \brief Helper method to reinterpret the buffer as an array of `T`.
+  template <typename T>
+  T* base() const {
+    return reinterpret_cast<T*>(data());
+  }
+
+  /// \brief Whether this TensorBuffer owns the underlying memory.
+  virtual bool OwnsMemory() const { return true; }
+
+  /// \brief The type of the underlying memory.
+  virtual AllocatorMemoryType GetMemoryType() const {
+    return AllocatorMemoryType::kUnknown;
+  }
+
+ private:
+  void* const data_;
+};
+
+/// Represents an n-dimensional array of values.
+class Tensor {
+ public:
+  /// \brief Creates a 1-dimensional, 0-element float tensor.
+  ///
+  /// The returned Tensor is not a scalar (shape {}), but is instead
+  /// an empty one-dimensional Tensor (shape {0}, NumElements() ==
+  /// 0). Since it has no elements, it does not need to be assigned a
+  /// value and is initialized by default (IsInitialized() is
+  /// true). If this is undesirable, consider creating a one-element
+  /// scalar which does require initialization:
+  ///
+  /// ```c++
+  ///
+  ///     Tensor(DT_FLOAT, TensorShape({}))
+  ///
+  /// ```
+  Tensor();
+
+  /// \brief Creates a Tensor of the given `type` and `shape`.  If
+  /// LogMemory::IsEnabled() the allocation is logged as coming from
+  /// an unknown kernel and step. Calling the Tensor constructor
+  /// directly from within an Op is deprecated: use the
+  /// OpKernelConstruction/OpKernelContext allocate_* methods to
+  /// allocate a new tensor, which record the kernel and step.
+  ///
+  /// The underlying buffer is allocated using a `CPUAllocator`.
+  Tensor(DataType type, const TensorShape& shape);
+
+  /// \brief Creates a tensor with the input `type` and `shape`, using
+  /// the allocator `a` to allocate the underlying buffer. If
+  /// LogMemory::IsEnabled() the allocation is logged as coming from
+  /// an unknown kernel and step. Calling the Tensor constructor
+  /// directly from within an Op is deprecated: use the
+  /// OpKernelConstruction/OpKernelContext allocate_* methods to
+  /// allocate a new tensor, which record the kernel and step.
+  ///
+  /// `a` must outlive the lifetime of this Tensor.
+  Tensor(Allocator* a, DataType type, const TensorShape& shape);
+
+  /// \brief Creates a tensor with the input `type` and `shape`, using
+  /// the allocator `a` and the specified "allocation_attr" to
+  /// allocate the underlying buffer. If the kernel and step are known
+  /// allocation_attr.allocation_will_be_logged should be set to true
+  /// and LogMemory::RecordTensorAllocation should be called after the
+  /// tensor is constructed. Calling the Tensor constructor directly
+  /// from within an Op is deprecated: use the
+  /// OpKernelConstruction/OpKernelContext allocate_* methods to
+  /// allocate a new tensor, which record the kernel and step.
+  ///
+  /// `a` must outlive the lifetime of this Tensor.
+  Tensor(Allocator* a, DataType type, const TensorShape& shape,
+         const AllocationAttributes& allocation_attr);
+
+  /// \brief Creates a tensor with the input datatype, shape and buf.
+  ///
+  /// Acquires a ref on buf that belongs to this Tensor.
+  Tensor(DataType type, const TensorShape& shape, TensorBuffer* buf);
+
+  /// \brief Creates a tensor with the input datatype, shape and buf.
+  ///
+  /// Takes an ownership of the bufffer from the reference counted pointer.
+  Tensor(DataType type, TensorShape shape, core::RefCountPtr<TensorBuffer> buf);
+
+  /// \brief Creates an empty Tensor of the given data type.
+  ///
+  /// Like Tensor(), returns a 1-dimensional, 0-element Tensor with
+  /// IsInitialized() returning True. See the Tensor() documentation
+  /// for details.
+  explicit Tensor(DataType type);
+
+  /// \brief Initializes a tensor with the input `type` and `shape`, or returns
+  /// an error and leaves `out_tensor` unmodified. This factory method should be
+  /// used instead of the corresponding constructor if calling code cannot
+  /// validate that the `DataType` is valid and supported.
+  ///
+  /// The underlying buffer is allocated using a `CPUAllocator`.
+  static Status BuildTensor(DataType type, const TensorShape& shape,
+                            Tensor* out_tensor);
+
+ private:
+  // A tag type for selecting the `Tensor` constructor overload that creates a
+  // scalar tensor in host memory.
+  struct host_scalar_tag {};
+
+  class HostScalarTensorBufferBase;
+  template <typename T>
+  struct ValueAndTensorBuffer;
+
+  // Creates a tensor with the given scalar `value` in CPU memory.
+  template <typename T>
+  Tensor(T value, host_scalar_tag tag);
+
+ public:
+  // A series of specialized constructors for scalar tensors in host memory.
+  //
+  // NOTE: The `Variant` host-scalar constructor is not defined, because Variant
+  // is implicitly constructible from many different types, and this causes
+  // ambiguities with some compilers.
+  explicit Tensor(float scalar_value)
+      : Tensor(scalar_value, host_scalar_tag{}) {}
+  explicit Tensor(double scalar_value)
+      : Tensor(scalar_value, host_scalar_tag{}) {}
+  explicit Tensor(int32_t scalar_value)
+      : Tensor(scalar_value, host_scalar_tag{}) {}
+  explicit Tensor(uint32 scalar_value)
+      : Tensor(scalar_value, host_scalar_tag{}) {}
+  explicit Tensor(uint16 scalar_value)
+      : Tensor(scalar_value, host_scalar_tag{}) {}
+  explicit Tensor(uint8 scalar_value)
+      : Tensor(scalar_value, host_scalar_tag{}) {}
+  explicit Tensor(int16_t scalar_value)
+      : Tensor(scalar_value, host_scalar_tag{}) {}
+  explicit Tensor(int8_t scalar_value)
+      : Tensor(scalar_value, host_scalar_tag{}) {}
+  explicit Tensor(tstring scalar_value)
+      : Tensor(std::move(scalar_value), host_scalar_tag{}) {}
+  explicit Tensor(complex64 scalar_value)
+      : Tensor(scalar_value, host_scalar_tag{}) {}
+  explicit Tensor(complex128 scalar_value)
+      : Tensor(scalar_value, host_scalar_tag{}) {}
+  explicit Tensor(int64_t scalar_value)
+      : Tensor(scalar_value, host_scalar_tag{}) {}
+  explicit Tensor(uint64 scalar_value)
+      : Tensor(scalar_value, host_scalar_tag{}) {}
+  explicit Tensor(bool scalar_value)
+      : Tensor(scalar_value, host_scalar_tag{}) {}
+  explicit Tensor(qint8 scalar_value)
+      : Tensor(scalar_value, host_scalar_tag{}) {}
+  explicit Tensor(quint8 scalar_value)
+      : Tensor(scalar_value, host_scalar_tag{}) {}
+  explicit Tensor(qint16 scalar_value)
+      : Tensor(scalar_value, host_scalar_tag{}) {}
+  explicit Tensor(quint16 scalar_value)
+      : Tensor(scalar_value, host_scalar_tag{}) {}
+  explicit Tensor(qint32 scalar_value)
+      : Tensor(scalar_value, host_scalar_tag{}) {}
+  explicit Tensor(bfloat16 scalar_value)
+      : Tensor(scalar_value, host_scalar_tag{}) {}
+  explicit Tensor(Eigen::half scalar_value)
+      : Tensor(scalar_value, host_scalar_tag{}) {}
+  explicit Tensor(ResourceHandle scalar_value)
+      : Tensor(std::move(scalar_value), host_scalar_tag{}) {}
+
+  // NOTE: The `const char*` host-scalar constructor is provided as a
+  // convenience because otherwise passing a string literal would surprisingly
+  // construct a DT_BOOL tensor.
+  explicit Tensor(const char* scalar_value)
+      : Tensor(tstring(scalar_value), host_scalar_tag{}) {}
+
+  /// Copy constructor.
+  Tensor(const Tensor& other);
+
+  /// \brief Move constructor. After this call, <other> is safely destructible
+  /// can be assigned to, and IsInitialized() can be called and will return
+  /// false. Other calls on <other> (e.g. shape manipulation) are not valid.
+  Tensor(Tensor&& other);
+
+  // Explicitly delete constructor that take a pointer (except char*)
+  // so that the pointer doesn't get implicitly cast to bool.
+  template <typename T, typename std::enable_if<!std::is_same<T, char>::value,
+                                                T>::type* = nullptr>
+  explicit Tensor(T* t) = delete;
+
+  ~Tensor();
+
+  // I/O operators.
+  friend std::ostream&  // NOLINT: iosfwd
+  operator<<(std::ostream& out, const Tensor& tensor);
+
+  /// Returns the data type.
+  DataType dtype() const { return shape_.data_type(); }
+
+  /// Returns the shape of the tensor.
+  const TensorShape& shape() const { return shape_; }
+
+  /// \brief Convenience accessor for the tensor shape.
+  ///
+  /// For all shape accessors, see comments for relevant methods of
+  /// `TensorShape` in `tensor_shape.h`.
+  int dims() const { return shape().dims(); }
+
+  /// Convenience accessor for the tensor shape.
+  int64_t dim_size(int d) const { return shape().dim_size(d); }
+
+  /// Convenience accessor for the tensor shape.
+  int64_t NumElements() const { return shape().num_elements(); }
+
+  bool IsSameSize(const Tensor& b) const {
+    return shape().IsSameSize(b.shape());
+  }
+
+  // True iff the two tensors use the same underlying refcounted storage
+  bool SharesBufferWith(const Tensor& b) const;
+
+  /// \brief If necessary, has this Tensor been initialized?
+  ///
+  /// Zero-element Tensors are always considered initialized, even if they
+  /// have never been assigned to and do not have any memory allocated.
+  bool IsInitialized() const;
+
+  /// Returns the estimated memory usage of this tensor.
+  size_t TotalBytes() const;
+
+  // Returns the size of allocated memory for this tensor.
+  size_t AllocatedBytes() const;
+
+  /// Returns true iff this tensor is aligned.
+  bool IsAligned() const {
+#if EIGEN_MAX_ALIGN_BYTES == 0
+    return true;
+#else
+    void* ptr = base<void>();
+    return dtype() == DT_STRING || NumElements() == 0 ||
+           (reinterpret_cast<intptr_t>(ptr) % EIGEN_MAX_ALIGN_BYTES == 0);
+#endif
+  }
+
+  /// Assign operator. This tensor shares other's underlying storage.
+  Tensor& operator=(const Tensor& other) {
+    CopyFromInternal(other, other.shape());
+    return *this;
+  }
+
+  /// Move operator.  See move constructor for details.
+  Tensor& operator=(Tensor&& other);
+
+  /// \brief Copy the other tensor into this tensor and reshape it.
+  ///
+  /// This tensor shares other's underlying storage. Returns `true`
+  /// iff `other.shape()` has the same number of elements of the given
+  /// `shape`.
+  bool CopyFrom(const Tensor& other,
+                const TensorShape& shape) TF_MUST_USE_RESULT {
+    if (other.NumElements() != shape.num_elements()) return false;
+    CopyFromInternal(other, shape);
+    return true;
+  }
+
+  /// \brief Slice this tensor along the 1st dimension.
+
+  /// I.e., the returned tensor satisfies
+  ///     returned[i, ...] == this[dim0_start + i, ...].
+  /// The returned tensor shares the underlying tensor buffer with this
+  /// tensor.
+  ///
+  /// NOTE: The returned tensor may not satisfy the same alignment
+  /// requirement as this tensor depending on the shape. The caller
+  /// must check the returned tensor's alignment before calling certain
+  /// methods that have alignment requirement (e.g., `flat()`, `tensor()`).
+  ///
+  /// NOTE: When fed with an N-dimensional tensor, this method returns a tensor
+  /// also with N dimensions. If you want to select a sub tensor, see SubSlice.
+  ///
+  /// REQUIRES: `dims()` >= 1
+  /// REQUIRES: `0 <= dim0_start <= dim0_limit <= dim_size(0)`
+  Tensor Slice(int64_t dim0_start, int64_t dim0_limit) const;
+
+  /// \brief Select a subslice from this tensor along the 1st dimension.
+  ///
+  /// When fed with an N-dimensional tensor, this method returns a tensor with
+  /// N-1 dimensions, where the returned tensor is a subslice of the input
+  /// tensor along the first dimension. The N-1 dimensions of the returned
+  /// tensor are the last N-1 dimensions of the input tensor.
+  ///
+  /// NOTE: The returned tensor may not satisfy the same alignment
+  /// requirement as this tensor depending on the shape. The caller
+  /// must check the returned tensor's alignment before calling certain
+  /// methods that have alignment requirement (e.g., `flat()`, `tensor()`).
+  ///
+  /// REQUIRES: `dims()` >= 1
+  /// REQUIRES: `0 <= index < dim_size(0)`
+  Tensor SubSlice(int64_t index) const;
+
+  /// \brief Parse `other` and construct the tensor.
+
+  /// Returns `true` iff the parsing succeeds. If the parsing fails,
+  /// the state of `*this` is unchanged.
+  bool FromProto(const TensorProto& other) TF_MUST_USE_RESULT;
+  bool FromProto(Allocator* a, const TensorProto& other) TF_MUST_USE_RESULT;
+
+  /// \brief Fills in `proto` with `*this` tensor's content.
+  ///
+  /// `AsProtoField()` fills in the repeated field for `proto.dtype()`, while
+  /// `AsProtoTensorContent()` encodes the content in `proto.tensor_content()`
+  /// in a compact form.
+  void AsProtoField(TensorProto* proto) const;
+  void AsProtoTensorContent(TensorProto* proto) const;
+
+  /// \brief Return the tensor data as an `Eigen::Tensor` with the type and
+  /// sizes of this `Tensor`.
+  ///
+  /// Use these methods when you know the data type and the number of
+  /// dimensions of the Tensor and you want an `Eigen::Tensor`
+  /// automatically sized to the `Tensor` sizes. The implementation check
+  /// fails if either type or sizes mismatch.
+  ///
+  /// Example:
+  ///
+  /// ```c++
+  ///
+  ///     typedef float T;
+  ///     Tensor my_mat(...built with Shape{rows: 3, cols: 5}...);
+  ///     auto mat = my_mat.matrix<T>();    // 2D Eigen::Tensor, 3 x 5.
+  ///     auto mat = my_mat.tensor<T, 2>(); // 2D Eigen::Tensor, 3 x 5.
+  ///     auto vec = my_mat.vec<T>();       // CHECK fails as my_mat is 2D.
+  ///     auto vec = my_mat.tensor<T, 3>(); // CHECK fails as my_mat is 2D.
+  ///     auto mat = my_mat.matrix<int32>();// CHECK fails as type mismatch.
+  ///
+  /// ```
+  template <typename T>
+  typename TTypes<T>::Vec vec() {
+    return tensor<T, 1>();
+  }
+
+  template <typename T>
+  typename TTypes<T>::Matrix matrix() {
+    return tensor<T, 2>();
+  }
+
+  template <typename T, size_t NDIMS>
+  typename TTypes<T, NDIMS>::Tensor tensor() TF_ATTRIBUTE_NOINLINE;
+
+  /// \brief Return the tensor data to an `Eigen::Tensor` with the
+  /// same size but a bitwise cast to the specified dtype `T`.
+  ///
+  /// Using a bitcast is useful for move and copy operations.
+  /// NOTE: this is the same as `tensor()` except a bitcast is allowed.
+  template <typename T, size_t NDIMS>
+  typename TTypes<T, NDIMS>::Tensor bit_casted_tensor();
+
+  /// \brief Return the tensor data to an `Eigen::Tensor` with the
+  /// last dimension elements converted into single elements of a larger type.
+  ///
+  /// For example, this is useful for kernels that can treat NCHW_VECT_C int8
+  /// tensors as NCHW int32 tensors. The sizeof(T) should equal the size of
+  /// the original element type * num elements in the original last dimension.
+  /// NDIMS should be 1 less than the original number of dimensions.
+  template <typename T, size_t NDIMS>
+  typename TTypes<T, NDIMS>::Tensor reinterpret_last_dimension();
+
+  /// \brief Return the tensor data as an `Eigen::Tensor` of the data type and a
+  /// specified shape.
+  ///
+  /// These methods allow you to access the data with the dimensions
+  /// and sizes of your choice.  You do not need to know the number of
+  /// dimensions of the Tensor to call them.  However, they `CHECK` that
+  /// the type matches and the dimensions requested creates an
+  /// `Eigen::Tensor` with the same number of elements as the tensor.
+  ///
+  /// Example:
+  ///
+  /// ```c++
+  ///
+  ///     typedef float T;
+  ///     Tensor my_ten(...built with Shape{planes: 4, rows: 3, cols: 5}...);
+  ///     // 1D Eigen::Tensor, size 60:
+  ///     auto flat = my_ten.flat<T>();
+  ///     // 2D Eigen::Tensor 12 x 5:
+  ///     auto inner = my_ten.flat_inner_dims<T>();
+  ///     // 2D Eigen::Tensor 4 x 15:
+  ///     auto outer = my_ten.shaped<T, 2>({4, 15});
+  ///     // CHECK fails, bad num elements:
+  ///     auto outer = my_ten.shaped<T, 2>({4, 8});
+  ///     // 3D Eigen::Tensor 6 x 5 x 2:
+  ///     auto weird = my_ten.shaped<T, 3>({6, 5, 2});
+  ///     // CHECK fails, type mismatch:
+  ///     auto bad   = my_ten.flat<int32>();
+  ///
+  /// ```
+  template <typename T>
+  typename TTypes<T>::Flat flat();
+
+  template <typename T>
+  typename TTypes<T>::UnalignedFlat unaligned_flat() {
+    return unaligned_shaped<T, 1>({NumElements()});
+  }
+
+  /// Returns the data as an Eigen::Tensor with NDIMS dimensions, collapsing all
+  /// Tensor dimensions but the last NDIMS-1 into the first dimension of the
+  /// result. If NDIMS > dims() then leading dimensions of size 1 will be
+  /// added to make the output rank NDIMS.
+  template <typename T, size_t NDIMS = 2>
+  typename TTypes<T, NDIMS>::Tensor flat_inner_dims();
+
+  /// Returns the data as an Eigen::Tensor with NDIMS dimensions, collapsing all
+  /// Tensor dimensions but the first NDIMS-1 into the last dimension of the
+  /// result. If NDIMS > dims() then trailing dimensions of size 1 will be
+  /// added to make the output rank NDIMS.
+  template <typename T, size_t NDIMS = 2>
+  typename TTypes<T, NDIMS>::Tensor flat_outer_dims();
+
+  /// Returns the data as an Eigen::Tensor with NDIMS dimensions, collapsing the
+  /// first 'begin' Tensor dimensions into the first dimension of the result and
+  /// the Tensor dimensions of the last dims() - 'begin' - NDIMS into the last
+  /// dimension of the result. If 'begin' < 0 then the |'begin'| leading
+  /// dimensions of size 1 will be added. If 'begin' + NDIMS > dims() then
+  /// 'begin' + NDIMS - dims() trailing dimensions of size 1 will be added.
+  template <typename T, size_t NDIMS = 3>
+  typename TTypes<T, NDIMS>::Tensor flat_inner_outer_dims(int64_t begin);
+
+  template <typename T, size_t NDIMS>
+  typename TTypes<T, NDIMS>::Tensor shaped(gtl::ArraySlice<int64_t> new_sizes);
+
+  /// \brief Return the tensor data to an `Eigen::Tensor` with the new
+  /// shape specified in `new_sizes` and cast to a new dtype `T`.
+  ///
+  /// Using a bitcast is useful for move and copy operations.
+  /// The allowed bitcast is the only difference from `shaped()`.
+  template <typename T, size_t NDIMS>
+  typename TTypes<T, NDIMS>::Tensor bit_casted_shaped(
+      gtl::ArraySlice<int64_t> new_sizes);
+
+  template <typename T, size_t NDIMS>
+  typename TTypes<T, NDIMS>::UnalignedTensor unaligned_shaped(
+      gtl::ArraySlice<int64_t> new_sizes);
+
+  /// \brief Return the Tensor data as a `TensorMap` of fixed size 1:
+  /// `TensorMap<TensorFixedSize<T, 1>>`.
+
+  /// Using `scalar()` allows the compiler to perform optimizations as
+  /// the size of the tensor is known at compile time.
+  template <typename T>
+  typename TTypes<T>::Scalar scalar();
+
+  /// Const versions of all the methods above.
+  template <typename T>
+  typename TTypes<T>::ConstVec vec() const {
+    return tensor<T, 1>();
+  }
+
+  template <typename T>
+  typename TTypes<T>::ConstMatrix matrix() const {
+    return tensor<T, 2>();
+  }
+
+  template <typename T, size_t NDIMS>
+  typename TTypes<T, NDIMS>::ConstTensor tensor() const TF_ATTRIBUTE_NOINLINE;
+
+  /// \brief Return the tensor data to an `Eigen::Tensor` with the
+  /// same size but a bitwise cast to the specified dtype `T`.
+  ///
+  /// Using a bitcast is useful for move and copy operations.
+  /// NOTE: this is the same as `tensor()` except a bitcast is allowed.
+  template <typename T, size_t NDIMS>
+  typename TTypes<T, NDIMS>::ConstTensor bit_casted_tensor() const;
+
+  /// \brief Return the tensor data to an `Eigen::Tensor` with the
+  /// last dimension elements converted into single elements of a larger type.
+  ///
+  /// For example, this is useful for kernels that can treat NCHW_VECT_C int8
+  /// tensors as NCHW int32 tensors. The sizeof(T) should equal the size of
+  /// the original element type * num elements in the original last dimension.
+  /// NDIMS should be 1 less than the original number of dimensions.
+  template <typename T, size_t NDIMS>
+  typename TTypes<T, NDIMS>::ConstTensor reinterpret_last_dimension() const;
+
+  template <typename T>
+  typename TTypes<T>::ConstFlat flat() const;
+
+  template <typename T>
+  typename TTypes<T>::UnalignedConstFlat unaligned_flat() const {
+    return unaligned_shaped<T, 1>({NumElements()});
+  }
+
+  template <typename T, size_t NDIMS>
+  typename TTypes<T, NDIMS>::ConstTensor shaped(
+      gtl::ArraySlice<int64_t> new_sizes) const;
+
+  /// \brief Return the tensor data to an `Eigen::Tensor` with the new
+  /// shape specified in `new_sizes` and cast to a new dtype `T`.
+  ///
+  /// Using a bitcast is useful for move and copy operations.
+  /// The allowed bitcast is the only difference from `shaped()`.
+  template <typename T, size_t NDIMS>
+  typename TTypes<T, NDIMS>::ConstTensor bit_casted_shaped(
+      gtl::ArraySlice<int64_t> new_sizes) const;
+
+  template <typename T, size_t NDIMS>
+  typename TTypes<T, NDIMS>::UnalignedConstTensor unaligned_shaped(
+      gtl::ArraySlice<int64_t> new_sizes) const;
+
+  template <typename T>
+  typename TTypes<T>::ConstScalar scalar() const;
+
+  template <typename T, size_t NDIMS = 2>
+  typename TTypes<T, NDIMS>::ConstTensor flat_inner_dims() const;
+
+  template <typename T, size_t NDIMS = 2>
+  typename TTypes<T, NDIMS>::ConstTensor flat_outer_dims() const;
+
+  template <typename T, size_t NDIMS = 3>
+  typename TTypes<T, NDIMS>::ConstTensor flat_inner_outer_dims(
+      int64_t begin) const;
+
+  /// Render the first `max_entries` values in `*this` into a string.
+  std::string SummarizeValue(int64_t max_entries, bool print_v2 = false) const;
+
+  /// A human-readable summary of the tensor suitable for debugging.
+  // `num_values` is the number of actual data values in the tensor
+  // included in the message. If the tensor might be resident in
+  // GPU/TPU memory use DeviceSafeDebugString instead.
+  std::string DebugString(int num_values) const;
+  std::string DebugString() const { return DebugString(3); }
+
+  // Variant of DebugString() that should be used for possibly non-CPU tensors.
+  // If the tensor is not resident on CPU, we can't read its values as
+  // DebugString() does.
+  std::string DeviceSafeDebugString() const;
+
+  /// Fill in the `TensorDescription` proto with metadata about the
+  /// tensor that is useful for monitoring and debugging.
+  void FillDescription(TensorDescription* description) const;
+
+  /// \brief Returns a `StringPiece` mapping the current tensor's buffer.
+  ///
+  /// The returned `StringPiece` may point to memory location on devices
+  /// that the CPU cannot address directly.
+  ///
+  /// NOTE: The underlying tensor buffer is refcounted, so the lifetime
+  /// of the contents mapped by the `StringPiece` matches the lifetime of
+  /// the buffer; callers should arrange to make sure the buffer does
+  /// not get destroyed while the `StringPiece` is still used.
+  ///
+  /// REQUIRES: `DataTypeCanUseMemcpy(dtype())`.
+  StringPiece tensor_data() const;
+  void* data() const;
+
+  /// Copy the other tensor into this tensor, reshape it and reinterpret the
+  /// buffer's datatype. If an ok Status is returned, the two tensors now share
+  /// the same underlying storage.
+  ///
+  /// This call requires that the `other` tensor and the given type and shape
+  /// are "compatible" (i.e. they occupy the same number of bytes).
+  ///
+  /// Specifically:
+  ///
+  /// shape.num_elements() * DataTypeSize(type)
+  ///
+  /// must equal
+  ///
+  /// other.num_elements() * DataTypeSize(other.dtype())
+  ///
+  /// In addition, this function requires:
+  ///   * DataTypeSize(other.dtype()) != 0
+  ///   * DataTypeSize(type) != 0
+  ///
+  /// If any of the requirements are not met, errors::InvalidArgument is
+  /// returned.
+  Status BitcastFrom(const Tensor& other, DataType dtype,
+                     const TensorShape& shape);
+
+  /// Like BitcastFrom, but CHECK fails if any preconditions are not met.
+  ///
+  /// Deprecated. Use BitcastFrom instead and check the returned Status.
+  void UnsafeCopyFromInternal(const Tensor& other, DataType dtype,
+                              const TensorShape& shape) {
+    TF_CHECK_OK(BitcastFrom(other, dtype, shape));
+  }
+
+  // Returns true if the refcount on buf_ and any possible underlying root
+  // buffer is one.
+  bool RefCountIsOne() const;
+
+  // Experimental. Returns the refcount on buf_ if it points to a regular
+  // TensorBuffer. If buf_ points to a SubBuffer, returns -1.
+  int RefCount() const;
+
+  // Returns the type of the underlying memory.
+  AllocatorMemoryType GetMemoryType() const { return buf_->GetMemoryType(); }
+
+ private:
+  void CheckType(DataType expected_dtype) const;
+  void CheckTypeAndIsAligned(DataType expected_dtype) const;
+  void CheckIsAlignedAndSingleElement() const;
+  void set_dtype(DataType t) { shape_.set_data_type(t); }
+
+  // TensorShape's InlineVector.
+  static gtl::InlinedVector<int64_t, 4> ComputeFlatInnerDims(
+      gtl::ArraySlice<int64_t> orig, int64_t num_out_dims);
+  static gtl::InlinedVector<int64_t, 4> ComputeFlatOuterDims(
+      gtl::ArraySlice<int64_t> orig, int64_t num_out_dims);
+
+  TensorShape shape_;
+  TensorBuffer* buf_;
+
+  friend class DMAHelper;             // For access to buf_.
+  friend class TensorCApi;            // For access to buf_.
+  friend class TensorCord;            // For access to buf_.
+  friend class TensorReference;       // For access to buf_.
+  friend class VariableOp;            // For access to set_shape.
+  friend class AutoReloadVariableOp;  // For access to set_shape.
+  friend class TensorTestHelper;      // For access to set_shape.
+  friend class TensorInterface;       // For access to set_shape.
+  friend class CastOpBase;            // For access to set_dtype.
+  friend class ScopedAllocator;       // For access to buf_.
+  friend class PjRtTensorBufferUtil;  // For access to buf_.
+  friend Status batch_util::CopyElementToSlice(
+      Tensor element, Tensor* parent,
+      int64_t index);  // For access to base<T>().
+  friend Status batch_util::CopySliceToElement(
+      const Tensor& parent, Tensor* element,
+      int64_t index);  // For access to base<T>().
+  friend Status batch_util::MaybeMoveSliceToElement(
+      Tensor* parent, Tensor* element,
+      int64_t index);  // For access to base<T>().
+  friend Status batch_util::CopyContiguousSlices(
+      const Tensor& src, int64_t src_offset, int64_t dst_offset,
+      int64_t num_slices,
+      Tensor* dst);  // For access to base<T>().
+
+  bool CanUseDMA() const;
+
+  // Only needed by variable op to set the shape of an uninitialized
+  // Tensor.
+  // TODO: Remove this when we have a better story for detecting
+  // uninitialized tensors.
+  void set_shape(const TensorShape& shape) {
+    DataType dt = dtype();
+    shape_ = shape;
+    set_dtype(dt);
+  }
+
+  inline void CopyFromInternal(const Tensor& other, const TensorShape& shape) {
+    DCHECK_EQ(shape.num_elements(), other.NumElements());
+    // Data type will be overwritten if this == &other, since dtype is part of
+    // shape.
+    DataType other_dtype = other.dtype();
+    shape_ = shape;
+    set_dtype(other_dtype);
+    if (buf_ != other.buf_) {
+      if (buf_) buf_->Unref();
+      buf_ = other.buf_;
+      if (buf_) buf_->Ref();
+    }
+  }
+
+  template <typename T>
+  T* base() const;
+
+  template <size_t NDIMS>
+  void FillDimsAndValidateCompatibleShape(
+      gtl::ArraySlice<int64_t> new_sizes,
+      Eigen::array<Eigen::DenseIndex, NDIMS>* dims) const;
+
+  template <typename T, size_t NDIMS>
+  void FillDimsAndValidateCompatibleShape(
+      gtl::ArraySlice<int64_t> new_sizes,
+      Eigen::array<Eigen::DenseIndex, NDIMS>* dims) const;
+};
+
+// Implementation details
+
+// START_SKIP_DOXYGEN
+
+template <typename T>
+T* Tensor::base() const {
+  return buf_ == nullptr ? nullptr : buf_->base<T>();
+}
+
+// This routine is defined out of line for code-space savings
+template <typename T, size_t NDIMS>
+typename TTypes<T, NDIMS>::Tensor Tensor::tensor() {
+  CheckTypeAndIsAligned(DataTypeToEnum<T>::v());
+  return typename TTypes<T, NDIMS>::Tensor(base<T>(),
+                                           shape().AsEigenDSizes<NDIMS>());
+}
+
+// This routine is defined out of line for code-space savings
+template <typename T, size_t NDIMS>
+typename TTypes<T, NDIMS>::ConstTensor Tensor::tensor() const {
+  CheckTypeAndIsAligned(DataTypeToEnum<T>::v());
+  return typename TTypes<T, NDIMS>::ConstTensor(base<const T>(),
+                                                shape().AsEigenDSizes<NDIMS>());
+}
+
+template <typename T, size_t NDIMS>
+typename TTypes<T, NDIMS>::Tensor Tensor::bit_casted_tensor() {
+  CHECK(IsAligned());
+  return typename TTypes<T, NDIMS>::Tensor(base<T>(),
+                                           shape().AsEigenDSizes<NDIMS>());
+}
+
+template <typename T, size_t NDIMS>
+typename TTypes<T, NDIMS>::ConstTensor Tensor::bit_casted_tensor() const {
+  CHECK(IsAligned());
+  return typename TTypes<T, NDIMS>::ConstTensor(base<const T>(),
+                                                shape().AsEigenDSizes<NDIMS>());
+}
+
+template <typename T, size_t NDIMS>
+typename TTypes<T, NDIMS>::Tensor Tensor::reinterpret_last_dimension() {
+  if (NDIMS == dims()) {
+    return tensor<T, NDIMS>();
+  }
+  CHECK(IsAligned());
+  CHECK_EQ(static_cast<int>(NDIMS), dims() - 1);
+  CHECK_EQ(static_cast<int64_t>(sizeof(T)),
+           shape_.dim_sizes()[NDIMS] * DataTypeSize(dtype()));
+  Eigen::array<Eigen::DenseIndex, NDIMS> dims;
+  for (int d = 0; d < NDIMS; ++d) {
+    dims[d] = shape_.dim_sizes()[d];
+  }
+  return typename TTypes<T, NDIMS>::Tensor(base<T>(), dims);
+}
+
+template <typename T, size_t NDIMS>
+typename TTypes<T, NDIMS>::ConstTensor Tensor::reinterpret_last_dimension()
+    const {
+  if (NDIMS == dims()) {
+    return tensor<T, NDIMS>();
+  }
+  CHECK(IsAligned());
+  CHECK_EQ(static_cast<int>(NDIMS), dims() - 1);
+  CHECK_EQ(static_cast<int64_t>(sizeof(T)),
+           shape_.dim_sizes()[NDIMS] * DataTypeSize(dtype()));
+  Eigen::array<Eigen::DenseIndex, NDIMS> dims;
+  for (int d = 0; d < NDIMS; ++d) {
+    dims[d] = shape_.dim_sizes()[d];
+  }
+  return typename TTypes<T, NDIMS>::ConstTensor(base<const T>(), dims);
+}
+
+template <size_t NDIMS>
+void Tensor::FillDimsAndValidateCompatibleShape(
+    gtl::ArraySlice<int64_t> new_sizes,
+    Eigen::array<Eigen::DenseIndex, NDIMS>* dims) const {
+  CHECK_EQ(NDIMS, new_sizes.size());
+  int64_t new_num_elements = 1;
+  for (size_t d = 0; d < NDIMS; d++) {
+    new_num_elements *= new_sizes[d];
+    (*dims)[d] = new_sizes[d];
+  }
+  CHECK_EQ(new_num_elements, NumElements());
+}
+
+template <typename T, size_t NDIMS>
+void Tensor::FillDimsAndValidateCompatibleShape(
+    gtl::ArraySlice<int64_t> new_sizes,
+    Eigen::array<Eigen::DenseIndex, NDIMS>* dims) const {
+  CHECK_EQ(NDIMS, new_sizes.size());
+  int64_t new_num_elements = 1;
+  for (size_t d = 0; d < NDIMS; d++) {
+    new_num_elements *= new_sizes[d];
+    (*dims)[d] = new_sizes[d];
+  }
+  const int element_size = DataTypeSize(BaseType(dtype()));
+  if (element_size > 0) {
+    CHECK_EQ(new_num_elements * static_cast<int64_t>(sizeof(T)),
+             NumElements() * element_size);
+  } else {
+    // DataTypeSize() returns 0 for some data types. In this case, assume that T
+    // has the same size as the buffer type.
+    // NOTE: If we can be sure that DataTypeSize() does not return 0 for all POD
+    // types, then we should check DataTypeToEnum<T>::v() == dtype(). Or simply
+    // check if `element_size > 0` to err when bit cast is attempted on Tensor
+    // of unknown data type size.
+    CHECK_EQ(new_num_elements, NumElements());
+  }
+}
+
+template <typename T>
+typename TTypes<T>::Flat Tensor::flat() {
+  // Equivalent to 'return shaped<T, 1>({NumElements()});'
+  CheckTypeAndIsAligned(DataTypeToEnum<T>::v());
+  Eigen::array<Eigen::DenseIndex, 1> dims;
+  dims[0] = NumElements();
+  return typename TTypes<T, 1>::Tensor(base<T>(), dims);
+}
+
+template <typename T>
+typename TTypes<T>::ConstFlat Tensor::flat() const {
+  // Equuivalent to 'return shaped<T, 1>({NumElements()});'
+  CheckTypeAndIsAligned(DataTypeToEnum<T>::v());
+  Eigen::array<Eigen::DenseIndex, 1> dims;
+  dims[0] = NumElements();
+  return typename TTypes<T, 1>::ConstTensor(base<T>(), dims);
+}
+
+template <typename T, size_t NDIMS>
+typename TTypes<T, NDIMS>::Tensor Tensor::shaped(
+    gtl::ArraySlice<int64_t> new_sizes) {
+  CheckTypeAndIsAligned(DataTypeToEnum<T>::v());
+  Eigen::array<Eigen::DenseIndex, NDIMS> dims;
+  FillDimsAndValidateCompatibleShape(new_sizes, &dims);
+  return typename TTypes<T, NDIMS>::Tensor(base<T>(), dims);
+}
+
+template <typename T, size_t NDIMS>
+typename TTypes<T, NDIMS>::Tensor Tensor::bit_casted_shaped(
+    gtl::ArraySlice<int64_t> new_sizes) {
+  CHECK(IsAligned());
+  Eigen::array<Eigen::DenseIndex, NDIMS> dims;
+  FillDimsAndValidateCompatibleShape<T>(new_sizes, &dims);
+  return typename TTypes<T, NDIMS>::Tensor(base<T>(), dims);
+}
+
+template <typename T, size_t NDIMS>
+typename TTypes<T, NDIMS>::UnalignedTensor Tensor::unaligned_shaped(
+    gtl::ArraySlice<int64_t> new_sizes) {
+  CheckType(DataTypeToEnum<T>::v());
+  Eigen::array<Eigen::DenseIndex, NDIMS> dims;
+  FillDimsAndValidateCompatibleShape(new_sizes, &dims);
+  return typename TTypes<T, NDIMS>::UnalignedTensor(base<T>(), dims);
+}
+
+template <typename T, size_t NDIMS>
+typename TTypes<T, NDIMS>::ConstTensor Tensor::shaped(
+    gtl::ArraySlice<int64_t> new_sizes) const {
+  CheckType(DataTypeToEnum<T>::v());
+  CHECK(IsAligned()) << "ptr = " << base<void>();
+  Eigen::array<Eigen::DenseIndex, NDIMS> dims;
+  FillDimsAndValidateCompatibleShape(new_sizes, &dims);
+  return typename TTypes<T, NDIMS>::ConstTensor(base<T>(), dims);
+}
+
+template <typename T, size_t NDIMS>
+typename TTypes<T, NDIMS>::ConstTensor Tensor::bit_casted_shaped(
+    gtl::ArraySlice<int64_t> new_sizes) const {
+  CHECK(IsAligned());
+  Eigen::array<Eigen::DenseIndex, NDIMS> dims;
+  FillDimsAndValidateCompatibleShape<T>(new_sizes, &dims);
+  return typename TTypes<T, NDIMS>::ConstTensor(base<T>(), dims);
+}
+
+template <typename T, size_t NDIMS>
+typename TTypes<T, NDIMS>::UnalignedConstTensor Tensor::unaligned_shaped(
+    gtl::ArraySlice<int64_t> new_sizes) const {
+  CheckType(DataTypeToEnum<T>::v());
+  Eigen::array<Eigen::DenseIndex, NDIMS> dims;
+  FillDimsAndValidateCompatibleShape(new_sizes, &dims);
+  return typename TTypes<T, NDIMS>::UnalignedConstTensor(base<T>(), dims);
+}
+
+template <typename T>
+typename TTypes<T>::Scalar Tensor::scalar() {
+  static_assert(
+      !std::is_same<T, std::string>::value,
+      "std::string is no longer a scalar type, use tensorflow::tstring");
+  CheckIsAlignedAndSingleElement();
+  return typename TTypes<T>::Scalar(base<T>());
+}
+
+template <typename T>
+typename TTypes<T>::ConstScalar Tensor::scalar() const {
+  static_assert(
+      !std::is_same<T, std::string>::value,
+      "std::string is no longer a scalar type, use tensorflow::tstring");
+  CheckIsAlignedAndSingleElement();
+  return typename TTypes<T>::ConstScalar(base<T>());
+}
+
+template <typename T, size_t NDIMS>
+typename TTypes<T, NDIMS>::Tensor Tensor::flat_inner_dims() {
+  return shaped<T, NDIMS>(ComputeFlatInnerDims(shape_.dim_sizes(), NDIMS));
+}
+
+template <typename T, size_t NDIMS>
+typename TTypes<T, NDIMS>::Tensor Tensor::flat_outer_dims() {
+  return shaped<T, NDIMS>(ComputeFlatOuterDims(shape_.dim_sizes(), NDIMS));
+}
+
+template <typename T, size_t NDIMS>
+typename TTypes<T, NDIMS>::Tensor Tensor::flat_inner_outer_dims(int64_t begin) {
+  gtl::InlinedVector<int64_t, 4> flat_outer =
+      ComputeFlatOuterDims(shape_.dim_sizes(), begin + NDIMS);
+  return shaped<T, NDIMS>(ComputeFlatInnerDims(flat_outer, NDIMS));
+}
+
+template <typename T, size_t NDIMS>
+typename TTypes<T, NDIMS>::ConstTensor Tensor::flat_inner_dims() const {
+  return shaped<T, NDIMS>(ComputeFlatInnerDims(shape_.dim_sizes(), NDIMS));
+}
+
+template <typename T, size_t NDIMS>
+typename TTypes<T, NDIMS>::ConstTensor Tensor::flat_outer_dims() const {
+  return shaped<T, NDIMS>(ComputeFlatOuterDims(shape_.dim_sizes(), NDIMS));
+}
+
+template <typename T, size_t NDIMS>
+typename TTypes<T, NDIMS>::ConstTensor Tensor::flat_inner_outer_dims(
+    int64_t begin) const {
+  gtl::InlinedVector<int64_t, 4> flat_outer =
+      ComputeFlatOuterDims(shape_.dim_sizes(), begin + NDIMS);
+  return shaped<T, NDIMS>(ComputeFlatInnerDims(flat_outer, NDIMS));
+}
+
+inline Tensor::Tensor(const Tensor& other)
+    : shape_(other.shape()), buf_(other.buf_) {
+  if (buf_) buf_->Ref();
+}
+
+inline Tensor::Tensor(Tensor&& other)
+    : shape_(std::move(other.shape_)), buf_(other.buf_) {
+  other.buf_ = nullptr;
+}
+
+class Tensor::HostScalarTensorBufferBase : public TensorBuffer {
+ public:
+  using TensorBuffer::TensorBuffer;
+  bool GetAllocatedBytes(size_t* out_bytes) const final;
+  void FillAllocationDescription(AllocationDescription* proto) const final;
+};
+
+// A packed representation for a single scalar value of type `T`, and a
+// `TensorBuffer` implementation that describes (and manages the lifetime of)
+// that value.
+template <typename T>
+struct Tensor::ValueAndTensorBuffer {
+  class HostScalarTensorBuffer : public Tensor::HostScalarTensorBufferBase {
+   public:
+    explicit HostScalarTensorBuffer(void* data)
+        : HostScalarTensorBufferBase(data) {}
+    size_t size() const final { return sizeof(T); }
+    TensorBuffer* root_buffer() final { return this; }
+
+    // Override `operator delete` so that calling `delete this` in
+    // `core::Refcounted::Unref()` for an object of this type will free
+    // the enclosing `ValueAndTensorBuffer` for the tensor buffer.
+    //
+    // NOTE(mrry): The definition of this method must be outside the class
+    // definition in order to satisfy some compilers.
+    static void operator delete(void* ptr);
+
+    static void operator delete(void*, void*) {
+      // Some compilers require an overridden class-specific deallocation
+      // function, which will be called if placement `new` throws an
+      // exception.
+    }
+
+   private:
+    ~HostScalarTensorBuffer() override { static_cast<T*>(data())->~T(); }
+  };
+
+  T value;
+  HostScalarTensorBuffer tensor_buffer;
+};
+
+/* static */
+template <typename T>
+void Tensor::ValueAndTensorBuffer<T>::HostScalarTensorBuffer::operator delete(
+    void* ptr) {
+  // Use a dummy object to compute to offset of
+  // `ValueAndTensorBuffer::tensor_buffer`, because `offsetof()` is not
+  // necessarily defined on this non-POD type (until C++17).
+  //
+  // NOTE(mrry): Using `sizeof(Tensor::ValueAndTensorBuffer<T>)` here requires
+  // us to define this method outside the class definition, so that it is not
+  // considered an incomplete type.
+  typename std::aligned_storage<sizeof(Tensor::ValueAndTensorBuffer<T>),
+                                alignof(Tensor::ValueAndTensorBuffer<T>)>::type
+      dummy_storage_;
+  Tensor::ValueAndTensorBuffer<T>* dummy_object =
+      reinterpret_cast<Tensor::ValueAndTensorBuffer<T>*>(&dummy_storage_);
+  intptr_t offset = reinterpret_cast<intptr_t>(&dummy_object->tensor_buffer) -
+                    reinterpret_cast<intptr_t>(dummy_object);
+
+  port::AlignedFree(static_cast<char*>(ptr) - offset);
+}
+
+template <typename T>
+Tensor::Tensor(T value, host_scalar_tag tag) {
+  auto* value_and_buf = static_cast<Tensor::ValueAndTensorBuffer<T>*>(
+      port::AlignedMalloc(sizeof(typename Tensor::ValueAndTensorBuffer<T>),
+                          EIGEN_MAX_ALIGN_BYTES));
+  new (&value_and_buf->value) T(std::move(value));
+  new (&value_and_buf->tensor_buffer)
+      typename Tensor::ValueAndTensorBuffer<T>::HostScalarTensorBuffer(
+          value_and_buf);
+  buf_ = &value_and_buf->tensor_buffer;
+  set_dtype(DataTypeToEnum<T>::value);
+}
+
+inline Tensor& Tensor::operator=(Tensor&& other) {
+  // Avoid self-assignment, since we might destroy our underlying buffer.
+  if (&other != this) {
+    shape_ = std::move(other.shape_);
+    if (buf_) buf_->Unref();
+    buf_ = other.buf_;
+    other.buf_ = nullptr;
+  }
+  return *this;
+}
+
+// END_SKIP_DOXYGEN
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_TENSOR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/tensor.pb.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/tensor.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..6979353c5fe47f9db7b7f7feabe73cefb3a83bc8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/tensor.pb.h
@@ -0,0 +1,1790 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: tensorflow/core/framework/tensor.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2ftensor_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2ftensor_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3021000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3021009 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+#include "tensorflow/core/framework/resource_handle.pb.h"
+#include "tensorflow/core/framework/tensor_shape.pb.h"
+#include "tensorflow/core/framework/types.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_tensorflow_2fcore_2fframework_2ftensor_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_tensorflow_2fcore_2fframework_2ftensor_2eproto {
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_tensorflow_2fcore_2fframework_2ftensor_2eproto;
+namespace tensorflow {
+class TensorProto;
+struct TensorProtoDefaultTypeInternal;
+extern TensorProtoDefaultTypeInternal _TensorProto_default_instance_;
+class VariantTensorDataProto;
+struct VariantTensorDataProtoDefaultTypeInternal;
+extern VariantTensorDataProtoDefaultTypeInternal _VariantTensorDataProto_default_instance_;
+}  // namespace tensorflow
+PROTOBUF_NAMESPACE_OPEN
+template<> ::tensorflow::TensorProto* Arena::CreateMaybeMessage<::tensorflow::TensorProto>(Arena*);
+template<> ::tensorflow::VariantTensorDataProto* Arena::CreateMaybeMessage<::tensorflow::VariantTensorDataProto>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace tensorflow {
+
+// ===================================================================
+
+class TensorProto final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.TensorProto) */ {
+ public:
+  inline TensorProto() : TensorProto(nullptr) {}
+  ~TensorProto() override;
+  explicit PROTOBUF_CONSTEXPR TensorProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  TensorProto(const TensorProto& from);
+  TensorProto(TensorProto&& from) noexcept
+    : TensorProto() {
+    *this = ::std::move(from);
+  }
+
+  inline TensorProto& operator=(const TensorProto& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline TensorProto& operator=(TensorProto&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const TensorProto& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const TensorProto* internal_default_instance() {
+    return reinterpret_cast<const TensorProto*>(
+               &_TensorProto_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(TensorProto& a, TensorProto& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(TensorProto* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(TensorProto* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  TensorProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<TensorProto>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const TensorProto& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const TensorProto& from) {
+    TensorProto::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(TensorProto* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.TensorProto";
+  }
+  protected:
+  explicit TensorProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kFloatValFieldNumber = 5,
+    kDoubleValFieldNumber = 6,
+    kIntValFieldNumber = 7,
+    kStringValFieldNumber = 8,
+    kScomplexValFieldNumber = 9,
+    kInt64ValFieldNumber = 10,
+    kBoolValFieldNumber = 11,
+    kDcomplexValFieldNumber = 12,
+    kHalfValFieldNumber = 13,
+    kResourceHandleValFieldNumber = 14,
+    kVariantValFieldNumber = 15,
+    kUint32ValFieldNumber = 16,
+    kUint64ValFieldNumber = 17,
+    kTensorContentFieldNumber = 4,
+    kFloat8ValFieldNumber = 18,
+    kTensorShapeFieldNumber = 2,
+    kDtypeFieldNumber = 1,
+    kVersionNumberFieldNumber = 3,
+  };
+  // repeated float float_val = 5 [packed = true];
+  int float_val_size() const;
+  private:
+  int _internal_float_val_size() const;
+  public:
+  void clear_float_val();
+  private:
+  float _internal_float_val(int index) const;
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
+      _internal_float_val() const;
+  void _internal_add_float_val(float value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
+      _internal_mutable_float_val();
+  public:
+  float float_val(int index) const;
+  void set_float_val(int index, float value);
+  void add_float_val(float value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
+      float_val() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
+      mutable_float_val();
+
+  // repeated double double_val = 6 [packed = true];
+  int double_val_size() const;
+  private:
+  int _internal_double_val_size() const;
+  public:
+  void clear_double_val();
+  private:
+  double _internal_double_val(int index) const;
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
+      _internal_double_val() const;
+  void _internal_add_double_val(double value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
+      _internal_mutable_double_val();
+  public:
+  double double_val(int index) const;
+  void set_double_val(int index, double value);
+  void add_double_val(double value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
+      double_val() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
+      mutable_double_val();
+
+  // repeated int32 int_val = 7 [packed = true];
+  int int_val_size() const;
+  private:
+  int _internal_int_val_size() const;
+  public:
+  void clear_int_val();
+  private:
+  int32_t _internal_int_val(int index) const;
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+      _internal_int_val() const;
+  void _internal_add_int_val(int32_t value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+      _internal_mutable_int_val();
+  public:
+  int32_t int_val(int index) const;
+  void set_int_val(int index, int32_t value);
+  void add_int_val(int32_t value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+      int_val() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+      mutable_int_val();
+
+  // repeated bytes string_val = 8;
+  int string_val_size() const;
+  private:
+  int _internal_string_val_size() const;
+  public:
+  void clear_string_val();
+  const std::string& string_val(int index) const;
+  std::string* mutable_string_val(int index);
+  void set_string_val(int index, const std::string& value);
+  void set_string_val(int index, std::string&& value);
+  void set_string_val(int index, const char* value);
+  void set_string_val(int index, const void* value, size_t size);
+  std::string* add_string_val();
+  void add_string_val(const std::string& value);
+  void add_string_val(std::string&& value);
+  void add_string_val(const char* value);
+  void add_string_val(const void* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& string_val() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_string_val();
+  private:
+  const std::string& _internal_string_val(int index) const;
+  std::string* _internal_add_string_val();
+  public:
+
+  // repeated float scomplex_val = 9 [packed = true];
+  int scomplex_val_size() const;
+  private:
+  int _internal_scomplex_val_size() const;
+  public:
+  void clear_scomplex_val();
+  private:
+  float _internal_scomplex_val(int index) const;
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
+      _internal_scomplex_val() const;
+  void _internal_add_scomplex_val(float value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
+      _internal_mutable_scomplex_val();
+  public:
+  float scomplex_val(int index) const;
+  void set_scomplex_val(int index, float value);
+  void add_scomplex_val(float value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
+      scomplex_val() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
+      mutable_scomplex_val();
+
+  // repeated int64 int64_val = 10 [packed = true];
+  int int64_val_size() const;
+  private:
+  int _internal_int64_val_size() const;
+  public:
+  void clear_int64_val();
+  private:
+  int64_t _internal_int64_val(int index) const;
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
+      _internal_int64_val() const;
+  void _internal_add_int64_val(int64_t value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
+      _internal_mutable_int64_val();
+  public:
+  int64_t int64_val(int index) const;
+  void set_int64_val(int index, int64_t value);
+  void add_int64_val(int64_t value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
+      int64_val() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
+      mutable_int64_val();
+
+  // repeated bool bool_val = 11 [packed = true];
+  int bool_val_size() const;
+  private:
+  int _internal_bool_val_size() const;
+  public:
+  void clear_bool_val();
+  private:
+  bool _internal_bool_val(int index) const;
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >&
+      _internal_bool_val() const;
+  void _internal_add_bool_val(bool value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >*
+      _internal_mutable_bool_val();
+  public:
+  bool bool_val(int index) const;
+  void set_bool_val(int index, bool value);
+  void add_bool_val(bool value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >&
+      bool_val() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >*
+      mutable_bool_val();
+
+  // repeated double dcomplex_val = 12 [packed = true];
+  int dcomplex_val_size() const;
+  private:
+  int _internal_dcomplex_val_size() const;
+  public:
+  void clear_dcomplex_val();
+  private:
+  double _internal_dcomplex_val(int index) const;
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
+      _internal_dcomplex_val() const;
+  void _internal_add_dcomplex_val(double value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
+      _internal_mutable_dcomplex_val();
+  public:
+  double dcomplex_val(int index) const;
+  void set_dcomplex_val(int index, double value);
+  void add_dcomplex_val(double value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
+      dcomplex_val() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
+      mutable_dcomplex_val();
+
+  // repeated int32 half_val = 13 [packed = true];
+  int half_val_size() const;
+  private:
+  int _internal_half_val_size() const;
+  public:
+  void clear_half_val();
+  private:
+  int32_t _internal_half_val(int index) const;
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+      _internal_half_val() const;
+  void _internal_add_half_val(int32_t value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+      _internal_mutable_half_val();
+  public:
+  int32_t half_val(int index) const;
+  void set_half_val(int index, int32_t value);
+  void add_half_val(int32_t value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+      half_val() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+      mutable_half_val();
+
+  // repeated .tensorflow.ResourceHandleProto resource_handle_val = 14;
+  int resource_handle_val_size() const;
+  private:
+  int _internal_resource_handle_val_size() const;
+  public:
+  void clear_resource_handle_val();
+  ::tensorflow::ResourceHandleProto* mutable_resource_handle_val(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::ResourceHandleProto >*
+      mutable_resource_handle_val();
+  private:
+  const ::tensorflow::ResourceHandleProto& _internal_resource_handle_val(int index) const;
+  ::tensorflow::ResourceHandleProto* _internal_add_resource_handle_val();
+  public:
+  const ::tensorflow::ResourceHandleProto& resource_handle_val(int index) const;
+  ::tensorflow::ResourceHandleProto* add_resource_handle_val();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::ResourceHandleProto >&
+      resource_handle_val() const;
+
+  // repeated .tensorflow.VariantTensorDataProto variant_val = 15;
+  int variant_val_size() const;
+  private:
+  int _internal_variant_val_size() const;
+  public:
+  void clear_variant_val();
+  ::tensorflow::VariantTensorDataProto* mutable_variant_val(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::VariantTensorDataProto >*
+      mutable_variant_val();
+  private:
+  const ::tensorflow::VariantTensorDataProto& _internal_variant_val(int index) const;
+  ::tensorflow::VariantTensorDataProto* _internal_add_variant_val();
+  public:
+  const ::tensorflow::VariantTensorDataProto& variant_val(int index) const;
+  ::tensorflow::VariantTensorDataProto* add_variant_val();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::VariantTensorDataProto >&
+      variant_val() const;
+
+  // repeated uint32 uint32_val = 16 [packed = true];
+  int uint32_val_size() const;
+  private:
+  int _internal_uint32_val_size() const;
+  public:
+  void clear_uint32_val();
+  private:
+  uint32_t _internal_uint32_val(int index) const;
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
+      _internal_uint32_val() const;
+  void _internal_add_uint32_val(uint32_t value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
+      _internal_mutable_uint32_val();
+  public:
+  uint32_t uint32_val(int index) const;
+  void set_uint32_val(int index, uint32_t value);
+  void add_uint32_val(uint32_t value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
+      uint32_val() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
+      mutable_uint32_val();
+
+  // repeated uint64 uint64_val = 17 [packed = true];
+  int uint64_val_size() const;
+  private:
+  int _internal_uint64_val_size() const;
+  public:
+  void clear_uint64_val();
+  private:
+  uint64_t _internal_uint64_val(int index) const;
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
+      _internal_uint64_val() const;
+  void _internal_add_uint64_val(uint64_t value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
+      _internal_mutable_uint64_val();
+  public:
+  uint64_t uint64_val(int index) const;
+  void set_uint64_val(int index, uint64_t value);
+  void add_uint64_val(uint64_t value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
+      uint64_val() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
+      mutable_uint64_val();
+
+  // bytes tensor_content = 4;
+  void clear_tensor_content();
+  const std::string& tensor_content() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_tensor_content(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_tensor_content();
+  PROTOBUF_NODISCARD std::string* release_tensor_content();
+  void set_allocated_tensor_content(std::string* tensor_content);
+  private:
+  const std::string& _internal_tensor_content() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_tensor_content(const std::string& value);
+  std::string* _internal_mutable_tensor_content();
+  public:
+
+  // bytes float8_val = 18;
+  void clear_float8_val();
+  const std::string& float8_val() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_float8_val(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_float8_val();
+  PROTOBUF_NODISCARD std::string* release_float8_val();
+  void set_allocated_float8_val(std::string* float8_val);
+  private:
+  const std::string& _internal_float8_val() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_float8_val(const std::string& value);
+  std::string* _internal_mutable_float8_val();
+  public:
+
+  // .tensorflow.TensorShapeProto tensor_shape = 2;
+  bool has_tensor_shape() const;
+  private:
+  bool _internal_has_tensor_shape() const;
+  public:
+  void clear_tensor_shape();
+  const ::tensorflow::TensorShapeProto& tensor_shape() const;
+  PROTOBUF_NODISCARD ::tensorflow::TensorShapeProto* release_tensor_shape();
+  ::tensorflow::TensorShapeProto* mutable_tensor_shape();
+  void set_allocated_tensor_shape(::tensorflow::TensorShapeProto* tensor_shape);
+  private:
+  const ::tensorflow::TensorShapeProto& _internal_tensor_shape() const;
+  ::tensorflow::TensorShapeProto* _internal_mutable_tensor_shape();
+  public:
+  void unsafe_arena_set_allocated_tensor_shape(
+      ::tensorflow::TensorShapeProto* tensor_shape);
+  ::tensorflow::TensorShapeProto* unsafe_arena_release_tensor_shape();
+
+  // .tensorflow.DataType dtype = 1;
+  void clear_dtype();
+  ::tensorflow::DataType dtype() const;
+  void set_dtype(::tensorflow::DataType value);
+  private:
+  ::tensorflow::DataType _internal_dtype() const;
+  void _internal_set_dtype(::tensorflow::DataType value);
+  public:
+
+  // int32 version_number = 3;
+  void clear_version_number();
+  int32_t version_number() const;
+  void set_version_number(int32_t value);
+  private:
+  int32_t _internal_version_number() const;
+  void _internal_set_version_number(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.TensorProto)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > float_val_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > double_val_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > int_val_;
+    mutable std::atomic<int> _int_val_cached_byte_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> string_val_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > scomplex_val_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > int64_val_;
+    mutable std::atomic<int> _int64_val_cached_byte_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool > bool_val_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > dcomplex_val_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > half_val_;
+    mutable std::atomic<int> _half_val_cached_byte_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::ResourceHandleProto > resource_handle_val_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::VariantTensorDataProto > variant_val_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > uint32_val_;
+    mutable std::atomic<int> _uint32_val_cached_byte_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t > uint64_val_;
+    mutable std::atomic<int> _uint64_val_cached_byte_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr tensor_content_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr float8_val_;
+    ::tensorflow::TensorShapeProto* tensor_shape_;
+    int dtype_;
+    int32_t version_number_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2ftensor_2eproto;
+};
+// -------------------------------------------------------------------
+
+class VariantTensorDataProto final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.VariantTensorDataProto) */ {
+ public:
+  inline VariantTensorDataProto() : VariantTensorDataProto(nullptr) {}
+  ~VariantTensorDataProto() override;
+  explicit PROTOBUF_CONSTEXPR VariantTensorDataProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  VariantTensorDataProto(const VariantTensorDataProto& from);
+  VariantTensorDataProto(VariantTensorDataProto&& from) noexcept
+    : VariantTensorDataProto() {
+    *this = ::std::move(from);
+  }
+
+  inline VariantTensorDataProto& operator=(const VariantTensorDataProto& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline VariantTensorDataProto& operator=(VariantTensorDataProto&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const VariantTensorDataProto& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const VariantTensorDataProto* internal_default_instance() {
+    return reinterpret_cast<const VariantTensorDataProto*>(
+               &_VariantTensorDataProto_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(VariantTensorDataProto& a, VariantTensorDataProto& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(VariantTensorDataProto* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(VariantTensorDataProto* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  VariantTensorDataProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<VariantTensorDataProto>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const VariantTensorDataProto& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const VariantTensorDataProto& from) {
+    VariantTensorDataProto::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(VariantTensorDataProto* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.VariantTensorDataProto";
+  }
+  protected:
+  explicit VariantTensorDataProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTensorsFieldNumber = 3,
+    kTypeNameFieldNumber = 1,
+    kMetadataFieldNumber = 2,
+  };
+  // repeated .tensorflow.TensorProto tensors = 3;
+  int tensors_size() const;
+  private:
+  int _internal_tensors_size() const;
+  public:
+  void clear_tensors();
+  ::tensorflow::TensorProto* mutable_tensors(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TensorProto >*
+      mutable_tensors();
+  private:
+  const ::tensorflow::TensorProto& _internal_tensors(int index) const;
+  ::tensorflow::TensorProto* _internal_add_tensors();
+  public:
+  const ::tensorflow::TensorProto& tensors(int index) const;
+  ::tensorflow::TensorProto* add_tensors();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TensorProto >&
+      tensors() const;
+
+  // string type_name = 1;
+  void clear_type_name();
+  const std::string& type_name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_type_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_type_name();
+  PROTOBUF_NODISCARD std::string* release_type_name();
+  void set_allocated_type_name(std::string* type_name);
+  private:
+  const std::string& _internal_type_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_type_name(const std::string& value);
+  std::string* _internal_mutable_type_name();
+  public:
+
+  // bytes metadata = 2;
+  void clear_metadata();
+  const std::string& metadata() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_metadata(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_metadata();
+  PROTOBUF_NODISCARD std::string* release_metadata();
+  void set_allocated_metadata(std::string* metadata);
+  private:
+  const std::string& _internal_metadata() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_metadata(const std::string& value);
+  std::string* _internal_mutable_metadata();
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.VariantTensorDataProto)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TensorProto > tensors_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_name_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr metadata_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2ftensor_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// TensorProto
+
+// .tensorflow.DataType dtype = 1;
+inline void TensorProto::clear_dtype() {
+  _impl_.dtype_ = 0;
+}
+inline ::tensorflow::DataType TensorProto::_internal_dtype() const {
+  return static_cast< ::tensorflow::DataType >(_impl_.dtype_);
+}
+inline ::tensorflow::DataType TensorProto::dtype() const {
+  // @@protoc_insertion_point(field_get:tensorflow.TensorProto.dtype)
+  return _internal_dtype();
+}
+inline void TensorProto::_internal_set_dtype(::tensorflow::DataType value) {
+  
+  _impl_.dtype_ = value;
+}
+inline void TensorProto::set_dtype(::tensorflow::DataType value) {
+  _internal_set_dtype(value);
+  // @@protoc_insertion_point(field_set:tensorflow.TensorProto.dtype)
+}
+
+// .tensorflow.TensorShapeProto tensor_shape = 2;
+inline bool TensorProto::_internal_has_tensor_shape() const {
+  return this != internal_default_instance() && _impl_.tensor_shape_ != nullptr;
+}
+inline bool TensorProto::has_tensor_shape() const {
+  return _internal_has_tensor_shape();
+}
+inline const ::tensorflow::TensorShapeProto& TensorProto::_internal_tensor_shape() const {
+  const ::tensorflow::TensorShapeProto* p = _impl_.tensor_shape_;
+  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::TensorShapeProto&>(
+      ::tensorflow::_TensorShapeProto_default_instance_);
+}
+inline const ::tensorflow::TensorShapeProto& TensorProto::tensor_shape() const {
+  // @@protoc_insertion_point(field_get:tensorflow.TensorProto.tensor_shape)
+  return _internal_tensor_shape();
+}
+inline void TensorProto::unsafe_arena_set_allocated_tensor_shape(
+    ::tensorflow::TensorShapeProto* tensor_shape) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.tensor_shape_);
+  }
+  _impl_.tensor_shape_ = tensor_shape;
+  if (tensor_shape) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.TensorProto.tensor_shape)
+}
+inline ::tensorflow::TensorShapeProto* TensorProto::release_tensor_shape() {
+  
+  ::tensorflow::TensorShapeProto* temp = _impl_.tensor_shape_;
+  _impl_.tensor_shape_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::tensorflow::TensorShapeProto* TensorProto::unsafe_arena_release_tensor_shape() {
+  // @@protoc_insertion_point(field_release:tensorflow.TensorProto.tensor_shape)
+  
+  ::tensorflow::TensorShapeProto* temp = _impl_.tensor_shape_;
+  _impl_.tensor_shape_ = nullptr;
+  return temp;
+}
+inline ::tensorflow::TensorShapeProto* TensorProto::_internal_mutable_tensor_shape() {
+  
+  if (_impl_.tensor_shape_ == nullptr) {
+    auto* p = CreateMaybeMessage<::tensorflow::TensorShapeProto>(GetArenaForAllocation());
+    _impl_.tensor_shape_ = p;
+  }
+  return _impl_.tensor_shape_;
+}
+inline ::tensorflow::TensorShapeProto* TensorProto::mutable_tensor_shape() {
+  ::tensorflow::TensorShapeProto* _msg = _internal_mutable_tensor_shape();
+  // @@protoc_insertion_point(field_mutable:tensorflow.TensorProto.tensor_shape)
+  return _msg;
+}
+inline void TensorProto::set_allocated_tensor_shape(::tensorflow::TensorShapeProto* tensor_shape) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.tensor_shape_);
+  }
+  if (tensor_shape) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(tensor_shape));
+    if (message_arena != submessage_arena) {
+      tensor_shape = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, tensor_shape, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.tensor_shape_ = tensor_shape;
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.TensorProto.tensor_shape)
+}
+
+// int32 version_number = 3;
+inline void TensorProto::clear_version_number() {
+  _impl_.version_number_ = 0;
+}
+inline int32_t TensorProto::_internal_version_number() const {
+  return _impl_.version_number_;
+}
+inline int32_t TensorProto::version_number() const {
+  // @@protoc_insertion_point(field_get:tensorflow.TensorProto.version_number)
+  return _internal_version_number();
+}
+inline void TensorProto::_internal_set_version_number(int32_t value) {
+  
+  _impl_.version_number_ = value;
+}
+inline void TensorProto::set_version_number(int32_t value) {
+  _internal_set_version_number(value);
+  // @@protoc_insertion_point(field_set:tensorflow.TensorProto.version_number)
+}
+
+// bytes tensor_content = 4;
+inline void TensorProto::clear_tensor_content() {
+  _impl_.tensor_content_.ClearToEmpty();
+}
+inline const std::string& TensorProto::tensor_content() const {
+  // @@protoc_insertion_point(field_get:tensorflow.TensorProto.tensor_content)
+  return _internal_tensor_content();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void TensorProto::set_tensor_content(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.tensor_content_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.TensorProto.tensor_content)
+}
+inline std::string* TensorProto::mutable_tensor_content() {
+  std::string* _s = _internal_mutable_tensor_content();
+  // @@protoc_insertion_point(field_mutable:tensorflow.TensorProto.tensor_content)
+  return _s;
+}
+inline const std::string& TensorProto::_internal_tensor_content() const {
+  return _impl_.tensor_content_.Get();
+}
+inline void TensorProto::_internal_set_tensor_content(const std::string& value) {
+  
+  _impl_.tensor_content_.Set(value, GetArenaForAllocation());
+}
+inline std::string* TensorProto::_internal_mutable_tensor_content() {
+  
+  return _impl_.tensor_content_.Mutable(GetArenaForAllocation());
+}
+inline std::string* TensorProto::release_tensor_content() {
+  // @@protoc_insertion_point(field_release:tensorflow.TensorProto.tensor_content)
+  return _impl_.tensor_content_.Release();
+}
+inline void TensorProto::set_allocated_tensor_content(std::string* tensor_content) {
+  if (tensor_content != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.tensor_content_.SetAllocated(tensor_content, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.tensor_content_.IsDefault()) {
+    _impl_.tensor_content_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.TensorProto.tensor_content)
+}
+
+// repeated int32 half_val = 13 [packed = true];
+inline int TensorProto::_internal_half_val_size() const {
+  return _impl_.half_val_.size();
+}
+inline int TensorProto::half_val_size() const {
+  return _internal_half_val_size();
+}
+inline void TensorProto::clear_half_val() {
+  _impl_.half_val_.Clear();
+}
+inline int32_t TensorProto::_internal_half_val(int index) const {
+  return _impl_.half_val_.Get(index);
+}
+inline int32_t TensorProto::half_val(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.TensorProto.half_val)
+  return _internal_half_val(index);
+}
+inline void TensorProto::set_half_val(int index, int32_t value) {
+  _impl_.half_val_.Set(index, value);
+  // @@protoc_insertion_point(field_set:tensorflow.TensorProto.half_val)
+}
+inline void TensorProto::_internal_add_half_val(int32_t value) {
+  _impl_.half_val_.Add(value);
+}
+inline void TensorProto::add_half_val(int32_t value) {
+  _internal_add_half_val(value);
+  // @@protoc_insertion_point(field_add:tensorflow.TensorProto.half_val)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+TensorProto::_internal_half_val() const {
+  return _impl_.half_val_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+TensorProto::half_val() const {
+  // @@protoc_insertion_point(field_list:tensorflow.TensorProto.half_val)
+  return _internal_half_val();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+TensorProto::_internal_mutable_half_val() {
+  return &_impl_.half_val_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+TensorProto::mutable_half_val() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.TensorProto.half_val)
+  return _internal_mutable_half_val();
+}
+
+// repeated float float_val = 5 [packed = true];
+inline int TensorProto::_internal_float_val_size() const {
+  return _impl_.float_val_.size();
+}
+inline int TensorProto::float_val_size() const {
+  return _internal_float_val_size();
+}
+inline void TensorProto::clear_float_val() {
+  _impl_.float_val_.Clear();
+}
+inline float TensorProto::_internal_float_val(int index) const {
+  return _impl_.float_val_.Get(index);
+}
+inline float TensorProto::float_val(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.TensorProto.float_val)
+  return _internal_float_val(index);
+}
+inline void TensorProto::set_float_val(int index, float value) {
+  _impl_.float_val_.Set(index, value);
+  // @@protoc_insertion_point(field_set:tensorflow.TensorProto.float_val)
+}
+inline void TensorProto::_internal_add_float_val(float value) {
+  _impl_.float_val_.Add(value);
+}
+inline void TensorProto::add_float_val(float value) {
+  _internal_add_float_val(value);
+  // @@protoc_insertion_point(field_add:tensorflow.TensorProto.float_val)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
+TensorProto::_internal_float_val() const {
+  return _impl_.float_val_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
+TensorProto::float_val() const {
+  // @@protoc_insertion_point(field_list:tensorflow.TensorProto.float_val)
+  return _internal_float_val();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
+TensorProto::_internal_mutable_float_val() {
+  return &_impl_.float_val_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
+TensorProto::mutable_float_val() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.TensorProto.float_val)
+  return _internal_mutable_float_val();
+}
+
+// repeated double double_val = 6 [packed = true];
+inline int TensorProto::_internal_double_val_size() const {
+  return _impl_.double_val_.size();
+}
+inline int TensorProto::double_val_size() const {
+  return _internal_double_val_size();
+}
+inline void TensorProto::clear_double_val() {
+  _impl_.double_val_.Clear();
+}
+inline double TensorProto::_internal_double_val(int index) const {
+  return _impl_.double_val_.Get(index);
+}
+inline double TensorProto::double_val(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.TensorProto.double_val)
+  return _internal_double_val(index);
+}
+inline void TensorProto::set_double_val(int index, double value) {
+  _impl_.double_val_.Set(index, value);
+  // @@protoc_insertion_point(field_set:tensorflow.TensorProto.double_val)
+}
+inline void TensorProto::_internal_add_double_val(double value) {
+  _impl_.double_val_.Add(value);
+}
+inline void TensorProto::add_double_val(double value) {
+  _internal_add_double_val(value);
+  // @@protoc_insertion_point(field_add:tensorflow.TensorProto.double_val)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
+TensorProto::_internal_double_val() const {
+  return _impl_.double_val_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
+TensorProto::double_val() const {
+  // @@protoc_insertion_point(field_list:tensorflow.TensorProto.double_val)
+  return _internal_double_val();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
+TensorProto::_internal_mutable_double_val() {
+  return &_impl_.double_val_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
+TensorProto::mutable_double_val() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.TensorProto.double_val)
+  return _internal_mutable_double_val();
+}
+
+// repeated int32 int_val = 7 [packed = true];
+inline int TensorProto::_internal_int_val_size() const {
+  return _impl_.int_val_.size();
+}
+inline int TensorProto::int_val_size() const {
+  return _internal_int_val_size();
+}
+inline void TensorProto::clear_int_val() {
+  _impl_.int_val_.Clear();
+}
+inline int32_t TensorProto::_internal_int_val(int index) const {
+  return _impl_.int_val_.Get(index);
+}
+inline int32_t TensorProto::int_val(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.TensorProto.int_val)
+  return _internal_int_val(index);
+}
+inline void TensorProto::set_int_val(int index, int32_t value) {
+  _impl_.int_val_.Set(index, value);
+  // @@protoc_insertion_point(field_set:tensorflow.TensorProto.int_val)
+}
+inline void TensorProto::_internal_add_int_val(int32_t value) {
+  _impl_.int_val_.Add(value);
+}
+inline void TensorProto::add_int_val(int32_t value) {
+  _internal_add_int_val(value);
+  // @@protoc_insertion_point(field_add:tensorflow.TensorProto.int_val)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+TensorProto::_internal_int_val() const {
+  return _impl_.int_val_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+TensorProto::int_val() const {
+  // @@protoc_insertion_point(field_list:tensorflow.TensorProto.int_val)
+  return _internal_int_val();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+TensorProto::_internal_mutable_int_val() {
+  return &_impl_.int_val_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+TensorProto::mutable_int_val() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.TensorProto.int_val)
+  return _internal_mutable_int_val();
+}
+
+// repeated bytes string_val = 8;
+inline int TensorProto::_internal_string_val_size() const {
+  return _impl_.string_val_.size();
+}
+inline int TensorProto::string_val_size() const {
+  return _internal_string_val_size();
+}
+inline void TensorProto::clear_string_val() {
+  _impl_.string_val_.Clear();
+}
+inline std::string* TensorProto::add_string_val() {
+  std::string* _s = _internal_add_string_val();
+  // @@protoc_insertion_point(field_add_mutable:tensorflow.TensorProto.string_val)
+  return _s;
+}
+inline const std::string& TensorProto::_internal_string_val(int index) const {
+  return _impl_.string_val_.Get(index);
+}
+inline const std::string& TensorProto::string_val(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.TensorProto.string_val)
+  return _internal_string_val(index);
+}
+inline std::string* TensorProto::mutable_string_val(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.TensorProto.string_val)
+  return _impl_.string_val_.Mutable(index);
+}
+inline void TensorProto::set_string_val(int index, const std::string& value) {
+  _impl_.string_val_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:tensorflow.TensorProto.string_val)
+}
+inline void TensorProto::set_string_val(int index, std::string&& value) {
+  _impl_.string_val_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:tensorflow.TensorProto.string_val)
+}
+inline void TensorProto::set_string_val(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.string_val_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:tensorflow.TensorProto.string_val)
+}
+inline void TensorProto::set_string_val(int index, const void* value, size_t size) {
+  _impl_.string_val_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:tensorflow.TensorProto.string_val)
+}
+inline std::string* TensorProto::_internal_add_string_val() {
+  return _impl_.string_val_.Add();
+}
+inline void TensorProto::add_string_val(const std::string& value) {
+  _impl_.string_val_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:tensorflow.TensorProto.string_val)
+}
+inline void TensorProto::add_string_val(std::string&& value) {
+  _impl_.string_val_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:tensorflow.TensorProto.string_val)
+}
+inline void TensorProto::add_string_val(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.string_val_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:tensorflow.TensorProto.string_val)
+}
+inline void TensorProto::add_string_val(const void* value, size_t size) {
+  _impl_.string_val_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:tensorflow.TensorProto.string_val)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+TensorProto::string_val() const {
+  // @@protoc_insertion_point(field_list:tensorflow.TensorProto.string_val)
+  return _impl_.string_val_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+TensorProto::mutable_string_val() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.TensorProto.string_val)
+  return &_impl_.string_val_;
+}
+
+// repeated float scomplex_val = 9 [packed = true];
+inline int TensorProto::_internal_scomplex_val_size() const {
+  return _impl_.scomplex_val_.size();
+}
+inline int TensorProto::scomplex_val_size() const {
+  return _internal_scomplex_val_size();
+}
+inline void TensorProto::clear_scomplex_val() {
+  _impl_.scomplex_val_.Clear();
+}
+inline float TensorProto::_internal_scomplex_val(int index) const {
+  return _impl_.scomplex_val_.Get(index);
+}
+inline float TensorProto::scomplex_val(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.TensorProto.scomplex_val)
+  return _internal_scomplex_val(index);
+}
+inline void TensorProto::set_scomplex_val(int index, float value) {
+  _impl_.scomplex_val_.Set(index, value);
+  // @@protoc_insertion_point(field_set:tensorflow.TensorProto.scomplex_val)
+}
+inline void TensorProto::_internal_add_scomplex_val(float value) {
+  _impl_.scomplex_val_.Add(value);
+}
+inline void TensorProto::add_scomplex_val(float value) {
+  _internal_add_scomplex_val(value);
+  // @@protoc_insertion_point(field_add:tensorflow.TensorProto.scomplex_val)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
+TensorProto::_internal_scomplex_val() const {
+  return _impl_.scomplex_val_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
+TensorProto::scomplex_val() const {
+  // @@protoc_insertion_point(field_list:tensorflow.TensorProto.scomplex_val)
+  return _internal_scomplex_val();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
+TensorProto::_internal_mutable_scomplex_val() {
+  return &_impl_.scomplex_val_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
+TensorProto::mutable_scomplex_val() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.TensorProto.scomplex_val)
+  return _internal_mutable_scomplex_val();
+}
+
+// repeated int64 int64_val = 10 [packed = true];
+inline int TensorProto::_internal_int64_val_size() const {
+  return _impl_.int64_val_.size();
+}
+inline int TensorProto::int64_val_size() const {
+  return _internal_int64_val_size();
+}
+inline void TensorProto::clear_int64_val() {
+  _impl_.int64_val_.Clear();
+}
+inline int64_t TensorProto::_internal_int64_val(int index) const {
+  return _impl_.int64_val_.Get(index);
+}
+inline int64_t TensorProto::int64_val(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.TensorProto.int64_val)
+  return _internal_int64_val(index);
+}
+inline void TensorProto::set_int64_val(int index, int64_t value) {
+  _impl_.int64_val_.Set(index, value);
+  // @@protoc_insertion_point(field_set:tensorflow.TensorProto.int64_val)
+}
+inline void TensorProto::_internal_add_int64_val(int64_t value) {
+  _impl_.int64_val_.Add(value);
+}
+inline void TensorProto::add_int64_val(int64_t value) {
+  _internal_add_int64_val(value);
+  // @@protoc_insertion_point(field_add:tensorflow.TensorProto.int64_val)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
+TensorProto::_internal_int64_val() const {
+  return _impl_.int64_val_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
+TensorProto::int64_val() const {
+  // @@protoc_insertion_point(field_list:tensorflow.TensorProto.int64_val)
+  return _internal_int64_val();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
+TensorProto::_internal_mutable_int64_val() {
+  return &_impl_.int64_val_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
+TensorProto::mutable_int64_val() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.TensorProto.int64_val)
+  return _internal_mutable_int64_val();
+}
+
+// repeated bool bool_val = 11 [packed = true];
+inline int TensorProto::_internal_bool_val_size() const {
+  return _impl_.bool_val_.size();
+}
+inline int TensorProto::bool_val_size() const {
+  return _internal_bool_val_size();
+}
+inline void TensorProto::clear_bool_val() {
+  _impl_.bool_val_.Clear();
+}
+inline bool TensorProto::_internal_bool_val(int index) const {
+  return _impl_.bool_val_.Get(index);
+}
+inline bool TensorProto::bool_val(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.TensorProto.bool_val)
+  return _internal_bool_val(index);
+}
+inline void TensorProto::set_bool_val(int index, bool value) {
+  _impl_.bool_val_.Set(index, value);
+  // @@protoc_insertion_point(field_set:tensorflow.TensorProto.bool_val)
+}
+inline void TensorProto::_internal_add_bool_val(bool value) {
+  _impl_.bool_val_.Add(value);
+}
+inline void TensorProto::add_bool_val(bool value) {
+  _internal_add_bool_val(value);
+  // @@protoc_insertion_point(field_add:tensorflow.TensorProto.bool_val)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >&
+TensorProto::_internal_bool_val() const {
+  return _impl_.bool_val_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >&
+TensorProto::bool_val() const {
+  // @@protoc_insertion_point(field_list:tensorflow.TensorProto.bool_val)
+  return _internal_bool_val();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >*
+TensorProto::_internal_mutable_bool_val() {
+  return &_impl_.bool_val_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >*
+TensorProto::mutable_bool_val() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.TensorProto.bool_val)
+  return _internal_mutable_bool_val();
+}
+
+// repeated double dcomplex_val = 12 [packed = true];
+inline int TensorProto::_internal_dcomplex_val_size() const {
+  return _impl_.dcomplex_val_.size();
+}
+inline int TensorProto::dcomplex_val_size() const {
+  return _internal_dcomplex_val_size();
+}
+inline void TensorProto::clear_dcomplex_val() {
+  _impl_.dcomplex_val_.Clear();
+}
+inline double TensorProto::_internal_dcomplex_val(int index) const {
+  return _impl_.dcomplex_val_.Get(index);
+}
+inline double TensorProto::dcomplex_val(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.TensorProto.dcomplex_val)
+  return _internal_dcomplex_val(index);
+}
+inline void TensorProto::set_dcomplex_val(int index, double value) {
+  _impl_.dcomplex_val_.Set(index, value);
+  // @@protoc_insertion_point(field_set:tensorflow.TensorProto.dcomplex_val)
+}
+inline void TensorProto::_internal_add_dcomplex_val(double value) {
+  _impl_.dcomplex_val_.Add(value);
+}
+inline void TensorProto::add_dcomplex_val(double value) {
+  _internal_add_dcomplex_val(value);
+  // @@protoc_insertion_point(field_add:tensorflow.TensorProto.dcomplex_val)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
+TensorProto::_internal_dcomplex_val() const {
+  return _impl_.dcomplex_val_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
+TensorProto::dcomplex_val() const {
+  // @@protoc_insertion_point(field_list:tensorflow.TensorProto.dcomplex_val)
+  return _internal_dcomplex_val();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
+TensorProto::_internal_mutable_dcomplex_val() {
+  return &_impl_.dcomplex_val_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
+TensorProto::mutable_dcomplex_val() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.TensorProto.dcomplex_val)
+  return _internal_mutable_dcomplex_val();
+}
+
+// repeated .tensorflow.ResourceHandleProto resource_handle_val = 14;
+inline int TensorProto::_internal_resource_handle_val_size() const {
+  return _impl_.resource_handle_val_.size();
+}
+inline int TensorProto::resource_handle_val_size() const {
+  return _internal_resource_handle_val_size();
+}
+inline ::tensorflow::ResourceHandleProto* TensorProto::mutable_resource_handle_val(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.TensorProto.resource_handle_val)
+  return _impl_.resource_handle_val_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::ResourceHandleProto >*
+TensorProto::mutable_resource_handle_val() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.TensorProto.resource_handle_val)
+  return &_impl_.resource_handle_val_;
+}
+inline const ::tensorflow::ResourceHandleProto& TensorProto::_internal_resource_handle_val(int index) const {
+  return _impl_.resource_handle_val_.Get(index);
+}
+inline const ::tensorflow::ResourceHandleProto& TensorProto::resource_handle_val(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.TensorProto.resource_handle_val)
+  return _internal_resource_handle_val(index);
+}
+inline ::tensorflow::ResourceHandleProto* TensorProto::_internal_add_resource_handle_val() {
+  return _impl_.resource_handle_val_.Add();
+}
+inline ::tensorflow::ResourceHandleProto* TensorProto::add_resource_handle_val() {
+  ::tensorflow::ResourceHandleProto* _add = _internal_add_resource_handle_val();
+  // @@protoc_insertion_point(field_add:tensorflow.TensorProto.resource_handle_val)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::ResourceHandleProto >&
+TensorProto::resource_handle_val() const {
+  // @@protoc_insertion_point(field_list:tensorflow.TensorProto.resource_handle_val)
+  return _impl_.resource_handle_val_;
+}
+
+// repeated .tensorflow.VariantTensorDataProto variant_val = 15;
+inline int TensorProto::_internal_variant_val_size() const {
+  return _impl_.variant_val_.size();
+}
+inline int TensorProto::variant_val_size() const {
+  return _internal_variant_val_size();
+}
+inline void TensorProto::clear_variant_val() {
+  _impl_.variant_val_.Clear();
+}
+inline ::tensorflow::VariantTensorDataProto* TensorProto::mutable_variant_val(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.TensorProto.variant_val)
+  return _impl_.variant_val_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::VariantTensorDataProto >*
+TensorProto::mutable_variant_val() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.TensorProto.variant_val)
+  return &_impl_.variant_val_;
+}
+inline const ::tensorflow::VariantTensorDataProto& TensorProto::_internal_variant_val(int index) const {
+  return _impl_.variant_val_.Get(index);
+}
+inline const ::tensorflow::VariantTensorDataProto& TensorProto::variant_val(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.TensorProto.variant_val)
+  return _internal_variant_val(index);
+}
+inline ::tensorflow::VariantTensorDataProto* TensorProto::_internal_add_variant_val() {
+  return _impl_.variant_val_.Add();
+}
+inline ::tensorflow::VariantTensorDataProto* TensorProto::add_variant_val() {
+  ::tensorflow::VariantTensorDataProto* _add = _internal_add_variant_val();
+  // @@protoc_insertion_point(field_add:tensorflow.TensorProto.variant_val)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::VariantTensorDataProto >&
+TensorProto::variant_val() const {
+  // @@protoc_insertion_point(field_list:tensorflow.TensorProto.variant_val)
+  return _impl_.variant_val_;
+}
+
+// repeated uint32 uint32_val = 16 [packed = true];
+inline int TensorProto::_internal_uint32_val_size() const {
+  return _impl_.uint32_val_.size();
+}
+inline int TensorProto::uint32_val_size() const {
+  return _internal_uint32_val_size();
+}
+inline void TensorProto::clear_uint32_val() {
+  _impl_.uint32_val_.Clear();
+}
+inline uint32_t TensorProto::_internal_uint32_val(int index) const {
+  return _impl_.uint32_val_.Get(index);
+}
+inline uint32_t TensorProto::uint32_val(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.TensorProto.uint32_val)
+  return _internal_uint32_val(index);
+}
+inline void TensorProto::set_uint32_val(int index, uint32_t value) {
+  _impl_.uint32_val_.Set(index, value);
+  // @@protoc_insertion_point(field_set:tensorflow.TensorProto.uint32_val)
+}
+inline void TensorProto::_internal_add_uint32_val(uint32_t value) {
+  _impl_.uint32_val_.Add(value);
+}
+inline void TensorProto::add_uint32_val(uint32_t value) {
+  _internal_add_uint32_val(value);
+  // @@protoc_insertion_point(field_add:tensorflow.TensorProto.uint32_val)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
+TensorProto::_internal_uint32_val() const {
+  return _impl_.uint32_val_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
+TensorProto::uint32_val() const {
+  // @@protoc_insertion_point(field_list:tensorflow.TensorProto.uint32_val)
+  return _internal_uint32_val();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
+TensorProto::_internal_mutable_uint32_val() {
+  return &_impl_.uint32_val_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
+TensorProto::mutable_uint32_val() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.TensorProto.uint32_val)
+  return _internal_mutable_uint32_val();
+}
+
+// repeated uint64 uint64_val = 17 [packed = true];
+inline int TensorProto::_internal_uint64_val_size() const {
+  return _impl_.uint64_val_.size();
+}
+inline int TensorProto::uint64_val_size() const {
+  return _internal_uint64_val_size();
+}
+inline void TensorProto::clear_uint64_val() {
+  _impl_.uint64_val_.Clear();
+}
+inline uint64_t TensorProto::_internal_uint64_val(int index) const {
+  return _impl_.uint64_val_.Get(index);
+}
+inline uint64_t TensorProto::uint64_val(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.TensorProto.uint64_val)
+  return _internal_uint64_val(index);
+}
+inline void TensorProto::set_uint64_val(int index, uint64_t value) {
+  _impl_.uint64_val_.Set(index, value);
+  // @@protoc_insertion_point(field_set:tensorflow.TensorProto.uint64_val)
+}
+inline void TensorProto::_internal_add_uint64_val(uint64_t value) {
+  _impl_.uint64_val_.Add(value);
+}
+inline void TensorProto::add_uint64_val(uint64_t value) {
+  _internal_add_uint64_val(value);
+  // @@protoc_insertion_point(field_add:tensorflow.TensorProto.uint64_val)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
+TensorProto::_internal_uint64_val() const {
+  return _impl_.uint64_val_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
+TensorProto::uint64_val() const {
+  // @@protoc_insertion_point(field_list:tensorflow.TensorProto.uint64_val)
+  return _internal_uint64_val();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
+TensorProto::_internal_mutable_uint64_val() {
+  return &_impl_.uint64_val_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
+TensorProto::mutable_uint64_val() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.TensorProto.uint64_val)
+  return _internal_mutable_uint64_val();
+}
+
+// bytes float8_val = 18;
+inline void TensorProto::clear_float8_val() {
+  _impl_.float8_val_.ClearToEmpty();
+}
+inline const std::string& TensorProto::float8_val() const {
+  // @@protoc_insertion_point(field_get:tensorflow.TensorProto.float8_val)
+  return _internal_float8_val();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void TensorProto::set_float8_val(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.float8_val_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.TensorProto.float8_val)
+}
+inline std::string* TensorProto::mutable_float8_val() {
+  std::string* _s = _internal_mutable_float8_val();
+  // @@protoc_insertion_point(field_mutable:tensorflow.TensorProto.float8_val)
+  return _s;
+}
+inline const std::string& TensorProto::_internal_float8_val() const {
+  return _impl_.float8_val_.Get();
+}
+inline void TensorProto::_internal_set_float8_val(const std::string& value) {
+  
+  _impl_.float8_val_.Set(value, GetArenaForAllocation());
+}
+inline std::string* TensorProto::_internal_mutable_float8_val() {
+  
+  return _impl_.float8_val_.Mutable(GetArenaForAllocation());
+}
+inline std::string* TensorProto::release_float8_val() {
+  // @@protoc_insertion_point(field_release:tensorflow.TensorProto.float8_val)
+  return _impl_.float8_val_.Release();
+}
+inline void TensorProto::set_allocated_float8_val(std::string* float8_val) {
+  if (float8_val != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.float8_val_.SetAllocated(float8_val, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.float8_val_.IsDefault()) {
+    _impl_.float8_val_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.TensorProto.float8_val)
+}
+
+// -------------------------------------------------------------------
+
+// VariantTensorDataProto
+
+// string type_name = 1;
+inline void VariantTensorDataProto::clear_type_name() {
+  _impl_.type_name_.ClearToEmpty();
+}
+inline const std::string& VariantTensorDataProto::type_name() const {
+  // @@protoc_insertion_point(field_get:tensorflow.VariantTensorDataProto.type_name)
+  return _internal_type_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void VariantTensorDataProto::set_type_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.type_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.VariantTensorDataProto.type_name)
+}
+inline std::string* VariantTensorDataProto::mutable_type_name() {
+  std::string* _s = _internal_mutable_type_name();
+  // @@protoc_insertion_point(field_mutable:tensorflow.VariantTensorDataProto.type_name)
+  return _s;
+}
+inline const std::string& VariantTensorDataProto::_internal_type_name() const {
+  return _impl_.type_name_.Get();
+}
+inline void VariantTensorDataProto::_internal_set_type_name(const std::string& value) {
+  
+  _impl_.type_name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* VariantTensorDataProto::_internal_mutable_type_name() {
+  
+  return _impl_.type_name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* VariantTensorDataProto::release_type_name() {
+  // @@protoc_insertion_point(field_release:tensorflow.VariantTensorDataProto.type_name)
+  return _impl_.type_name_.Release();
+}
+inline void VariantTensorDataProto::set_allocated_type_name(std::string* type_name) {
+  if (type_name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.type_name_.SetAllocated(type_name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.type_name_.IsDefault()) {
+    _impl_.type_name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.VariantTensorDataProto.type_name)
+}
+
+// bytes metadata = 2;
+inline void VariantTensorDataProto::clear_metadata() {
+  _impl_.metadata_.ClearToEmpty();
+}
+inline const std::string& VariantTensorDataProto::metadata() const {
+  // @@protoc_insertion_point(field_get:tensorflow.VariantTensorDataProto.metadata)
+  return _internal_metadata();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void VariantTensorDataProto::set_metadata(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.metadata_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.VariantTensorDataProto.metadata)
+}
+inline std::string* VariantTensorDataProto::mutable_metadata() {
+  std::string* _s = _internal_mutable_metadata();
+  // @@protoc_insertion_point(field_mutable:tensorflow.VariantTensorDataProto.metadata)
+  return _s;
+}
+inline const std::string& VariantTensorDataProto::_internal_metadata() const {
+  return _impl_.metadata_.Get();
+}
+inline void VariantTensorDataProto::_internal_set_metadata(const std::string& value) {
+  
+  _impl_.metadata_.Set(value, GetArenaForAllocation());
+}
+inline std::string* VariantTensorDataProto::_internal_mutable_metadata() {
+  
+  return _impl_.metadata_.Mutable(GetArenaForAllocation());
+}
+inline std::string* VariantTensorDataProto::release_metadata() {
+  // @@protoc_insertion_point(field_release:tensorflow.VariantTensorDataProto.metadata)
+  return _impl_.metadata_.Release();
+}
+inline void VariantTensorDataProto::set_allocated_metadata(std::string* metadata) {
+  if (metadata != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.metadata_.SetAllocated(metadata, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.metadata_.IsDefault()) {
+    _impl_.metadata_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.VariantTensorDataProto.metadata)
+}
+
+// repeated .tensorflow.TensorProto tensors = 3;
+inline int VariantTensorDataProto::_internal_tensors_size() const {
+  return _impl_.tensors_.size();
+}
+inline int VariantTensorDataProto::tensors_size() const {
+  return _internal_tensors_size();
+}
+inline void VariantTensorDataProto::clear_tensors() {
+  _impl_.tensors_.Clear();
+}
+inline ::tensorflow::TensorProto* VariantTensorDataProto::mutable_tensors(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.VariantTensorDataProto.tensors)
+  return _impl_.tensors_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TensorProto >*
+VariantTensorDataProto::mutable_tensors() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.VariantTensorDataProto.tensors)
+  return &_impl_.tensors_;
+}
+inline const ::tensorflow::TensorProto& VariantTensorDataProto::_internal_tensors(int index) const {
+  return _impl_.tensors_.Get(index);
+}
+inline const ::tensorflow::TensorProto& VariantTensorDataProto::tensors(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.VariantTensorDataProto.tensors)
+  return _internal_tensors(index);
+}
+inline ::tensorflow::TensorProto* VariantTensorDataProto::_internal_add_tensors() {
+  return _impl_.tensors_.Add();
+}
+inline ::tensorflow::TensorProto* VariantTensorDataProto::add_tensors() {
+  ::tensorflow::TensorProto* _add = _internal_add_tensors();
+  // @@protoc_insertion_point(field_add:tensorflow.VariantTensorDataProto.tensors)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TensorProto >&
+VariantTensorDataProto::tensors() const {
+  // @@protoc_insertion_point(field_list:tensorflow.VariantTensorDataProto.tensors)
+  return _impl_.tensors_;
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace tensorflow
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2ftensor_2eproto
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/tensor.proto b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/tensor.proto
new file mode 100644
index 0000000000000000000000000000000000000000..86012a1045d30545cf620286b39dd769d8d38f76
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/tensor.proto
@@ -0,0 +1,100 @@
+syntax = "proto3";
+
+package tensorflow;
+
+import "tensorflow/core/framework/resource_handle.proto";
+import "tensorflow/core/framework/tensor_shape.proto";
+import "tensorflow/core/framework/types.proto";
+
+option cc_enable_arenas = true;
+option java_outer_classname = "TensorProtos";
+option java_multiple_files = true;
+option java_package = "org.tensorflow.framework";
+option go_package = "github.com/tensorflow/tensorflow/tensorflow/go/core/framework/tensor_go_proto";
+
+// Protocol buffer representing a tensor.
+message TensorProto {
+  DataType dtype = 1;
+
+  // Shape of the tensor.  TODO(touts): sort out the 0-rank issues.
+  TensorShapeProto tensor_shape = 2;
+
+  // Only one of the representations below is set, one of "tensor_contents" and
+  // the "xxx_val" attributes.  We are not using oneof because as oneofs cannot
+  // contain repeated fields it would require another extra set of messages.
+
+  // Version number.
+  //
+  // In version 0, if the "repeated xxx" representations contain only one
+  // element, that element is repeated to fill the shape.  This makes it easy
+  // to represent a constant Tensor with a single value.
+  int32 version_number = 3;
+
+  // Serialized raw tensor content from either Tensor::AsProtoTensorContent or
+  // memcpy in tensorflow::grpc::EncodeTensorToByteBuffer. This representation
+  // can be used for all tensor types. The purpose of this representation is to
+  // reduce serialization overhead during RPC call by avoiding serialization of
+  // many repeated small items.
+  bytes tensor_content = 4;
+
+  // Type specific representations that make it easy to create tensor protos in
+  // all languages.  Only the representation corresponding to "dtype" can
+  // be set.  The values hold the flattened representation of the tensor in
+  // row major order.
+
+  // DT_HALF, DT_BFLOAT16. Note that since protobuf has no int16 type, we'll
+  // have some pointless zero padding for each value here.
+  repeated int32 half_val = 13 [packed = true];
+
+  // DT_FLOAT.
+  repeated float float_val = 5 [packed = true];
+
+  // DT_DOUBLE.
+  repeated double double_val = 6 [packed = true];
+
+  // DT_INT32, DT_INT16, DT_UINT16, DT_INT8, DT_UINT8.
+  repeated int32 int_val = 7 [packed = true];
+
+  // DT_STRING
+  repeated bytes string_val = 8;
+
+  // DT_COMPLEX64. scomplex_val(2*i) and scomplex_val(2*i+1) are real
+  // and imaginary parts of i-th single precision complex.
+  repeated float scomplex_val = 9 [packed = true];
+
+  // DT_INT64
+  repeated int64 int64_val = 10 [packed = true];
+
+  // DT_BOOL
+  repeated bool bool_val = 11 [packed = true];
+
+  // DT_COMPLEX128. dcomplex_val(2*i) and dcomplex_val(2*i+1) are real
+  // and imaginary parts of i-th double precision complex.
+  repeated double dcomplex_val = 12 [packed = true];
+
+  // DT_RESOURCE
+  repeated ResourceHandleProto resource_handle_val = 14;
+
+  // DT_VARIANT
+  repeated VariantTensorDataProto variant_val = 15;
+
+  // DT_UINT32
+  repeated uint32 uint32_val = 16 [packed = true];
+
+  // DT_UINT64
+  repeated uint64 uint64_val = 17 [packed = true];
+
+  // DT_FLOAT8_*, use variable-sized set of bytes
+  // (i.e. the equivalent of repeated uint8, if such a thing existed).
+  bytes float8_val = 18;
+}
+
+// Protocol buffer representing the serialization format of DT_VARIANT tensors.
+message VariantTensorDataProto {
+  // Name of the type of objects being serialized.
+  string type_name = 1;
+  // Portions of the object that are not Tensors.
+  bytes metadata = 2;
+  // Tensors contained within objects being serialized.
+  repeated TensorProto tensors = 3;
+}
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/tensor_description.pb.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/tensor_description.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..d1a1c8b82fe2590962089ed159831de4def9aca7
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/tensor_description.pb.h
@@ -0,0 +1,460 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: tensorflow/core/framework/tensor_description.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2ftensor_5fdescription_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2ftensor_5fdescription_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3021000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3021009 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+#include "tensorflow/core/framework/allocation_description.pb.h"
+#include "tensorflow/core/framework/tensor_shape.pb.h"
+#include "tensorflow/core/framework/types.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_tensorflow_2fcore_2fframework_2ftensor_5fdescription_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_tensorflow_2fcore_2fframework_2ftensor_5fdescription_2eproto {
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_tensorflow_2fcore_2fframework_2ftensor_5fdescription_2eproto;
+namespace tensorflow {
+class TensorDescription;
+struct TensorDescriptionDefaultTypeInternal;
+extern TensorDescriptionDefaultTypeInternal _TensorDescription_default_instance_;
+}  // namespace tensorflow
+PROTOBUF_NAMESPACE_OPEN
+template<> ::tensorflow::TensorDescription* Arena::CreateMaybeMessage<::tensorflow::TensorDescription>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace tensorflow {
+
+// ===================================================================
+
+class TensorDescription final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.TensorDescription) */ {
+ public:
+  inline TensorDescription() : TensorDescription(nullptr) {}
+  ~TensorDescription() override;
+  explicit PROTOBUF_CONSTEXPR TensorDescription(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  TensorDescription(const TensorDescription& from);
+  TensorDescription(TensorDescription&& from) noexcept
+    : TensorDescription() {
+    *this = ::std::move(from);
+  }
+
+  inline TensorDescription& operator=(const TensorDescription& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline TensorDescription& operator=(TensorDescription&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const TensorDescription& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const TensorDescription* internal_default_instance() {
+    return reinterpret_cast<const TensorDescription*>(
+               &_TensorDescription_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(TensorDescription& a, TensorDescription& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(TensorDescription* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(TensorDescription* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  TensorDescription* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<TensorDescription>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const TensorDescription& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const TensorDescription& from) {
+    TensorDescription::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(TensorDescription* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.TensorDescription";
+  }
+  protected:
+  explicit TensorDescription(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kShapeFieldNumber = 2,
+    kAllocationDescriptionFieldNumber = 4,
+    kDtypeFieldNumber = 1,
+  };
+  // .tensorflow.TensorShapeProto shape = 2;
+  bool has_shape() const;
+  private:
+  bool _internal_has_shape() const;
+  public:
+  void clear_shape();
+  const ::tensorflow::TensorShapeProto& shape() const;
+  PROTOBUF_NODISCARD ::tensorflow::TensorShapeProto* release_shape();
+  ::tensorflow::TensorShapeProto* mutable_shape();
+  void set_allocated_shape(::tensorflow::TensorShapeProto* shape);
+  private:
+  const ::tensorflow::TensorShapeProto& _internal_shape() const;
+  ::tensorflow::TensorShapeProto* _internal_mutable_shape();
+  public:
+  void unsafe_arena_set_allocated_shape(
+      ::tensorflow::TensorShapeProto* shape);
+  ::tensorflow::TensorShapeProto* unsafe_arena_release_shape();
+
+  // .tensorflow.AllocationDescription allocation_description = 4;
+  bool has_allocation_description() const;
+  private:
+  bool _internal_has_allocation_description() const;
+  public:
+  void clear_allocation_description();
+  const ::tensorflow::AllocationDescription& allocation_description() const;
+  PROTOBUF_NODISCARD ::tensorflow::AllocationDescription* release_allocation_description();
+  ::tensorflow::AllocationDescription* mutable_allocation_description();
+  void set_allocated_allocation_description(::tensorflow::AllocationDescription* allocation_description);
+  private:
+  const ::tensorflow::AllocationDescription& _internal_allocation_description() const;
+  ::tensorflow::AllocationDescription* _internal_mutable_allocation_description();
+  public:
+  void unsafe_arena_set_allocated_allocation_description(
+      ::tensorflow::AllocationDescription* allocation_description);
+  ::tensorflow::AllocationDescription* unsafe_arena_release_allocation_description();
+
+  // .tensorflow.DataType dtype = 1;
+  void clear_dtype();
+  ::tensorflow::DataType dtype() const;
+  void set_dtype(::tensorflow::DataType value);
+  private:
+  ::tensorflow::DataType _internal_dtype() const;
+  void _internal_set_dtype(::tensorflow::DataType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.TensorDescription)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::tensorflow::TensorShapeProto* shape_;
+    ::tensorflow::AllocationDescription* allocation_description_;
+    int dtype_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2ftensor_5fdescription_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// TensorDescription
+
+// .tensorflow.DataType dtype = 1;
+inline void TensorDescription::clear_dtype() {
+  _impl_.dtype_ = 0;
+}
+inline ::tensorflow::DataType TensorDescription::_internal_dtype() const {
+  return static_cast< ::tensorflow::DataType >(_impl_.dtype_);
+}
+inline ::tensorflow::DataType TensorDescription::dtype() const {
+  // @@protoc_insertion_point(field_get:tensorflow.TensorDescription.dtype)
+  return _internal_dtype();
+}
+inline void TensorDescription::_internal_set_dtype(::tensorflow::DataType value) {
+  
+  _impl_.dtype_ = value;
+}
+inline void TensorDescription::set_dtype(::tensorflow::DataType value) {
+  _internal_set_dtype(value);
+  // @@protoc_insertion_point(field_set:tensorflow.TensorDescription.dtype)
+}
+
+// .tensorflow.TensorShapeProto shape = 2;
+inline bool TensorDescription::_internal_has_shape() const {
+  return this != internal_default_instance() && _impl_.shape_ != nullptr;
+}
+inline bool TensorDescription::has_shape() const {
+  return _internal_has_shape();
+}
+inline const ::tensorflow::TensorShapeProto& TensorDescription::_internal_shape() const {
+  const ::tensorflow::TensorShapeProto* p = _impl_.shape_;
+  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::TensorShapeProto&>(
+      ::tensorflow::_TensorShapeProto_default_instance_);
+}
+inline const ::tensorflow::TensorShapeProto& TensorDescription::shape() const {
+  // @@protoc_insertion_point(field_get:tensorflow.TensorDescription.shape)
+  return _internal_shape();
+}
+inline void TensorDescription::unsafe_arena_set_allocated_shape(
+    ::tensorflow::TensorShapeProto* shape) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.shape_);
+  }
+  _impl_.shape_ = shape;
+  if (shape) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.TensorDescription.shape)
+}
+inline ::tensorflow::TensorShapeProto* TensorDescription::release_shape() {
+  
+  ::tensorflow::TensorShapeProto* temp = _impl_.shape_;
+  _impl_.shape_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::tensorflow::TensorShapeProto* TensorDescription::unsafe_arena_release_shape() {
+  // @@protoc_insertion_point(field_release:tensorflow.TensorDescription.shape)
+  
+  ::tensorflow::TensorShapeProto* temp = _impl_.shape_;
+  _impl_.shape_ = nullptr;
+  return temp;
+}
+inline ::tensorflow::TensorShapeProto* TensorDescription::_internal_mutable_shape() {
+  
+  if (_impl_.shape_ == nullptr) {
+    auto* p = CreateMaybeMessage<::tensorflow::TensorShapeProto>(GetArenaForAllocation());
+    _impl_.shape_ = p;
+  }
+  return _impl_.shape_;
+}
+inline ::tensorflow::TensorShapeProto* TensorDescription::mutable_shape() {
+  ::tensorflow::TensorShapeProto* _msg = _internal_mutable_shape();
+  // @@protoc_insertion_point(field_mutable:tensorflow.TensorDescription.shape)
+  return _msg;
+}
+inline void TensorDescription::set_allocated_shape(::tensorflow::TensorShapeProto* shape) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.shape_);
+  }
+  if (shape) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(shape));
+    if (message_arena != submessage_arena) {
+      shape = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, shape, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.shape_ = shape;
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.TensorDescription.shape)
+}
+
+// .tensorflow.AllocationDescription allocation_description = 4;
+inline bool TensorDescription::_internal_has_allocation_description() const {
+  return this != internal_default_instance() && _impl_.allocation_description_ != nullptr;
+}
+inline bool TensorDescription::has_allocation_description() const {
+  return _internal_has_allocation_description();
+}
+inline const ::tensorflow::AllocationDescription& TensorDescription::_internal_allocation_description() const {
+  const ::tensorflow::AllocationDescription* p = _impl_.allocation_description_;
+  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::AllocationDescription&>(
+      ::tensorflow::_AllocationDescription_default_instance_);
+}
+inline const ::tensorflow::AllocationDescription& TensorDescription::allocation_description() const {
+  // @@protoc_insertion_point(field_get:tensorflow.TensorDescription.allocation_description)
+  return _internal_allocation_description();
+}
+inline void TensorDescription::unsafe_arena_set_allocated_allocation_description(
+    ::tensorflow::AllocationDescription* allocation_description) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.allocation_description_);
+  }
+  _impl_.allocation_description_ = allocation_description;
+  if (allocation_description) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.TensorDescription.allocation_description)
+}
+inline ::tensorflow::AllocationDescription* TensorDescription::release_allocation_description() {
+  
+  ::tensorflow::AllocationDescription* temp = _impl_.allocation_description_;
+  _impl_.allocation_description_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::tensorflow::AllocationDescription* TensorDescription::unsafe_arena_release_allocation_description() {
+  // @@protoc_insertion_point(field_release:tensorflow.TensorDescription.allocation_description)
+  
+  ::tensorflow::AllocationDescription* temp = _impl_.allocation_description_;
+  _impl_.allocation_description_ = nullptr;
+  return temp;
+}
+inline ::tensorflow::AllocationDescription* TensorDescription::_internal_mutable_allocation_description() {
+  
+  if (_impl_.allocation_description_ == nullptr) {
+    auto* p = CreateMaybeMessage<::tensorflow::AllocationDescription>(GetArenaForAllocation());
+    _impl_.allocation_description_ = p;
+  }
+  return _impl_.allocation_description_;
+}
+inline ::tensorflow::AllocationDescription* TensorDescription::mutable_allocation_description() {
+  ::tensorflow::AllocationDescription* _msg = _internal_mutable_allocation_description();
+  // @@protoc_insertion_point(field_mutable:tensorflow.TensorDescription.allocation_description)
+  return _msg;
+}
+inline void TensorDescription::set_allocated_allocation_description(::tensorflow::AllocationDescription* allocation_description) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.allocation_description_);
+  }
+  if (allocation_description) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(allocation_description));
+    if (message_arena != submessage_arena) {
+      allocation_description = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, allocation_description, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.allocation_description_ = allocation_description;
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.TensorDescription.allocation_description)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace tensorflow
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2ftensor_5fdescription_2eproto
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/tensor_description.proto b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/tensor_description.proto
new file mode 100644
index 0000000000000000000000000000000000000000..8462c63bb3815b65da615399ba672e1c12f64f73
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/tensor_description.proto
@@ -0,0 +1,24 @@
+syntax = "proto3";
+
+package tensorflow;
+
+import "tensorflow/core/framework/allocation_description.proto";
+import "tensorflow/core/framework/tensor_shape.proto";
+import "tensorflow/core/framework/types.proto";
+
+option cc_enable_arenas = true;
+option java_outer_classname = "TensorDescriptionProtos";
+option java_multiple_files = true;
+option java_package = "org.tensorflow.framework";
+option go_package = "github.com/tensorflow/tensorflow/tensorflow/go/core/framework/tensor_description_go_proto";
+
+message TensorDescription {
+  // Data type of tensor elements
+  DataType dtype = 1;
+
+  // Shape of the tensor.
+  TensorShapeProto shape = 2;
+
+  // Information about the size and allocator used for the data
+  AllocationDescription allocation_description = 4;
+}
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/tensor_key.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/tensor_key.h
new file mode 100644
index 0000000000000000000000000000000000000000..3bde6fce6214c7200ad12516eb4d615db0e342ed
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/tensor_key.h
@@ -0,0 +1,77 @@
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_FRAMEWORK_TENSOR_KEY_H_
+#define TENSORFLOW_CORE_FRAMEWORK_TENSOR_KEY_H_
+
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/types.h"
+
+namespace tensorflow {
+
+class TensorKey : public Tensor {
+ public:
+  using Tensor::Tensor;
+
+  TensorKey(const Tensor& t) : Tensor(t) {}
+
+  // Equality operator. Needed for absl hashing.
+  friend bool operator==(const TensorKey& t1, const TensorKey& t2) {
+    if (t1.dtype() != t2.dtype() || t1.shape() != t2.shape()) {
+      return false;
+    }
+    if (DataTypeCanUseMemcpy(t1.dtype())) {
+      return t1.tensor_data() == t2.tensor_data();
+    } else if (t1.dtype() == DT_STRING) {
+      const auto s1 = t1.unaligned_flat<tstring>();
+      const auto s2 = t2.unaligned_flat<tstring>();
+      for (int64_t i = 0, n = t1.NumElements(); i < n; ++i) {
+        if (TF_PREDICT_FALSE(s1(i) != s2(i))) {
+          return false;
+        }
+      }
+      return true;
+    } else {
+      DCHECK(false) << "Unimplemented dtype " << DataTypeString(t1.dtype())
+                    << std::endl;
+    }
+    return false;
+  }
+
+  friend bool operator!=(const TensorKey& t1, const TensorKey& t2) {
+    return !(t1 == t2);
+  }
+
+  // Needed for absl hash function.
+  template <typename H>
+  friend H AbslHashValue(H h, const TensorKey& k) {
+    if (DataTypeCanUseMemcpy(k.dtype())) {
+      return H::combine(std::move(h), k.tensor_data());
+    } else if (k.dtype() == DT_STRING) {
+      const auto strs = k.unaligned_flat<tstring>();
+      for (int64_t i = 0, n = k.NumElements(); i < n; ++i) {
+        h = H::combine(std::move(h), strs(i));
+      }
+      return h;
+    } else {
+      DCHECK(false) << "Unimplemented dtype " << DataTypeString(k.dtype())
+                    << std::endl;
+    }
+    return h;
+  }
+};
+
+}  // namespace tensorflow
+
+#endif
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/tensor_reference.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/tensor_reference.h
new file mode 100644
index 0000000000000000000000000000000000000000..59ccd281906a5b094a18f31e3d4cba88e8ce542a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/tensor_reference.h
@@ -0,0 +1,54 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_TENSOR_REFERENCE_H_
+#define TENSORFLOW_CORE_FRAMEWORK_TENSOR_REFERENCE_H_
+
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/lib/gtl/inlined_vector.h"
+
+namespace tensorflow {
+
+// An opaque class that holds a reference to an underlying TensorBuffer.
+// Unlike Tensor, it does not have any shape or type information, so
+// it is cheaper to construct/move, but the only thing you can really do
+// with it is Unref it, which releases one of the references to the underlying
+// TensorBuffer.
+// IMPORTANT: If you do not call Unref(), you will likely leak tensor memory.
+class TensorReference {
+ public:
+  // Take the reference of the root buffer so the size will be more accurate
+  explicit TensorReference(const Tensor& tensor)
+      : buf_(tensor.buf_ ? tensor.buf_->root_buffer() : nullptr) {
+    if (buf_) buf_->Ref();
+  }
+
+  ~TensorReference() {}
+
+  void Unref() const {
+    if (buf_) buf_->Unref();
+  }
+
+  void FillDescription(AllocationDescription* description) const {
+    if (buf_) buf_->FillAllocationDescription(description);
+  }
+
+ private:
+  TensorBuffer* buf_;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_TENSOR_REFERENCE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/tensor_shape.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/tensor_shape.h
new file mode 100644
index 0000000000000000000000000000000000000000..8b1373bf0e945cca7352f7e0ee485d43b077ed01
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/tensor_shape.h
@@ -0,0 +1,788 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_TENSOR_SHAPE_H_
+#define TENSORFLOW_CORE_FRAMEWORK_TENSOR_SHAPE_H_
+
+#include <string>
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/framework/types.pb.h"
+#include "tensorflow/core/lib/gtl/array_slice.h"
+#include "tensorflow/core/lib/gtl/inlined_vector.h"
+#include "tensorflow/core/lib/strings/str_util.h"
+#include "tensorflow/core/platform/errors.h"
+#include "tensorflow/core/platform/logging.h"
+#include "tensorflow/core/platform/macros.h"
+#include "tensorflow/core/platform/status.h"
+#include "tensorflow/core/platform/statusor.h"
+
+namespace tensorflow {
+
+// START_SKIP_DOXYGEN
+template <class Shape>
+class TensorShapeIter;
+class TensorShape;
+class TensorShapeProto;
+class PartialTensorShape;
+// END_SKIP_DOXYGEN
+
+/// Internal representation for both TensorShape and PartialTensorShape.
+class TensorShapeRep {
+ public:
+  ~TensorShapeRep();
+
+  /// Copy the specified shape
+  TensorShapeRep(const TensorShapeRep& b);
+  void operator=(const TensorShapeRep& b);
+
+  /// Move the specified shape.  After moving, `b` is safe for destruction and
+  // can be reassigned into, but its dimensions and number of elements can be
+  // nonsensical (e.g., negative dimension sizes, or number of elements not
+  // properly recomputed).
+  TensorShapeRep(TensorShapeRep&& b);
+  void operator=(TensorShapeRep&& b);
+
+  /// Clear a tensor shape, producing the scalar shape.
+  void Clear();
+
+  // Maximum number of dimensions in a tensor.
+  // It's 254 because 255 = kUnknownRank is used to represent unknown rank.
+  static constexpr int MaxDimensions() { return 254; }
+
+  /// \brief Returns the number of elements in the tensor.
+  ///
+  /// We use `int64` and not `size_t` to be compatible with `Eigen::Tensor`
+  /// which uses `ptrdiff_t`.  For PartialTensorShape, -1 means not fully
+  /// defined.
+  int64_t num_elements() const { return num_elements_; }
+
+  /// For error messages.
+  std::string DebugString() const;
+  static std::string DebugString(const TensorShapeProto& proto);
+
+ protected:
+  // Constructable only via TensorShapeBase
+  TensorShapeRep() = default;
+
+  void ClearAllButDataType();
+
+  // We use 16 bytes to represent a TensorShape.  Because we need to
+  // be able to support full 64-bit dimension sizes and an arbitrary
+  // number of dimensions for a Tensor, but most tensor dimensions are
+  // significantly smaller than 64 bits and most tensors are 1, 2, or 3
+  // dimensions, we have several representations.
+  // Rep16: Supports up to 6 dimensions where each dimension is < 2^16 - 1
+  // Rep32: Supports up to 3 dimensions where each dimension is < 2^32 - 1
+  // Rep64: Supports arbitrary dimensionality, 64-bit dimensions using
+  //        an out of line vector.
+  // For PartialTensorShape, a dimension of static_cast<uint??>(-1) is unknown.
+  // This value is not allowed in TensorShape either for format compatibility.
+  struct Rep16 {
+    uint16 dims_[6];
+  };
+  struct Rep32 {
+    uint32 dims_[3];
+  };
+  struct Rep64 {
+    gtl::InlinedVector<int64_t, 4>* dims_;
+  };
+
+  // We use the max value of uint16 or uint32 to represent unknown shapes, so
+  // the maximum representable valid shape in these representations is one less.
+  static constexpr int64_t kMaxRep16 = std::numeric_limits<uint16>::max() - 1;
+  static constexpr int64_t kMaxRep32 = std::numeric_limits<uint32>::max() - 1;
+  static constexpr uint16 kUnknownRep16 = std::numeric_limits<uint16>::max();
+  static constexpr uint32 kUnknownRep32 = std::numeric_limits<uint32>::max();
+
+  Rep16* as16() { return reinterpret_cast<Rep16*>(buf()); }
+  Rep32* as32() { return reinterpret_cast<Rep32*>(buf()); }
+  Rep64* as64() { return reinterpret_cast<Rep64*>(buf()); }
+
+  const Rep16* as16() const { return reinterpret_cast<const Rep16*>(buf()); }
+  const Rep32* as32() const { return reinterpret_cast<const Rep32*>(buf()); }
+  const Rep64* as64() const { return reinterpret_cast<const Rep64*>(buf()); }
+
+  enum RepTag { REP16 = 0, REP32 = 1, REP_OUT_OF_LINE = 2 };
+
+  // Since we have a convenient extra byte available, we allow the
+  // Tensor class to store an 8-bit value in this extra storage.  This
+  // allows it to store the Tensor's datatype enum value here and avoid
+  // an extra word of storage.
+  friend class Tensor;
+  friend class TensorShapeTestHelper;
+  DataType data_type() const { return static_cast<DataType>(buf()[13]); }
+  void set_data_type(DataType dt) {
+    // We only have 8 bits available to store DataType, so make sure it fits
+    DCHECK_LT(static_cast<uint32>(dt), 256u);
+    buf()[13] = static_cast<uint8>(dt);
+  }
+
+  // We store the number of dimensions in byte 14, and the RepTag in byte 15.
+  // Bytes [0..13] vary depending on the representation.
+  // A value of 255 indicates unknown rank in the PartialTensorShape case.
+  static constexpr uint8 kUnknownRank = 255;
+  uint8 ndims_byte() const { return buf()[14]; }
+  void set_ndims_byte(uint8 nd) { buf()[14] = nd; }
+
+  RepTag tag() const { return static_cast<RepTag>(buf()[15]); }
+  void set_tag(RepTag tag) { buf()[15] = static_cast<uint8>(tag); }
+
+  void set_num_elements(int64_t n) { num_elements_ = n; }
+
+ private:
+  void DestructorOutOfLine();
+  void SlowCopyFrom(const TensorShapeRep& b);
+
+  uint8* buf() { return &u_.buf[0]; }
+  const uint8* buf() const { return &u_.buf[0]; }
+
+  union {
+    uint8 buf[16];
+    // Force data to be aligned enough for a pointer.
+    Rep64* unused_aligner;
+  } u_;
+  int64_t num_elements_;
+};
+
+/// Base class for TensorShape and PartialTensorShape.
+/// The class is templatized by either TensorShape or PartialTensorShape to
+/// allow skipping known/unknown checks in the TensorShape case, but the
+/// representation is shared exactly for fast conversion.
+template <class Shape>
+class TensorShapeBase : public TensorShapeRep {
+ public:
+  /// \brief Construct a `TensorShapeBase` from the provided sizes.
+  /// REQUIRES: `dim_sizes[i] >= 0` (or >= -1 for PartialTensorShape)
+  explicit TensorShapeBase(gtl::ArraySlice<int64_t> dim_sizes);
+  TensorShapeBase(std::initializer_list<int64_t> dim_sizes)
+      : TensorShapeBase(gtl::ArraySlice<int64_t>(dim_sizes)) {}
+
+  /// Construct an empty TensorShape, or an unknown rank PartialTensorShape
+  TensorShapeBase();
+
+  // Cannot be made explicit because we rely on conversion between proto and
+  // `TensorShapeBase` throughtout the codebase (needs bigger cleanup)
+  TensorShapeBase(const TensorShapeProto& proto);
+
+  // These factory methods should be used instead of the constructors that take
+  // an array of sizes if calling code cannot validate that the sizes specify a
+  // valid `TensorShape`.
+  // The value in `*out` is valid iff the returned value is `Status::OK`.
+  static Status BuildTensorShapeBase(gtl::ArraySlice<int64_t> dim_sizes,
+                                     TensorShapeBase* out);
+  static Status BuildTensorShapeBase(std::initializer_list<int64_t> dim_sizes,
+                                     TensorShapeBase* out) {
+    return BuildTensorShapeBase(gtl::ArraySlice<int64_t>(dim_sizes), out);
+  }
+  static Status BuildTensorShapeBase(const TensorShapeProto& proto,
+                                     TensorShapeBase* out);
+
+  /// Returns `true` iff `proto` is a valid tensor shape.
+  // For TensorShape, the proto shape must be fully defined.
+  static bool IsValid(const TensorShapeProto& proto);
+
+  /// Returns `OK` iff `proto` is a valid tensor shape, and a descriptive error
+  /// status otherwise.
+  static Status IsValidShape(const TensorShapeProto& proto);
+
+  /// Returns `true` iff this is a valid tensor shape.
+  bool IsValid();
+
+  /// \brief Add a dimension to the end ("inner-most").
+  /// REQUIRES: `size >= 0`
+  void AddDim(int64_t size);
+
+  /// Same as `AddDim` but returns a `Status`.
+  /// Use if unsure is `size >= 0`, to prevent `CHECK`-crashes.
+  Status AddDimWithStatus(int64_t size);
+
+  /// Appends all the dimensions from `shape`.
+  void AppendShape(const TensorShapeBase& shape);
+
+  /// Same as `RemoveDim` but returns a `Status`.
+  /// Use if you cannot validate all invariants, to prevent `CHECK`-fail.
+  Status AppendShapeWithStatus(const TensorShapeBase& shape);
+
+  /// \brief Insert a dimension somewhere in the `TensorShape`.
+  /// REQUIRES: `0 <= d <= dims()`
+  /// REQUIRES: `size >= 0`
+  void InsertDim(int d, int64_t size);
+
+  /// Same as `InsertDim` but returns a `Status`.
+  /// Use if unsure if requirements in `InsertDim` are satistified, to prevent
+  /// `CHECK`-fail crashes.
+  Status InsertDimWithStatus(int d, int64_t size);
+
+  /// \brief Modifies the size of the dimension `d` to be `size`
+  /// REQUIRES: `0 <= d < dims()`
+  /// REQUIRES: `size >= 0`
+  void set_dim(int d, int64_t size);
+
+  /// Same as `set_dim` but returns a `Status`.
+  /// Use if unsure if requirements in `set_dim` are satistified, to prevent
+  /// `CHECK`-fail crashes.
+  Status SetDimWithStatus(int d, int64_t size);
+
+  /// \brief Removes dimension `d` from the `TensorShape`.
+  /// REQUIRES: `0 <= d < dims()`
+  void RemoveDim(int d) {
+    CHECK_GE(d, 0);
+    RemoveDimRange(d, d + 1);
+  }
+
+  /// Same as `RemoveDim` but returns a `Status`.
+  /// Use if unsure is `0 <= d < dims()`, to prevent `CHECK`-crashes.
+  Status RemoveDimWithStatus(int64_t d) {
+    if (TF_PREDICT_FALSE(d < 0)) {
+      return errors::Internal(
+          "Expected dimension index to be non-negative, got ", d);
+    }
+    return RemoveDimRangeWithStatus(d, d + 1);
+  }
+
+  /// \brief Removes last `n` dimensions from the `TensorShape`.
+  /// REQUIRES: `0 <= n <= dims()`
+  void RemoveLastDims(int n) {
+    CHECK_LE(n, dims());
+    RemoveDimRange(dims() - n, dims());
+  }
+
+  /// Same as `RemoveLastDims` but returns a `Status`.
+  /// Use if unsure is `0 <= n <= dims()`, to prevent `CHECK`-crashes.
+  Status RemoveLastDimsWithStatus(int64_t n) {
+    if (TF_PREDICT_FALSE(n > dims())) {
+      return errors::Internal("Expected dimension index to be at most ", dims(),
+                              " got ", n);
+    }
+    return RemoveDimRangeWithStatus(dims() - n, dims());
+  }
+
+  /// \brief Removes the dimensions in range `[begin:end)` from `TensorShape`.
+  /// Negative values of `end` are interpreted as `dims() + end + 1` (as in
+  /// Python). The same is true for negative values of `begin`.
+  /// REQUIRES: `-(dims()+1) <= begin <= dims()`
+  /// REQUIRES: `-(dims()+1) <= end <= dims()`
+  void RemoveDimRange(int begin, int end);
+
+  /// Same as `RemoveDimRange` but returns a `Status`.
+  /// Use if unsure if requirements in `RemoveDimRange` are satistified, to
+  /// prevent `CHECK`-fail crashes.
+  Status RemoveDimRangeWithStatus(int begin, int end);
+
+  /// Return whether the rank is unknown
+  bool unknown_rank() const {
+    return kIsPartial && ndims_byte() == kUnknownRank;
+  }
+
+  /// Return the number of dimensions in the tensor.
+  /// Can be -1 meaning unknown rank for PartialTensorShape.
+  int dims() const {
+    uint8 dims = ndims_byte();
+    return kIsPartial && dims == kUnknownRank ? -1 : dims;
+  }
+
+  /// \brief Returns the number of elements in dimension `d`.
+  /// REQUIRES: `0 <= d < dims()`
+  // TODO(touts): Rename to `dimension()` to match
+  // `Eigen::Tensor::dimension()`?
+  int64_t dim_size(int d) const;
+
+  /// Returns sizes of all dimensions.
+  // Returns an empty list for unknown rank PartialTensorShape.
+  gtl::InlinedVector<int64_t, 4> dim_sizes() const;
+
+  /// Return true iff the rank and all of the dimensions are well defined
+  // TODO(irving): Rename to is_fully_defined now that it's fast.
+  bool IsFullyDefined() const { return !kIsPartial || num_elements() != -1; }
+
+  /// Fill `*proto` from `*this`.
+  void AsProto(TensorShapeProto* proto) const;
+  TensorShapeProto AsProto() const;
+
+  /// For iterating through the dimensions.
+  TensorShapeIter<Shape> begin() const;
+  TensorShapeIter<Shape> end() const;
+
+ protected:
+  // Optimized constructor for a shape representing an empty vector.
+  //
+  // This constructor is provided to optimize the default constructor for
+  // `Tensor`.
+  explicit TensorShapeBase(DataType dt);
+
+ private:
+  Status RecomputeNumElements();
+  Status InitDims(gtl::ArraySlice<int64_t> dim_sizes);
+
+  // True for PartialTensorShape, false for TensorShape
+  static constexpr bool kIsPartial =
+      std::is_same<Shape, PartialTensorShape>::value;
+  static_assert(kIsPartial || std::is_same<Shape, TensorShape>::value,
+                "Shape is neither TensorShape nor PartialTensorShape");
+
+  // Used by AddDim and MakeShapeHelper.  Does no error checking.
+  void UnsafeAddDim(int64_t size, int64_t new_num_elements);
+
+  // For use by TensorShapeUtils::MakeShape
+  template <class T, class S>
+  friend Status MakeShapeHelper(const T*, int64_t, S*);
+};
+
+/// Outputs `TensorShapeBase` to `std::ostream`.
+template <typename Shape>
+std::ostream& operator<<(std::ostream& os, const TensorShapeBase<Shape>& tsb) {
+  return os << tsb.DebugString();
+}
+
+/// Represents the shape of a Tensor.
+///
+/// A tensor's shape is denoted by its number of dimensions and a size for each
+/// dimension.  For example, a Tensor represented by a 3 x 4 matrix would have
+/// a shape of 2-D, [3,4].
+///
+/// If you know the exact shape of your Tensor when you create the TensorShape
+/// object, you can specify it then, or you can create a TensorShape with
+/// zero dimensions and one element, and call AddDim() to add dimensions later.
+class TensorShape : public TensorShapeBase<TensorShape> {
+ public:
+  using TensorShapeBase<TensorShape>::TensorShapeBase;
+
+  // These factory methods should be used instead of the constructors that take
+  // an array of sizes if calling code cannot validate that the sizes specify a
+  // valid `TensorShape`.
+  // The value in `*out` is valid iff the returned value is `Status::OK`.
+  static Status BuildTensorShape(gtl::ArraySlice<int64_t> dim_sizes,
+                                 TensorShape* out) {
+    return BuildTensorShapeBase(dim_sizes, out);
+  }
+  static Status BuildTensorShape(std::initializer_list<int64_t> dim_sizes,
+                                 TensorShape* out) {
+    return BuildTensorShape(gtl::ArraySlice<int64_t>(dim_sizes), out);
+  }
+  static Status BuildTensorShape(const TensorShapeProto& proto,
+                                 TensorShape* out) {
+    return BuildTensorShapeBase(proto, out);
+  }
+
+  static StatusOr<TensorShape> BuildTensorShape(const TensorShapeProto& proto) {
+    TensorShape out;
+    TF_RETURN_IF_ERROR(BuildTensorShape(proto, &out));
+    return out;
+  }
+
+  /// Allow a TensorShape to be used as a PartialTensorShape without copying
+  operator const PartialTensorShape&() const;  // NOLINT(runtime/explicit)
+
+  /// Returns true if `*this` and `b` have the same sizes. Ignores
+  /// dimension names.
+  bool IsSameSize(const TensorShape& b) const;
+
+  /// Fill `*dsizes` from `*this`.
+  /// Notice: Using IndexType=int32 in combination with To32Bit() can
+  /// significantly improve performance on GPU.
+  template <int NDIMS, typename IndexType = Eigen::DenseIndex>
+  Eigen::DSizes<IndexType, NDIMS> AsEigenDSizes() const;
+
+  // Same as `AsEigenDSizes()` but returns a `Status` instead.
+  // Use this method to surface error to user instead of crashing if `NDMIS` is
+  // not equal to `dims()`.
+  // Caller must take ownership of `out`.
+  template <int NDIMS, typename IndexType = Eigen::DenseIndex>
+  Status AsEigenDSizesWithStatus(Eigen::DSizes<IndexType, NDIMS>* out) const;
+
+  /// Same as `AsEigenDSizes()` but allows for `NDIMS > dims()` -- in
+  /// which case we pad the rest of the sizes with 1.
+  /// Notice: Using IndexType=int32 in combination with To32Bit() can
+  /// significantly improve performance on GPU.
+  template <int NDIMS, typename IndexType = Eigen::DenseIndex>
+  Eigen::DSizes<IndexType, NDIMS> AsEigenDSizesWithPadding() const;
+
+  // Same as `AsEigenDSizesWithPadding()` but returns a `Status` instead.
+  // Use this method to surface error to user instead of crashing if `NDMIS` is
+  // not equal to `dims()`.
+  // Caller must take ownership of `out`.
+  template <int NDIMS, typename IndexType = Eigen::DenseIndex>
+  Status AsEigenDSizesWithPaddingWithStatus(
+      Eigen::DSizes<IndexType, NDIMS>* out) const;
+
+ private:
+  // These CHECK fail to ease debugging.
+  // REQUIRES: dims() == NDIMS
+  void CheckDimsEqual(int NDIMS) const;
+  // REQUIRES: dims() <= NDIMS
+  void CheckDimsAtMost(int NDIMS) const;
+
+  // Fill output from `*this`.
+  // Helper method for common code between `AsEigenDSize()` and
+  // `AsEigenDSizeWithStatus()`.
+  template <int NDIMS, typename IndexType = Eigen::DenseIndex>
+  Eigen::DSizes<IndexType, NDIMS> AsEigenDSizesCopy() const;
+
+  // Fill output from `*this`.
+  // Helper method for common code between `AsEigenDSizesWithPadding()` and
+  // `AsEigenDSizeWithPaddingWithStatus()`.
+  template <int NDIMS, typename IndexType = Eigen::DenseIndex>
+  Eigen::DSizes<IndexType, NDIMS> AsEigenDSizesCopyAndPad() const;
+
+  // For access to TensorShapeBase(DataType).
+  friend class Tensor;
+};
+
+inline bool operator==(const TensorShape& a, const TensorShape& b) {
+  return a.IsSameSize(b);
+}
+inline bool operator!=(const TensorShape& a, const TensorShape& b) {
+  return !(a == b);
+}
+
+/// Outputs `TensorShapeBase` to `std::ostream`.
+inline std::ostream& operator<<(std::ostream& os, const TensorShape& ts) {
+  return os << ts.DebugString();
+}
+
+/// Represents the value of one dimension in a TensorShape.
+struct TensorShapeDim {
+  explicit TensorShapeDim(int64_t s) : size(s) {}
+  int64_t size;
+};
+
+// START_SKIP_DOXYGEN
+template <class Shape>
+class TensorShapeIter {
+ public:
+  TensorShapeIter(const Shape* shape, int d) : shape_(shape), d_(d) {}
+  bool operator==(const TensorShapeIter& rhs) {
+    DCHECK(shape_ == rhs.shape_);
+    return d_ == rhs.d_;
+  }
+  bool operator!=(const TensorShapeIter& rhs) {
+    DCHECK(shape_ == rhs.shape_);
+    return d_ != rhs.d_;
+  }
+  void operator++() { ++d_; }
+  TensorShapeDim operator*() { return TensorShapeDim(shape_->dim_size(d_)); }
+
+ private:
+  const Shape* shape_;
+  int d_;
+};
+// END_SKIP_DOXYGEN
+
+/// \brief Static helper routines for `TensorShape`. Includes a few common
+/// predicates on a tensor shape.
+class TensorShapeUtils {
+ public:
+  static bool IsScalar(const TensorShape& shape) { return shape.dims() == 0; }
+
+  static bool IsVector(const TensorShape& shape) { return shape.dims() == 1; }
+
+  static bool IsVectorOrHigher(const TensorShape& shape) {
+    return shape.dims() >= 1;
+  }
+
+  static bool IsMatrix(const TensorShape& shape) { return shape.dims() == 2; }
+
+  static bool IsSquareMatrix(const TensorShape& shape) {
+    return shape.dims() == 2 && shape.dim_size(0) == shape.dim_size(1);
+  }
+
+  static bool IsMatrixOrHigher(const TensorShape& shape) {
+    return shape.dims() >= 2;
+  }
+
+  /// \brief Returns a `TensorShape` whose dimensions are
+  /// `dims[0]`, `dims[1]`, ..., `dims[n-1]`.
+  static Status MakeShape(const int32* dims, int64_t n, TensorShape* out);
+  static Status MakeShape(const int64_t* dims, int64_t n, TensorShape* out);
+  static Status MakeShape(gtl::ArraySlice<int32> shape, TensorShape* out);
+  static Status MakeShape(gtl::ArraySlice<int64_t> shape, TensorShape* out);
+  static Status MakeShape(const int32* dims, int64_t n,
+                          PartialTensorShape* out);
+  static Status MakeShape(const int64_t* dims, int64_t n,
+                          PartialTensorShape* out);
+  static Status MakeShape(gtl::ArraySlice<int32> shape,
+                          PartialTensorShape* out);
+  static Status MakeShape(gtl::ArraySlice<int64_t> shape,
+                          PartialTensorShape* out);
+
+  static std::string ShapeListString(
+      const gtl::ArraySlice<TensorShape>& shapes);
+
+  /// \brief Returns true iff `shape` starts with `prefix`.
+  static bool StartsWith(const TensorShape& shape, const TensorShape& prefix);
+
+  /// \brief Returns true iff `shape` ends with `suffix`.
+  static bool EndsWith(const TensorShape& shape, const TensorShape& suffix);
+
+  /// \brief Returns the product of values in an int64 array,
+  /// or a failing Status if the array represents a value larger than
+  /// a `TensorShape` can hold.
+  static Status NumElements(gtl::ArraySlice<int64_t> shape,
+                            int64_t* num_elements);
+};
+
+/// Manages the partially known dimensions of a Tensor and their sizes.
+class PartialTensorShape : public TensorShapeBase<PartialTensorShape> {
+ public:
+  PartialTensorShape() {}
+  using TensorShapeBase<PartialTensorShape>::TensorShapeBase;
+
+  // These factory methods should be used instead of the constructors that take
+  // an array of sizes if calling code cannot validate that the sizes specify a
+  // valid `PartialTensorShape`.
+  // The value in `*out` is valid iff the returned value is `Status::OK`.
+  static Status BuildPartialTensorShape(gtl::ArraySlice<int64_t> dim_sizes,
+                                        PartialTensorShape* out) {
+    return BuildTensorShapeBase(dim_sizes, out);
+  }
+  static Status BuildPartialTensorShape(
+      std::initializer_list<int64_t> dim_sizes, PartialTensorShape* out) {
+    return BuildPartialTensorShape(gtl::ArraySlice<int64_t>(dim_sizes), out);
+  }
+  static Status BuildPartialTensorShape(const TensorShapeProto& proto,
+                                        PartialTensorShape* out) {
+    return BuildTensorShapeBase(proto, out);
+  }
+
+  static StatusOr<PartialTensorShape> BuildPartialTensorShape(
+      const TensorShapeProto& proto) {
+    PartialTensorShape out;
+    TF_RETURN_IF_ERROR(BuildTensorShapeBase(proto, &out));
+    return out;
+  }
+
+  /// Add a dimension to the end ("inner-most"), returns a new
+  /// PartialTensorShape.
+  /// REQUIRES: `size >= -1`, where -1 means unknown
+  PartialTensorShape Concatenate(int64_t size) const;
+
+  /// Similar to `Concatenate` but returning `Status`.
+  /// Use if calling code cannot validate all requirements and if `CHECK`-fails
+  /// are to be avoided.
+  Status ConcatenateWithStatus(int64_t size, PartialTensorShape* out) const;
+
+  /// Appends all the dimensions from `shape`.  Returns a new
+  /// PartialTensorShape.
+  PartialTensorShape Concatenate(const PartialTensorShape& shape) const;
+
+  /// Similar to `Concatenate` but returning `Status`.
+  /// Use if calling code cannot validate all requirements and if `CHECK`-fails
+  /// are to be avoided.
+  Status ConcatenateWithStatus(const PartialTensorShape& shape,
+                               PartialTensorShape* out) const;
+
+  /// Merges all the dimensions from `shape`.  Returns
+  /// `InvalidArgument` error if either `shape` has a different rank
+  /// or if any of the dimensions are incompatible.
+  Status MergeWith(const PartialTensorShape& shape,
+                   PartialTensorShape* result) const;
+
+  /// Exact equality test. Returns true iff the ranks match (i.e., both are
+  /// unknown, or both are known and equal), and all dimensions are equal (i.e.,
+  /// both dimensions are known, or both are known and equal). This is a
+  /// stronger condition that IsCompatibleWith.
+  bool IsIdenticalTo(const PartialTensorShape& shape) const;
+
+  /// Return true iff the ranks match, and if the
+  /// dimensions all either match or one is unknown.
+  bool IsCompatibleWith(const PartialTensorShape& shape) const;
+
+  // Fill `*shape` from `*this`.
+  // If `*this` is not fully defined, returns false and
+  // `*shape` is left in an intermediate state.  Otherwise
+  // returns true.
+  bool AsTensorShape(TensorShape* shape) const;
+
+  /// \brief Returns a `PartialTensorShape` whose dimensions are
+  /// `dims[0]`, `dims[1]`, ..., `dims[n-1]`.  Values of -1 are
+  /// considered "unknown".
+  template <class T>
+  static Status MakePartialShape(const T* dims, int n,
+                                 PartialTensorShape* out) {
+    return TensorShapeUtils::MakeShape(dims, n, out);
+  }
+};
+
+inline bool operator==(const PartialTensorShape& a,
+                       const PartialTensorShape& b) {
+  return a.IsIdenticalTo(b);
+}
+
+/// \brief Static helper routines for `PartialTensorShape`. Includes a few
+/// common predicates on a partially known tensor shape.
+class PartialTensorShapeUtils {
+ public:
+  static std::string PartialShapeListString(
+      const gtl::ArraySlice<PartialTensorShape>& shapes);
+
+  static bool AreIdentical(const gtl::ArraySlice<PartialTensorShape>& shapes0,
+                           const gtl::ArraySlice<PartialTensorShape>& shapes1);
+
+  static bool AreCompatible(const gtl::ArraySlice<PartialTensorShape>& shapes0,
+                            const gtl::ArraySlice<PartialTensorShape>& shapes1);
+};
+
+// ----------------------------------------------------------------------------
+// Template method implementation details below
+// ----------------------------------------------------------------------------
+
+template <int NDIMS, typename IndexType>
+Eigen::DSizes<IndexType, NDIMS> TensorShape::AsEigenDSizesCopy() const {
+  Eigen::DSizes<IndexType, NDIMS> dsizes;
+  for (int d = 0; d < NDIMS; d++) {
+    dsizes[d] = static_cast<IndexType>(dim_size(d));
+  }
+  return dsizes;
+}
+
+template <int NDIMS, typename IndexType>
+Eigen::DSizes<IndexType, NDIMS> TensorShape::AsEigenDSizesCopyAndPad() const {
+  static_assert(NDIMS <= TensorShape::MaxDimensions(), "Too many dimensions");
+  Eigen::DSizes<IndexType, NDIMS> dsizes;
+  for (int d = 0; d < dims(); d++) {
+    dsizes[d] = static_cast<IndexType>(dim_size(d));
+  }
+  for (int d = dims(); d < NDIMS; d++) {
+    dsizes[d] = 1;
+  }
+  return dsizes;
+}
+
+template <int NDIMS, typename IndexType>
+Eigen::DSizes<IndexType, NDIMS> TensorShape::AsEigenDSizes() const {
+  CheckDimsEqual(NDIMS);
+  return AsEigenDSizesCopy<NDIMS, IndexType>();
+}
+
+template <int NDIMS, typename IndexType>
+Status TensorShape::AsEigenDSizesWithStatus(
+    Eigen::DSizes<IndexType, NDIMS>* out) const {
+  if (TF_PREDICT_FALSE(NDIMS != dims())) {
+    return errors::Internal("Asking for tensor of ", NDIMS,
+                            " dimensions from a tensor of ", dims(),
+                            " dimensions");
+  }
+  *out = AsEigenDSizesCopy<NDIMS, IndexType>();
+  return OkStatus();
+}
+
+template <int NDIMS, typename IndexType>
+Eigen::DSizes<IndexType, NDIMS> TensorShape::AsEigenDSizesWithPadding() const {
+  CheckDimsAtMost(NDIMS);
+  return AsEigenDSizesCopyAndPad<NDIMS, IndexType>();
+}
+
+template <int NDIMS, typename IndexType>
+Status TensorShape::AsEigenDSizesWithPaddingWithStatus(
+    Eigen::DSizes<IndexType, NDIMS>* out) const {
+  if (TF_PREDICT_FALSE(NDIMS < dims())) {
+    return errors::Internal("Asking for tensor of at most ", NDIMS,
+                            " dimensions from a tensor of ", dims(),
+                            " dimensions");
+  }
+  *out = AsEigenDSizesCopyAndPad<NDIMS, IndexType>();
+  return OkStatus();
+}
+
+// ----------------------------------------------------------------------------
+// Inlining of some performance critical routines
+// ----------------------------------------------------------------------------
+
+inline TensorShapeRep::TensorShapeRep(const TensorShapeRep& b) {
+  num_elements_ = b.num_elements_;
+  if (b.tag() != REP_OUT_OF_LINE) {
+    memcpy(buf(), b.buf(), sizeof(u_.buf));
+    // memcpy above Implicitly does:
+    //   set_ndims_byte(b.ndims_byte());
+    //   set_tag(b.tag());
+  } else {
+    set_tag(REP16);  // So that SlowCopyFrom does not try to deallocate
+    SlowCopyFrom(b);
+  }
+}
+
+inline TensorShapeRep::TensorShapeRep(TensorShapeRep&& b) {
+  num_elements_ = b.num_elements_;
+  memcpy(buf(), b.buf(), sizeof(u_.buf));
+  // memcpy above Implicitly does:
+  //   set_ndims_byte(b.ndims_byte());
+  //   set_tag(b.tag());
+  b.set_tag(REP16);  // other shape no longer owns out-of-line data, if any.
+}
+
+inline TensorShapeRep::~TensorShapeRep() {
+  if (tag() == REP_OUT_OF_LINE) {
+    DestructorOutOfLine();
+  }
+}
+
+inline void TensorShapeRep::operator=(const TensorShapeRep& b) {
+  num_elements_ = b.num_elements_;
+  if (tag() != REP_OUT_OF_LINE && b.tag() != REP_OUT_OF_LINE) {
+    memcpy(buf(), b.buf(), sizeof(u_.buf));
+    // memcpy above implicitly also does:
+    //   set_tag(b.tag());
+    //   set_ndims_byte(b.ndims_byte());
+  } else {
+    SlowCopyFrom(b);
+  }
+}
+
+inline void TensorShapeRep::operator=(TensorShapeRep&& b) {
+  if (tag() == REP_OUT_OF_LINE) {
+    DestructorOutOfLine();
+  }
+  num_elements_ = b.num_elements_;
+  memcpy(buf(), b.buf(), sizeof(u_.buf));
+  // memcpy above Implicitly does:
+  //   set_ndims_byte(b.ndims_byte());
+  //   set_tag(b.tag());
+  b.set_tag(REP16);  // other shape no longer owns out-of-line data, if any.
+}
+
+inline TensorShape::operator const PartialTensorShape&() const {
+  // Downcast to the shared representation and upcast to PartialTensorShape
+  const TensorShapeRep* rep = this;
+  return *static_cast<const PartialTensorShape*>(rep);
+}
+
+template <class Shape>
+inline TensorShapeBase<Shape>::TensorShapeBase(DataType dt) {
+  set_tag(REP16);
+  set_data_type(dt);
+
+  // Optimized implementation of InitDims() where the shape is statically known
+  // to be {0}.
+  set_ndims_byte(1);
+  uint16* dst = as16()->dims_;
+  *dst = 0;
+  set_num_elements(0);
+}
+
+// Declare explicit instantiations in .cc file
+extern template class TensorShapeBase<TensorShape>;
+extern template class TensorShapeBase<PartialTensorShape>;
+
+// A convenient struct to represent a (DataType, PartialTensorShape) pair. It's
+// often used in shape inference.
+struct DtypeAndPartialTensorShape {
+  DataType dtype;
+  PartialTensorShape shape;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_TENSOR_SHAPE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/tensor_shape.pb.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/tensor_shape.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..0e97fd89f110d4df362a68d157c3430041ac03ba
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/tensor_shape.pb.h
@@ -0,0 +1,553 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: tensorflow/core/framework/tensor_shape.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2ftensor_5fshape_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2ftensor_5fshape_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3021000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3021009 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_tensorflow_2fcore_2fframework_2ftensor_5fshape_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_tensorflow_2fcore_2fframework_2ftensor_5fshape_2eproto {
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_tensorflow_2fcore_2fframework_2ftensor_5fshape_2eproto;
+namespace tensorflow {
+class TensorShapeProto;
+struct TensorShapeProtoDefaultTypeInternal;
+extern TensorShapeProtoDefaultTypeInternal _TensorShapeProto_default_instance_;
+class TensorShapeProto_Dim;
+struct TensorShapeProto_DimDefaultTypeInternal;
+extern TensorShapeProto_DimDefaultTypeInternal _TensorShapeProto_Dim_default_instance_;
+}  // namespace tensorflow
+PROTOBUF_NAMESPACE_OPEN
+template<> ::tensorflow::TensorShapeProto* Arena::CreateMaybeMessage<::tensorflow::TensorShapeProto>(Arena*);
+template<> ::tensorflow::TensorShapeProto_Dim* Arena::CreateMaybeMessage<::tensorflow::TensorShapeProto_Dim>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace tensorflow {
+
+// ===================================================================
+
+class TensorShapeProto_Dim final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.TensorShapeProto.Dim) */ {
+ public:
+  inline TensorShapeProto_Dim() : TensorShapeProto_Dim(nullptr) {}
+  ~TensorShapeProto_Dim() override;
+  explicit PROTOBUF_CONSTEXPR TensorShapeProto_Dim(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  TensorShapeProto_Dim(const TensorShapeProto_Dim& from);
+  TensorShapeProto_Dim(TensorShapeProto_Dim&& from) noexcept
+    : TensorShapeProto_Dim() {
+    *this = ::std::move(from);
+  }
+
+  inline TensorShapeProto_Dim& operator=(const TensorShapeProto_Dim& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline TensorShapeProto_Dim& operator=(TensorShapeProto_Dim&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const TensorShapeProto_Dim& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const TensorShapeProto_Dim* internal_default_instance() {
+    return reinterpret_cast<const TensorShapeProto_Dim*>(
+               &_TensorShapeProto_Dim_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(TensorShapeProto_Dim& a, TensorShapeProto_Dim& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(TensorShapeProto_Dim* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(TensorShapeProto_Dim* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  TensorShapeProto_Dim* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<TensorShapeProto_Dim>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const TensorShapeProto_Dim& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const TensorShapeProto_Dim& from) {
+    TensorShapeProto_Dim::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(TensorShapeProto_Dim* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.TensorShapeProto.Dim";
+  }
+  protected:
+  explicit TensorShapeProto_Dim(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNameFieldNumber = 2,
+    kSizeFieldNumber = 1,
+  };
+  // string name = 2;
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // int64 size = 1;
+  void clear_size();
+  int64_t size() const;
+  void set_size(int64_t value);
+  private:
+  int64_t _internal_size() const;
+  void _internal_set_size(int64_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.TensorShapeProto.Dim)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+    int64_t size_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2ftensor_5fshape_2eproto;
+};
+// -------------------------------------------------------------------
+
+class TensorShapeProto final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.TensorShapeProto) */ {
+ public:
+  inline TensorShapeProto() : TensorShapeProto(nullptr) {}
+  ~TensorShapeProto() override;
+  explicit PROTOBUF_CONSTEXPR TensorShapeProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  TensorShapeProto(const TensorShapeProto& from);
+  TensorShapeProto(TensorShapeProto&& from) noexcept
+    : TensorShapeProto() {
+    *this = ::std::move(from);
+  }
+
+  inline TensorShapeProto& operator=(const TensorShapeProto& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline TensorShapeProto& operator=(TensorShapeProto&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const TensorShapeProto& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const TensorShapeProto* internal_default_instance() {
+    return reinterpret_cast<const TensorShapeProto*>(
+               &_TensorShapeProto_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(TensorShapeProto& a, TensorShapeProto& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(TensorShapeProto* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(TensorShapeProto* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  TensorShapeProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<TensorShapeProto>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const TensorShapeProto& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const TensorShapeProto& from) {
+    TensorShapeProto::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(TensorShapeProto* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.TensorShapeProto";
+  }
+  protected:
+  explicit TensorShapeProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef TensorShapeProto_Dim Dim;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDimFieldNumber = 2,
+    kUnknownRankFieldNumber = 3,
+  };
+  // repeated .tensorflow.TensorShapeProto.Dim dim = 2;
+  int dim_size() const;
+  private:
+  int _internal_dim_size() const;
+  public:
+  void clear_dim();
+  ::tensorflow::TensorShapeProto_Dim* mutable_dim(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TensorShapeProto_Dim >*
+      mutable_dim();
+  private:
+  const ::tensorflow::TensorShapeProto_Dim& _internal_dim(int index) const;
+  ::tensorflow::TensorShapeProto_Dim* _internal_add_dim();
+  public:
+  const ::tensorflow::TensorShapeProto_Dim& dim(int index) const;
+  ::tensorflow::TensorShapeProto_Dim* add_dim();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TensorShapeProto_Dim >&
+      dim() const;
+
+  // bool unknown_rank = 3;
+  void clear_unknown_rank();
+  bool unknown_rank() const;
+  void set_unknown_rank(bool value);
+  private:
+  bool _internal_unknown_rank() const;
+  void _internal_set_unknown_rank(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.TensorShapeProto)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TensorShapeProto_Dim > dim_;
+    bool unknown_rank_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2ftensor_5fshape_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// TensorShapeProto_Dim
+
+// int64 size = 1;
+inline void TensorShapeProto_Dim::clear_size() {
+  _impl_.size_ = int64_t{0};
+}
+inline int64_t TensorShapeProto_Dim::_internal_size() const {
+  return _impl_.size_;
+}
+inline int64_t TensorShapeProto_Dim::size() const {
+  // @@protoc_insertion_point(field_get:tensorflow.TensorShapeProto.Dim.size)
+  return _internal_size();
+}
+inline void TensorShapeProto_Dim::_internal_set_size(int64_t value) {
+  
+  _impl_.size_ = value;
+}
+inline void TensorShapeProto_Dim::set_size(int64_t value) {
+  _internal_set_size(value);
+  // @@protoc_insertion_point(field_set:tensorflow.TensorShapeProto.Dim.size)
+}
+
+// string name = 2;
+inline void TensorShapeProto_Dim::clear_name() {
+  _impl_.name_.ClearToEmpty();
+}
+inline const std::string& TensorShapeProto_Dim::name() const {
+  // @@protoc_insertion_point(field_get:tensorflow.TensorShapeProto.Dim.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void TensorShapeProto_Dim::set_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.TensorShapeProto.Dim.name)
+}
+inline std::string* TensorShapeProto_Dim::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:tensorflow.TensorShapeProto.Dim.name)
+  return _s;
+}
+inline const std::string& TensorShapeProto_Dim::_internal_name() const {
+  return _impl_.name_.Get();
+}
+inline void TensorShapeProto_Dim::_internal_set_name(const std::string& value) {
+  
+  _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* TensorShapeProto_Dim::_internal_mutable_name() {
+  
+  return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* TensorShapeProto_Dim::release_name() {
+  // @@protoc_insertion_point(field_release:tensorflow.TensorShapeProto.Dim.name)
+  return _impl_.name_.Release();
+}
+inline void TensorShapeProto_Dim::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.TensorShapeProto.Dim.name)
+}
+
+// -------------------------------------------------------------------
+
+// TensorShapeProto
+
+// repeated .tensorflow.TensorShapeProto.Dim dim = 2;
+inline int TensorShapeProto::_internal_dim_size() const {
+  return _impl_.dim_.size();
+}
+inline int TensorShapeProto::dim_size() const {
+  return _internal_dim_size();
+}
+inline void TensorShapeProto::clear_dim() {
+  _impl_.dim_.Clear();
+}
+inline ::tensorflow::TensorShapeProto_Dim* TensorShapeProto::mutable_dim(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.TensorShapeProto.dim)
+  return _impl_.dim_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TensorShapeProto_Dim >*
+TensorShapeProto::mutable_dim() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.TensorShapeProto.dim)
+  return &_impl_.dim_;
+}
+inline const ::tensorflow::TensorShapeProto_Dim& TensorShapeProto::_internal_dim(int index) const {
+  return _impl_.dim_.Get(index);
+}
+inline const ::tensorflow::TensorShapeProto_Dim& TensorShapeProto::dim(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.TensorShapeProto.dim)
+  return _internal_dim(index);
+}
+inline ::tensorflow::TensorShapeProto_Dim* TensorShapeProto::_internal_add_dim() {
+  return _impl_.dim_.Add();
+}
+inline ::tensorflow::TensorShapeProto_Dim* TensorShapeProto::add_dim() {
+  ::tensorflow::TensorShapeProto_Dim* _add = _internal_add_dim();
+  // @@protoc_insertion_point(field_add:tensorflow.TensorShapeProto.dim)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TensorShapeProto_Dim >&
+TensorShapeProto::dim() const {
+  // @@protoc_insertion_point(field_list:tensorflow.TensorShapeProto.dim)
+  return _impl_.dim_;
+}
+
+// bool unknown_rank = 3;
+inline void TensorShapeProto::clear_unknown_rank() {
+  _impl_.unknown_rank_ = false;
+}
+inline bool TensorShapeProto::_internal_unknown_rank() const {
+  return _impl_.unknown_rank_;
+}
+inline bool TensorShapeProto::unknown_rank() const {
+  // @@protoc_insertion_point(field_get:tensorflow.TensorShapeProto.unknown_rank)
+  return _internal_unknown_rank();
+}
+inline void TensorShapeProto::_internal_set_unknown_rank(bool value) {
+  
+  _impl_.unknown_rank_ = value;
+}
+inline void TensorShapeProto::set_unknown_rank(bool value) {
+  _internal_set_unknown_rank(value);
+  // @@protoc_insertion_point(field_set:tensorflow.TensorShapeProto.unknown_rank)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace tensorflow
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2ftensor_5fshape_2eproto
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/tensor_shape.proto b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/tensor_shape.proto
new file mode 100644
index 0000000000000000000000000000000000000000..45d5b78ecbbc4cd0b1156e4e295ee1b7cf0fb916
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/tensor_shape.proto
@@ -0,0 +1,46 @@
+// Protocol buffer representing the shape of tensors.
+
+syntax = "proto3";
+option cc_enable_arenas = true;
+option java_outer_classname = "TensorShapeProtos";
+option java_multiple_files = true;
+option java_package = "org.tensorflow.framework";
+option go_package = "github.com/tensorflow/tensorflow/tensorflow/go/core/framework/tensor_shape_go_proto";
+
+package tensorflow;
+
+// Dimensions of a tensor.
+message TensorShapeProto {
+  // One dimension of the tensor.
+  message Dim {
+    // Size of the tensor in that dimension.
+    // This value must be >= -1, but values of -1 are reserved for "unknown"
+    // shapes (values of -1 mean "unknown" dimension).  Certain wrappers
+    // that work with TensorShapeProto may fail at runtime when deserializing
+    // a TensorShapeProto containing a dim value of -1.
+    int64 size = 1;
+
+    // Optional name of the tensor dimension.
+    string name = 2;
+  };
+
+  // Dimensions of the tensor, such as {"input", 30}, {"output", 40}
+  // for a 30 x 40 2D tensor.  If an entry has size -1, this
+  // corresponds to a dimension of unknown size. The names are
+  // optional.
+  //
+  // The order of entries in "dim" matters: It indicates the layout of the
+  // values in the tensor in-memory representation.
+  //
+  // The first entry in "dim" is the outermost dimension used to layout the
+  // values, the last entry is the innermost dimension.  This matches the
+  // in-memory layout of RowMajor Eigen tensors.
+  //
+  // If "dim.size()" > 0, "unknown_rank" must be false.
+  repeated Dim dim = 2;
+
+  // If true, the number of dimensions in the shape is unknown.
+  //
+  // If true, "dim.size()" must be 0.
+  bool unknown_rank = 3;
+};
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/tensor_slice.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/tensor_slice.h
new file mode 100644
index 0000000000000000000000000000000000000000..297a20300e5b056459d2ff5d56e7f8dbe4ae6525
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/tensor_slice.h
@@ -0,0 +1,231 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_TENSOR_SLICE_H_
+#define TENSORFLOW_CORE_FRAMEWORK_TENSOR_SLICE_H_
+
+#include <string>
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/framework/tensor_shape.h"
+#include "tensorflow/core/framework/tensor_slice.pb.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/lib/core/stringpiece.h"
+#include "tensorflow/core/lib/gtl/inlined_vector.h"
+#include "tensorflow/core/platform/logging.h"
+
+namespace tensorflow {
+
+// A tensor slice represents a slice of a given tensor. It is represented by a
+// list of (start, length) pairs, where the size of the list is the rank of the
+// tensor.
+
+class TensorSlice {
+ public:
+  // Construct a tensor slice: you have a number of ways:
+  // -- creating an empty slice
+  // -- from just a dimension (in this case it will create a full slice)
+  // -- from an array of pairs of integers.
+  // -- from a TensorSliceProto protocol buffer
+  // -- from a string format of "start,length:start,length..." where each
+  //    "start,length" pair represents the slice on one dimension. We allow a
+  //    special "-" that means "everything for this dimension". One such example
+  //    is:  0,10:-:14,1:-:-
+  TensorSlice() {}
+  explicit TensorSlice(int dim);
+  explicit TensorSlice(const TensorSliceProto& proto);
+  explicit TensorSlice(
+      std::initializer_list<std::pair<int64_t, int64_t>> extents);
+
+  // This factory methods should be used instead of the constructor that takes a
+  // `TensorSliceProto` if calling code cannot validate that the sizes specify a
+  // valid `TensorSlice`.
+  static Status BuildTensorSlice(const TensorSliceProto& proto,
+                                 TensorSlice* output);
+
+  static Status Parse(const string& str, TensorSlice* output);
+  static TensorSlice ParseOrDie(const string& str) {
+    TensorSlice ret;
+    Status s = Parse(str, &ret);
+    if (!s.ok()) {
+      LOG(FATAL) << "Could not parse TensorSlice";
+    }
+    return ret;
+  }
+
+  void Clear();
+
+  // Accessors
+  int dims() const { return starts_.size(); }
+
+  int64_t start(int d) const {
+    DCHECK_GE(d, 0);
+    DCHECK_LT(d, dims());
+    return starts_[d];
+  }
+
+  int64_t length(int d) const {
+    DCHECK_GE(d, 0);
+    DCHECK_LT(d, dims());
+    return lengths_[d];
+  }
+
+  int64_t end(int d) const {
+    DCHECK_GE(d, 0);
+    DCHECK_LT(d, dims());
+    return start(d) + length(d);
+  }
+
+  void set_start(int d, int64_t x) {
+    DCHECK_GE(d, 0);
+    DCHECK_LT(d, dims());
+    DCHECK_GE(x, 0);
+    starts_[d] = x;
+  }
+
+  void set_length(int d, int64_t x) {
+    DCHECK_GE(d, 0);
+    DCHECK_LT(d, dims());
+    lengths_[d] = x;
+  }
+
+  // If we have a full slice along dimension "d".
+  bool IsFullAt(int d) const {
+    return lengths_[d] == kFullExtent && starts_[d] == 0;
+  }
+
+  // If this is a full slice, i.e. IsFullAt(d) for every d.
+  bool IsFull() const;
+
+  // Set the slice to be a full slice of "dim" dimensions
+  void SetFullSlice(int dim);
+
+  // Extend a slice to "dim" dimensions: all the added dimensions are full.
+  // Requires: dim >= dims().
+  void Extend(int dim);
+
+  // Conversion of a TensorSlice to other formats
+  void AsProto(TensorSliceProto* proto) const;
+  string DebugString() const;
+
+  // Fill *indices and *sizes from *this (so that we can use the slice()
+  // function in eigen tensor). We need a tensor shape in case some of the
+  // slices are full slices.
+  // We allow NDIMS to be greater than dims(), in which case we will pad the
+  // higher dimensions with trivial dimensions.
+  template <int NDIMS>
+  void FillIndicesAndSizes(
+      const TensorShape& shape,
+      Eigen::DSizes<Eigen::DenseIndex, NDIMS>* indices,
+      Eigen::DSizes<Eigen::DenseIndex, NDIMS>* sizes) const;
+
+  // Interaction with other TensorSlices.
+
+  // Compute the intersection with another slice and if "result" is not
+  // nullptr, store the results in *result; returns true if there is any real
+  // intersection.
+  bool Intersect(const TensorSlice& other, TensorSlice* result) const;
+  // A short hand.
+  bool Overlaps(const TensorSlice& other) const {
+    return Intersect(other, nullptr);
+  }
+
+  // Equals iff "*this" and "other" are logically equivalent.
+  bool operator==(const TensorSlice& other) const;
+  bool operator!=(const TensorSlice& other) const { return !(*this == other); }
+
+  // Interaction with TensorShape.
+
+  // Slices a shape and stores the result into *result_shape.
+  // Requires that the shape and *this have the same rank.
+  // For example, given a tensor shape of {3, 4, 5}, and a slice of
+  // 1,2:-:0,2, the result shape is {2, 4, 2}.
+  Status SliceTensorShape(const TensorShape& shape,
+                          TensorShape* result_shape) const;
+
+  // Given slice "sub" where "sub" is fully contained in *this,
+  // (meaning that the intersection of "sub" and *this equals "sub"), computes
+  // the "relative" slice of "sub" with respect to *this.
+  //
+  // In other words, if we use A>S to denote slicing a shape S with a slice A,
+  // then the function is computing a slice X such that:
+  //   X > (this > S) = sub > S
+  // for any shape S.
+  //
+  // In general, along every dimension, the start of the relative slice is the
+  // start of the "sub" slice minus the start of *this; the length of the
+  // relative slice is the length of the "sub" slice.
+  //
+  // For example, say we have a shape of {3, 4, 5}, "this" is 0,2:-:1,2, and
+  // "sub" is 1,1:2:2,1,2, then the related slice is 1,1:2,2:0,2.
+  //
+  // The caller needs to make sure that "sub" is indeed a sub-slice of *this;
+  // otherwise the result is undefined.
+  void ComputeRelative(const TensorSlice& sub, TensorSlice* relative) const;
+
+  // Updates the slice in such a way that it fully covers "other" slice.
+  // Note, "other" slice should refer to the same tensor shape.
+  // Example:
+  //   given a slice [2:4, :, 3:] and "other" slice [:, 1:4, 2:4] the
+  //   updated slice would be [:, :, 2:]. Here is why:
+  //   dim 0: "2:4"  U  ":"    ->  ":"
+  //   dim 1: ":"    U  "1-4"  ->  ":"
+  //   dim 2: "3:"   U  "2:4"  ->  "2:"
+  void UpdateToCover(const TensorSlice& other);
+
+  // Returns true if the length field was specified in an Extent.
+  static bool HasExtentLength(const TensorSliceProto::Extent& extent);
+
+  // Returns the value of the length field in an Extent, or -1 if it
+  // is not present.
+  static int64_t GetExtentLength(const TensorSliceProto::Extent& extent);
+
+ private:
+  // a length value of kFullExtent (-1) means we have a full slice at this
+  // dimension. It's defined in tensor_slice.cc.
+  static const int64_t kFullExtent;
+
+  // TODO(yangke): switch to Eigen once it supports variable size arrays.
+  // A value of
+  gtl::InlinedVector<int64_t, 4> starts_;
+  gtl::InlinedVector<int64_t, 4> lengths_;
+};
+
+template <int NDIMS>
+void TensorSlice::FillIndicesAndSizes(
+    const TensorShape& shape, Eigen::DSizes<Eigen::DenseIndex, NDIMS>* indices,
+    Eigen::DSizes<Eigen::DenseIndex, NDIMS>* sizes) const {
+  CHECK_EQ(shape.dims(), dims()) << "Incompatible dimensions between shape "
+                                 << "slices: shape = " << shape.DebugString()
+                                 << ", slice = " << DebugString();
+  CHECK_GE(NDIMS, dims()) << "Asking for a " << NDIMS << "-dim slice from "
+                          << "a slice of dimension " << dims();
+  for (int d = 0; d < dims(); ++d) {
+    if (IsFullAt(d)) {
+      (*indices)[d] = 0;
+      (*sizes)[d] = shape.dim_size(d);
+    } else {
+      (*indices)[d] = starts_[d];
+      (*sizes)[d] = lengths_[d];
+    }
+  }
+  for (int d = dims(); d < NDIMS; ++d) {
+    (*indices)[d] = 0;
+    (*sizes)[d] = 1;
+  }
+}
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_TENSOR_SLICE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/tensor_slice.pb.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/tensor_slice.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..858d2c57443547c75cac32125185a30e77660b68
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/tensor_slice.pb.h
@@ -0,0 +1,535 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: tensorflow/core/framework/tensor_slice.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2ftensor_5fslice_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2ftensor_5fslice_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3021000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3021009 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_tensorflow_2fcore_2fframework_2ftensor_5fslice_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_tensorflow_2fcore_2fframework_2ftensor_5fslice_2eproto {
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_tensorflow_2fcore_2fframework_2ftensor_5fslice_2eproto;
+namespace tensorflow {
+class TensorSliceProto;
+struct TensorSliceProtoDefaultTypeInternal;
+extern TensorSliceProtoDefaultTypeInternal _TensorSliceProto_default_instance_;
+class TensorSliceProto_Extent;
+struct TensorSliceProto_ExtentDefaultTypeInternal;
+extern TensorSliceProto_ExtentDefaultTypeInternal _TensorSliceProto_Extent_default_instance_;
+}  // namespace tensorflow
+PROTOBUF_NAMESPACE_OPEN
+template<> ::tensorflow::TensorSliceProto* Arena::CreateMaybeMessage<::tensorflow::TensorSliceProto>(Arena*);
+template<> ::tensorflow::TensorSliceProto_Extent* Arena::CreateMaybeMessage<::tensorflow::TensorSliceProto_Extent>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace tensorflow {
+
+// ===================================================================
+
+class TensorSliceProto_Extent final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.TensorSliceProto.Extent) */ {
+ public:
+  inline TensorSliceProto_Extent() : TensorSliceProto_Extent(nullptr) {}
+  ~TensorSliceProto_Extent() override;
+  explicit PROTOBUF_CONSTEXPR TensorSliceProto_Extent(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  TensorSliceProto_Extent(const TensorSliceProto_Extent& from);
+  TensorSliceProto_Extent(TensorSliceProto_Extent&& from) noexcept
+    : TensorSliceProto_Extent() {
+    *this = ::std::move(from);
+  }
+
+  inline TensorSliceProto_Extent& operator=(const TensorSliceProto_Extent& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline TensorSliceProto_Extent& operator=(TensorSliceProto_Extent&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const TensorSliceProto_Extent& default_instance() {
+    return *internal_default_instance();
+  }
+  enum HasLengthCase {
+    kLength = 2,
+    HAS_LENGTH_NOT_SET = 0,
+  };
+
+  static inline const TensorSliceProto_Extent* internal_default_instance() {
+    return reinterpret_cast<const TensorSliceProto_Extent*>(
+               &_TensorSliceProto_Extent_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(TensorSliceProto_Extent& a, TensorSliceProto_Extent& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(TensorSliceProto_Extent* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(TensorSliceProto_Extent* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  TensorSliceProto_Extent* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<TensorSliceProto_Extent>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const TensorSliceProto_Extent& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const TensorSliceProto_Extent& from) {
+    TensorSliceProto_Extent::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(TensorSliceProto_Extent* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.TensorSliceProto.Extent";
+  }
+  protected:
+  explicit TensorSliceProto_Extent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kStartFieldNumber = 1,
+    kLengthFieldNumber = 2,
+  };
+  // int64 start = 1;
+  void clear_start();
+  int64_t start() const;
+  void set_start(int64_t value);
+  private:
+  int64_t _internal_start() const;
+  void _internal_set_start(int64_t value);
+  public:
+
+  // int64 length = 2;
+  bool has_length() const;
+  private:
+  bool _internal_has_length() const;
+  public:
+  void clear_length();
+  int64_t length() const;
+  void set_length(int64_t value);
+  private:
+  int64_t _internal_length() const;
+  void _internal_set_length(int64_t value);
+  public:
+
+  void clear_has_length();
+  HasLengthCase has_length_case() const;
+  // @@protoc_insertion_point(class_scope:tensorflow.TensorSliceProto.Extent)
+ private:
+  class _Internal;
+  void set_has_length();
+
+  inline bool has_has_length() const;
+  inline void clear_has_has_length();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    int64_t start_;
+    union HasLengthUnion {
+      constexpr HasLengthUnion() : _constinit_{} {}
+        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+      int64_t length_;
+    } has_length_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    uint32_t _oneof_case_[1];
+
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2ftensor_5fslice_2eproto;
+};
+// -------------------------------------------------------------------
+
+class TensorSliceProto final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.TensorSliceProto) */ {
+ public:
+  inline TensorSliceProto() : TensorSliceProto(nullptr) {}
+  ~TensorSliceProto() override;
+  explicit PROTOBUF_CONSTEXPR TensorSliceProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  TensorSliceProto(const TensorSliceProto& from);
+  TensorSliceProto(TensorSliceProto&& from) noexcept
+    : TensorSliceProto() {
+    *this = ::std::move(from);
+  }
+
+  inline TensorSliceProto& operator=(const TensorSliceProto& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline TensorSliceProto& operator=(TensorSliceProto&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const TensorSliceProto& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const TensorSliceProto* internal_default_instance() {
+    return reinterpret_cast<const TensorSliceProto*>(
+               &_TensorSliceProto_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(TensorSliceProto& a, TensorSliceProto& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(TensorSliceProto* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(TensorSliceProto* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  TensorSliceProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<TensorSliceProto>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const TensorSliceProto& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const TensorSliceProto& from) {
+    TensorSliceProto::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(TensorSliceProto* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.TensorSliceProto";
+  }
+  protected:
+  explicit TensorSliceProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef TensorSliceProto_Extent Extent;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kExtentFieldNumber = 1,
+  };
+  // repeated .tensorflow.TensorSliceProto.Extent extent = 1;
+  int extent_size() const;
+  private:
+  int _internal_extent_size() const;
+  public:
+  void clear_extent();
+  ::tensorflow::TensorSliceProto_Extent* mutable_extent(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TensorSliceProto_Extent >*
+      mutable_extent();
+  private:
+  const ::tensorflow::TensorSliceProto_Extent& _internal_extent(int index) const;
+  ::tensorflow::TensorSliceProto_Extent* _internal_add_extent();
+  public:
+  const ::tensorflow::TensorSliceProto_Extent& extent(int index) const;
+  ::tensorflow::TensorSliceProto_Extent* add_extent();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TensorSliceProto_Extent >&
+      extent() const;
+
+  // @@protoc_insertion_point(class_scope:tensorflow.TensorSliceProto)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TensorSliceProto_Extent > extent_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2ftensor_5fslice_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// TensorSliceProto_Extent
+
+// int64 start = 1;
+inline void TensorSliceProto_Extent::clear_start() {
+  _impl_.start_ = int64_t{0};
+}
+inline int64_t TensorSliceProto_Extent::_internal_start() const {
+  return _impl_.start_;
+}
+inline int64_t TensorSliceProto_Extent::start() const {
+  // @@protoc_insertion_point(field_get:tensorflow.TensorSliceProto.Extent.start)
+  return _internal_start();
+}
+inline void TensorSliceProto_Extent::_internal_set_start(int64_t value) {
+  
+  _impl_.start_ = value;
+}
+inline void TensorSliceProto_Extent::set_start(int64_t value) {
+  _internal_set_start(value);
+  // @@protoc_insertion_point(field_set:tensorflow.TensorSliceProto.Extent.start)
+}
+
+// int64 length = 2;
+inline bool TensorSliceProto_Extent::_internal_has_length() const {
+  return has_length_case() == kLength;
+}
+inline bool TensorSliceProto_Extent::has_length() const {
+  return _internal_has_length();
+}
+inline void TensorSliceProto_Extent::set_has_length() {
+  _impl_._oneof_case_[0] = kLength;
+}
+inline void TensorSliceProto_Extent::clear_length() {
+  if (_internal_has_length()) {
+    _impl_.has_length_.length_ = int64_t{0};
+    clear_has_has_length();
+  }
+}
+inline int64_t TensorSliceProto_Extent::_internal_length() const {
+  if (_internal_has_length()) {
+    return _impl_.has_length_.length_;
+  }
+  return int64_t{0};
+}
+inline void TensorSliceProto_Extent::_internal_set_length(int64_t value) {
+  if (!_internal_has_length()) {
+    clear_has_length();
+    set_has_length();
+  }
+  _impl_.has_length_.length_ = value;
+}
+inline int64_t TensorSliceProto_Extent::length() const {
+  // @@protoc_insertion_point(field_get:tensorflow.TensorSliceProto.Extent.length)
+  return _internal_length();
+}
+inline void TensorSliceProto_Extent::set_length(int64_t value) {
+  _internal_set_length(value);
+  // @@protoc_insertion_point(field_set:tensorflow.TensorSliceProto.Extent.length)
+}
+
+inline bool TensorSliceProto_Extent::has_has_length() const {
+  return has_length_case() != HAS_LENGTH_NOT_SET;
+}
+inline void TensorSliceProto_Extent::clear_has_has_length() {
+  _impl_._oneof_case_[0] = HAS_LENGTH_NOT_SET;
+}
+inline TensorSliceProto_Extent::HasLengthCase TensorSliceProto_Extent::has_length_case() const {
+  return TensorSliceProto_Extent::HasLengthCase(_impl_._oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// TensorSliceProto
+
+// repeated .tensorflow.TensorSliceProto.Extent extent = 1;
+inline int TensorSliceProto::_internal_extent_size() const {
+  return _impl_.extent_.size();
+}
+inline int TensorSliceProto::extent_size() const {
+  return _internal_extent_size();
+}
+inline void TensorSliceProto::clear_extent() {
+  _impl_.extent_.Clear();
+}
+inline ::tensorflow::TensorSliceProto_Extent* TensorSliceProto::mutable_extent(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.TensorSliceProto.extent)
+  return _impl_.extent_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TensorSliceProto_Extent >*
+TensorSliceProto::mutable_extent() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.TensorSliceProto.extent)
+  return &_impl_.extent_;
+}
+inline const ::tensorflow::TensorSliceProto_Extent& TensorSliceProto::_internal_extent(int index) const {
+  return _impl_.extent_.Get(index);
+}
+inline const ::tensorflow::TensorSliceProto_Extent& TensorSliceProto::extent(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.TensorSliceProto.extent)
+  return _internal_extent(index);
+}
+inline ::tensorflow::TensorSliceProto_Extent* TensorSliceProto::_internal_add_extent() {
+  return _impl_.extent_.Add();
+}
+inline ::tensorflow::TensorSliceProto_Extent* TensorSliceProto::add_extent() {
+  ::tensorflow::TensorSliceProto_Extent* _add = _internal_add_extent();
+  // @@protoc_insertion_point(field_add:tensorflow.TensorSliceProto.extent)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TensorSliceProto_Extent >&
+TensorSliceProto::extent() const {
+  // @@protoc_insertion_point(field_list:tensorflow.TensorSliceProto.extent)
+  return _impl_.extent_;
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace tensorflow
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2ftensor_5fslice_2eproto
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/tensor_slice.proto b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/tensor_slice.proto
new file mode 100644
index 0000000000000000000000000000000000000000..4463658d391e2fc2072175c56e28f63a0be31d2f
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/tensor_slice.proto
@@ -0,0 +1,39 @@
+// Protocol buffer representing slices of a tensor
+
+syntax = "proto3";
+
+package tensorflow;
+
+option cc_enable_arenas = true;
+option java_outer_classname = "TensorSliceProtos";
+option java_multiple_files = true;
+option java_package = "org.tensorflow.framework";
+option go_package = "github.com/tensorflow/tensorflow/tensorflow/go/core/framework/tensor_slice_go_proto";
+
+// Can only be interpreted if you know the corresponding TensorShape.
+message TensorSliceProto {
+  // Extent of the slice in one dimension.
+  message Extent {
+    // Either both or no attributes must be set.  When no attribute is set
+    // means: All data in that dimension.
+
+    // Start index of the slice, starting at 0.
+    int64 start = 1;
+
+    // Length of the slice: if the length is missing or -1 we will
+    // interpret this as "everything in this dimension".  We use
+    // "oneof" to preserve information about whether the length is
+    // present without changing the serialization format from the
+    // prior proto2 version of this proto.
+    oneof has_length {
+      int64 length = 2;
+    }
+  }
+
+  // Extent of the slice in all tensor dimensions.
+  //
+  // Must have one entry for each of the dimension of the tensor that this
+  // slice belongs to.  The order of sizes is the same as the order of
+  // dimensions in the TensorShape.
+  repeated Extent extent = 1;
+}
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/tensor_types.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/tensor_types.h
new file mode 100644
index 0000000000000000000000000000000000000000..2381d6b77f6fe2c2675703de5ff33e950d5abc9c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/tensor_types.h
@@ -0,0 +1,199 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_TENSOR_TYPES_H_
+#define TENSORFLOW_CORE_FRAMEWORK_TENSOR_TYPES_H_
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/platform/logging.h"
+
+namespace tensorflow {
+
+// Helper to define Tensor types given that the scalar is of type T.
+template <typename T, int NDIMS = 1, typename IndexType = Eigen::DenseIndex>
+struct TTypes {
+  // Rank-<NDIMS> tensor of scalar type T.
+  typedef Eigen::TensorMap<Eigen::Tensor<T, NDIMS, Eigen::RowMajor, IndexType>,
+                           Eigen::Aligned>
+      Tensor;
+  typedef Eigen::TensorMap<
+      Eigen::Tensor<const T, NDIMS, Eigen::RowMajor, IndexType>, Eigen::Aligned>
+      ConstTensor;
+
+  // Unaligned Rank-<NDIMS> tensor of scalar type T.
+  typedef Eigen::TensorMap<Eigen::Tensor<T, NDIMS, Eigen::RowMajor, IndexType> >
+      UnalignedTensor;
+  typedef Eigen::TensorMap<
+      Eigen::Tensor<const T, NDIMS, Eigen::RowMajor, IndexType> >
+      UnalignedConstTensor;
+
+  typedef Eigen::TensorMap<Eigen::Tensor<T, NDIMS, Eigen::RowMajor, int>,
+                           Eigen::Aligned>
+      Tensor32Bit;
+
+  // Scalar tensor (implemented as a rank-0 tensor) of scalar type T.
+  typedef Eigen::TensorMap<
+      Eigen::TensorFixedSize<T, Eigen::Sizes<>, Eigen::RowMajor, IndexType>,
+      Eigen::Aligned>
+      Scalar;
+  typedef Eigen::TensorMap<Eigen::TensorFixedSize<const T, Eigen::Sizes<>,
+                                                  Eigen::RowMajor, IndexType>,
+                           Eigen::Aligned>
+      ConstScalar;
+
+  // Unaligned Scalar tensor of scalar type T.
+  typedef Eigen::TensorMap<
+      Eigen::TensorFixedSize<T, Eigen::Sizes<>, Eigen::RowMajor, IndexType> >
+      UnalignedScalar;
+  typedef Eigen::TensorMap<Eigen::TensorFixedSize<const T, Eigen::Sizes<>,
+                                                  Eigen::RowMajor, IndexType> >
+      UnalignedConstScalar;
+
+  // Rank-1 tensor (vector) of scalar type T.
+  typedef Eigen::TensorMap<Eigen::Tensor<T, 1, Eigen::RowMajor, IndexType>,
+                           Eigen::Aligned>
+      Flat;
+  typedef Eigen::TensorMap<
+      Eigen::Tensor<const T, 1, Eigen::RowMajor, IndexType>, Eigen::Aligned>
+      ConstFlat;
+  typedef Eigen::TensorMap<Eigen::Tensor<T, 1, Eigen::RowMajor, IndexType>,
+                           Eigen::Aligned>
+      Vec;
+  typedef Eigen::TensorMap<
+      Eigen::Tensor<const T, 1, Eigen::RowMajor, IndexType>, Eigen::Aligned>
+      ConstVec;
+
+  // Unaligned Rank-1 tensor (vector) of scalar type T.
+  typedef Eigen::TensorMap<Eigen::Tensor<T, 1, Eigen::RowMajor, IndexType> >
+      UnalignedFlat;
+  typedef Eigen::TensorMap<
+      Eigen::Tensor<const T, 1, Eigen::RowMajor, IndexType> >
+      UnalignedConstFlat;
+  typedef Eigen::TensorMap<Eigen::Tensor<T, 1, Eigen::RowMajor, IndexType> >
+      UnalignedVec;
+  typedef Eigen::TensorMap<
+      Eigen::Tensor<const T, 1, Eigen::RowMajor, IndexType> >
+      UnalignedConstVec;
+
+  // Rank-2 tensor (matrix) of scalar type T.
+  typedef Eigen::TensorMap<Eigen::Tensor<T, 2, Eigen::RowMajor, IndexType>,
+                           Eigen::Aligned>
+      Matrix;
+  typedef Eigen::TensorMap<
+      Eigen::Tensor<const T, 2, Eigen::RowMajor, IndexType>, Eigen::Aligned>
+      ConstMatrix;
+
+  // Unaligned Rank-2 tensor (matrix) of scalar type T.
+  typedef Eigen::TensorMap<Eigen::Tensor<T, 2, Eigen::RowMajor, IndexType> >
+      UnalignedMatrix;
+  typedef Eigen::TensorMap<
+      Eigen::Tensor<const T, 2, Eigen::RowMajor, IndexType> >
+      UnalignedConstMatrix;
+};
+
+typedef typename TTypes<float, 1>::Tensor32Bit::Index Index32;
+
+template <typename Index, int NumDims>
+bool SafeFor32BitIndexing(const Eigen::DSizes<Index, NumDims>& in) {
+  for (int i = 0; i < NumDims; ++i) {
+    if (in[i] > std::numeric_limits<Index32>::max()) return false;
+  }
+  return true;
+}
+
+template <typename Index, size_t NumDims>
+bool SafeFor32BitIndexing(const Eigen::array<Index, NumDims>& in) {
+  for (size_t i = 0; i < NumDims; ++i) {
+    if (in[i] > std::numeric_limits<Index32>::max()) return false;
+  }
+  return true;
+}
+
+template <typename TensorType,
+          typename Enable = typename TTypes<
+              typename TensorType::Scalar, TensorType::NumIndices>::Tensor32Bit>
+bool SafeFor32BitIndexing(TensorType in) {
+  return in.size() <= std::numeric_limits<Index32>::max();
+}
+
+template <typename Index, int NumDims>
+Eigen::DSizes<Index32, NumDims> To32Bit(
+    const Eigen::DSizes<Index, NumDims>& in) {
+  DCHECK(SafeFor32BitIndexing(in));
+  Eigen::DSizes<Index32, NumDims> out;
+  for (int i = 0; i < NumDims; ++i) {
+    out[i] = static_cast<Index32>(in[i]);
+  }
+  return out;
+}
+
+template <typename Index, size_t NumDims>
+Eigen::array<Index32, NumDims> To32Bit(const Eigen::array<Index, NumDims>& in) {
+  DCHECK(SafeFor32BitIndexing(in));
+  Eigen::array<Index32, NumDims> out;
+  for (size_t i = 0; i < NumDims; ++i) {
+    out[i] = static_cast<Index32>(in[i]);
+  }
+  return out;
+}
+
+template <typename TensorType>
+typename TTypes<typename TensorType::Scalar,
+                TensorType::NumIndices>::Tensor32Bit
+To32Bit(TensorType in) {
+  typedef typename TTypes<typename TensorType::Scalar,
+                          TensorType::NumIndices>::Tensor32Bit RetType;
+  DCHECK(SafeFor32BitIndexing(in));
+  return RetType(in.data(), To32Bit(in.dimensions()));
+}
+
+namespace internal {
+
+template <typename Device>
+struct MaybeWith32BitIndexingImpl {
+  template <typename Func, typename... Args>
+  void operator()(Func func, Args&&... args) const {
+    func(std::forward<Args>(args)...);
+  }
+};
+
+template <>
+struct MaybeWith32BitIndexingImpl<Eigen::GpuDevice> {
+  template <typename Func, typename... Args>
+  void operator()(Func func, Args&&... args) const {
+    auto all = [](const auto&... bool_vals) {
+      for (bool b : {bool_vals...}) {
+        if (!b) return false;
+      }
+      return true;
+    };
+    if (all(SafeFor32BitIndexing(std::forward<Args>(args))...)) {
+      func(To32Bit(std::forward<Args>(args))...);
+    } else {
+      func(std::forward<Args>(args)...);
+    }
+  }
+};
+
+}  // namespace internal
+
+template <typename Device, typename Func, typename... Args>
+void MaybeWith32BitIndexing(Func func, Args&&... args) {
+  return internal::MaybeWith32BitIndexingImpl<Device>()(
+      func, std::forward<Args>(args)...);
+}
+
+}  // namespace tensorflow
+#endif  // TENSORFLOW_CORE_FRAMEWORK_TENSOR_TYPES_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/tensor_util.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/tensor_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..6e09b8ee93d619cae33a619f547f6c26472d2d87
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/tensor_util.h
@@ -0,0 +1,332 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_TENSOR_UTIL_H_
+#define TENSORFLOW_CORE_FRAMEWORK_TENSOR_UTIL_H_
+
+#include <algorithm>
+#include <vector>
+
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/tensor.pb.h"
+#include "tensorflow/core/framework/tensor_shape.pb.h"
+#include "tensorflow/core/framework/type_traits.h"
+#include "tensorflow/core/platform/protobuf.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+namespace tensor {
+
+// DeepCopy returns a tensor whose contents are a deep copy of the
+// contents of 'other'.  This function is intended only for
+// convenience, not speed.
+//
+// REQUIRES: 'other' must point to data stored in CPU memory.
+// REQUIRES: 'other' must be a Tensor of a copy-able type if
+//           'other' is not appropriately memory-aligned.
+Tensor DeepCopy(const Tensor& other);
+
+// Deep copies input to output.  This function is similar to above, but assumes
+// that the memory for the output has already been allocated.
+void DeepCopy(const Tensor& input, Tensor* output);
+
+// Concatenates 'tensors' into a single tensor, along their 0th dimension.
+//
+// REQUIRES: All members of 'tensors' must have the same data type parameter.
+// REQUIRES: Each member of 'tensors' must have at least one dimension.
+// REQUIRES: Each member of 'tensors' must point to data stored in CPU memory.
+// REQUIRES: Each member of 'tensors' must be a Tensor of a copy-able type if it
+//           is not appropriately memory-aligned.
+Status Concat(const gtl::ArraySlice<Tensor>& tensors,
+              Tensor* result) TF_MUST_USE_RESULT;
+
+// Splits 'tensor' into 'sizes.size()' individual tensors, along the 0th
+// dimension. The ith output tensor has 0th-dimension size 'sizes[i]'.
+//
+// REQUIRES: 'tensor' must have at least one dimension.
+// REQUIRES: 'tensor.dim_size(0)' must equal the sum of the elements of 'sizes'.
+// REQUIRES: 'tensor' must point to data stored in CPU memory.
+// REQUIRES: 'tensor' must be a Tensor of a copy-able type if it is not
+//           appropriately memory-aligned.
+//
+// Split() and Concat() are inverse operations.
+Status Split(const Tensor& tensor, const gtl::ArraySlice<int64_t>& sizes,
+             std::vector<Tensor>* result) TF_MUST_USE_RESULT;
+
+namespace internal {
+void SetTensorProtoShape(std::vector<size_t> shape,
+                         TensorShapeProto* shape_proto);
+
+template <typename Type>
+class TensorProtoFieldHelper : public std::false_type {};
+
+#define DEFINE_PROTO_FIELD_HELPER(TYPE, FIELDNAME)                            \
+  template <>                                                                 \
+  class TensorProtoFieldHelper<TYPE> : public std::true_type {                \
+   public:                                                                    \
+    typedef decltype(                                                         \
+        std::declval<TensorProto>().FIELDNAME##_val(0)) FieldType;            \
+    typedef decltype(                                                         \
+        std::declval<TensorProto>().FIELDNAME##_val()) RepeatedFieldType;     \
+    typedef decltype(std::declval<TensorProto>().mutable_##FIELDNAME##_val()) \
+        MutableRepeatedFieldType;                                             \
+    static MutableRepeatedFieldType GetMutableField(TensorProto* proto) {     \
+      return proto->mutable_##FIELDNAME##_val();                              \
+    }                                                                         \
+    static RepeatedFieldType& GetField(const TensorProto& proto) {            \
+      return proto.FIELDNAME##_val();                                         \
+    }                                                                         \
+  }
+
+// The argument pairs in the following macro instantiations encode the
+// mapping from C++ type ($1) to repeated field name "$2_val" used for storing
+// values in TensorProto. See tensorflow/core/framework/tensor.proto.
+DEFINE_PROTO_FIELD_HELPER(float, float);
+DEFINE_PROTO_FIELD_HELPER(double, double);
+DEFINE_PROTO_FIELD_HELPER(int8, int);
+DEFINE_PROTO_FIELD_HELPER(uint8, int);
+DEFINE_PROTO_FIELD_HELPER(int16, int);
+DEFINE_PROTO_FIELD_HELPER(uint16, int);
+DEFINE_PROTO_FIELD_HELPER(int32, int);
+DEFINE_PROTO_FIELD_HELPER(uint32, uint32);
+DEFINE_PROTO_FIELD_HELPER(int64_t, int64);
+DEFINE_PROTO_FIELD_HELPER(uint64, uint64);
+DEFINE_PROTO_FIELD_HELPER(bool, bool);
+DEFINE_PROTO_FIELD_HELPER(qint8, int);
+DEFINE_PROTO_FIELD_HELPER(quint8, int);
+DEFINE_PROTO_FIELD_HELPER(qint16, int);
+DEFINE_PROTO_FIELD_HELPER(quint16, int);
+DEFINE_PROTO_FIELD_HELPER(qint32, int);
+DEFINE_PROTO_FIELD_HELPER(Eigen::half, half);
+DEFINE_PROTO_FIELD_HELPER(bfloat16, half);
+DEFINE_PROTO_FIELD_HELPER(complex64, scomplex);
+DEFINE_PROTO_FIELD_HELPER(complex128, dcomplex);
+
+#undef DEFINE_PROTO_HELPER
+
+template <typename T>
+struct CopyHelper {
+  template <typename SrcIter, typename DstIter>
+  static void ToArray(SrcIter begin, SrcIter end, DstIter dst) {
+    using SrcType = typename std::iterator_traits<SrcIter>::value_type;
+    using DstType = typename std::iterator_traits<DstIter>::value_type;
+    std::transform(begin, end, dst, [](const SrcType& x) -> DstType {
+      return static_cast<DstType>(x);
+    });
+  }
+  template <typename SrcIter>
+  static void ToArray(SrcIter begin, SrcIter end, SrcIter dst) {
+    std::copy(begin, end, dst);
+  }
+  template <typename SrcIter, typename DstIter>
+  static void FromArray(SrcIter begin, SrcIter end, DstIter dst) {
+    ToArray(begin, end, dst);
+  }
+};
+
+// Overloads for Eigen::half and bfloat16 that are 16 bits in size but are
+// stored in an int32 field.
+template <>
+struct CopyHelper<Eigen::half> {
+  template <typename SrcIter>
+  static void ToArray(SrcIter begin, SrcIter end, Eigen::half* dst) {
+    std::transform(begin, end, dst, [](int x) -> Eigen::half {
+      return Eigen::numext::bit_cast<Eigen::half>(static_cast<uint16>(x));
+    });
+  }
+  template <typename SrcIter, typename DstIter>
+  static void FromArray(SrcIter begin, SrcIter end, DstIter dst) {
+    std::transform(begin, end, dst, [](Eigen::half h) -> int {
+      return static_cast<int>(Eigen::numext::bit_cast<uint16>(h));
+    });
+  }
+};
+
+template <>
+struct CopyHelper<bfloat16> {
+  template <typename SrcIter>
+  static void ToArray(SrcIter begin, SrcIter end, bfloat16* dst) {
+    std::transform(begin, end, dst, [](int x) -> bfloat16 {
+      return Eigen::numext::bit_cast<bfloat16>(static_cast<uint16>(x));
+    });
+  }
+  template <typename SrcIter, typename DstIter>
+  static void FromArray(SrcIter begin, SrcIter end, DstIter dst) {
+    std::transform(begin, end, dst, [](bfloat16 bf16) -> int {
+      return static_cast<int>(Eigen::numext::bit_cast<uint16>(bf16));
+    });
+  }
+};
+
+// Overloads for complex types that store real and imaginary parts
+// at indices 2*i and 2*i+1 in float or double field.
+template <typename RealType>
+struct CopyHelper<std::complex<RealType>> {
+  template <typename SrcIter>
+  static void ToArray(SrcIter begin, SrcIter end, std::complex<RealType>* dst) {
+    RealType* real_dst = reinterpret_cast<RealType*>(dst);
+    std::copy(begin, end, real_dst);
+  }
+
+  template <typename SrcIter, typename DstIter>
+  static void FromArray(SrcIter begin, SrcIter end, DstIter dst) {
+    size_t n = std::distance(begin, end);
+    const RealType* real_begin = reinterpret_cast<const RealType*>(&(*begin));
+    std::copy_n(real_begin, 2 * n, dst);
+  }
+};
+
+// Helper class to extract and insert values into TensorProto represented as
+// repeated fields.
+template <typename T>
+class TensorProtoHelper : public std::true_type {
+ public:
+  using FieldHelper = TensorProtoFieldHelper<T>;
+  using FieldType = typename TensorProtoFieldHelper<T>::FieldType;
+
+  static DataType GetDataType() { return DataTypeToEnum<T>::value; }
+
+  // Returns the number of values of type T encoded in the proto.
+  static size_t NumValues(const TensorProto& proto) {
+    size_t raw_size = FieldHelper::GetField(proto).size();
+    return is_complex<T>::value ? raw_size / 2 : raw_size;
+  }
+
+  static void AddValue(const T& value, TensorProto* proto) {
+    const T* val_ptr = &value;
+    AddValues(val_ptr, val_ptr + 1, proto);
+  }
+
+  static T GetValue(size_t index, const TensorProto& proto) {
+    const size_t stride = is_complex<T>::value ? 2 : 1;
+    T val;
+    CopyHelper<T>::ToArray(
+        FieldHelper::GetField(proto).begin() + stride * index,
+        FieldHelper::GetField(proto).begin() + stride * (index + 1), &val);
+    return val;
+  }
+
+  template <typename IterType>
+  static void AddValues(IterType begin, IterType end, TensorProto* proto) {
+    size_t n = std::distance(begin, end);
+    FieldType* dst = AppendUninitialized(n, proto);
+    CopyHelper<T>::FromArray(begin, end, dst);
+  }
+
+  template <typename IterType>
+  static void CopyValues(IterType dst, const TensorProto& proto) {
+    CopyHelper<T>::ToArray(FieldHelper::GetField(proto).begin(),
+                           FieldHelper::GetField(proto).end(), dst);
+  }
+
+  static void Truncate(size_t new_size, TensorProto* proto) {
+    if (is_complex<T>::value) new_size *= 2;
+    FieldHelper::GetMutableField(proto)->Truncate(new_size);
+  }
+
+  static FieldType* AppendUninitialized(size_t n, TensorProto* proto) {
+    if (is_complex<T>::value) n *= 2;
+    auto* field = FieldHelper::GetMutableField(proto);
+    field->Reserve(field->size() + n);
+    return reinterpret_cast<FieldType*>(field->AddNAlreadyReserved(n));
+  }
+};
+
+// Specialization for string.
+template <>
+class TensorProtoHelper<string> : public std::true_type {
+ public:
+  static DataType GetDataType() { return DataType::DT_STRING; }
+  static void AddValue(const string& value, TensorProto* proto) {
+    *proto->mutable_string_val()->Add() = value;
+  }
+  template <typename IterType>
+  static void AddValues(IterType begin, IterType end, TensorProto* proto) {
+    for (IterType it = begin; it != end; ++it) {
+      AddValue(*it, proto);
+    }
+  }
+  template <typename IterType>
+  static void CopyToTensorContent(IterType begin, IterType end,
+                                  TensorProto* proto) {
+    AddValues(begin, end, proto);
+  }
+};
+
+}  // namespace internal
+
+// Creates a 'TensorProto' with specified shape and values.
+// The dtype and a field to represent data values of the returned 'TensorProto'
+// are determined based on type of the 'values' parameter.
+template <typename Type>
+typename std::enable_if<internal::TensorProtoHelper<Type>::value,
+                        TensorProto>::type
+CreateTensorProto(const std::vector<Type>& values,
+                  const std::vector<size_t>& shape) {
+  TensorProto tensor;
+  TensorShapeProto tensor_shape_proto;
+  internal::SetTensorProtoShape(shape, &tensor_shape_proto);
+  if (TensorShape(tensor_shape_proto).num_elements() != values.size()) {
+    LOG(ERROR) << "Shape and number of values (" << values.size()
+               << ") are incompatible.";
+    return tensor;
+  }
+  using TypeHelper = internal::TensorProtoHelper<Type>;
+  tensor.set_dtype(TypeHelper::GetDataType());
+  tensor.mutable_tensor_shape()->Swap(&tensor_shape_proto);
+  TypeHelper::AddValues(values.begin(), values.end(), &tensor);
+  return tensor;
+}
+
+// Converts values in tensor to run-length encoded compressed form.
+//
+// The elements of a tensor can be stored in a TensorProto in one of the
+// following two forms:
+// 1. As a raw byte string in the field `tensor_content` containing the
+//    serialized in-memory representation of the tensor.
+// 2. As values of a repeated field depending on the datatype, e.g. that
+//    values of a DT_FLOAT tensor would be stored in the repeated field
+//    `float_val`.
+// Storage scheme 2 may use a simple form of run-length encoding to compress
+// data: If the values contains a tail of identical values, the repeated field
+// will be truncated such that the number of values in the repeated field is
+// less than the number of elements implied by the field`tensor_shape`. The
+// original tensor can be recovered by repeating the final value in the repeated
+// field.
+//
+// The TensorProto will be compressed if a) the tensor contains at least
+// min_num_elements elements and b) the compressed tensor proto is would be at
+// most the size of the original tensor proto divided by min_compression_ratio.
+//
+// Returns true if the tensor was compressed.
+bool CompressTensorProtoInPlace(int64_t min_num_elements,
+                                float min_compression_ratio,
+                                TensorProto* tensor);
+
+inline bool CompressTensorProtoInPlace(TensorProto* tensor) {
+  static const int64_t kDefaultMinNumElements = 64;
+  static const float kDefaultMinCompressionRatio = 2.0f;
+  return CompressTensorProtoInPlace(kDefaultMinNumElements,
+                                    kDefaultMinCompressionRatio, tensor);
+}
+
+// Make a TensorShape from the contents of shape_t. Shape_t must be a
+// 1-dimensional tensor of type int32 or int64.
+Status MakeShape(const Tensor& shape_t, TensorShape* out);
+
+}  // namespace tensor
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_TENSOR_UTIL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/thread_factory.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/thread_factory.h
new file mode 100644
index 0000000000000000000000000000000000000000..769ada29a5fe05f5c4461b1163274bdda50a2841
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/thread_factory.h
@@ -0,0 +1,44 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_FRAMEWORK_THREAD_FACTORY_H_
+#define TENSORFLOW_CORE_FRAMEWORK_THREAD_FACTORY_H_
+
+#include <functional>
+#include <memory>
+
+#include "tensorflow/core/platform/types.h"
+
+namespace tsl {
+class Thread;
+}  // namespace tsl
+namespace tensorflow {
+using tsl::Thread;  // NOLINT
+
+// Virtual interface for an object that creates threads.
+class ThreadFactory {
+ public:
+  virtual ~ThreadFactory() {}
+
+  // Runs `fn` asynchronously in a different thread. `fn` may block.
+  //
+  // NOTE: The caller is responsible for ensuring that this `ThreadFactory`
+  // outlives the returned `Thread`.
+  virtual std::unique_ptr<Thread> StartThread(const string& name,
+                                              std::function<void()> fn) = 0;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_THREAD_FACTORY_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/tracking_allocator.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/tracking_allocator.h
new file mode 100644
index 0000000000000000000000000000000000000000..8a40ff90ae08046d0a8b06e1a9ed1c78b1f0248d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/tracking_allocator.h
@@ -0,0 +1,37 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_TRACKING_ALLOCATOR_H_
+#define TENSORFLOW_CORE_FRAMEWORK_TRACKING_ALLOCATOR_H_
+
+#include <unordered_map>
+
+#include "tensorflow/core/framework/allocator.h"
+#include "tensorflow/core/lib/gtl/inlined_vector.h"
+#include "tensorflow/core/platform/mutex.h"
+#include "tensorflow/core/platform/thread_annotations.h"
+#include "tensorflow/core/platform/types.h"
+#include "tsl/framework/tracking_allocator.h"
+
+namespace tensorflow {
+
+// NOLINTEND(misc-unused-using-decls)
+using tsl::AllocRecord;
+using tsl::TrackingAllocator;
+// NOLINTEND(misc-unused-using-decls)
+
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_TRACKING_ALLOCATOR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/type_index.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/type_index.h
new file mode 100644
index 0000000000000000000000000000000000000000..d73ca52743cd8c2ed078e13d3a0633dd1bccbb0d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/type_index.h
@@ -0,0 +1,95 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_TYPE_INDEX_H_
+#define TENSORFLOW_CORE_FRAMEWORK_TYPE_INDEX_H_
+
+#include <string>
+
+#if defined(__GXX_RTTI) || defined(_CPPRTTI)
+#include <typeinfo>
+#endif  // __GXX_RTTI
+
+#include "tensorflow/core/platform/hash.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+
+// On some platforms, we would like to avoid using RTTI in order to have smaller
+// binary sizes. This file provides a thin TypeIndex class that mimics
+// std::type_index but does not use RTTI (with a minimal set of functions needed
+// by the TensorFlow framework, and more can be added if necessary). In the
+// absence of RTTI, it does not provide the actual name of the type, and only
+// returns a pre-baked string specifying that RTTI is disabled. The hash code
+// provided in this class is unique for each class. However, it is generated at
+// runtime so this hash code should not be serialized - the value for the same
+// type can change from run to run.
+class TypeIndex {
+ public:
+  TypeIndex(const TypeIndex& src) : hash_(src.hash_), name_(src.name_) {}
+  TypeIndex& operator=(const TypeIndex& src) {
+    hash_ = src.hash_;
+    name_ = src.name_;
+    return *this;
+  }
+  bool operator==(const TypeIndex& rhs) const { return (hash_ == rhs.hash_); }
+  bool operator!=(const TypeIndex& rhs) const { return (hash_ != rhs.hash_); }
+  ~TypeIndex() {}
+
+  const char* name() const { return name_; }
+
+  uint64 hash_code() const { return hash_; }
+
+  // Returns a TypeIndex object that corresponds to a typename.
+  template <typename T>
+  static TypeIndex Make() {
+#ifdef PLATFORM_CLOUD_TPU
+    static bool hash_bit[1];
+    return TypeIndex(static_cast<uint64>(reinterpret_cast<intptr_t>(hash_bit)),
+                     typeid(T).name());
+#endif
+#if defined(__GXX_RTTI) || defined(_CPPRTTI)
+
+    // Use a hash based on the type name to avoid issues due to RTLD_LOCAL on
+    // MacOS (b/156979412).
+    return TypeIndex(Hash64(typeid(T).name()), typeid(T).name());
+
+#else
+    static bool hash_bit[1];
+#if TARGET_OS_OSX
+    // Warn MacOS users that not using RTTI can cause problems (b/156979412).
+#warning \
+    "Compiling with RTTI disabled on MacOS can cause problems when comparing " \
+    "types across shared libraries."
+#endif  // TARGET_OS_OSX
+
+    // No type names available.
+    return TypeIndex(static_cast<uint64>(reinterpret_cast<intptr_t>(hash_bit)),
+                     "[RTTI disabled]");
+#endif  // __GXX_RTTI
+  }
+
+ private:
+  // We hide the constructor of the TypeIndex class. Use the templated
+  // Make<T>() function to create a TypeIndex object.
+  explicit TypeIndex(const uint64 hash, const char* name)
+      : hash_(hash), name_(name) {}
+  uint64 hash_;
+  const char* name_;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_TYPE_INDEX_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/type_traits.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/type_traits.h
new file mode 100644
index 0000000000000000000000000000000000000000..c955181093a2368f9a16bbbd6b507b1820f9f45a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/type_traits.h
@@ -0,0 +1,38 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_TYPE_TRAITS_H_
+#define TENSORFLOW_CORE_FRAMEWORK_TYPE_TRAITS_H_
+
+#include <limits>
+#include <utility>
+
+#include "tensorflow/core/framework/numeric_types.h"
+#include "tensorflow/core/platform/types.h"
+#include "tsl/framework/type_traits.h"
+
+namespace tensorflow {
+
+// NOLINTBEGIN(misc-unused-using-decls)
+using tsl::false_type;
+using tsl::is_complex;
+using tsl::is_quantized;
+using tsl::is_simple_type;
+using tsl::true_type;
+// NOLINTEND(misc-unused-using-decls)
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_TYPE_TRAITS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/typed_allocator.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/typed_allocator.h
new file mode 100644
index 0000000000000000000000000000000000000000..20e16358f2c4c3ad9b7bdc6ff366b83b18c78a19
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/typed_allocator.h
@@ -0,0 +1,134 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_TYPED_ALLOCATOR_H_
+#define TENSORFLOW_CORE_FRAMEWORK_TYPED_ALLOCATOR_H_
+
+#include <limits>
+
+#include "tensorflow/core/framework/allocator.h"
+#include "tensorflow/core/framework/resource_handle.h"
+#include "tensorflow/core/framework/type_traits.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+
+class Variant;
+
+// Convenience functions to do typed allocation.  C++ constructors
+// and destructors are invoked for complex types if necessary.
+class TypedAllocator {
+ public:
+  // May return NULL if the tensor has too many elements to represent in a
+  // single allocation.
+  template <typename T>
+  static T* Allocate(Allocator* raw_allocator, size_t num_elements,
+                     const AllocationAttributes& allocation_attr) {
+    // TODO(jeff): Do we need to allow clients to pass in alignment
+    // requirements?
+
+    if (num_elements > (std::numeric_limits<size_t>::max() / sizeof(T))) {
+      return nullptr;
+    }
+
+    void* p =
+        raw_allocator->AllocateRaw(Allocator::kAllocatorAlignment,
+                                   sizeof(T) * num_elements, allocation_attr);
+    T* typed_p = reinterpret_cast<T*>(p);
+    if (typed_p) RunCtor<T>(raw_allocator, typed_p, num_elements);
+    return typed_p;
+  }
+
+  template <typename T>
+  static void Deallocate(Allocator* raw_allocator, T* ptr,
+                         size_t num_elements) {
+    if (ptr) {
+      RunDtor<T>(raw_allocator, ptr, num_elements);
+      raw_allocator->DeallocateRaw(ptr);
+    }
+  }
+
+ private:
+  // No constructors or destructors are run for simple types
+  template <typename T>
+  static void RunCtor(Allocator* raw_allocator, T* p, size_t n) {
+    static_assert(is_simple_type<T>::value, "T is not a simple type.");
+  }
+
+  template <typename T>
+  static void RunDtor(Allocator* raw_allocator, T* p, size_t n) {}
+
+  static void RunVariantCtor(Variant* p, size_t n);
+
+  static void RunVariantDtor(Variant* p, size_t n);
+};
+
+template <>
+/* static */
+inline void TypedAllocator::RunCtor(Allocator* raw_allocator, tstring* p,
+                                    size_t n) {
+  if (!raw_allocator->AllocatesOpaqueHandle()) {
+    for (size_t i = 0; i < n; ++p, ++i) new (p) tstring();
+  }
+}
+
+template <>
+/* static */
+inline void TypedAllocator::RunDtor(Allocator* raw_allocator, tstring* p,
+                                    size_t n) {
+  if (!raw_allocator->AllocatesOpaqueHandle()) {
+    for (size_t i = 0; i < n; ++p, ++i) p->~tstring();
+  }
+}
+
+template <>
+/* static */
+inline void TypedAllocator::RunCtor(Allocator* raw_allocator, ResourceHandle* p,
+                                    size_t n) {
+  if (!raw_allocator->AllocatesOpaqueHandle()) {
+    for (size_t i = 0; i < n; ++p, ++i) new (p) ResourceHandle();
+  }
+}
+
+template <>
+/* static */
+inline void TypedAllocator::RunDtor(Allocator* raw_allocator, ResourceHandle* p,
+                                    size_t n) {
+  if (!raw_allocator->AllocatesOpaqueHandle()) {
+    for (size_t i = 0; i < n; ++p, ++i) p->~ResourceHandle();
+  }
+}
+
+template <>
+/* static */
+inline void TypedAllocator::RunCtor(Allocator* raw_allocator, Variant* p,
+                                    size_t n) {
+  if (!raw_allocator->AllocatesOpaqueHandle()) {
+    RunVariantCtor(p, n);
+  }
+}
+
+template <>
+/* static */
+inline void TypedAllocator::RunDtor(Allocator* raw_allocator, Variant* p,
+                                    size_t n) {
+  if (!raw_allocator->AllocatesOpaqueHandle()) {
+    RunVariantDtor(p, n);
+  }
+}
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_TYPED_ALLOCATOR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/types.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/types.h
new file mode 100644
index 0000000000000000000000000000000000000000..9a6935b83dc4455e6903aadd45329abd89778625
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/types.h
@@ -0,0 +1,568 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_TYPES_H_
+#define TENSORFLOW_CORE_FRAMEWORK_TYPES_H_
+
+#include <map>
+#include <set>
+#include <string>
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/framework/bfloat16.h"
+#include "tensorflow/core/framework/full_type.pb.h"
+#include "tensorflow/core/framework/numeric_types.h"
+#include "tensorflow/core/framework/resource_handle.h"
+#include "tensorflow/core/framework/types.pb.h"
+#include "tensorflow/core/lib/core/stringpiece.h"
+#include "tensorflow/core/lib/gtl/array_slice.h"
+#include "tensorflow/core/lib/gtl/inlined_vector.h"
+#include "tensorflow/core/platform/logging.h"
+#include "tensorflow/core/platform/types.h"
+#include "tsl/framework/device_type.h"
+
+namespace tensorflow {
+
+class Variant;
+
+// MemoryType is used to describe whether input or output Tensors of
+// an OpKernel should reside in "Host memory" (e.g., CPU memory) or
+// "Device" Memory (CPU memory for CPU devices, GPU memory for GPU
+// devices).
+enum MemoryType {
+  DEVICE_MEMORY = 0,
+  HOST_MEMORY = 1,
+};
+
+using tsl::DeviceType;  // NOLINT
+
+// Convenient constants that can be passed to a DeviceType constructor.
+// See comments for CreateOpKernel in op_kernel.h for uses of DEVICE_DEFAULT
+// and other device types.
+TF_EXPORT extern const char* const DEVICE_DEFAULT;     // "DEFAULT"
+TF_EXPORT extern const char* const DEVICE_CPU;         // "CPU"
+TF_EXPORT extern const char* const DEVICE_GPU;         // "GPU"
+TF_EXPORT extern const char* const DEVICE_TPU;         // "TPU"
+TF_EXPORT extern const char* const DEVICE_TPU_SYSTEM;  // "TPU_SYSTEM"
+
+template <typename Device>
+struct DeviceName {};
+
+template <>
+struct DeviceName<Eigen::ThreadPoolDevice> {
+  static const std::string value;
+};
+
+#if (defined(GOOGLE_CUDA) && GOOGLE_CUDA) || \
+    (defined(TENSORFLOW_USE_ROCM) && TENSORFLOW_USE_ROCM)
+template <>
+struct DeviceName<Eigen::GpuDevice> {
+  static const std::string value;
+};
+#endif  // GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+
+typedef gtl::InlinedVector<MemoryType, 4> MemoryTypeVector;
+typedef gtl::ArraySlice<MemoryType> MemoryTypeSlice;
+
+typedef gtl::InlinedVector<DataType, 4> DataTypeVector;
+typedef gtl::ArraySlice<DataType> DataTypeSlice;
+
+typedef gtl::InlinedVector<DeviceType, 4> DeviceTypeVector;
+typedef gtl::InlinedVector<std::pair<DeviceType, int32>, 4>
+    PrioritizedDeviceTypeVector;
+
+// Convert the enums to strings for errors:
+std::string DataTypeString(DataType dtype);
+std::string DeviceTypeString(const DeviceType& device_type);
+std::string DataTypeSliceString(const DataTypeSlice dtypes);
+inline std::string DataTypeVectorString(const DataTypeVector& dtypes) {
+  return DataTypeSliceString(dtypes);
+}
+
+// DataTypeSet represents a set of DataType values as a simple and efficient
+// bit mask.  Note that DataTypeSet cannot represent all DataType values; it
+// cannot represent any of the DT_*_REF values.
+class DataTypeSet {
+ private:
+  const uint32 mask_;
+
+  static constexpr uint32 kNumBits = 32;
+
+ public:
+  constexpr DataTypeSet(const DataTypeSet& other) : mask_(other.mask_) {}
+  explicit constexpr DataTypeSet(uint32 mask) : mask_(mask) {}
+
+  constexpr bool Contains(DataType dt) const {
+    return (static_cast<uint32>(dt) < kNumBits) &&
+           ((mask_ >> static_cast<uint32>(dt)) & 1u) != 0u;
+  }
+
+  class Iterator {
+    const DataTypeSet& set_;
+    uint32 pos_;
+
+   public:
+    Iterator(const DataTypeSet& set, uint32 pos) : set_(set), pos_(pos) {
+      DCHECK_LE(pos, kNumBits);
+    }
+    DataType operator*() const { return static_cast<DataType>(pos_); }
+    Iterator& operator++() {
+      ++pos_;
+      DCHECK_LE(pos_, kNumBits);
+      if (pos_ < kNumBits) {
+        uint32 remaining_mask = set_.mask_ >> pos_;
+        if (remaining_mask != 0u) {
+          pos_ += ctz_uint32(remaining_mask);
+        }
+      }
+      DCHECK_LE(pos_, kNumBits);
+      return *this;
+    }
+    bool operator==(const Iterator& other) const { return pos_ == other.pos_; }
+    bool operator!=(const Iterator& other) const { return !(*this == other); }
+    size_t operator-(const Iterator& other) const {
+      return this->pos_ - other.pos_;
+    }
+  };
+
+  static uint32 ctz_uint32(uint32 x) {
+    DCHECK_NE(x, 0u);
+#ifdef __GNUC__
+    return __builtin_ctz(x);
+#else
+    uint32 n = 0u;
+    while ((x & 1u) == 0u) {
+      x >>= 1;
+      ++n;
+    }
+    return n;
+#endif
+  }
+
+  static uint32 clz_uint32(uint32 x) {
+    DCHECK_NE(x, 0u);
+#ifdef __GNUC__
+    return __builtin_clz(x);
+#else
+    uint32 n = 0u;
+    while ((x >> (kNumBits - 1u)) == 0u) {
+      x <<= 1;
+      ++n;
+    }
+    return n;
+#endif
+  }
+
+  Iterator begin() const {
+    // The begin position is the index of the first bit set to 1 in the entire
+    // bit mask. If there are no bits set to 1, then the index is 0.
+    if (mask_ != 0) {
+      return Iterator(*this, ctz_uint32(mask_));
+    }
+    // The set is empty.
+    return Iterator(*this, 0);
+  }
+
+  Iterator end() const {
+    // The end position is the index of the highest bit that is set, plus 1.
+    // If there are no bits set to 1, then the index is 0.
+    if (mask_ != 0) {
+      return Iterator(*this, kNumBits - clz_uint32(mask_));
+    }
+    // The set is empty.
+    return Iterator(*this, 0);
+  }
+
+  size_t size() const {
+#if defined(__GNUC__)
+    return __builtin_popcount(mask_);
+#else
+    size_t n = 0;
+    uint32 x = mask_;
+    while (x > 0) {
+      n += x & 1u;
+      x >>= 1;
+    }
+    return n;
+#endif
+  }
+
+  constexpr DataTypeSet operator|(const DataTypeSet& other) const {
+    return DataTypeSet(mask_ | other.mask_);
+  }
+};
+
+// If "sp" names a valid type, store it in "*dt" and return true.  Otherwise,
+// return false.
+bool DataTypeFromString(StringPiece sp, DataType* dt);
+
+constexpr inline DataTypeSet ToSet(DataType dt) {
+  return DataTypeSet(1u << static_cast<uint32>(dt));
+}
+
+// DT_FLOAT + kDataTypeRefOffset == DT_FLOAT_REF, etc.
+enum { kDataTypeRefOffset = 100 };
+inline bool IsRefType(DataType dtype) {
+  return dtype > static_cast<DataType>(kDataTypeRefOffset);
+}
+inline DataType MakeRefType(DataType dtype) {
+  DCHECK(!IsRefType(dtype));
+  return static_cast<DataType>(dtype + kDataTypeRefOffset);
+}
+inline DataType RemoveRefType(DataType dtype) {
+  DCHECK(IsRefType(dtype));
+  return static_cast<DataType>(dtype - kDataTypeRefOffset);
+}
+inline DataType BaseType(DataType dtype) {
+  return IsRefType(dtype) ? RemoveRefType(dtype) : dtype;
+}
+
+// Returns true if the actual type is the same as or ref of the expected type.
+inline bool TypesCompatible(DataType expected, DataType actual) {
+  return expected == actual || expected == BaseType(actual);
+}
+
+// Does not include _ref types.
+constexpr DataTypeSet kAllTypes =
+    ToSet(DT_FLOAT) | ToSet(DT_DOUBLE) | ToSet(DT_INT32) | ToSet(DT_UINT8) |
+    ToSet(DT_INT16) | ToSet(DT_UINT16) | ToSet(DT_INT8) | ToSet(DT_STRING) |
+    ToSet(DT_COMPLEX64) | ToSet(DT_COMPLEX128) | ToSet(DT_INT64) |
+    ToSet(DT_BOOL) | ToSet(DT_QINT8) | ToSet(DT_QUINT8) | ToSet(DT_QINT16) |
+    ToSet(DT_QUINT16) | ToSet(DT_QINT32) | ToSet(DT_HALF) | ToSet(DT_RESOURCE) |
+    ToSet(DT_VARIANT) | ToSet(DT_UINT32) | ToSet(DT_UINT64) |
+    ToSet(DT_BFLOAT16) | ToSet(DT_FLOAT8_E5M2) | ToSet(DT_FLOAT8_E4M3FN) |
+    ToSet(DT_INT4) | ToSet(DT_UINT4);
+
+inline const DataTypeSet& AllTypes() { return kAllTypes; }
+
+#if !defined(IS_MOBILE_PLATFORM) || defined(SUPPORT_SELECTIVE_REGISTRATION)
+
+// Types that support '<' and '>'.
+constexpr DataTypeSet kRealNumberTypes =
+    ToSet(DT_FLOAT) | ToSet(DT_DOUBLE) | ToSet(DT_INT32) | ToSet(DT_INT64) |
+    ToSet(DT_UINT8) | ToSet(DT_INT16) | ToSet(DT_INT8) | ToSet(DT_UINT16) |
+    ToSet(DT_HALF) | ToSet(DT_UINT32) | ToSet(DT_UINT64) | ToSet(DT_BFLOAT16);
+inline const DataTypeSet& RealNumberTypes() { return kRealNumberTypes; }
+
+// Return the list of all numeric types.
+// Includes complex and quantized types.
+// NOTE: On Android, we only include the float and int32 types for now.
+const DataTypeSet kNumberTypes =
+    ToSet(DT_FLOAT) | ToSet(DT_DOUBLE) | ToSet(DT_INT64) | ToSet(DT_INT32) |
+    ToSet(DT_UINT8) | ToSet(DT_UINT16) | ToSet(DT_INT16) | ToSet(DT_INT8) |
+    ToSet(DT_COMPLEX64) | ToSet(DT_COMPLEX128) | ToSet(DT_QINT8) |
+    ToSet(DT_QUINT8) | ToSet(DT_QINT16) | ToSet(DT_QUINT16) | ToSet(DT_QINT32) |
+    ToSet(DT_HALF) | ToSet(DT_UINT32) | ToSet(DT_UINT64) | ToSet(DT_BFLOAT16);
+inline const DataTypeSet& NumberTypes() { return kNumberTypes; }
+
+constexpr DataTypeSet kQuantizedTypes = ToSet(DT_QINT8) | ToSet(DT_QUINT8) |
+                                        ToSet(DT_QINT16) | ToSet(DT_QUINT16) |
+                                        ToSet(DT_QINT32);
+inline const DataTypeSet& QuantizedTypes() { return kQuantizedTypes; }
+
+// Types that support '<' and '>', including quantized types.
+const DataTypeSet kRealAndQuantizedTypes =
+    ToSet(DT_FLOAT) | ToSet(DT_DOUBLE) | ToSet(DT_INT32) | ToSet(DT_INT64) |
+    ToSet(DT_UINT8) | ToSet(DT_UINT16) | ToSet(DT_INT16) | ToSet(DT_INT8) |
+    ToSet(DT_QINT8) | ToSet(DT_QUINT8) | ToSet(DT_QINT16) | ToSet(DT_QUINT16) |
+    ToSet(DT_QINT32) | ToSet(DT_HALF) | ToSet(DT_BFLOAT16);
+inline const DataTypeSet& RealAndQuantizedTypes() {
+  return kRealAndQuantizedTypes;
+}
+
+#elif defined(__ANDROID_TYPES_FULL__)
+
+constexpr DataTypeSet kRealNumberTypes =
+    ToSet(DT_FLOAT) | ToSet(DT_INT32) | ToSet(DT_INT64) | ToSet(DT_HALF);
+inline DataTypeSet RealNumberTypes() { return kRealNumberTypes; }
+
+constexpr DataTypeSet kNumberTypes =
+    ToSet(DT_FLOAT) | ToSet(DT_INT32) | ToSet(DT_INT64) | ToSet(DT_QINT8) |
+    ToSet(DT_QUINT8) | ToSet(DT_QINT32) | ToSet(DT_HALF);
+inline DataTypeSet NumberTypes() { return kNumberTypes; }
+
+constexpr DataTypeSet kQuantizedTypes = ToSet(DT_QINT8) | ToSet(DT_QUINT8) |
+                                        ToSet(DT_QINT16) | ToSet(DT_QUINT16) |
+                                        ToSet(DT_QINT32);
+inline DataTypeSet QuantizedTypes() { return kQuantizedTypes; }
+
+constexpr DataTypeSet kRealAndQuantizedTypes =
+    ToSet(DT_FLOAT) | ToSet(DT_INT32) | ToSet(DT_INT64) | ToSet(DT_QINT8) |
+    ToSet(DT_QUINT8) | ToSet(DT_QINT16) | ToSet(DT_QUINT16) | ToSet(DT_QINT32) |
+    ToSet(DT_HALF);
+inline DataTypeSet RealAndQuantizedTypes() { return kRealAndQuantizedTypes; }
+
+#else  // defined(IS_MOBILE_PLATFORM) && !defined(__ANDROID_TYPES_FULL__)
+
+constexpr DataTypeSet kRealNumberTypes = ToSet(DT_FLOAT) | ToSet(DT_INT32);
+inline DataTypeSet RealNumberTypes() { return kRealNumberTypes; }
+
+constexpr DataTypeSet kNumberTypes = ToSet(DT_FLOAT) | ToSet(DT_INT32) |
+                                     ToSet(DT_QINT8) | ToSet(DT_QUINT8) |
+                                     ToSet(DT_QINT32);
+inline DataTypeSet NumberTypes() { return kNumberTypes; }
+
+constexpr DataTypeSet kQuantizedTypes = ToSet(DT_QINT8) | ToSet(DT_QUINT8) |
+                                        ToSet(DT_QINT16) | ToSet(DT_QUINT16) |
+                                        ToSet(DT_QINT32);
+inline DataTypeSet QuantizedTypes() { return kQuantizedTypes; }
+
+constexpr DataTypeSet kRealAndQuantizedTypes =
+    ToSet(DT_FLOAT) | ToSet(DT_INT32) | ToSet(DT_QINT8) | ToSet(DT_QUINT8) |
+    ToSet(DT_QINT16) | ToSet(DT_QUINT16) | ToSet(DT_QINT32);
+inline DataTypeSet RealAndQuantizedTypes() { return kRealAndQuantizedTypes; }
+
+#endif  // defined(IS_MOBILE_PLATFORM)
+
+// Validates type T for whether it is a supported DataType.
+template <class T>
+struct IsValidDataType;
+
+// DataTypeToEnum<T>::v() and DataTypeToEnum<T>::value are the DataType
+// constants for T, e.g. DataTypeToEnum<float>::v() is DT_FLOAT.
+template <class T>
+struct DataTypeToEnum {
+  static_assert(IsValidDataType<T>::value, "Specified Data Type not supported");
+};  // Specializations below
+
+// EnumToDataType<VALUE>::Type is the type for DataType constant VALUE, e.g.
+// EnumToDataType<DT_FLOAT>::Type is float.
+template <DataType VALUE>
+struct EnumToDataType {};  // Specializations below
+
+// Template specialization for both DataTypeToEnum and EnumToDataType.
+#define MATCH_TYPE_AND_ENUM(TYPE, ENUM)                 \
+  template <>                                           \
+  struct DataTypeToEnum<TYPE> {                         \
+    static DataType v() { return ENUM; }                \
+    static DataType ref() { return MakeRefType(ENUM); } \
+    static constexpr DataType value = ENUM;             \
+  };                                                    \
+  template <>                                           \
+  struct IsValidDataType<TYPE> {                        \
+    static constexpr bool value = true;                 \
+  };                                                    \
+  template <>                                           \
+  struct EnumToDataType<ENUM> {                         \
+    typedef TYPE Type;                                  \
+  }
+
+MATCH_TYPE_AND_ENUM(float, DT_FLOAT);
+MATCH_TYPE_AND_ENUM(double, DT_DOUBLE);
+MATCH_TYPE_AND_ENUM(int32, DT_INT32);
+MATCH_TYPE_AND_ENUM(uint32, DT_UINT32);
+MATCH_TYPE_AND_ENUM(uint16, DT_UINT16);
+MATCH_TYPE_AND_ENUM(uint8, DT_UINT8);
+MATCH_TYPE_AND_ENUM(int16, DT_INT16);
+MATCH_TYPE_AND_ENUM(int8, DT_INT8);
+MATCH_TYPE_AND_ENUM(tstring, DT_STRING);
+MATCH_TYPE_AND_ENUM(complex64, DT_COMPLEX64);
+MATCH_TYPE_AND_ENUM(complex128, DT_COMPLEX128);
+MATCH_TYPE_AND_ENUM(bool, DT_BOOL);
+MATCH_TYPE_AND_ENUM(qint8, DT_QINT8);
+MATCH_TYPE_AND_ENUM(quint8, DT_QUINT8);
+MATCH_TYPE_AND_ENUM(qint16, DT_QINT16);
+MATCH_TYPE_AND_ENUM(quint16, DT_QUINT16);
+MATCH_TYPE_AND_ENUM(qint32, DT_QINT32);
+MATCH_TYPE_AND_ENUM(bfloat16, DT_BFLOAT16);
+MATCH_TYPE_AND_ENUM(Eigen::half, DT_HALF);
+MATCH_TYPE_AND_ENUM(float8_e5m2, DT_FLOAT8_E5M2);
+MATCH_TYPE_AND_ENUM(float8_e4m3fn, DT_FLOAT8_E4M3FN);
+MATCH_TYPE_AND_ENUM(int4, DT_INT4);
+MATCH_TYPE_AND_ENUM(uint4, DT_UINT4);
+MATCH_TYPE_AND_ENUM(ResourceHandle, DT_RESOURCE);
+MATCH_TYPE_AND_ENUM(Variant, DT_VARIANT);
+
+template <>
+struct DataTypeToEnum<long> {
+  static DataType v() { return value; }
+  static DataType ref() { return MakeRefType(value); }
+  static constexpr DataType value = sizeof(long) == 4 ? DT_INT32 : DT_INT64;
+};
+template <>
+struct IsValidDataType<long> {
+  static constexpr bool value = true;
+};
+template <>
+struct EnumToDataType<DT_INT64> {
+  typedef int64_t Type;
+};
+
+template <>
+struct DataTypeToEnum<unsigned long> {
+  static DataType v() { return value; }
+  static DataType ref() { return MakeRefType(value); }
+  static constexpr DataType value =
+      sizeof(unsigned long) == 4 ? DT_UINT32 : DT_UINT64;
+};
+template <>
+struct IsValidDataType<unsigned long> {
+  static constexpr bool value = true;
+};
+template <>
+struct EnumToDataType<DT_UINT64> {
+  typedef tensorflow::uint64 Type;
+};
+
+template <>
+struct DataTypeToEnum<long long> {
+  static DataType v() { return DT_INT64; }
+  static DataType ref() { return MakeRefType(DT_INT64); }
+  static constexpr DataType value = DT_INT64;
+};
+template <>
+struct IsValidDataType<long long> {
+  static constexpr bool value = true;
+};
+
+template <>
+struct DataTypeToEnum<unsigned long long> {
+  static DataType v() { return DT_UINT64; }
+  static DataType ref() { return MakeRefType(DT_UINT64); }
+  static constexpr DataType value = DT_UINT64;
+};
+template <>
+struct IsValidDataType<unsigned long long> {
+  static constexpr bool value = true;
+};
+
+#undef MATCH_TYPE_AND_ENUM
+
+// All types not specialized are marked invalid.
+template <class T>
+struct IsValidDataType {
+  static constexpr bool value = false;
+};
+
+// Extra validity checking; not part of public API.
+static_assert(IsValidDataType<int64_t>::value, "Incorrect impl for int64");
+static_assert(IsValidDataType<int32>::value, "Incorrect impl for int32");
+
+// TODO(jeff): Maybe unify this with Tensor::CanUseDMA, or the underlying
+// is_simple<T> in tensor.cc (and possible choose a more general name?)
+constexpr DataTypeSet kDataTypesCanUseMemcpy =
+    ToSet(DT_FLOAT) | ToSet(DT_DOUBLE) | ToSet(DT_INT32) | ToSet(DT_UINT32) |
+    ToSet(DT_UINT8) | ToSet(DT_UINT16) | ToSet(DT_INT16) | ToSet(DT_INT8) |
+    ToSet(DT_COMPLEX64) | ToSet(DT_COMPLEX128) | ToSet(DT_INT64) |
+    ToSet(DT_UINT64) | ToSet(DT_BOOL) | ToSet(DT_QINT8) | ToSet(DT_QUINT8) |
+    ToSet(DT_QINT16) | ToSet(DT_QUINT16) | ToSet(DT_QINT32) |
+    ToSet(DT_BFLOAT16) | ToSet(DT_HALF) | ToSet(DT_FLOAT8_E5M2) |
+    ToSet(DT_FLOAT8_E4M3FN) | ToSet(DT_INT4) | ToSet(DT_UINT4);
+inline bool DataTypeCanUseMemcpy(DataType dt) {
+  return kDataTypesCanUseMemcpy.Contains(dt);
+}
+
+// Returns true iff 'dt' is a real, non-quantized floating point type.
+constexpr DataTypeSet kDataTypeIsFloating =
+    ToSet(DT_HALF) | ToSet(DT_BFLOAT16) | ToSet(DT_FLOAT) | ToSet(DT_DOUBLE) |
+    ToSet(DT_FLOAT8_E4M3FN) | ToSet(DT_FLOAT8_E5M2);
+inline bool DataTypeIsFloating(DataType dt) {
+  return kDataTypeIsFloating.Contains(dt);
+}
+
+// Returns true iff 'dt' is a numeric type.
+inline bool DataTypeIsNumeric(DataType dt) { return kNumberTypes.Contains(dt); }
+
+// Returns true iff 'dt' is a complex type.
+constexpr DataTypeSet kDataTypeIsComplex =
+    ToSet(DT_COMPLEX64) | ToSet(DT_COMPLEX128);
+inline bool DataTypeIsComplex(DataType dt) {
+  return kDataTypeIsComplex.Contains(dt);
+}
+
+inline bool DataTypeIsQuantized(DataType dt) {
+  return kQuantizedTypes.Contains(dt);
+}
+
+// Is the dtype nonquantized integral?
+constexpr DataTypeSet kDataTypeIsInteger =
+    ToSet(DT_INT4) | ToSet(DT_UINT4) | ToSet(DT_INT8) | ToSet(DT_UINT8) |
+    ToSet(DT_INT16) | ToSet(DT_UINT16) | ToSet(DT_INT32) | ToSet(DT_UINT32) |
+    ToSet(DT_INT64) | ToSet(DT_UINT64);
+inline bool DataTypeIsInteger(DataType dt) {
+  return kDataTypeIsInteger.Contains(dt);
+}
+
+// Is the dtype a signed integral type?
+constexpr DataTypeSet kDataTypeIsSigned = ToSet(DT_INT4) | ToSet(DT_INT8) |
+                                          ToSet(DT_INT16) | ToSet(DT_INT32) |
+                                          ToSet(DT_INT64);
+inline bool DataTypeIsSigned(DataType dt) {
+  return kDataTypeIsSigned.Contains(dt);
+}
+
+// Is the dtype an unsigned integral type?
+constexpr DataTypeSet kDataTypeIsUnsigned = ToSet(DT_UINT4) | ToSet(DT_UINT8) |
+                                            ToSet(DT_UINT16) |
+                                            ToSet(DT_UINT32) | ToSet(DT_UINT64);
+inline bool DataTypeIsUnsigned(DataType dt) {
+  return kDataTypeIsUnsigned.Contains(dt);
+}
+
+// Returns a 0 on failure
+int DataTypeSize(DataType dt);
+
+// Returns HOST_MEMORY if `dtype` is always on host or is a DT_INT32,
+// DEVICE_MEMORY otherwise.
+MemoryType MTypeFromDType(const DataType dtype);
+
+// Returns HOST_MEMORY if `dtype` is always on host, DEVICE_MEMORY otherwise.
+// The reason we have MTypeFromDType() and MTypeFromDTypeIntsOnDevice(): for
+// GPUs, we would like to keep int operations on host for performance concerns.
+// But for TPUs (and other devices), int operations are placed on device.
+MemoryType MTypeFromDTypeIntsOnDevice(const DataType dtype);
+
+// Types that always sit on host: DT_STRING, DT_STRING_REF, DT_RESOURCE.
+// For DT_RESOURCE, the handle always sits on host (even if the underlying
+// object has device-allocated resources).
+bool DataTypeAlwaysOnHost(DataType dt);
+
+// FullType implementation.
+
+// Reference container for a type definition. These values are usually interned.
+// These containers admit a notion of ordering for efficient access. The
+// ordering has no semantic otherwise.
+struct TypeRef {
+  std::shared_ptr<FullTypeDef> full_type;
+
+  bool operator==(const TypeRef& other) const {
+    // TODO(mdan): This should be more efficient.
+    return full_type->SerializeAsString() ==
+           other.full_type->SerializeAsString();
+  }
+  bool operator<(const TypeRef& other) const {
+    return full_type->SerializeAsString() <
+           other.full_type->SerializeAsString();
+  }
+};
+
+struct TypeHasher {
+  std::size_t operator()(const TypeRef& k) const {
+    return std::hash<std::string>()(k.full_type->SerializeAsString());
+  }
+};
+
+// Maps a legacy DType proto enum to an equivalent FullType ID,
+// i.e. sets the type_id of t based on dtype.
+void map_dtype_to_tensor(const DataType& dtype, FullTypeDef& t);
+
+// Set the type id_of t to TFT_TENSOR and add a child arg by mapping
+// a legacy DType proto enun to an equivalent FullType ID, e.g.
+// if dtype is DT_FLOAT, sets t to TFT_TENSOR[TFT_FLOAT].
+void map_dtype_to_child_of_tensor(const DataType& dtype, FullTypeDef& t);
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_TYPES_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/types.pb.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/types.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..0887cfca0d556d08c1f16a11427e03d5dcf7cbb2
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/types.pb.h
@@ -0,0 +1,336 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: tensorflow/core/framework/types.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2ftypes_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2ftypes_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3021000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3021009 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_tensorflow_2fcore_2fframework_2ftypes_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_tensorflow_2fcore_2fframework_2ftypes_2eproto {
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_tensorflow_2fcore_2fframework_2ftypes_2eproto;
+namespace tensorflow {
+class SerializedDType;
+struct SerializedDTypeDefaultTypeInternal;
+extern SerializedDTypeDefaultTypeInternal _SerializedDType_default_instance_;
+}  // namespace tensorflow
+PROTOBUF_NAMESPACE_OPEN
+template<> ::tensorflow::SerializedDType* Arena::CreateMaybeMessage<::tensorflow::SerializedDType>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace tensorflow {
+
+enum DataType : int {
+  DT_INVALID = 0,
+  DT_FLOAT = 1,
+  DT_DOUBLE = 2,
+  DT_INT32 = 3,
+  DT_UINT8 = 4,
+  DT_INT16 = 5,
+  DT_INT8 = 6,
+  DT_STRING = 7,
+  DT_COMPLEX64 = 8,
+  DT_INT64 = 9,
+  DT_BOOL = 10,
+  DT_QINT8 = 11,
+  DT_QUINT8 = 12,
+  DT_QINT32 = 13,
+  DT_BFLOAT16 = 14,
+  DT_QINT16 = 15,
+  DT_QUINT16 = 16,
+  DT_UINT16 = 17,
+  DT_COMPLEX128 = 18,
+  DT_HALF = 19,
+  DT_RESOURCE = 20,
+  DT_VARIANT = 21,
+  DT_UINT32 = 22,
+  DT_UINT64 = 23,
+  DT_FLOAT8_E5M2 = 24,
+  DT_FLOAT8_E4M3FN = 25,
+  DT_INT4 = 29,
+  DT_UINT4 = 30,
+  DT_FLOAT_REF = 101,
+  DT_DOUBLE_REF = 102,
+  DT_INT32_REF = 103,
+  DT_UINT8_REF = 104,
+  DT_INT16_REF = 105,
+  DT_INT8_REF = 106,
+  DT_STRING_REF = 107,
+  DT_COMPLEX64_REF = 108,
+  DT_INT64_REF = 109,
+  DT_BOOL_REF = 110,
+  DT_QINT8_REF = 111,
+  DT_QUINT8_REF = 112,
+  DT_QINT32_REF = 113,
+  DT_BFLOAT16_REF = 114,
+  DT_QINT16_REF = 115,
+  DT_QUINT16_REF = 116,
+  DT_UINT16_REF = 117,
+  DT_COMPLEX128_REF = 118,
+  DT_HALF_REF = 119,
+  DT_RESOURCE_REF = 120,
+  DT_VARIANT_REF = 121,
+  DT_UINT32_REF = 122,
+  DT_UINT64_REF = 123,
+  DT_FLOAT8_E5M2_REF = 124,
+  DT_FLOAT8_E4M3FN_REF = 125,
+  DT_INT4_REF = 129,
+  DT_UINT4_REF = 130,
+  DataType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
+  DataType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
+};
+bool DataType_IsValid(int value);
+constexpr DataType DataType_MIN = DT_INVALID;
+constexpr DataType DataType_MAX = DT_UINT4_REF;
+constexpr int DataType_ARRAYSIZE = DataType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DataType_descriptor();
+template<typename T>
+inline const std::string& DataType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, DataType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function DataType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    DataType_descriptor(), enum_t_value);
+}
+inline bool DataType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DataType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DataType>(
+    DataType_descriptor(), name, value);
+}
+// ===================================================================
+
+class SerializedDType final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.SerializedDType) */ {
+ public:
+  inline SerializedDType() : SerializedDType(nullptr) {}
+  ~SerializedDType() override;
+  explicit PROTOBUF_CONSTEXPR SerializedDType(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SerializedDType(const SerializedDType& from);
+  SerializedDType(SerializedDType&& from) noexcept
+    : SerializedDType() {
+    *this = ::std::move(from);
+  }
+
+  inline SerializedDType& operator=(const SerializedDType& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SerializedDType& operator=(SerializedDType&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SerializedDType& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SerializedDType* internal_default_instance() {
+    return reinterpret_cast<const SerializedDType*>(
+               &_SerializedDType_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(SerializedDType& a, SerializedDType& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SerializedDType* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SerializedDType* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SerializedDType* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SerializedDType>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SerializedDType& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const SerializedDType& from) {
+    SerializedDType::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SerializedDType* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.SerializedDType";
+  }
+  protected:
+  explicit SerializedDType(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDatatypeFieldNumber = 1,
+  };
+  // .tensorflow.DataType datatype = 1;
+  void clear_datatype();
+  ::tensorflow::DataType datatype() const;
+  void set_datatype(::tensorflow::DataType value);
+  private:
+  ::tensorflow::DataType _internal_datatype() const;
+  void _internal_set_datatype(::tensorflow::DataType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.SerializedDType)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    int datatype_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2ftypes_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// SerializedDType
+
+// .tensorflow.DataType datatype = 1;
+inline void SerializedDType::clear_datatype() {
+  _impl_.datatype_ = 0;
+}
+inline ::tensorflow::DataType SerializedDType::_internal_datatype() const {
+  return static_cast< ::tensorflow::DataType >(_impl_.datatype_);
+}
+inline ::tensorflow::DataType SerializedDType::datatype() const {
+  // @@protoc_insertion_point(field_get:tensorflow.SerializedDType.datatype)
+  return _internal_datatype();
+}
+inline void SerializedDType::_internal_set_datatype(::tensorflow::DataType value) {
+  
+  _impl_.datatype_ = value;
+}
+inline void SerializedDType::set_datatype(::tensorflow::DataType value) {
+  _internal_set_datatype(value);
+  // @@protoc_insertion_point(field_set:tensorflow.SerializedDType.datatype)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace tensorflow
+
+PROTOBUF_NAMESPACE_OPEN
+
+template <> struct is_proto_enum< ::tensorflow::DataType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::tensorflow::DataType>() {
+  return ::tensorflow::DataType_descriptor();
+}
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2ftypes_2eproto
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/types.proto b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/types.proto
new file mode 100644
index 0000000000000000000000000000000000000000..d0a973845f9fedd0b6052cc9e139e7b1ffc10d85
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/types.proto
@@ -0,0 +1,100 @@
+syntax = "proto3";
+
+package tensorflow;
+
+option cc_enable_arenas = true;
+option java_outer_classname = "TypesProtos";
+option java_multiple_files = true;
+option java_package = "org.tensorflow.framework";
+option go_package = "github.com/tensorflow/tensorflow/tensorflow/go/core/framework/types_go_proto";
+
+// (== suppress_warning documentation-presence ==)
+// LINT.IfChange
+enum DataType {
+  // Not a legal value for DataType.  Used to indicate a DataType field
+  // has not been set.
+  DT_INVALID = 0;
+
+  // Data types that all computation devices are expected to be
+  // capable to support.
+  DT_FLOAT = 1;
+  DT_DOUBLE = 2;
+  DT_INT32 = 3;
+  DT_UINT8 = 4;
+  DT_INT16 = 5;
+  DT_INT8 = 6;
+  DT_STRING = 7;
+  DT_COMPLEX64 = 8;  // Single-precision complex
+  DT_INT64 = 9;
+  DT_BOOL = 10;
+  DT_QINT8 = 11;     // Quantized int8
+  DT_QUINT8 = 12;    // Quantized uint8
+  DT_QINT32 = 13;    // Quantized int32
+  DT_BFLOAT16 = 14;  // Float32 truncated to 16 bits.
+  DT_QINT16 = 15;    // Quantized int16
+  DT_QUINT16 = 16;   // Quantized uint16
+  DT_UINT16 = 17;
+  DT_COMPLEX128 = 18;  // Double-precision complex
+  DT_HALF = 19;
+  DT_RESOURCE = 20;
+  DT_VARIANT = 21;  // Arbitrary C++ data types
+  DT_UINT32 = 22;
+  DT_UINT64 = 23;
+  DT_FLOAT8_E5M2 = 24;    // 5 exponent bits, 2 mantissa bits.
+  DT_FLOAT8_E4M3FN = 25;  // 4 exponent bits, 3 mantissa bits, finite-only, with
+                          // 2 NaNs (0bS1111111).
+  // TODO - b/299182407: Leaving room for remaining float8 types.
+  // DT_FLOAT8_E4M3FNUZ = 26;
+  // DT_FLOAT8_E4M3B11FNUZ = 27;
+  // DT_FLOAT8_E5M2FNUZ = 28;
+  DT_INT4 = 29;
+  DT_UINT4 = 30;
+
+  // Do not use!  These are only for TF1's obsolete reference Variables.
+  // Every enum above should have a corresponding value below (verified by
+  // types_test).
+  DT_FLOAT_REF = 101;
+  DT_DOUBLE_REF = 102;
+  DT_INT32_REF = 103;
+  DT_UINT8_REF = 104;
+  DT_INT16_REF = 105;
+  DT_INT8_REF = 106;
+  DT_STRING_REF = 107;
+  DT_COMPLEX64_REF = 108;
+  DT_INT64_REF = 109;
+  DT_BOOL_REF = 110;
+  DT_QINT8_REF = 111;
+  DT_QUINT8_REF = 112;
+  DT_QINT32_REF = 113;
+  DT_BFLOAT16_REF = 114;
+  DT_QINT16_REF = 115;
+  DT_QUINT16_REF = 116;
+  DT_UINT16_REF = 117;
+  DT_COMPLEX128_REF = 118;
+  DT_HALF_REF = 119;
+  DT_RESOURCE_REF = 120;
+  DT_VARIANT_REF = 121;
+  DT_UINT32_REF = 122;
+  DT_UINT64_REF = 123;
+  DT_FLOAT8_E5M2_REF = 124;
+  DT_FLOAT8_E4M3FN_REF = 125;
+  // TODO - b/299182407: Leaving room for remaining float8 types.
+  // DT_FLOAT8_E4M3FNUZ_REF = 126;
+  // DT_FLOAT8_E4M3B11FNUZ_REF = 127;
+  // DT_FLOAT8_E5M2FNUZ_REF = 128;
+  DT_INT4_REF = 129;
+  DT_UINT4_REF = 130;
+}
+// LINT.ThenChange(
+//    https://www.tensorflow.org/code/tensorflow/c/tf_datatype.h,
+//    https://www.tensorflow.org/code/tensorflow/go/tensor.go,
+//    https://www.tensorflow.org/code/tensorflow/core/framework/tensor.cc,
+//    https://www.tensorflow.org/code/tensorflow/core/framework/types.h,
+//    https://www.tensorflow.org/code/tensorflow/core/framework/types.cc,
+//    https://www.tensorflow.org/code/tensorflow/python/framework/dtypes.py,
+//    https://www.tensorflow.org/code/tensorflow/python/framework/function.py)
+
+// Represents a serialized tf.dtypes.Dtype
+message SerializedDType {
+  DataType datatype = 1;
+}
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/variable.pb.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/variable.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..d60b831e116c3bff79f69118a04f5d63d456f02d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/variable.pb.h
@@ -0,0 +1,1213 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: tensorflow/core/framework/variable.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fvariable_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fvariable_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3021000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3021009 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_tensorflow_2fcore_2fframework_2fvariable_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_tensorflow_2fcore_2fframework_2fvariable_2eproto {
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_tensorflow_2fcore_2fframework_2fvariable_2eproto;
+namespace tensorflow {
+class SaveSliceInfoDef;
+struct SaveSliceInfoDefDefaultTypeInternal;
+extern SaveSliceInfoDefDefaultTypeInternal _SaveSliceInfoDef_default_instance_;
+class VariableDef;
+struct VariableDefDefaultTypeInternal;
+extern VariableDefDefaultTypeInternal _VariableDef_default_instance_;
+}  // namespace tensorflow
+PROTOBUF_NAMESPACE_OPEN
+template<> ::tensorflow::SaveSliceInfoDef* Arena::CreateMaybeMessage<::tensorflow::SaveSliceInfoDef>(Arena*);
+template<> ::tensorflow::VariableDef* Arena::CreateMaybeMessage<::tensorflow::VariableDef>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace tensorflow {
+
+enum VariableSynchronization : int {
+  VARIABLE_SYNCHRONIZATION_AUTO = 0,
+  VARIABLE_SYNCHRONIZATION_NONE = 1,
+  VARIABLE_SYNCHRONIZATION_ON_WRITE = 2,
+  VARIABLE_SYNCHRONIZATION_ON_READ = 3,
+  VariableSynchronization_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
+  VariableSynchronization_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
+};
+bool VariableSynchronization_IsValid(int value);
+constexpr VariableSynchronization VariableSynchronization_MIN = VARIABLE_SYNCHRONIZATION_AUTO;
+constexpr VariableSynchronization VariableSynchronization_MAX = VARIABLE_SYNCHRONIZATION_ON_READ;
+constexpr int VariableSynchronization_ARRAYSIZE = VariableSynchronization_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* VariableSynchronization_descriptor();
+template<typename T>
+inline const std::string& VariableSynchronization_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, VariableSynchronization>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function VariableSynchronization_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    VariableSynchronization_descriptor(), enum_t_value);
+}
+inline bool VariableSynchronization_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, VariableSynchronization* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<VariableSynchronization>(
+    VariableSynchronization_descriptor(), name, value);
+}
+enum VariableAggregation : int {
+  VARIABLE_AGGREGATION_NONE = 0,
+  VARIABLE_AGGREGATION_SUM = 1,
+  VARIABLE_AGGREGATION_MEAN = 2,
+  VARIABLE_AGGREGATION_ONLY_FIRST_REPLICA = 3,
+  VariableAggregation_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
+  VariableAggregation_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
+};
+bool VariableAggregation_IsValid(int value);
+constexpr VariableAggregation VariableAggregation_MIN = VARIABLE_AGGREGATION_NONE;
+constexpr VariableAggregation VariableAggregation_MAX = VARIABLE_AGGREGATION_ONLY_FIRST_REPLICA;
+constexpr int VariableAggregation_ARRAYSIZE = VariableAggregation_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* VariableAggregation_descriptor();
+template<typename T>
+inline const std::string& VariableAggregation_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, VariableAggregation>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function VariableAggregation_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    VariableAggregation_descriptor(), enum_t_value);
+}
+inline bool VariableAggregation_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, VariableAggregation* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<VariableAggregation>(
+    VariableAggregation_descriptor(), name, value);
+}
+// ===================================================================
+
+class VariableDef final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.VariableDef) */ {
+ public:
+  inline VariableDef() : VariableDef(nullptr) {}
+  ~VariableDef() override;
+  explicit PROTOBUF_CONSTEXPR VariableDef(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  VariableDef(const VariableDef& from);
+  VariableDef(VariableDef&& from) noexcept
+    : VariableDef() {
+    *this = ::std::move(from);
+  }
+
+  inline VariableDef& operator=(const VariableDef& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline VariableDef& operator=(VariableDef&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const VariableDef& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const VariableDef* internal_default_instance() {
+    return reinterpret_cast<const VariableDef*>(
+               &_VariableDef_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(VariableDef& a, VariableDef& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(VariableDef* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(VariableDef* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  VariableDef* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<VariableDef>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const VariableDef& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const VariableDef& from) {
+    VariableDef::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(VariableDef* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.VariableDef";
+  }
+  protected:
+  explicit VariableDef(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kVariableNameFieldNumber = 1,
+    kInitializerNameFieldNumber = 2,
+    kSnapshotNameFieldNumber = 3,
+    kInitialValueNameFieldNumber = 6,
+    kSaveSliceInfoDefFieldNumber = 4,
+    kIsResourceFieldNumber = 5,
+    kTrainableFieldNumber = 7,
+    kSynchronizationFieldNumber = 8,
+    kAggregationFieldNumber = 9,
+  };
+  // string variable_name = 1;
+  void clear_variable_name();
+  const std::string& variable_name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_variable_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_variable_name();
+  PROTOBUF_NODISCARD std::string* release_variable_name();
+  void set_allocated_variable_name(std::string* variable_name);
+  private:
+  const std::string& _internal_variable_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_variable_name(const std::string& value);
+  std::string* _internal_mutable_variable_name();
+  public:
+
+  // string initializer_name = 2;
+  void clear_initializer_name();
+  const std::string& initializer_name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_initializer_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_initializer_name();
+  PROTOBUF_NODISCARD std::string* release_initializer_name();
+  void set_allocated_initializer_name(std::string* initializer_name);
+  private:
+  const std::string& _internal_initializer_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_initializer_name(const std::string& value);
+  std::string* _internal_mutable_initializer_name();
+  public:
+
+  // string snapshot_name = 3;
+  void clear_snapshot_name();
+  const std::string& snapshot_name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_snapshot_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_snapshot_name();
+  PROTOBUF_NODISCARD std::string* release_snapshot_name();
+  void set_allocated_snapshot_name(std::string* snapshot_name);
+  private:
+  const std::string& _internal_snapshot_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_snapshot_name(const std::string& value);
+  std::string* _internal_mutable_snapshot_name();
+  public:
+
+  // string initial_value_name = 6;
+  void clear_initial_value_name();
+  const std::string& initial_value_name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_initial_value_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_initial_value_name();
+  PROTOBUF_NODISCARD std::string* release_initial_value_name();
+  void set_allocated_initial_value_name(std::string* initial_value_name);
+  private:
+  const std::string& _internal_initial_value_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_initial_value_name(const std::string& value);
+  std::string* _internal_mutable_initial_value_name();
+  public:
+
+  // .tensorflow.SaveSliceInfoDef save_slice_info_def = 4;
+  bool has_save_slice_info_def() const;
+  private:
+  bool _internal_has_save_slice_info_def() const;
+  public:
+  void clear_save_slice_info_def();
+  const ::tensorflow::SaveSliceInfoDef& save_slice_info_def() const;
+  PROTOBUF_NODISCARD ::tensorflow::SaveSliceInfoDef* release_save_slice_info_def();
+  ::tensorflow::SaveSliceInfoDef* mutable_save_slice_info_def();
+  void set_allocated_save_slice_info_def(::tensorflow::SaveSliceInfoDef* save_slice_info_def);
+  private:
+  const ::tensorflow::SaveSliceInfoDef& _internal_save_slice_info_def() const;
+  ::tensorflow::SaveSliceInfoDef* _internal_mutable_save_slice_info_def();
+  public:
+  void unsafe_arena_set_allocated_save_slice_info_def(
+      ::tensorflow::SaveSliceInfoDef* save_slice_info_def);
+  ::tensorflow::SaveSliceInfoDef* unsafe_arena_release_save_slice_info_def();
+
+  // bool is_resource = 5;
+  void clear_is_resource();
+  bool is_resource() const;
+  void set_is_resource(bool value);
+  private:
+  bool _internal_is_resource() const;
+  void _internal_set_is_resource(bool value);
+  public:
+
+  // bool trainable = 7;
+  void clear_trainable();
+  bool trainable() const;
+  void set_trainable(bool value);
+  private:
+  bool _internal_trainable() const;
+  void _internal_set_trainable(bool value);
+  public:
+
+  // .tensorflow.VariableSynchronization synchronization = 8;
+  void clear_synchronization();
+  ::tensorflow::VariableSynchronization synchronization() const;
+  void set_synchronization(::tensorflow::VariableSynchronization value);
+  private:
+  ::tensorflow::VariableSynchronization _internal_synchronization() const;
+  void _internal_set_synchronization(::tensorflow::VariableSynchronization value);
+  public:
+
+  // .tensorflow.VariableAggregation aggregation = 9;
+  void clear_aggregation();
+  ::tensorflow::VariableAggregation aggregation() const;
+  void set_aggregation(::tensorflow::VariableAggregation value);
+  private:
+  ::tensorflow::VariableAggregation _internal_aggregation() const;
+  void _internal_set_aggregation(::tensorflow::VariableAggregation value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.VariableDef)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr variable_name_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr initializer_name_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr snapshot_name_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr initial_value_name_;
+    ::tensorflow::SaveSliceInfoDef* save_slice_info_def_;
+    bool is_resource_;
+    bool trainable_;
+    int synchronization_;
+    int aggregation_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fvariable_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SaveSliceInfoDef final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.SaveSliceInfoDef) */ {
+ public:
+  inline SaveSliceInfoDef() : SaveSliceInfoDef(nullptr) {}
+  ~SaveSliceInfoDef() override;
+  explicit PROTOBUF_CONSTEXPR SaveSliceInfoDef(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SaveSliceInfoDef(const SaveSliceInfoDef& from);
+  SaveSliceInfoDef(SaveSliceInfoDef&& from) noexcept
+    : SaveSliceInfoDef() {
+    *this = ::std::move(from);
+  }
+
+  inline SaveSliceInfoDef& operator=(const SaveSliceInfoDef& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SaveSliceInfoDef& operator=(SaveSliceInfoDef&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SaveSliceInfoDef& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SaveSliceInfoDef* internal_default_instance() {
+    return reinterpret_cast<const SaveSliceInfoDef*>(
+               &_SaveSliceInfoDef_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(SaveSliceInfoDef& a, SaveSliceInfoDef& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SaveSliceInfoDef* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SaveSliceInfoDef* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SaveSliceInfoDef* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SaveSliceInfoDef>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SaveSliceInfoDef& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const SaveSliceInfoDef& from) {
+    SaveSliceInfoDef::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SaveSliceInfoDef* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.SaveSliceInfoDef";
+  }
+  protected:
+  explicit SaveSliceInfoDef(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kFullShapeFieldNumber = 2,
+    kVarOffsetFieldNumber = 3,
+    kVarShapeFieldNumber = 4,
+    kFullNameFieldNumber = 1,
+  };
+  // repeated int64 full_shape = 2;
+  int full_shape_size() const;
+  private:
+  int _internal_full_shape_size() const;
+  public:
+  void clear_full_shape();
+  private:
+  int64_t _internal_full_shape(int index) const;
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
+      _internal_full_shape() const;
+  void _internal_add_full_shape(int64_t value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
+      _internal_mutable_full_shape();
+  public:
+  int64_t full_shape(int index) const;
+  void set_full_shape(int index, int64_t value);
+  void add_full_shape(int64_t value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
+      full_shape() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
+      mutable_full_shape();
+
+  // repeated int64 var_offset = 3;
+  int var_offset_size() const;
+  private:
+  int _internal_var_offset_size() const;
+  public:
+  void clear_var_offset();
+  private:
+  int64_t _internal_var_offset(int index) const;
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
+      _internal_var_offset() const;
+  void _internal_add_var_offset(int64_t value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
+      _internal_mutable_var_offset();
+  public:
+  int64_t var_offset(int index) const;
+  void set_var_offset(int index, int64_t value);
+  void add_var_offset(int64_t value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
+      var_offset() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
+      mutable_var_offset();
+
+  // repeated int64 var_shape = 4;
+  int var_shape_size() const;
+  private:
+  int _internal_var_shape_size() const;
+  public:
+  void clear_var_shape();
+  private:
+  int64_t _internal_var_shape(int index) const;
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
+      _internal_var_shape() const;
+  void _internal_add_var_shape(int64_t value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
+      _internal_mutable_var_shape();
+  public:
+  int64_t var_shape(int index) const;
+  void set_var_shape(int index, int64_t value);
+  void add_var_shape(int64_t value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
+      var_shape() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
+      mutable_var_shape();
+
+  // string full_name = 1;
+  void clear_full_name();
+  const std::string& full_name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_full_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_full_name();
+  PROTOBUF_NODISCARD std::string* release_full_name();
+  void set_allocated_full_name(std::string* full_name);
+  private:
+  const std::string& _internal_full_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_full_name(const std::string& value);
+  std::string* _internal_mutable_full_name();
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.SaveSliceInfoDef)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > full_shape_;
+    mutable std::atomic<int> _full_shape_cached_byte_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > var_offset_;
+    mutable std::atomic<int> _var_offset_cached_byte_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > var_shape_;
+    mutable std::atomic<int> _var_shape_cached_byte_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr full_name_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fvariable_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// VariableDef
+
+// string variable_name = 1;
+inline void VariableDef::clear_variable_name() {
+  _impl_.variable_name_.ClearToEmpty();
+}
+inline const std::string& VariableDef::variable_name() const {
+  // @@protoc_insertion_point(field_get:tensorflow.VariableDef.variable_name)
+  return _internal_variable_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void VariableDef::set_variable_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.variable_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.VariableDef.variable_name)
+}
+inline std::string* VariableDef::mutable_variable_name() {
+  std::string* _s = _internal_mutable_variable_name();
+  // @@protoc_insertion_point(field_mutable:tensorflow.VariableDef.variable_name)
+  return _s;
+}
+inline const std::string& VariableDef::_internal_variable_name() const {
+  return _impl_.variable_name_.Get();
+}
+inline void VariableDef::_internal_set_variable_name(const std::string& value) {
+  
+  _impl_.variable_name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* VariableDef::_internal_mutable_variable_name() {
+  
+  return _impl_.variable_name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* VariableDef::release_variable_name() {
+  // @@protoc_insertion_point(field_release:tensorflow.VariableDef.variable_name)
+  return _impl_.variable_name_.Release();
+}
+inline void VariableDef::set_allocated_variable_name(std::string* variable_name) {
+  if (variable_name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.variable_name_.SetAllocated(variable_name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.variable_name_.IsDefault()) {
+    _impl_.variable_name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.VariableDef.variable_name)
+}
+
+// string initial_value_name = 6;
+inline void VariableDef::clear_initial_value_name() {
+  _impl_.initial_value_name_.ClearToEmpty();
+}
+inline const std::string& VariableDef::initial_value_name() const {
+  // @@protoc_insertion_point(field_get:tensorflow.VariableDef.initial_value_name)
+  return _internal_initial_value_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void VariableDef::set_initial_value_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.initial_value_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.VariableDef.initial_value_name)
+}
+inline std::string* VariableDef::mutable_initial_value_name() {
+  std::string* _s = _internal_mutable_initial_value_name();
+  // @@protoc_insertion_point(field_mutable:tensorflow.VariableDef.initial_value_name)
+  return _s;
+}
+inline const std::string& VariableDef::_internal_initial_value_name() const {
+  return _impl_.initial_value_name_.Get();
+}
+inline void VariableDef::_internal_set_initial_value_name(const std::string& value) {
+  
+  _impl_.initial_value_name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* VariableDef::_internal_mutable_initial_value_name() {
+  
+  return _impl_.initial_value_name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* VariableDef::release_initial_value_name() {
+  // @@protoc_insertion_point(field_release:tensorflow.VariableDef.initial_value_name)
+  return _impl_.initial_value_name_.Release();
+}
+inline void VariableDef::set_allocated_initial_value_name(std::string* initial_value_name) {
+  if (initial_value_name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.initial_value_name_.SetAllocated(initial_value_name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.initial_value_name_.IsDefault()) {
+    _impl_.initial_value_name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.VariableDef.initial_value_name)
+}
+
+// string initializer_name = 2;
+inline void VariableDef::clear_initializer_name() {
+  _impl_.initializer_name_.ClearToEmpty();
+}
+inline const std::string& VariableDef::initializer_name() const {
+  // @@protoc_insertion_point(field_get:tensorflow.VariableDef.initializer_name)
+  return _internal_initializer_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void VariableDef::set_initializer_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.initializer_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.VariableDef.initializer_name)
+}
+inline std::string* VariableDef::mutable_initializer_name() {
+  std::string* _s = _internal_mutable_initializer_name();
+  // @@protoc_insertion_point(field_mutable:tensorflow.VariableDef.initializer_name)
+  return _s;
+}
+inline const std::string& VariableDef::_internal_initializer_name() const {
+  return _impl_.initializer_name_.Get();
+}
+inline void VariableDef::_internal_set_initializer_name(const std::string& value) {
+  
+  _impl_.initializer_name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* VariableDef::_internal_mutable_initializer_name() {
+  
+  return _impl_.initializer_name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* VariableDef::release_initializer_name() {
+  // @@protoc_insertion_point(field_release:tensorflow.VariableDef.initializer_name)
+  return _impl_.initializer_name_.Release();
+}
+inline void VariableDef::set_allocated_initializer_name(std::string* initializer_name) {
+  if (initializer_name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.initializer_name_.SetAllocated(initializer_name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.initializer_name_.IsDefault()) {
+    _impl_.initializer_name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.VariableDef.initializer_name)
+}
+
+// string snapshot_name = 3;
+inline void VariableDef::clear_snapshot_name() {
+  _impl_.snapshot_name_.ClearToEmpty();
+}
+inline const std::string& VariableDef::snapshot_name() const {
+  // @@protoc_insertion_point(field_get:tensorflow.VariableDef.snapshot_name)
+  return _internal_snapshot_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void VariableDef::set_snapshot_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.snapshot_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.VariableDef.snapshot_name)
+}
+inline std::string* VariableDef::mutable_snapshot_name() {
+  std::string* _s = _internal_mutable_snapshot_name();
+  // @@protoc_insertion_point(field_mutable:tensorflow.VariableDef.snapshot_name)
+  return _s;
+}
+inline const std::string& VariableDef::_internal_snapshot_name() const {
+  return _impl_.snapshot_name_.Get();
+}
+inline void VariableDef::_internal_set_snapshot_name(const std::string& value) {
+  
+  _impl_.snapshot_name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* VariableDef::_internal_mutable_snapshot_name() {
+  
+  return _impl_.snapshot_name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* VariableDef::release_snapshot_name() {
+  // @@protoc_insertion_point(field_release:tensorflow.VariableDef.snapshot_name)
+  return _impl_.snapshot_name_.Release();
+}
+inline void VariableDef::set_allocated_snapshot_name(std::string* snapshot_name) {
+  if (snapshot_name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.snapshot_name_.SetAllocated(snapshot_name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.snapshot_name_.IsDefault()) {
+    _impl_.snapshot_name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.VariableDef.snapshot_name)
+}
+
+// .tensorflow.SaveSliceInfoDef save_slice_info_def = 4;
+inline bool VariableDef::_internal_has_save_slice_info_def() const {
+  return this != internal_default_instance() && _impl_.save_slice_info_def_ != nullptr;
+}
+inline bool VariableDef::has_save_slice_info_def() const {
+  return _internal_has_save_slice_info_def();
+}
+inline void VariableDef::clear_save_slice_info_def() {
+  if (GetArenaForAllocation() == nullptr && _impl_.save_slice_info_def_ != nullptr) {
+    delete _impl_.save_slice_info_def_;
+  }
+  _impl_.save_slice_info_def_ = nullptr;
+}
+inline const ::tensorflow::SaveSliceInfoDef& VariableDef::_internal_save_slice_info_def() const {
+  const ::tensorflow::SaveSliceInfoDef* p = _impl_.save_slice_info_def_;
+  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::SaveSliceInfoDef&>(
+      ::tensorflow::_SaveSliceInfoDef_default_instance_);
+}
+inline const ::tensorflow::SaveSliceInfoDef& VariableDef::save_slice_info_def() const {
+  // @@protoc_insertion_point(field_get:tensorflow.VariableDef.save_slice_info_def)
+  return _internal_save_slice_info_def();
+}
+inline void VariableDef::unsafe_arena_set_allocated_save_slice_info_def(
+    ::tensorflow::SaveSliceInfoDef* save_slice_info_def) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.save_slice_info_def_);
+  }
+  _impl_.save_slice_info_def_ = save_slice_info_def;
+  if (save_slice_info_def) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.VariableDef.save_slice_info_def)
+}
+inline ::tensorflow::SaveSliceInfoDef* VariableDef::release_save_slice_info_def() {
+  
+  ::tensorflow::SaveSliceInfoDef* temp = _impl_.save_slice_info_def_;
+  _impl_.save_slice_info_def_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::tensorflow::SaveSliceInfoDef* VariableDef::unsafe_arena_release_save_slice_info_def() {
+  // @@protoc_insertion_point(field_release:tensorflow.VariableDef.save_slice_info_def)
+  
+  ::tensorflow::SaveSliceInfoDef* temp = _impl_.save_slice_info_def_;
+  _impl_.save_slice_info_def_ = nullptr;
+  return temp;
+}
+inline ::tensorflow::SaveSliceInfoDef* VariableDef::_internal_mutable_save_slice_info_def() {
+  
+  if (_impl_.save_slice_info_def_ == nullptr) {
+    auto* p = CreateMaybeMessage<::tensorflow::SaveSliceInfoDef>(GetArenaForAllocation());
+    _impl_.save_slice_info_def_ = p;
+  }
+  return _impl_.save_slice_info_def_;
+}
+inline ::tensorflow::SaveSliceInfoDef* VariableDef::mutable_save_slice_info_def() {
+  ::tensorflow::SaveSliceInfoDef* _msg = _internal_mutable_save_slice_info_def();
+  // @@protoc_insertion_point(field_mutable:tensorflow.VariableDef.save_slice_info_def)
+  return _msg;
+}
+inline void VariableDef::set_allocated_save_slice_info_def(::tensorflow::SaveSliceInfoDef* save_slice_info_def) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.save_slice_info_def_;
+  }
+  if (save_slice_info_def) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(save_slice_info_def);
+    if (message_arena != submessage_arena) {
+      save_slice_info_def = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, save_slice_info_def, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.save_slice_info_def_ = save_slice_info_def;
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.VariableDef.save_slice_info_def)
+}
+
+// bool is_resource = 5;
+inline void VariableDef::clear_is_resource() {
+  _impl_.is_resource_ = false;
+}
+inline bool VariableDef::_internal_is_resource() const {
+  return _impl_.is_resource_;
+}
+inline bool VariableDef::is_resource() const {
+  // @@protoc_insertion_point(field_get:tensorflow.VariableDef.is_resource)
+  return _internal_is_resource();
+}
+inline void VariableDef::_internal_set_is_resource(bool value) {
+  
+  _impl_.is_resource_ = value;
+}
+inline void VariableDef::set_is_resource(bool value) {
+  _internal_set_is_resource(value);
+  // @@protoc_insertion_point(field_set:tensorflow.VariableDef.is_resource)
+}
+
+// bool trainable = 7;
+inline void VariableDef::clear_trainable() {
+  _impl_.trainable_ = false;
+}
+inline bool VariableDef::_internal_trainable() const {
+  return _impl_.trainable_;
+}
+inline bool VariableDef::trainable() const {
+  // @@protoc_insertion_point(field_get:tensorflow.VariableDef.trainable)
+  return _internal_trainable();
+}
+inline void VariableDef::_internal_set_trainable(bool value) {
+  
+  _impl_.trainable_ = value;
+}
+inline void VariableDef::set_trainable(bool value) {
+  _internal_set_trainable(value);
+  // @@protoc_insertion_point(field_set:tensorflow.VariableDef.trainable)
+}
+
+// .tensorflow.VariableSynchronization synchronization = 8;
+inline void VariableDef::clear_synchronization() {
+  _impl_.synchronization_ = 0;
+}
+inline ::tensorflow::VariableSynchronization VariableDef::_internal_synchronization() const {
+  return static_cast< ::tensorflow::VariableSynchronization >(_impl_.synchronization_);
+}
+inline ::tensorflow::VariableSynchronization VariableDef::synchronization() const {
+  // @@protoc_insertion_point(field_get:tensorflow.VariableDef.synchronization)
+  return _internal_synchronization();
+}
+inline void VariableDef::_internal_set_synchronization(::tensorflow::VariableSynchronization value) {
+  
+  _impl_.synchronization_ = value;
+}
+inline void VariableDef::set_synchronization(::tensorflow::VariableSynchronization value) {
+  _internal_set_synchronization(value);
+  // @@protoc_insertion_point(field_set:tensorflow.VariableDef.synchronization)
+}
+
+// .tensorflow.VariableAggregation aggregation = 9;
+inline void VariableDef::clear_aggregation() {
+  _impl_.aggregation_ = 0;
+}
+inline ::tensorflow::VariableAggregation VariableDef::_internal_aggregation() const {
+  return static_cast< ::tensorflow::VariableAggregation >(_impl_.aggregation_);
+}
+inline ::tensorflow::VariableAggregation VariableDef::aggregation() const {
+  // @@protoc_insertion_point(field_get:tensorflow.VariableDef.aggregation)
+  return _internal_aggregation();
+}
+inline void VariableDef::_internal_set_aggregation(::tensorflow::VariableAggregation value) {
+  
+  _impl_.aggregation_ = value;
+}
+inline void VariableDef::set_aggregation(::tensorflow::VariableAggregation value) {
+  _internal_set_aggregation(value);
+  // @@protoc_insertion_point(field_set:tensorflow.VariableDef.aggregation)
+}
+
+// -------------------------------------------------------------------
+
+// SaveSliceInfoDef
+
+// string full_name = 1;
+inline void SaveSliceInfoDef::clear_full_name() {
+  _impl_.full_name_.ClearToEmpty();
+}
+inline const std::string& SaveSliceInfoDef::full_name() const {
+  // @@protoc_insertion_point(field_get:tensorflow.SaveSliceInfoDef.full_name)
+  return _internal_full_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SaveSliceInfoDef::set_full_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.full_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.SaveSliceInfoDef.full_name)
+}
+inline std::string* SaveSliceInfoDef::mutable_full_name() {
+  std::string* _s = _internal_mutable_full_name();
+  // @@protoc_insertion_point(field_mutable:tensorflow.SaveSliceInfoDef.full_name)
+  return _s;
+}
+inline const std::string& SaveSliceInfoDef::_internal_full_name() const {
+  return _impl_.full_name_.Get();
+}
+inline void SaveSliceInfoDef::_internal_set_full_name(const std::string& value) {
+  
+  _impl_.full_name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* SaveSliceInfoDef::_internal_mutable_full_name() {
+  
+  return _impl_.full_name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* SaveSliceInfoDef::release_full_name() {
+  // @@protoc_insertion_point(field_release:tensorflow.SaveSliceInfoDef.full_name)
+  return _impl_.full_name_.Release();
+}
+inline void SaveSliceInfoDef::set_allocated_full_name(std::string* full_name) {
+  if (full_name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.full_name_.SetAllocated(full_name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.full_name_.IsDefault()) {
+    _impl_.full_name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.SaveSliceInfoDef.full_name)
+}
+
+// repeated int64 full_shape = 2;
+inline int SaveSliceInfoDef::_internal_full_shape_size() const {
+  return _impl_.full_shape_.size();
+}
+inline int SaveSliceInfoDef::full_shape_size() const {
+  return _internal_full_shape_size();
+}
+inline void SaveSliceInfoDef::clear_full_shape() {
+  _impl_.full_shape_.Clear();
+}
+inline int64_t SaveSliceInfoDef::_internal_full_shape(int index) const {
+  return _impl_.full_shape_.Get(index);
+}
+inline int64_t SaveSliceInfoDef::full_shape(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.SaveSliceInfoDef.full_shape)
+  return _internal_full_shape(index);
+}
+inline void SaveSliceInfoDef::set_full_shape(int index, int64_t value) {
+  _impl_.full_shape_.Set(index, value);
+  // @@protoc_insertion_point(field_set:tensorflow.SaveSliceInfoDef.full_shape)
+}
+inline void SaveSliceInfoDef::_internal_add_full_shape(int64_t value) {
+  _impl_.full_shape_.Add(value);
+}
+inline void SaveSliceInfoDef::add_full_shape(int64_t value) {
+  _internal_add_full_shape(value);
+  // @@protoc_insertion_point(field_add:tensorflow.SaveSliceInfoDef.full_shape)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
+SaveSliceInfoDef::_internal_full_shape() const {
+  return _impl_.full_shape_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
+SaveSliceInfoDef::full_shape() const {
+  // @@protoc_insertion_point(field_list:tensorflow.SaveSliceInfoDef.full_shape)
+  return _internal_full_shape();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
+SaveSliceInfoDef::_internal_mutable_full_shape() {
+  return &_impl_.full_shape_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
+SaveSliceInfoDef::mutable_full_shape() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.SaveSliceInfoDef.full_shape)
+  return _internal_mutable_full_shape();
+}
+
+// repeated int64 var_offset = 3;
+inline int SaveSliceInfoDef::_internal_var_offset_size() const {
+  return _impl_.var_offset_.size();
+}
+inline int SaveSliceInfoDef::var_offset_size() const {
+  return _internal_var_offset_size();
+}
+inline void SaveSliceInfoDef::clear_var_offset() {
+  _impl_.var_offset_.Clear();
+}
+inline int64_t SaveSliceInfoDef::_internal_var_offset(int index) const {
+  return _impl_.var_offset_.Get(index);
+}
+inline int64_t SaveSliceInfoDef::var_offset(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.SaveSliceInfoDef.var_offset)
+  return _internal_var_offset(index);
+}
+inline void SaveSliceInfoDef::set_var_offset(int index, int64_t value) {
+  _impl_.var_offset_.Set(index, value);
+  // @@protoc_insertion_point(field_set:tensorflow.SaveSliceInfoDef.var_offset)
+}
+inline void SaveSliceInfoDef::_internal_add_var_offset(int64_t value) {
+  _impl_.var_offset_.Add(value);
+}
+inline void SaveSliceInfoDef::add_var_offset(int64_t value) {
+  _internal_add_var_offset(value);
+  // @@protoc_insertion_point(field_add:tensorflow.SaveSliceInfoDef.var_offset)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
+SaveSliceInfoDef::_internal_var_offset() const {
+  return _impl_.var_offset_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
+SaveSliceInfoDef::var_offset() const {
+  // @@protoc_insertion_point(field_list:tensorflow.SaveSliceInfoDef.var_offset)
+  return _internal_var_offset();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
+SaveSliceInfoDef::_internal_mutable_var_offset() {
+  return &_impl_.var_offset_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
+SaveSliceInfoDef::mutable_var_offset() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.SaveSliceInfoDef.var_offset)
+  return _internal_mutable_var_offset();
+}
+
+// repeated int64 var_shape = 4;
+inline int SaveSliceInfoDef::_internal_var_shape_size() const {
+  return _impl_.var_shape_.size();
+}
+inline int SaveSliceInfoDef::var_shape_size() const {
+  return _internal_var_shape_size();
+}
+inline void SaveSliceInfoDef::clear_var_shape() {
+  _impl_.var_shape_.Clear();
+}
+inline int64_t SaveSliceInfoDef::_internal_var_shape(int index) const {
+  return _impl_.var_shape_.Get(index);
+}
+inline int64_t SaveSliceInfoDef::var_shape(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.SaveSliceInfoDef.var_shape)
+  return _internal_var_shape(index);
+}
+inline void SaveSliceInfoDef::set_var_shape(int index, int64_t value) {
+  _impl_.var_shape_.Set(index, value);
+  // @@protoc_insertion_point(field_set:tensorflow.SaveSliceInfoDef.var_shape)
+}
+inline void SaveSliceInfoDef::_internal_add_var_shape(int64_t value) {
+  _impl_.var_shape_.Add(value);
+}
+inline void SaveSliceInfoDef::add_var_shape(int64_t value) {
+  _internal_add_var_shape(value);
+  // @@protoc_insertion_point(field_add:tensorflow.SaveSliceInfoDef.var_shape)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
+SaveSliceInfoDef::_internal_var_shape() const {
+  return _impl_.var_shape_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
+SaveSliceInfoDef::var_shape() const {
+  // @@protoc_insertion_point(field_list:tensorflow.SaveSliceInfoDef.var_shape)
+  return _internal_var_shape();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
+SaveSliceInfoDef::_internal_mutable_var_shape() {
+  return &_impl_.var_shape_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
+SaveSliceInfoDef::mutable_var_shape() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.SaveSliceInfoDef.var_shape)
+  return _internal_mutable_var_shape();
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace tensorflow
+
+PROTOBUF_NAMESPACE_OPEN
+
+template <> struct is_proto_enum< ::tensorflow::VariableSynchronization> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::tensorflow::VariableSynchronization>() {
+  return ::tensorflow::VariableSynchronization_descriptor();
+}
+template <> struct is_proto_enum< ::tensorflow::VariableAggregation> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::tensorflow::VariableAggregation>() {
+  return ::tensorflow::VariableAggregation_descriptor();
+}
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fvariable_2eproto
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/variable.proto b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/variable.proto
new file mode 100644
index 0000000000000000000000000000000000000000..09d7fb3d45c95a6144a92f4939f0bba46c3d218c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/variable.proto
@@ -0,0 +1,84 @@
+syntax = "proto3";
+
+package tensorflow;
+
+option cc_enable_arenas = true;
+option java_outer_classname = "VariableProtos";
+option java_multiple_files = true;
+option java_package = "org.tensorflow.framework";
+option go_package = "github.com/tensorflow/tensorflow/tensorflow/go/core/framework/variable_go_proto";
+
+// Indicates when a distributed variable will be synced.
+enum VariableSynchronization {
+  // `AUTO`: Indicates that the synchronization will be determined by the
+  // current `DistributionStrategy` (eg. With `MirroredStrategy` this would be
+  // `ON_WRITE`).
+  VARIABLE_SYNCHRONIZATION_AUTO = 0;
+  // `NONE`: Indicates that there will only be one copy of the variable, so
+  // there is no need to sync.
+  VARIABLE_SYNCHRONIZATION_NONE = 1;
+  // `ON_WRITE`: Indicates that the variable will be updated across devices
+  // every time it is written.
+  VARIABLE_SYNCHRONIZATION_ON_WRITE = 2;
+  // `ON_READ`: Indicates that the variable will be aggregated across devices
+  // when it is read (eg. when checkpointing or when evaluating an op that uses
+  // the variable).
+  VARIABLE_SYNCHRONIZATION_ON_READ = 3;
+}
+
+// Indicates how a distributed variable will be aggregated.
+enum VariableAggregation {
+  // `NONE`: This is the default, giving an error if you use a
+  // variable-update operation with multiple replicas.
+  VARIABLE_AGGREGATION_NONE = 0;
+  // `SUM`: Add the updates across replicas.
+  VARIABLE_AGGREGATION_SUM = 1;
+  // `MEAN`: Take the arithmetic mean ("average") of the updates across
+  // replicas.
+  VARIABLE_AGGREGATION_MEAN = 2;
+  // `ONLY_FIRST_REPLICA`: This is for when every replica is performing the same
+  // update, but we only want to perform the update once. Used, e.g., for the
+  // global step counter.
+  VARIABLE_AGGREGATION_ONLY_FIRST_REPLICA = 3;
+}
+
+// Protocol buffer representing a Variable.
+message VariableDef {
+  // Name of the variable tensor.
+  string variable_name = 1;
+
+  // Name of the tensor holding the variable's initial value.
+  string initial_value_name = 6;
+
+  // Name of the initializer op.
+  string initializer_name = 2;
+
+  // Name of the snapshot tensor.
+  string snapshot_name = 3;
+
+  // Support for saving variables as slices of a larger variable.
+  SaveSliceInfoDef save_slice_info_def = 4;
+
+  // Whether to represent this as a ResourceVariable.
+  bool is_resource = 5;
+
+  // Whether this variable should be trained.
+  bool trainable = 7;
+
+  // Indicates when a distributed variable will be synced.
+  VariableSynchronization synchronization = 8;
+
+  // Indicates how a distributed variable will be aggregated.
+  VariableAggregation aggregation = 9;
+}
+
+message SaveSliceInfoDef {
+  // Name of the full variable of which this is a slice.
+  string full_name = 1;
+  // Shape of the full variable.
+  repeated int64 full_shape = 2;
+  // Offset of this variable into the full variable.
+  repeated int64 var_offset = 3;
+  // Shape of this variable.
+  repeated int64 var_shape = 4;
+}
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/variant.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/variant.h
new file mode 100644
index 0000000000000000000000000000000000000000..c4e23a8d07ba5e6ecf68da8853896fcf451b2de0
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/variant.h
@@ -0,0 +1,628 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_VARIANT_H_
+#define TENSORFLOW_CORE_FRAMEWORK_VARIANT_H_
+
+#include <functional>
+#include <iostream>
+#include <memory>
+#include <type_traits>
+#include <unordered_map>
+#include <utility>
+
+#include "absl/memory/memory.h"
+#include "tensorflow/core/framework/type_index.h"
+#include "tensorflow/core/framework/variant_tensor_data.h"
+#include "tensorflow/core/platform/logging.h"
+#include "tensorflow/core/platform/strcat.h"
+
+namespace tensorflow {
+
+template <typename T>
+std::string TypeNameVariant(const T& value);
+
+template <typename T>
+std::string DebugStringVariant(const T& value);
+
+// Allows for specializations of Variant Decoding.  `data` may be modified in
+// the process of decoding to `value`.
+template <typename T>
+bool DecodeVariant(VariantTensorData* data, T* value);
+
+template <typename T>
+bool DecodeVariant(std::string* buf, T* value);
+
+template <typename T>
+void EncodeVariant(const T& value, VariantTensorData* data);
+
+template <typename T>
+void EncodeVariant(const T& value, std::string* buf);
+
+// This is an implementation of a type-erased container that can store an
+// object of any type. The implementation is very similar to std::any, but has
+// restrictions on the types of objects that can be stored, and eschews some of
+// the fancier constructors available for std::any. An object of
+// tensorflow::Variant is intended to be used as the value that will be stored
+// in a tensorflow::Tensor object when its type is DT_VARIANT.
+//
+// tensorflow::Variant can store an object of a class that satisfies the
+// following constraints:
+//
+// * The class is CopyConstructible.
+// * The class has a default constructor.
+// * It's either a protocol buffer, a tensorflow::Tensor, or defines the
+// following functions:
+//
+//   string TypeName() const;
+//   void Encode(VariantTensorData* data) const;
+//   bool Decode(VariantTensorData data);
+//
+// Simple POD types can elide the Encode/Decode functions, they are provided by
+// helper methods.
+// Here are some typical usage patterns:
+//
+//   Variant x = 10;
+//   EXPECT_EQ(*x.get<int>(), 10);
+//
+//   Tensor t(DT_FLOAT, TensorShape({}));
+//   t.flat<float>()(0) = 42.0f;
+//   Variant x = t;
+//   EXPECT_EQ(x.get<Tensor>()->flat<float>()(0), 42.0f);
+//
+// Accessing the stored object:
+//
+// The get<T> function is the main mechanism to access the object
+// stored in the container. It is type-safe, that is, calling
+// get<T> when the stored object's type is not T, returns a
+// nullptr. A raw pointer to the stored object can be obtained by calling
+// get<void>().
+//
+// Serializing/deserializing Variant object:
+//
+// The Variant class delegates serializing and deserializing operations to the
+// contained object. Helper functions to do these operations are provided for
+// POD data types, tensorflow::Tensor, and protocol buffer objects. However,
+// other classes have to provide Encode/Decode functions to handle
+// serialization.
+//
+// Objects stored in a Variant object often contain references to other
+// tensorflow::Tensors of primitive types (Eg., a list of tensorflow::Tensors).
+// To efficiently support those use cases, a structure is imposed on the
+// serialization format. Namely, classes should serialize their contents into a
+// VariantTensorData object:
+//
+//   struct VariantTensorData {
+//     string type_name;
+//     string metadata;
+//     std::vector<Tensor> tensors;
+//   };
+//
+// Objects with references to other Tensors can simply store those tensors in
+// the `tensors` field, and serialize other metadata content in to the
+// `metadata` field.
+//
+// Serialization example:
+//
+//   Foo f = Foo {...};
+//   Variant x = f;
+//   string serialized_f;
+//   x.Encode(&serialized_f);
+//
+//   Variant y = Foo(); // default constructed Foo.
+//   y.Decode(std::move(serialized_f));
+//   EXPECT_EQ(*x.get<Foo>(), *y.get<Foo>());
+//
+//
+// A Variant storing serialized Variant data (a value of type
+// VariantTensorDataProto) has different behavior from a standard Variant.
+// Namely, its TypeName matches the TypeName of the original Variant;
+// and its non-const get method performs lazy deserialization.
+//
+// Decode and copy example:
+//
+//   Foo f = Foo {...};
+//   Variant x = f;
+//
+//   VariantTensorData serialized_data_f;
+//   VariantTensorDataProto serialized_proto_f;
+//   x.Encode(&serialized_data_f);
+//   serialized_data_f.ToProto(&serialized_proto_f);
+//
+//   Variant y_type_unknown = serialized_proto_f;  // Store serialized Variant.
+//
+//   EXPECT_EQ(x.TypeName(), y_type_unknown.TypeName());  // Looks like Foo.
+//   EXPECT_EQ(TypeIndex::Make<VariantTensorDataProto>(),
+//             y_type_unknown.TypeId());
+//
+class Variant {
+ public:
+  // Constructs a Variant holding no value (aka `is_empty()`).
+  //
+  // This is done by pointing at nullptr via the heap value.
+  Variant() noexcept : heap_value_(/*pointer=*/nullptr), is_inline_(false) {}
+
+  ~Variant();
+
+  Variant(const Variant& other);
+  Variant(Variant&& other) noexcept;
+
+  // Make sure that the type is CopyConstructible and not a
+  // tensorflow::Variant object itself. We want the copy constructor to be
+  // chosen for the tensorflow::Variant case.
+  template <typename T, typename VT = typename std::decay<T>::type,
+            typename std::enable_if<!std::is_same<Variant, VT>::value &&
+                                        std::is_move_constructible<VT>::value,
+                                    void>::type* = nullptr>
+  Variant(T&& value);
+
+  template <typename T, typename VT = typename std::decay<T>::type,
+            typename std::enable_if<!std::is_same<Variant, VT>::value &&
+                                        std::is_copy_constructible<VT>::value,
+                                    void>::type* = nullptr>
+  Variant(const T& value);
+
+  template <typename T, typename VT = typename std::decay<T>::type,
+            typename std::enable_if<!std::is_same<Variant, VT>::value &&
+                                        std::is_copy_constructible<VT>::value,
+                                    void>::type* = nullptr>
+  Variant& operator=(const T& value);
+
+  template <typename T, typename VT = typename std::decay<T>::type,
+            typename std::enable_if<!std::is_same<Variant, VT>::value &&
+                                        std::is_move_constructible<VT>::value,
+                                    void>::type* = nullptr>
+  Variant& operator=(T&& value);
+
+  Variant& operator=(const Variant& rhs) {
+    if (&rhs == this) return *this;
+    Variant(rhs).swap(*this);
+    return *this;
+  }
+
+  Variant& operator=(Variant&& rhs) noexcept {
+    if (&rhs == this) return *this;
+    Variant(std::move(rhs)).swap(*this);
+    return *this;
+  }
+
+  // Constructs a value of type T with the given args in-place in this Variant.
+  // Returns a reference to the newly constructed value.
+  // The signature is based on std::variant<Types...>::emplace() in C++17.
+  template <typename T, class... Args>
+  T& emplace(Args&&... args) {
+    ResetMemory();
+    is_inline_ = CanInlineType<T>();
+    if (is_inline_) {
+      new (&inline_value_)
+          InlineValue(InlineValue::Tag<T>{}, std::forward<Args>(args)...);
+      return static_cast<Variant::Value<T>*>(inline_value_.AsValueInterface())
+          ->value;
+    } else {
+      new (&heap_value_) HeapValue(
+          absl::make_unique<Value<T>>(InPlace(), std::forward<Args>(args)...));
+      return static_cast<Variant::Value<T>*>(heap_value_.get())->value;
+    }
+  }
+
+  bool is_empty() const { return GetValue() == nullptr; }
+
+  void clear() noexcept;
+
+  void swap(Variant& other) noexcept;
+
+  // Note, unlike TypeName(), TypeId() does not return the TypeIndex
+  // of the original type when a TensorValueDataProto is stored as the
+  // value.  In this case, it returns the TypeIndex of TensorValueDataProto.
+  TypeIndex TypeId() const {
+    const TypeIndex VoidTypeIndex = TypeIndex::Make<void>();
+    if (is_empty()) {
+      return VoidTypeIndex;
+    }
+    return GetValue()->TypeId();
+  }
+
+  std::string DebugString() const {
+    return strings::StrCat("Variant<type: ", TypeName(),
+                           " value: ", SummarizeValue(), ">");
+  }
+
+  std::string SummarizeValue() const {
+    return is_empty() ? "[empty]" : GetValue()->DebugString();
+  }
+
+  // Returns a pointer to the stored value if it is type T, or nullptr
+  // otherwise.
+  template <typename T>
+  T* get() {
+    const TypeIndex TTypeIndex = TypeIndex::Make<T>();
+    if (is_empty() || (TTypeIndex != TypeId())) return nullptr;
+    return std::addressof(static_cast<Variant::Value<T>*>(GetValue())->value);
+  }
+
+  // Returns a pointer to the stored value if it is type T, or nullptr
+  // otherwise.
+  template <typename T>
+  const T* get() const {
+    const TypeIndex TTypeIndex = TypeIndex::Make<T>();
+    if (is_empty() || (TTypeIndex != TypeId())) return nullptr;
+    return std::addressof(
+        static_cast<const Variant::Value<T>*>(GetValue())->value);
+  }
+
+  // Returns TypeNameVariant(value).
+  //
+  // In the special case that a serialized Variant is stored (value
+  // is a VariantTensorDataProto), returns value.TypeName(), the
+  // TypeName field stored in the VariantTensorDataProto buffer.
+  std::string TypeName() const {
+    if (is_empty()) {
+      return "";
+    }
+    return GetValue()->TypeName();
+  }
+
+  // Serialize the contents of the stored object into `data`.
+  void Encode(VariantTensorData* data) const {
+    if (!is_empty()) {
+      GetValue()->Encode(data);
+    }
+  }
+
+  // Deserialize `data` and update the stored object.
+  bool Decode(VariantTensorData data);
+
+  // Helper methods to directly serialize/deserialize from strings.
+  void Encode(std::string* buf) const {
+    if (!is_empty()) {
+      GetValue()->Encode(buf);
+    }
+  }
+  bool Decode(std::string buf) {
+    if (!is_empty()) {
+      return GetValue()->Decode(std::move(buf));
+    }
+    return true;
+  }
+
+  template <typename VT>
+  static constexpr bool CanInlineType() {
+    return ((sizeof(Value<VT>) <= InlineValue::kMaxValueSize) &&
+            (alignof(Value<VT>) <= kMaxInlineValueAlignSize));
+  }
+
+ private:
+  struct in_place_t {};
+  static constexpr in_place_t InPlace() { return in_place_t{}; }
+
+  struct ValueInterface {
+    virtual ~ValueInterface() = default;
+    virtual TypeIndex TypeId() const = 0;
+    virtual void* RawPtr() = 0;
+    virtual const void* RawPtr() const = 0;
+    virtual std::unique_ptr<ValueInterface> Clone() const = 0;
+    virtual void CloneInto(ValueInterface* memory) const = 0;
+    virtual void MoveAssign(ValueInterface* memory) = 0;
+    virtual void MoveInto(ValueInterface* memory) = 0;
+    virtual std::string TypeName() const = 0;
+    virtual std::string DebugString() const = 0;
+    virtual void Encode(VariantTensorData* data) const = 0;
+    virtual bool Decode(VariantTensorData data) = 0;
+    virtual void Encode(std::string* buf) const = 0;
+    virtual bool Decode(std::string data) = 0;
+  };
+
+  template <typename T>
+  struct Value final : ValueInterface {
+    template <class... Args>
+    explicit Value(in_place_t /*tag*/, Args&&... args)
+        : value(std::forward<Args>(args)...) {}
+
+    // NOTE(ebrevdo): Destructor must be explicitly defined for CUDA to happily
+    // build `alignof(Variant<void*>)`.
+    ~Value() final = default;
+
+    TypeIndex TypeId() const final {
+      const TypeIndex value_type_index =
+          TypeIndex::Make<typename std::decay<T>::type>();
+      return value_type_index;
+    }
+
+    void* RawPtr() final { return &value; }
+
+    const void* RawPtr() const final { return &value; }
+
+    std::unique_ptr<ValueInterface> Clone() const final {
+      return absl::make_unique<Value>(InPlace(), value);
+    }
+
+    void MoveAssign(ValueInterface* memory) final {
+      CHECK(TypeId() == memory->TypeId())
+          << TypeId().name() << " vs. " << memory->TypeId().name();
+      static_cast<Value*>(memory)->value = std::move(value);
+    }
+
+    void CloneInto(ValueInterface* memory) const final {
+      new (memory) Value(InPlace(), value);
+    }
+
+    void MoveInto(ValueInterface* memory) final {
+      new (memory) Value(InPlace(), std::move(value));
+    }
+
+    std::string TypeName() const final { return TypeNameVariant(value); }
+
+    std::string DebugString() const final { return DebugStringVariant(value); }
+
+    void Encode(VariantTensorData* data) const final {
+      EncodeVariant(value, data);
+    }
+
+    bool Decode(VariantTensorData data) final {
+      return DecodeVariant(&data, &value);
+    }
+
+    void Encode(std::string* buf) const final { EncodeVariant(value, buf); }
+
+    bool Decode(std::string buf) final { return DecodeVariant(&buf, &value); }
+
+    T value;
+  };
+  static constexpr int kMaxInlineValueAlignSize = alignof(Value<void*>);
+
+  using HeapValue = std::unique_ptr<ValueInterface>;
+
+  struct InlineValue {
+    // We try to size InlineValue so that sizeof(Variant) <= 64 and it can fit
+    // into the aligned space of a TensorBuffer.
+    static constexpr int kMaxValueSize = (64 - /*some extra padding=*/8);
+
+    typedef char ValueDataArray[kMaxValueSize];
+    alignas(kMaxInlineValueAlignSize) ValueDataArray value_data;
+
+    // Tag is used for deducing the right type when constructing a Value in
+    // place.
+    template <typename VT>
+    struct Tag {};
+
+    template <typename VT, class... Args>
+    explicit InlineValue(Tag<VT> /*tag*/, Args&&... args) noexcept {
+      Value<VT>* inline_value_data = reinterpret_cast<Value<VT>*>(value_data);
+      new (inline_value_data) Value<VT>(InPlace(), std::forward<Args>(args)...);
+    }
+
+    InlineValue(const InlineValue& other) noexcept {
+      other.AsValueInterface()->CloneInto(AsValueInterface());
+    }
+
+    InlineValue(InlineValue&& other) noexcept {
+      other.AsValueInterface()->MoveInto(AsValueInterface());
+    }
+
+    void ResetMemory() { AsValueInterface()->~ValueInterface(); }
+
+    InlineValue& operator=(const InlineValue& other) {
+      if (&other == this) return *this;
+      ResetMemory();
+      other.AsValueInterface()->CloneInto(AsValueInterface());
+      return *this;
+    }
+
+    InlineValue& operator=(InlineValue&& other) {
+      if (&other == this) return *this;
+      if (AsValueInterface()->TypeId() == other.AsValueInterface()->TypeId()) {
+        other.AsValueInterface()->MoveAssign(AsValueInterface());
+      } else {
+        ResetMemory();
+        other.AsValueInterface()->MoveInto(AsValueInterface());
+      }
+      return *this;
+    }
+
+    ValueInterface* AsValueInterface() {
+      return reinterpret_cast<ValueInterface*>(value_data);
+    }
+
+    const ValueInterface* AsValueInterface() const {
+      return reinterpret_cast<const ValueInterface*>(value_data);
+    }
+
+    ~InlineValue() { ResetMemory(); }
+  };
+
+  union {
+    HeapValue heap_value_;
+    InlineValue inline_value_;
+  };
+  // is_inline_ provides discrimination between which member of the prior union
+  // is currently within it's lifetime. To switch from one member to the other,
+  // the destructor must be called on the currently alive member before calling
+  // the constructor on the other member. In effect, a member is expected to be
+  // live at any given time and that member is tracked via this boolean.
+  bool is_inline_;
+
+  bool IsInlineValue() const { return is_inline_; }
+
+  // ResetMemory causes the destructor of the currently active member of the
+  // union to be run. This must be follwed with a placement new call on the
+  // member whose lifetime is to start. Additionally, is_inline_ needs to be set
+  // accordingly. ResetAndSetInline and ResetAndSetHeap are simple helper
+  // functions for performing the actions that are required to follow.
+  void ResetMemory() {
+    if (IsInlineValue()) {
+      inline_value_.~InlineValue();
+    } else {
+      heap_value_.~HeapValue();
+    }
+  }
+
+  // ResetAndSetInline clears the current state and then constructs a new value
+  // inline with the provided arguments.
+  template <typename... Args>
+  void ResetAndSetInline(Args&&... args) noexcept {
+    ResetMemory();
+    new (&inline_value_) InlineValue(std::forward<Args>(args)...);
+    is_inline_ = true;
+  }
+
+  // ResetAndSetHeap clears the current state then constructs a new value on the
+  // heap with the provided arguments.
+  template <typename... Args>
+  void ResetAndSetHeap(Args&&... args) noexcept {
+    ResetMemory();
+    new (&heap_value_) HeapValue(std::forward<Args>(args)...);
+    is_inline_ = false;
+  }
+
+  ValueInterface* GetValue() {
+    if (IsInlineValue()) {
+      return inline_value_.AsValueInterface();
+    } else {
+      return heap_value_.get();
+    }
+  }
+
+  const ValueInterface* GetValue() const {
+    if (IsInlineValue()) {
+      return inline_value_.AsValueInterface();
+    } else {
+      return heap_value_.get();
+    }
+  }
+
+  // PRECONDITION: Called on construction or ResetMemory() has been called
+  // before this method.
+  template <typename VT, typename T>
+  void InsertValue(T&& value) {
+    if (IsInlineValue()) {
+      new (&inline_value_)
+          InlineValue(InlineValue::Tag<VT>{}, std::forward<T>(value));
+    } else {
+      new (&heap_value_) HeapValue(
+          absl::make_unique<Value<VT>>(InPlace(), std::forward<T>(value)));
+    }
+  }
+};
+
+// Make sure that a Variant object can reside in a 64-byte aligned Tensor
+// buffer.
+static_assert(sizeof(Variant) <= 64,
+              "Expected internal representation to be 64 bytes.");
+
+inline Variant::Variant(const Variant& other)
+    : is_inline_(other.IsInlineValue()) {
+  if (IsInlineValue()) {
+    new (&inline_value_) InlineValue(other.inline_value_);
+  } else {
+    new (&heap_value_)
+        HeapValue(other.heap_value_ ? other.heap_value_->Clone() : nullptr);
+  }
+}
+
+inline Variant::Variant(Variant&& other) noexcept
+    : is_inline_(other.IsInlineValue()) {
+  if (IsInlineValue()) {
+    new (&inline_value_) InlineValue(std::move(other.inline_value_));
+  } else {
+    new (&heap_value_) HeapValue(std::move(other.heap_value_));
+  }
+}
+
+template <typename T, typename VT,
+          typename std::enable_if<!std::is_same<Variant, VT>::value &&
+                                      std::is_move_constructible<VT>::value,
+                                  void>::type*>
+inline Variant::Variant(T&& value) : is_inline_(CanInlineType<VT>()) {
+  InsertValue<VT>(std::forward<T>(value));
+}
+
+template <typename T, typename VT,
+          typename std::enable_if<!std::is_same<Variant, VT>::value &&
+                                      std::is_copy_constructible<VT>::value,
+                                  void>::type*>
+inline Variant::Variant(const T& value) : is_inline_(CanInlineType<VT>()) {
+  InsertValue<VT>(value);
+}
+
+template <typename T, typename VT,
+          typename std::enable_if<!std::is_same<Variant, VT>::value &&
+                                      std::is_move_constructible<VT>::value,
+                                  void>::type*>
+inline Variant& Variant::operator=(T&& value) {
+  ResetMemory();
+  is_inline_ = CanInlineType<VT>();
+  InsertValue<VT>(std::forward<T>(value));
+  return *this;
+}
+
+template <typename T, typename VT,
+          typename std::enable_if<!std::is_same<Variant, VT>::value &&
+                                      std::is_copy_constructible<VT>::value,
+                                  void>::type*>
+inline Variant& Variant::operator=(const T& value) {
+  ResetMemory();
+  is_inline_ = CanInlineType<VT>();
+  InsertValue<VT>(value);
+  return *this;
+}
+
+inline void Variant::clear() noexcept {
+  // We set the internal unique_ptr to nullptr so that we preserve the
+  // invariant that one of the two states must be set at all times. nullptr
+  // indicates that the variant is empty.
+  ResetAndSetHeap(/*pointer=*/nullptr);
+}
+
+inline void Variant::swap(Variant& other) noexcept {
+  if (is_empty()) {
+    if (other.IsInlineValue()) {
+      ResetAndSetInline(std::move(other.inline_value_));
+    } else {
+      ResetAndSetHeap(std::move(other.heap_value_));
+    }
+    other.clear();
+  } else if (other.is_empty()) {
+    if (IsInlineValue()) {
+      other.ResetAndSetInline(std::move(inline_value_));
+    } else {
+      other.ResetAndSetHeap(std::move(heap_value_));
+    }
+    clear();
+  } else {  // Both Variants have values.
+    if (other.IsInlineValue() && IsInlineValue()) {
+      std::swap(inline_value_, other.inline_value_);
+    } else if (!other.IsInlineValue() && !IsInlineValue()) {
+      std::swap(heap_value_, other.heap_value_);
+    } else if (other.IsInlineValue() && !IsInlineValue()) {
+      HeapValue v = std::move(heap_value_);
+      ResetAndSetInline(std::move(other.inline_value_));
+      other.ResetAndSetHeap(std::move(v));
+    } else {  // !other.IsInlineValue() && IsInlineValue()
+      HeapValue v = std::move(other.heap_value_);
+      other.ResetAndSetInline(std::move(inline_value_));
+      ResetAndSetHeap(std::move(v));
+    }
+  }
+}
+
+template <>
+void* Variant::get();
+
+template <>
+const void* Variant::get() const;
+
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_VARIANT_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/variant_encode_decode.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/variant_encode_decode.h
new file mode 100644
index 0000000000000000000000000000000000000000..f481714eee2c4b21df64b950445052a04cf0b12f
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/variant_encode_decode.h
@@ -0,0 +1,280 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_VARIANT_ENCODE_DECODE_H_
+#define TENSORFLOW_CORE_FRAMEWORK_VARIANT_ENCODE_DECODE_H_
+
+#include <iostream>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/type_index.h"
+#include "tensorflow/core/framework/variant_tensor_data.h"
+#include "tensorflow/core/lib/strings/strcat.h"
+#include "tensorflow/core/platform/abi.h"
+#include "tensorflow/core/platform/protobuf.h"
+
+namespace tensorflow {
+
+// Type used for tag-dispatch of the Encode/Decode Variant implementations. This
+// template can determine whether the first type parameter `T` is one of the
+// following:
+//
+// * A POD type (TypeResolver<T, true>)
+// * A tensorflow::Tensor (TypeResolver<T, false, true>)
+// * A protocol buffer (TypeResolver<T, false, false, true>)
+// * None of the above (TypeResolver<T, false, false, false>)
+//
+template <typename T, bool = std::is_pod<typename std::decay<T>::type>::value,
+          bool = std::is_same<typename std::decay<T>::type,
+                              ::tensorflow::Tensor>::value,
+          bool = std::is_base_of<protobuf::MessageLite,
+                                 typename std::decay<T>::type>::value>
+struct TypeResolver {};
+
+// Specialization for POD type
+template <typename T>
+void EncodeVariantImpl(const T& value, TypeResolver<T, true /* is_pod */>,
+                       VariantTensorData* data) {
+  data->set_metadata(value);
+}
+
+// Specialization for tensorflow::Tensor
+template <typename T>
+void EncodeVariantImpl(const T& value,
+                       TypeResolver<T, false /* is_pod */, true /* Tensor */>,
+                       VariantTensorData* data) {
+  data->tensors_.clear();
+  data->tensors_.push_back(value);
+}
+
+// Specialization for protobuf
+template <typename T>
+void EncodeVariantImpl(const T& value,
+                       TypeResolver<T, false /* is_pod */, false /* Tensor */,
+                                    true /* protobuf */>,
+                       VariantTensorData* data) {
+  value.SerializeToString(&data->metadata_);
+}
+
+// Specialization for other types
+template <typename T>
+void EncodeVariantImpl(const T& value,
+                       TypeResolver<T, false /* is_pod */, false /* Tensor */,
+                                    false /* protobuf */>,
+                       VariantTensorData* data) {
+  value.Encode(data);
+}
+
+// Specialization for POD type
+template <typename T>
+bool DecodeVariantImpl(VariantTensorData data,
+                       TypeResolver<T, true /* is_pod */, false /* Tensor */,
+                                    false /* protobuf */>,
+                       T* value) {
+  return data.get_metadata(value);
+}
+
+// Specialization for tensorflow::Tensor
+template <typename T>
+bool DecodeVariantImpl(VariantTensorData data,
+                       TypeResolver<T, false /* is_pod */, true /* Tensor */,
+                                    false /* protobuf */>,
+                       T* value) {
+  *value = data.tensors(0);
+  return true;
+}
+
+// Specialization for protobuf
+template <typename T>
+bool DecodeVariantImpl(VariantTensorData data,
+                       TypeResolver<T, false /* is_pod */, false /* Tensor */,
+                                    true /* protobuf */>,
+                       T* value) {
+  std::string metadata;
+  data.get_metadata(&metadata);
+  return value->ParseFromString(std::move(metadata));
+}
+
+// Specialization for other types
+template <typename T>
+bool DecodeVariantImpl(VariantTensorData data,
+                       TypeResolver<T, false /* is_pod */, false /* Tensor */,
+                                    false /* protobuf */>,
+                       T* value) {
+  return value->Decode(std::move(data));
+}
+
+template <typename C, typename = void>
+struct has_type_name : std::false_type {};
+
+template <typename C>
+struct has_type_name<
+    C, typename std::enable_if<std::is_same<
+           decltype(std::declval<C>().TypeName()), string>::value>::type>
+    : std::true_type {};
+
+template <typename T, bool = has_type_name<typename std::decay<T>::type>::value,
+          bool = std::is_same<typename std::decay<T>::type,
+                              ::tensorflow::Tensor>::value,
+          bool = std::is_base_of<protobuf::MessageLite,
+                                 typename std::decay<T>::type>::value>
+struct TypeNameResolver {};
+
+template <typename T>
+std::string TypeNameVariantImpl(const T& value,
+                                TypeNameResolver<T, true /* has_type_name */>) {
+  return value.TypeName();
+}
+
+template <typename T>
+std::string TypeNameVariantImpl(
+    const T& value,
+    TypeNameResolver<T, false /* has_type_name */, true /* Tensor */>) {
+  return "tensorflow::Tensor";
+}
+
+template <typename T>
+std::string TypeNameVariantImpl(
+    const T& value, TypeNameResolver<T, false /* has_type_name */,
+                                     false /* Tensor */, true /* protobuf */>) {
+  return value.GetTypeName();
+}
+
+template <typename T>
+std::string TypeNameVariantImpl(
+    const T& value,
+    TypeNameResolver<T, false /* has_type_name */, false /* Tensor */,
+                     false /* protobuf */>) {
+  return port::MaybeAbiDemangle(TypeIndex::Make<T>().name());
+}
+
+template <typename T>
+std::string TypeNameVariant(const T& value) {
+  return TypeNameVariantImpl(value, TypeNameResolver<T>());
+}
+
+template <typename C, typename = void>
+struct has_debug_string : std::false_type {};
+
+template <typename C>
+struct has_debug_string<
+    C, typename std::enable_if<std::is_same<
+           decltype(std::declval<C>().DebugString()), string>::value>::type>
+    : std::true_type {};
+
+template <typename C, typename = void>
+struct can_strcat : std::false_type {};
+
+template <typename C>
+struct can_strcat<
+    C, typename std::enable_if<std::is_same<
+           decltype(strings::StrCat(std::declval<C>())), string>::value>::type>
+    : std::true_type {};
+
+template <typename T,
+          bool = has_debug_string<typename std::decay<T>::type>::value,
+          bool = can_strcat<typename std::decay<T>::type>::value>
+struct DebugStringResolver {};
+
+// TODO(ebrevdo): Expand DebugStringResolver to return TypeString if
+// there is no StrCat<T>() constructor.
+template <typename T>
+std::string DebugStringVariantImpl(
+    const T& value, DebugStringResolver<T, true /* has_debug_string */>) {
+  return value.DebugString();
+}
+
+template <typename T>
+std::string DebugStringVariantImpl(
+    const T& value, DebugStringResolver<T, false /* has_debug_string */,
+                                        true /* can_strcat */>) {
+  return strings::StrCat(value);
+}
+
+template <typename T>
+std::string DebugStringVariantImpl(
+    const T& value, DebugStringResolver<T, false /* has_debug_string */,
+                                        false /* can_strcat */>) {
+  return "?";
+}
+
+template <typename T>
+std::string DebugStringVariant(const T& value) {
+  return DebugStringVariantImpl(value, DebugStringResolver<T>());
+}
+
+template <typename T>
+void EncodeVariant(const T& value, VariantTensorData* data) {
+  EncodeVariantImpl(value, TypeResolver<T>(), data);
+  data->set_type_name(TypeNameVariant(value));
+}
+
+template <typename T>
+bool DecodeVariant(VariantTensorData* data, T* value) {
+  return DecodeVariantImpl(std::move(*data), TypeResolver<T>(), value);
+}
+
+template <typename T>
+void EncodeVariant(const T& value, std::string* buf) {
+  VariantTensorData data;
+  EncodeVariantImpl(value, TypeResolver<T>(), &data);
+  data.set_type_name(TypeNameVariant(value));
+  DCHECK(buf != nullptr);
+  data.SerializeToString(buf);
+}
+
+template <typename T>
+bool DecodeVariant(std::string* buf, T* value) {
+  VariantTensorData data;
+  if (!data.ParseFromString(*buf)) return false;
+  if (!DecodeVariantImpl(std::move(data), TypeResolver<T>(), value)) {
+    return false;
+  }
+  return true;
+}
+
+// Specializations for VariantTensorDataProto
+template <>
+std::string TypeNameVariant(const VariantTensorDataProto& value);
+
+template <>
+void EncodeVariant(const VariantTensorDataProto& value,
+                   VariantTensorData* data);
+
+template <>
+bool DecodeVariant(VariantTensorData* data, VariantTensorDataProto* value);
+
+template <>
+void EncodeVariant(const VariantTensorDataProto& value, std::string* buf);
+
+template <>
+bool DecodeVariant(std::string* buf, VariantTensorDataProto* value);
+
+// Encodes an array of Variant objects in to the given StringListEncoder.
+// `variant_array` is assumed to point to an array of `n` Variant objects.
+void EncodeVariantList(const Variant* variant_array, int64_t n,
+                       std::unique_ptr<port::StringListEncoder> e);
+
+// Decodes an array of Variant objects from the given StringListDecoder.
+// `variant_array` is assumed to point to an array of `n` Variant objects.
+bool DecodeVariantList(std::unique_ptr<port::StringListDecoder> d,
+                       Variant* variant_array, int64_t n);
+
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_VARIANT_ENCODE_DECODE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/variant_op_registry.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/variant_op_registry.h
new file mode 100644
index 0000000000000000000000000000000000000000..0584fb7c573244f1c9dd0e42c3ffd35a9e8b81a8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/variant_op_registry.h
@@ -0,0 +1,591 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_VARIANT_OP_REGISTRY_H_
+#define TENSORFLOW_CORE_FRAMEWORK_VARIANT_OP_REGISTRY_H_
+
+#include <string>
+#include <unordered_set>
+#include <vector>
+
+#define EIGEN_USE_THREADS
+
+#include "tensorflow/core/framework/tensor.pb.h"
+#include "tensorflow/core/framework/type_index.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/framework/variant.h"
+#include "tensorflow/core/framework/variant_encode_decode.h"
+#include "tensorflow/core/lib/gtl/flatmap.h"
+#include "tensorflow/core/lib/hash/hash.h"
+#include "tensorflow/core/platform/abi.h"
+
+namespace tensorflow {
+
+class OpKernelContext;
+// A global UnaryVariantOpRegistry is used to hold callback functions
+// for different variant types.  To be used by ShapeOp, RankOp, and
+// SizeOp, decoding, etc.
+
+enum VariantUnaryOp {
+  INVALID_VARIANT_UNARY_OP = 0,
+  ZEROS_LIKE_VARIANT_UNARY_OP = 1,
+  CONJ_VARIANT_UNARY_OP = 2,
+};
+
+const char* VariantUnaryOpToString(VariantUnaryOp op);
+
+enum VariantBinaryOp {
+  INVALID_VARIANT_BINARY_OP = 0,
+  ADD_VARIANT_BINARY_OP = 1,
+};
+
+const char* VariantBinaryOpToString(VariantBinaryOp op);
+
+enum VariantDeviceCopyDirection {
+  INVALID_DEVICE_COPY_DIRECTION = 0,
+  HOST_TO_DEVICE = 1,
+  DEVICE_TO_HOST = 2,
+  DEVICE_TO_DEVICE = 3,
+};
+
+class UnaryVariantOpRegistry;
+extern UnaryVariantOpRegistry* UnaryVariantOpRegistryGlobal();
+
+class UnaryVariantOpRegistry {
+ public:
+  typedef std::function<bool(Variant*)> VariantDecodeFn;
+  typedef std::function<Status(OpKernelContext*, const Variant&, Variant*)>
+      VariantUnaryOpFn;
+  typedef std::function<Status(OpKernelContext*, const Variant&, const Variant&,
+                               Variant*)>
+      VariantBinaryOpFn;
+
+  // An AsyncTensorDeviceCopyFn is a function provided to
+  // the user-provided DeviceCopyFn callback as the third argument ("copier").
+  //
+  // Expected inputs:
+  //   from: A Tensor on the host (if performing cpu->gpu copy), or
+  //         device (if performing gpu->cpu or gpu->gpu copy).
+  //   to: An empty/uninitialized tensor.  It will be updated upon
+  //       successful return of the function with the correct dtype and shape.
+  //       However, the copied data will not be available until the compute
+  //       stream has been synchronized.
+  //
+  // Returns:
+  //   The status upon memory allocation / initialization of the
+  //   "to" tensor, and enqueue of the copy onto the compute stream.
+  //   Any failure of the copy itself will update the underlying
+  //   stream status and propagate through the runtime independent
+  //   of the caller.
+  typedef std::function<Status(const Tensor& from, Tensor* to)>
+      AsyncTensorDeviceCopyFn;
+
+  // The AsyncVariantDeviceCopyFn is the signature of the 'device_copy_fn'
+  // expected to be passed to the registration macro
+  // INTERNAL_REGISTER_UNARY_VARIANT_DEVICE_COPY_FUNCTION.
+  typedef std::function<Status(const Variant& from, Variant* to,
+                               AsyncTensorDeviceCopyFn copy_fn)>
+      AsyncVariantDeviceCopyFn;
+
+  // Add a decode function to the registry.
+  void RegisterDecodeFn(const std::string& type_name,
+                        const VariantDecodeFn& decode_fn);
+
+  // Returns nullptr if no decode function was found for the given TypeName.
+  VariantDecodeFn* GetDecodeFn(StringPiece type_name);
+
+  // Add a copy-to-GPU function to the registry.
+  void RegisterDeviceCopyFn(const VariantDeviceCopyDirection direction,
+                            const TypeIndex& type_index,
+                            const AsyncVariantDeviceCopyFn& device_copy_fn) {
+    AsyncVariantDeviceCopyFn* existing = GetDeviceCopyFn(direction, type_index);
+    CHECK_EQ(existing, nullptr)
+        << "UnaryVariantDeviceCopy for direction: " << direction
+        << " and type_index: " << port::MaybeAbiDemangle(type_index.name())
+        << " already registered";
+    device_copy_fns.insert(
+        std::pair<std::pair<VariantDeviceCopyDirection, TypeIndex>,
+                  AsyncVariantDeviceCopyFn>(
+            std::make_pair(direction, type_index), device_copy_fn));
+  }
+
+  // Returns nullptr if no copy function was found for the given
+  // TypeName and direction.
+  AsyncVariantDeviceCopyFn* GetDeviceCopyFn(
+      const VariantDeviceCopyDirection direction, const TypeIndex& type_index) {
+    auto found = device_copy_fns.find(std::make_pair(direction, type_index));
+    if (found == device_copy_fns.end()) return nullptr;
+    return &found->second;
+  }
+
+  // Add a unary op function to the registry.
+  void RegisterUnaryOpFn(VariantUnaryOp op, const std::string& device,
+                         const TypeIndex& type_index,
+                         const VariantUnaryOpFn& unary_op_fn) {
+    VariantUnaryOpFn* existing = GetUnaryOpFn(op, device, type_index);
+    CHECK_EQ(existing, nullptr)
+        << "Unary VariantUnaryOpFn for type_index: "
+        << port::MaybeAbiDemangle(type_index.name())
+        << " already registered for device type: " << device;
+    unary_op_fns.insert(std::pair<FuncTuple<VariantUnaryOp>, VariantUnaryOpFn>(
+        {op, GetPersistentStringPiece(device), type_index}, unary_op_fn));
+  }
+
+  // Returns nullptr if no unary op function was found for the given
+  // op, device, and TypeName.
+  VariantUnaryOpFn* GetUnaryOpFn(VariantUnaryOp op, StringPiece device,
+                                 const TypeIndex& type_index) {
+    auto found = unary_op_fns.find({op, device, type_index});
+    if (found == unary_op_fns.end()) return nullptr;
+    return &found->second;
+  }
+
+  // Add a binary op function to the registry.
+  void RegisterBinaryOpFn(VariantBinaryOp op, const std::string& device,
+                          const TypeIndex& type_index,
+                          const VariantBinaryOpFn& add_fn) {
+    VariantBinaryOpFn* existing = GetBinaryOpFn(op, device, type_index);
+    CHECK_EQ(existing, nullptr)
+        << "Unary VariantBinaryOpFn for type_index: "
+        << port::MaybeAbiDemangle(type_index.name())
+        << " already registered for device type: " << device;
+    binary_op_fns.insert(
+        std::pair<FuncTuple<VariantBinaryOp>, VariantBinaryOpFn>(
+            {op, GetPersistentStringPiece(device), type_index}, add_fn));
+  }
+
+  // Returns nullptr if no binary op function was found for the given
+  // op, device and TypeName.
+  VariantBinaryOpFn* GetBinaryOpFn(VariantBinaryOp op, StringPiece device,
+                                   const TypeIndex& type_index) {
+    auto found = binary_op_fns.find({op, device, type_index});
+    if (found == binary_op_fns.end()) return nullptr;
+    return &found->second;
+  }
+
+  // Get a pointer to a global UnaryVariantOpRegistry object
+  static UnaryVariantOpRegistry* Global() {
+    return UnaryVariantOpRegistryGlobal();
+  }
+
+  // Get a pointer to a global persistent string storage object.
+  // ISO/IEC C++ working draft N4296 clarifies that insertion into an
+  // std::unordered_set does not invalidate memory locations of
+  // *values* inside the set (though it may invalidate existing
+  // iterators).  In other words, one may safely point a StringPiece to
+  // a value in the set without that StringPiece being invalidated by
+  // future insertions.
+  static std::unordered_set<string>* PersistentStringStorage();
+
+ private:
+  struct TypeIndexHash {
+    std::size_t operator()(const TypeIndex& x) const { return x.hash_code(); }
+  };
+
+  gtl::FlatMap<StringPiece, VariantDecodeFn, StringPieceHasher> decode_fns;
+
+  // Map std::pair<Direction, type_name> to function.
+  struct PairHash {
+    template <typename Direction>
+    std::size_t operator()(const std::pair<Direction, TypeIndex>& x) const {
+      // The hash of an enum is just its value as a std::size_t.
+      std::size_t ret = static_cast<std::size_t>(std::get<0>(x));
+      ret = Hash64Combine(ret, std::get<1>(x).hash_code());
+      return ret;
+    }
+  };
+
+  gtl::FlatMap<std::pair<VariantDeviceCopyDirection, TypeIndex>,
+               AsyncVariantDeviceCopyFn, PairHash>
+      device_copy_fns;
+
+  // Map std::tuple<Op, device, type_name> to function.
+
+  // this breaks by falling victim to "too perfect forwarding"
+  // see https://stackoverflow.com/questions/44475317/variadic-template-issue
+  // and references therein
+  template <typename Op>
+  struct FuncTuple {
+    FuncTuple(const Op& op, const StringPiece& dev, const TypeIndex& type_index)
+        : op_type_(op), device_(dev), type_index_(type_index) {}
+    Op op_type_;
+    StringPiece device_;
+    TypeIndex type_index_;
+  };
+  // friend declaration for operator==
+  // needed for clang
+  template <typename Op>
+  friend bool operator==(const FuncTuple<Op>& l, const FuncTuple<Op>& r);
+  struct TupleHash {
+    template <typename Op>
+    std::size_t operator()(
+        const std::tuple<Op, StringPiece, TypeIndex>& x) const {
+      // The hash of an enum is just its value as a std::size_t.
+      std::size_t ret = static_cast<std::size_t>(std::get<0>(x));
+      ret = Hash64Combine(ret, sp_hasher_(std::get<1>(x)));
+      ret = Hash64Combine(ret, std::get<2>(x).hash_code());
+      return ret;
+    }
+
+    template <typename Op>
+    std::size_t operator()(const FuncTuple<Op>& x) const {
+      // The hash of an enum is just its value as a std::size_t.
+      std::size_t ret = static_cast<std::size_t>(x.op_type_);
+      ret = Hash64Combine(ret, sp_hasher_(x.device_));
+      ret = Hash64Combine(ret, x.type_index_.hash_code());
+      return ret;
+    }
+    StringPieceHasher sp_hasher_;
+  };
+  gtl::FlatMap<FuncTuple<VariantUnaryOp>, VariantUnaryOpFn, TupleHash>
+      unary_op_fns;
+  gtl::FlatMap<FuncTuple<VariantBinaryOp>, VariantBinaryOpFn, TupleHash>
+      binary_op_fns;
+
+  // Find or insert a string into a persistent string storage
+  // container; return the StringPiece pointing to the permanent string
+  // location.
+  static StringPiece GetPersistentStringPiece(const std::string& str) {
+    const auto string_storage = PersistentStringStorage();
+    auto found = string_storage->find(str);
+    if (found == string_storage->end()) {
+      auto inserted = string_storage->insert(str);
+      return StringPiece(*inserted.first);
+    } else {
+      return StringPiece(*found);
+    }
+  }
+};
+template <typename Op>
+inline bool operator==(const UnaryVariantOpRegistry::FuncTuple<Op>& lhs,
+                       const UnaryVariantOpRegistry::FuncTuple<Op>& rhs) {
+  return (lhs.op_type_ == rhs.op_type_) && (lhs.device_ == rhs.device_) &&
+         (lhs.type_index_ == rhs.type_index_);
+}
+
+// Decodes the Variant whose data_type has a registered decode
+// function.  Returns an Internal error if the Variant does not have a
+// registered decode function, or if the decoding function fails.
+//
+// REQUIRES:
+//   variant is not null.
+//
+bool DecodeUnaryVariant(Variant* variant);
+
+// Copies a variant between CPU<->GPU, or between GPU<->GPU.
+// The variant 'from' must have a registered DeviceCopyFn for the
+// given direction.  The returned variant 'to' will have
+// (some subset of its) tensors stored on destination according to the
+// registered DeviceCopyFn function for the given direction.  Returns
+// an Internal error if the Variant does not have a registered
+// DeviceCopyFn function for the given direction, or if initiating the
+// copy fails.
+//
+// REQUIRES:
+//   'to' is not null.
+//
+Status VariantDeviceCopy(
+    const VariantDeviceCopyDirection direction, const Variant& from,
+    Variant* to,
+    const UnaryVariantOpRegistry::AsyncTensorDeviceCopyFn& copy_fn);
+
+// Sets *v_out = unary_op(v).  The variant v must have a registered
+// UnaryOp function for the given Device.  Returns an Internal error
+// if v does not have a registered unary_op function for this device, or if
+// UnaryOp fails.
+//
+// REQUIRES:
+//   v_out is not null.
+//
+template <typename Device>
+Status UnaryOpVariant(OpKernelContext* ctx, VariantUnaryOp op, const Variant& v,
+                      Variant* v_out) {
+  const std::string& device = DeviceName<Device>::value;
+  UnaryVariantOpRegistry::VariantUnaryOpFn* unary_op_fn =
+      UnaryVariantOpRegistry::Global()->GetUnaryOpFn(op, device, v.TypeId());
+  if (unary_op_fn == nullptr) {
+    return errors::Internal("No unary variant unary_op function found for op ",
+                            VariantUnaryOpToString(op),
+                            " Variant type_name: ", v.TypeName(),
+                            " for device type: ", device);
+  }
+  return (*unary_op_fn)(ctx, v, v_out);
+}
+
+// Sets *out = binary_op(a, b).  The variants a and b must be the same type
+// and have a registered binary_op function for the given Device.  Returns an
+// Internal error if a and b are not the same type_name or if
+// if a does not have a registered op function for this device, or if
+// BinaryOp fails.
+//
+// REQUIRES:
+//   out is not null.
+//
+template <typename Device>
+Status BinaryOpVariants(OpKernelContext* ctx, VariantBinaryOp op,
+                        const Variant& a, const Variant& b, Variant* out) {
+  if (a.TypeId() != b.TypeId()) {
+    return errors::Internal(
+        "BinaryOpVariants: Variants a and b have different "
+        "type ids.  Type names: '",
+        a.TypeName(), "' vs. '", b.TypeName(), "'");
+  }
+  const std::string& device = DeviceName<Device>::value;
+  UnaryVariantOpRegistry::VariantBinaryOpFn* binary_op_fn =
+      UnaryVariantOpRegistry::Global()->GetBinaryOpFn(op, device, a.TypeId());
+  if (binary_op_fn == nullptr) {
+    return errors::Internal("No unary variant binary_op function found for op ",
+                            VariantBinaryOpToString(op),
+                            " Variant type_name: '", a.TypeName(),
+                            "' for device type: ", device);
+  }
+  return (*binary_op_fn)(ctx, a, b, out);
+}
+
+namespace variant_op_registry_fn_registration {
+
+template <typename T>
+class UnaryVariantDecodeRegistration {
+ public:
+  UnaryVariantDecodeRegistration(const std::string& type_name) {
+    // The Variant is passed by pointer because it should be
+    // mutable: get below may Decode the variant, which
+    // is a self-mutating behavior.  The variant is not modified in
+    // any other way.
+    UnaryVariantOpRegistry::Global()->RegisterDecodeFn(
+        type_name, [type_name](Variant* v) -> bool {
+          DCHECK_NE(v, nullptr);
+          VariantTensorDataProto* t = v->get<VariantTensorDataProto>();
+          if (t == nullptr) {
+            return false;
+          }
+          Variant decoded = T();
+          VariantTensorData data(std::move(*t));
+          if (!decoded.Decode(std::move(data))) {
+            return false;
+          }
+          std::swap(decoded, *v);
+          return true;
+        });
+  }
+};
+
+template <typename T>
+class UnaryVariantDeviceCopyRegistration {
+ public:
+  typedef std::function<Status(const T& t, T* t_out,
+                               UnaryVariantOpRegistry::AsyncTensorDeviceCopyFn)>
+      LocalVariantDeviceCopyFn;
+  UnaryVariantDeviceCopyRegistration(
+      const VariantDeviceCopyDirection direction, const TypeIndex& type_index,
+      const LocalVariantDeviceCopyFn& device_copy_fn) {
+    const std::string type_index_name =
+        port::MaybeAbiDemangle(type_index.name());
+    UnaryVariantOpRegistry::Global()->RegisterDeviceCopyFn(
+        direction, type_index,
+        [type_index_name, device_copy_fn](
+            const Variant& from, Variant* to,
+            UnaryVariantOpRegistry::AsyncTensorDeviceCopyFn
+                device_copy_tensor_fn) -> Status {
+          DCHECK_NE(to, nullptr);
+          *to = T();
+          if (from.get<T>() == nullptr) {
+            return errors::Internal(
+                "VariantCopyToGPUFn: Could not access object, type_index: ",
+                type_index_name);
+          }
+          const T& t = *from.get<T>();
+          T* t_out = to->get<T>();
+          return device_copy_fn(t, t_out, device_copy_tensor_fn);
+        });
+  }
+};
+
+template <typename T>
+class UnaryVariantUnaryOpRegistration {
+  typedef std::function<Status(OpKernelContext* ctx, const T& t, T* t_out)>
+      LocalVariantUnaryOpFn;
+
+ public:
+  UnaryVariantUnaryOpRegistration(VariantUnaryOp op, const std::string& device,
+                                  const TypeIndex& type_index,
+                                  const LocalVariantUnaryOpFn& unary_op_fn) {
+    const std::string type_index_name =
+        port::MaybeAbiDemangle(type_index.name());
+    UnaryVariantOpRegistry::Global()->RegisterUnaryOpFn(
+        op, device, type_index,
+        [type_index_name, unary_op_fn](OpKernelContext* ctx, const Variant& v,
+                                       Variant* v_out) -> Status {
+          DCHECK_NE(v_out, nullptr);
+          *v_out = T();
+          if (v.get<T>() == nullptr) {
+            return errors::Internal(
+                "VariantUnaryOpFn: Could not access object, type_index: ",
+                type_index_name);
+          }
+          const T& t = *v.get<T>();
+          T* t_out = v_out->get<T>();
+          return unary_op_fn(ctx, t, t_out);
+        });
+  }
+};
+
+template <typename T>
+class UnaryVariantBinaryOpRegistration {
+  typedef std::function<Status(OpKernelContext* ctx, const T& a, const T& b,
+                               T* out)>
+      LocalVariantBinaryOpFn;
+
+ public:
+  UnaryVariantBinaryOpRegistration(VariantBinaryOp op,
+                                   const std::string& device,
+                                   const TypeIndex& type_index,
+                                   const LocalVariantBinaryOpFn& binary_op_fn) {
+    const std::string type_index_name =
+        port::MaybeAbiDemangle(type_index.name());
+    UnaryVariantOpRegistry::Global()->RegisterBinaryOpFn(
+        op, device, type_index,
+        [type_index_name, binary_op_fn](OpKernelContext* ctx, const Variant& a,
+                                        const Variant& b,
+                                        Variant* out) -> Status {
+          DCHECK_NE(out, nullptr);
+          *out = T();
+          if (a.get<T>() == nullptr) {
+            return errors::Internal(
+                "VariantBinaryOpFn: Could not access object 'a', type_index: ",
+                type_index_name);
+          }
+          if (b.get<T>() == nullptr) {
+            return errors::Internal(
+                "VariantBinaryOpFn: Could not access object 'b', type_index: ",
+                type_index_name);
+          }
+          const T& t_a = *a.get<T>();
+          const T& t_b = *b.get<T>();
+          T* t_out = out->get<T>();
+          return binary_op_fn(ctx, t_a, t_b, t_out);
+        });
+  }
+};
+
+};  // namespace variant_op_registry_fn_registration
+
+// Register a unary decode variant function for the given type.
+#define REGISTER_UNARY_VARIANT_DECODE_FUNCTION(T, type_name) \
+  REGISTER_UNARY_VARIANT_DECODE_FUNCTION_UNIQ_HELPER(__COUNTER__, T, type_name)
+
+#define REGISTER_UNARY_VARIANT_DECODE_FUNCTION_UNIQ_HELPER(ctr, T, type_name) \
+  REGISTER_UNARY_VARIANT_DECODE_FUNCTION_UNIQ(ctr, T, type_name)
+
+#define REGISTER_UNARY_VARIANT_DECODE_FUNCTION_UNIQ(ctr, T, type_name) \
+  static ::tensorflow::variant_op_registry_fn_registration::           \
+      UnaryVariantDecodeRegistration<T>                                \
+          register_unary_variant_op_decoder_fn_##ctr(type_name)
+
+// ****** NOTE ******
+// FOR INTERNAL USE ONLY.  IF YOU USE THIS WE MAY BREAK YOUR CODE.
+// ****** NOTE ******
+//
+// Register a device copy variant function for the given copy
+// direction and type; where direction is the enum
+// VariantDeviceCopyDirection, and the device_copy_fn has signature:
+//
+//   Status device_copy_fn(
+//     const T& t, T* t_out,
+//     const UnaryVariantOpRegistry::AsyncTensorDeviceCopyFn& copier);
+//
+// And device_copy_fn calls copier 0 or more times.  For details on
+// the behavior of the copier function, see the comments at the
+// declaration of UnaryVariantOpRegistry::AsyncTensorDeviceCopyFn.
+//
+// Note, the device_copy_fn may choose to keep some tensors
+// on host, e.g. by assigning to->tensor = from.tensor (assuming
+// from.tensor is already on host); or by setting
+//   to->tensor = Tensor(cpu_allocator(), ...)
+// and manually updating its values.
+//
+// If this is the case, the CopyFns for HOST_TO_DEVICE,
+// DEVICE_TO_HOST, and DEVICE_TO_DEVICE must perform host-to-host
+// copies in a consistent manner.  For example, one must always
+// manually copy any "always on host" tensors in all directions instead of e.g.
+//   - performing a host-to-host copy in one direction,
+//   - using the provided copier function in the reverse direction.
+// Doing the latter will cause program failures.
+//
+// ****** NOTE ******
+// FOR INTERNAL USE ONLY.  IF YOU USE THIS WE MAY BREAK YOUR CODE.
+// ****** NOTE ******
+#define INTERNAL_REGISTER_UNARY_VARIANT_DEVICE_COPY_FUNCTION(T, direction,   \
+                                                             device_copy_fn) \
+  INTERNAL_REGISTER_UNARY_VARIANT_DEVICE_COPY_FUNCTION_UNIQ_HELPER(          \
+      __COUNTER__, T, direction, TypeIndex::Make<T>(), device_copy_fn)
+
+#define INTERNAL_REGISTER_UNARY_VARIANT_DEVICE_COPY_FUNCTION_UNIQ_HELPER( \
+    ctr, T, direction, type_index, device_copy_fn)                        \
+  INTERNAL_REGISTER_UNARY_VARIANT_DEVICE_COPY_FUNCTION_UNIQ(              \
+      ctr, T, direction, type_index, device_copy_fn)
+
+#define INTERNAL_REGISTER_UNARY_VARIANT_DEVICE_COPY_FUNCTION_UNIQ( \
+    ctr, T, direction, type_index, device_copy_fn)                 \
+  static variant_op_registry_fn_registration::                     \
+      UnaryVariantDeviceCopyRegistration<T>                        \
+          register_unary_variant_op_device_copy_fn_##ctr(          \
+              direction, type_index, device_copy_fn)
+
+// Register a unary unary_op variant function with the signature:
+//    Status UnaryOpFn(OpKernelContext* ctx, const T& t, T* t_out);
+// to Variants having TypeIndex type_index, for device string device,
+// for UnaryVariantOp enum op.
+#define REGISTER_UNARY_VARIANT_UNARY_OP_FUNCTION(op, device, T,     \
+                                                 unary_op_function) \
+  REGISTER_UNARY_VARIANT_UNARY_OP_FUNCTION_UNIQ_HELPER(             \
+      __COUNTER__, op, device, T, TypeIndex::Make<T>(), unary_op_function)
+
+#define REGISTER_UNARY_VARIANT_UNARY_OP_FUNCTION_UNIQ_HELPER(       \
+    ctr, op, device, T, type_index, unary_op_function)              \
+  REGISTER_UNARY_VARIANT_UNARY_OP_FUNCTION_UNIQ(ctr, op, device, T, \
+                                                type_index, unary_op_function)
+
+#define REGISTER_UNARY_VARIANT_UNARY_OP_FUNCTION_UNIQ(                       \
+    ctr, op, device, T, type_index, unary_op_function)                       \
+  static ::tensorflow::variant_op_registry_fn_registration::                 \
+      UnaryVariantUnaryOpRegistration<T>                                     \
+          register_unary_variant_op_decoder_fn_##ctr(op, device, type_index, \
+                                                     unary_op_function)
+
+// Register a binary_op variant function with the signature:
+//    Status BinaryOpFn(OpKernelContext* ctx, const T& a, const T& b, T* out);
+// to Variants having TypeIndex type_index, for device string device,
+// for BinaryVariantOp enum OP.
+#define REGISTER_UNARY_VARIANT_BINARY_OP_FUNCTION(op, device, T,      \
+                                                  binary_op_function) \
+  REGISTER_UNARY_VARIANT_BINARY_OP_FUNCTION_UNIQ_HELPER(              \
+      __COUNTER__, op, device, T, TypeIndex::Make<T>(), binary_op_function)
+
+#define REGISTER_UNARY_VARIANT_BINARY_OP_FUNCTION_UNIQ_HELPER( \
+    ctr, op, device, T, type_index, binary_op_function)        \
+  REGISTER_UNARY_VARIANT_BINARY_OP_FUNCTION_UNIQ(              \
+      ctr, op, device, T, type_index, binary_op_function)
+
+#define REGISTER_UNARY_VARIANT_BINARY_OP_FUNCTION_UNIQ(                      \
+    ctr, op, device, T, type_index, binary_op_function)                      \
+  static ::tensorflow::variant_op_registry_fn_registration::                 \
+      UnaryVariantBinaryOpRegistration<T>                                    \
+          register_unary_variant_op_decoder_fn_##ctr(op, device, type_index, \
+                                                     binary_op_function)
+
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_VARIANT_OP_REGISTRY_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/variant_tensor_data.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/variant_tensor_data.h
new file mode 100644
index 0000000000000000000000000000000000000000..bfe5899d3265e6bce48d73aa66127a98d28b0f40
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/variant_tensor_data.h
@@ -0,0 +1,144 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_VARIANT_TENSOR_DATA_H_
+#define TENSORFLOW_CORE_FRAMEWORK_VARIANT_TENSOR_DATA_H_
+
+#include <algorithm>
+#include <vector>
+
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/lib/core/stringpiece.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+
+class VariantTensorDataProto;
+
+// The serialization format for Variant objects. Objects with references to
+// other Tensors can simply store those tensors in the `tensors` field, and
+// serialize other metadata content in to the `metadata` field. Objects can
+// optionally set the `type_name` for type-checking before deserializing an
+// object.
+//
+// This is the native C++ class equivalent of VariantTensorDataProto. They are
+// separate so that kernels do not need to depend on protos.
+class VariantTensorData {
+ public:
+  VariantTensorData() = default;
+
+  // TODO(b/118823936): This silently returns if the proto is invalid.
+  // Consider calling FromProto explicitly instead.
+  VariantTensorData(VariantTensorDataProto proto);
+
+  // Name of the type of objects being serialized.
+  const std::string& type_name() const { return type_name_; }
+  void set_type_name(const std::string& type_name) { type_name_ = type_name; }
+
+  template <typename T, bool = std::is_pod<typename std::decay<T>::type>::value>
+  struct PODResolver {};
+
+  // Portions of the object that are not Tensors.
+  // Directly supported types include string POD types.
+  template <typename T>
+  void set_metadata(const T& value) {
+    SetMetadata(value, PODResolver<T>());
+  }
+
+  template <typename T>
+  bool get_metadata(T* value) const {
+    return GetMetadata(value, PODResolver<T>());
+  }
+
+  std::string& metadata_string() { return metadata_; }
+
+  const std::string& metadata_string() const { return metadata_; }
+
+  // Tensors contained within objects being serialized.
+  int tensors_size() const;
+  const Tensor& tensors(int index) const;
+  const std::vector<Tensor>& tensors() const;
+  Tensor* add_tensors();
+
+  // A more general version of add_tensors. Parameters are perfectly forwarded
+  // to the constructor of the tensor added here.
+  template <typename... TensorConstructorArgs>
+  Tensor* add_tensor(TensorConstructorArgs&&... args);
+
+  // Conversion to and from VariantTensorDataProto
+  void ToProto(VariantTensorDataProto* proto) const;
+  // This allows optimizations via std::move.
+  bool FromProto(VariantTensorDataProto proto);
+  bool FromConstProto(const VariantTensorDataProto& proto);
+
+  // Serialization via VariantTensorDataProto
+  std::string SerializeAsString() const;
+  bool SerializeToString(std::string* buf);
+  bool ParseFromString(std::string s);
+
+  std::string DebugString() const;
+
+ public:
+  std::string type_name_;
+  std::string metadata_;
+  std::vector<Tensor> tensors_;
+
+ private:
+  void SetMetadata(const std::string& value,
+                   PODResolver<std::string, false /* is_pod */>) {
+    metadata_ = value;
+  }
+
+  bool GetMetadata(std::string* value,
+                   PODResolver<std::string, false /* is_pod */>) const {
+    *value = metadata_;
+    return true;
+  }
+
+  // Specialize for bool, it is undefined behvaior to assign a non 0/1 value to
+  // a bool. Now we coerce a non-zero value to true.
+  bool GetMetadata(bool* value, PODResolver<bool, true /* is_pod */>) const {
+    if (metadata_.size() != sizeof(bool)) return false;
+    *value = false;
+    for (size_t i = 0; i < sizeof(bool); ++i)
+      *value = *value || (metadata_.data()[i] != 0);
+    return true;
+  }
+
+  template <typename T>
+  void SetMetadata(const T& value, PODResolver<T, true /* is_pod */>) {
+    metadata_.assign(reinterpret_cast<const char*>(&value), sizeof(T));
+  }
+
+  template <typename T>
+  bool GetMetadata(T* value, PODResolver<T, true /* is_pod */>) const {
+    if (metadata_.size() != sizeof(T)) return false;
+    std::copy_n(metadata_.data(), sizeof(T), reinterpret_cast<char*>(value));
+    return true;
+  }
+};
+
+// For backwards compatibility for when this was a proto
+std::string ProtoDebugString(const VariantTensorData& object);
+
+template <typename... TensorConstructorArgs>
+Tensor* VariantTensorData::add_tensor(TensorConstructorArgs&&... args) {
+  tensors_.emplace_back(std::forward<TensorConstructorArgs>(args)...);
+  return &tensors_.back();
+}
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_VARIANT_TENSOR_DATA_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/versions.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/versions.h
new file mode 100644
index 0000000000000000000000000000000000000000..2e043fedeffeed68adfaf84f2a1ac8d3dd048548
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/versions.h
@@ -0,0 +1,39 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_FRAMEWORK_VERSIONS_H_
+#define TENSORFLOW_CORE_FRAMEWORK_VERSIONS_H_
+
+#include "tensorflow/core/lib/core/status.h"
+
+namespace tensorflow {
+
+class VersionDef;
+
+// Check whether data with the given versions is compatible with the given
+// consumer and min producer.  upper_name and lower_name are used to form
+// error messages upon failure.  Example usage:
+//
+//   #include "tensorflow/core/public/version.h"
+//
+//   TF_RETURN_IF_ERROR(CheckVersions(versions, TF_GRAPH_DEF_VERSION,
+//                                    TF_GRAPH_DEF_VERSION_MIN_PRODUCER,
+//                                    "GraphDef", "graph"));
+Status CheckVersions(const VersionDef& versions, int consumer, int min_producer,
+                     const char* upper_name, const char* lower_name);
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_FRAMEWORK_VERSIONS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/versions.pb.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/versions.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..1868f88e4850edf60501c55bdd8fd37b48f6a026
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/versions.pb.h
@@ -0,0 +1,350 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: tensorflow/core/framework/versions.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fversions_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fversions_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3021000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3021009 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_tensorflow_2fcore_2fframework_2fversions_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_tensorflow_2fcore_2fframework_2fversions_2eproto {
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_tensorflow_2fcore_2fframework_2fversions_2eproto;
+namespace tensorflow {
+class VersionDef;
+struct VersionDefDefaultTypeInternal;
+extern VersionDefDefaultTypeInternal _VersionDef_default_instance_;
+}  // namespace tensorflow
+PROTOBUF_NAMESPACE_OPEN
+template<> ::tensorflow::VersionDef* Arena::CreateMaybeMessage<::tensorflow::VersionDef>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace tensorflow {
+
+// ===================================================================
+
+class VersionDef final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.VersionDef) */ {
+ public:
+  inline VersionDef() : VersionDef(nullptr) {}
+  ~VersionDef() override;
+  explicit PROTOBUF_CONSTEXPR VersionDef(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  VersionDef(const VersionDef& from);
+  VersionDef(VersionDef&& from) noexcept
+    : VersionDef() {
+    *this = ::std::move(from);
+  }
+
+  inline VersionDef& operator=(const VersionDef& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline VersionDef& operator=(VersionDef&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const VersionDef& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const VersionDef* internal_default_instance() {
+    return reinterpret_cast<const VersionDef*>(
+               &_VersionDef_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(VersionDef& a, VersionDef& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(VersionDef* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(VersionDef* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  VersionDef* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<VersionDef>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const VersionDef& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const VersionDef& from) {
+    VersionDef::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(VersionDef* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.VersionDef";
+  }
+  protected:
+  explicit VersionDef(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kBadConsumersFieldNumber = 3,
+    kProducerFieldNumber = 1,
+    kMinConsumerFieldNumber = 2,
+  };
+  // repeated int32 bad_consumers = 3;
+  int bad_consumers_size() const;
+  private:
+  int _internal_bad_consumers_size() const;
+  public:
+  void clear_bad_consumers();
+  private:
+  int32_t _internal_bad_consumers(int index) const;
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+      _internal_bad_consumers() const;
+  void _internal_add_bad_consumers(int32_t value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+      _internal_mutable_bad_consumers();
+  public:
+  int32_t bad_consumers(int index) const;
+  void set_bad_consumers(int index, int32_t value);
+  void add_bad_consumers(int32_t value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+      bad_consumers() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+      mutable_bad_consumers();
+
+  // int32 producer = 1;
+  void clear_producer();
+  int32_t producer() const;
+  void set_producer(int32_t value);
+  private:
+  int32_t _internal_producer() const;
+  void _internal_set_producer(int32_t value);
+  public:
+
+  // int32 min_consumer = 2;
+  void clear_min_consumer();
+  int32_t min_consumer() const;
+  void set_min_consumer(int32_t value);
+  private:
+  int32_t _internal_min_consumer() const;
+  void _internal_set_min_consumer(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.VersionDef)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > bad_consumers_;
+    mutable std::atomic<int> _bad_consumers_cached_byte_size_;
+    int32_t producer_;
+    int32_t min_consumer_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fversions_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// VersionDef
+
+// int32 producer = 1;
+inline void VersionDef::clear_producer() {
+  _impl_.producer_ = 0;
+}
+inline int32_t VersionDef::_internal_producer() const {
+  return _impl_.producer_;
+}
+inline int32_t VersionDef::producer() const {
+  // @@protoc_insertion_point(field_get:tensorflow.VersionDef.producer)
+  return _internal_producer();
+}
+inline void VersionDef::_internal_set_producer(int32_t value) {
+  
+  _impl_.producer_ = value;
+}
+inline void VersionDef::set_producer(int32_t value) {
+  _internal_set_producer(value);
+  // @@protoc_insertion_point(field_set:tensorflow.VersionDef.producer)
+}
+
+// int32 min_consumer = 2;
+inline void VersionDef::clear_min_consumer() {
+  _impl_.min_consumer_ = 0;
+}
+inline int32_t VersionDef::_internal_min_consumer() const {
+  return _impl_.min_consumer_;
+}
+inline int32_t VersionDef::min_consumer() const {
+  // @@protoc_insertion_point(field_get:tensorflow.VersionDef.min_consumer)
+  return _internal_min_consumer();
+}
+inline void VersionDef::_internal_set_min_consumer(int32_t value) {
+  
+  _impl_.min_consumer_ = value;
+}
+inline void VersionDef::set_min_consumer(int32_t value) {
+  _internal_set_min_consumer(value);
+  // @@protoc_insertion_point(field_set:tensorflow.VersionDef.min_consumer)
+}
+
+// repeated int32 bad_consumers = 3;
+inline int VersionDef::_internal_bad_consumers_size() const {
+  return _impl_.bad_consumers_.size();
+}
+inline int VersionDef::bad_consumers_size() const {
+  return _internal_bad_consumers_size();
+}
+inline void VersionDef::clear_bad_consumers() {
+  _impl_.bad_consumers_.Clear();
+}
+inline int32_t VersionDef::_internal_bad_consumers(int index) const {
+  return _impl_.bad_consumers_.Get(index);
+}
+inline int32_t VersionDef::bad_consumers(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.VersionDef.bad_consumers)
+  return _internal_bad_consumers(index);
+}
+inline void VersionDef::set_bad_consumers(int index, int32_t value) {
+  _impl_.bad_consumers_.Set(index, value);
+  // @@protoc_insertion_point(field_set:tensorflow.VersionDef.bad_consumers)
+}
+inline void VersionDef::_internal_add_bad_consumers(int32_t value) {
+  _impl_.bad_consumers_.Add(value);
+}
+inline void VersionDef::add_bad_consumers(int32_t value) {
+  _internal_add_bad_consumers(value);
+  // @@protoc_insertion_point(field_add:tensorflow.VersionDef.bad_consumers)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+VersionDef::_internal_bad_consumers() const {
+  return _impl_.bad_consumers_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+VersionDef::bad_consumers() const {
+  // @@protoc_insertion_point(field_list:tensorflow.VersionDef.bad_consumers)
+  return _internal_bad_consumers();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+VersionDef::_internal_mutable_bad_consumers() {
+  return &_impl_.bad_consumers_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+VersionDef::mutable_bad_consumers() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.VersionDef.bad_consumers)
+  return _internal_mutable_bad_consumers();
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace tensorflow
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fversions_2eproto
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/versions.proto b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/versions.proto
new file mode 100644
index 0000000000000000000000000000000000000000..2cca6e37d325dcc500dea17910853415856ebaac
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/framework/versions.proto
@@ -0,0 +1,33 @@
+syntax = "proto3";
+
+package tensorflow;
+
+option cc_enable_arenas = true;
+option java_outer_classname = "VersionsProtos";
+option java_multiple_files = true;
+option java_package = "org.tensorflow.framework";
+option go_package = "github.com/tensorflow/tensorflow/tensorflow/go/core/framework/versions_go_proto";
+
+// Version information for a piece of serialized data
+//
+// There are different types of versions for each type of data
+// (GraphDef, etc.), but they all have the same common shape
+// described here.
+//
+// Each consumer has "consumer" and "min_producer" versions (specified
+// elsewhere).  A consumer is allowed to consume this data if
+//
+//   producer >= min_producer
+//   consumer >= min_consumer
+//   consumer not in bad_consumers
+//
+message VersionDef {
+  // The version of the code that produced this data.
+  int32 producer = 1;
+
+  // Any consumer below this version is not allowed to consume this data.
+  int32 min_consumer = 2;
+
+  // Specific consumer versions which are disallowed (e.g. due to bugs).
+  repeated int32 bad_consumers = 3;
+}
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/algorithm.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/algorithm.h
new file mode 100644
index 0000000000000000000000000000000000000000..c9f328a0cdcc2ba111fb76b625040e3af4bc971a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/algorithm.h
@@ -0,0 +1,154 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPH_ALGORITHM_H_
+#define TENSORFLOW_CORE_GRAPH_ALGORITHM_H_
+
+#include <functional>
+#include <unordered_set>
+#include <vector>
+
+#include "tensorflow/core/graph/graph.h"
+#include "tensorflow/core/lib/gtl/array_slice.h"
+
+namespace tensorflow {
+
+// Comparator for two nodes. This is used in order to get a stable ording.
+using NodeComparator = std::function<bool(const Node*, const Node*)>;
+
+using EdgeFilter = std::function<bool(const Edge&)>;
+
+// Compares two node based on their ids.
+struct NodeComparatorID {
+  bool operator()(const Node* n1, const Node* n2) const {
+    return n1->id() < n2->id();
+  }
+};
+
+// Compare two nodes based on their names.
+struct NodeComparatorName {
+  bool operator()(const Node* n1, const Node* n2) const {
+    return n1->name() < n2->name();
+  }
+};
+
+// Perform a depth-first-search on g starting at the source node.
+// If enter is not empty, calls enter(n) before visiting any children of n.
+// If leave is not empty, calls leave(n) after visiting all children of n.
+// If stable_comparator is set, a stable ordering of visit is achieved by
+// sorting a node's neighbors first before visiting them.
+// If edge_filter is set then ignores edges for which edge_filter returns false.
+void DFS(const Graph& g, const std::function<void(Node*)>& enter,
+         const std::function<void(Node*)>& leave,
+         const NodeComparator& stable_comparator = {},
+         const EdgeFilter& edge_filter = {});
+
+// Perform a depth-first-search on g starting at the 'start' nodes.
+// If enter is not empty, calls enter(n) before visiting any children of n.
+// If leave is not empty, calls leave(n) after visiting all children of n.
+// If stable_comparator is set, a stable ordering of visit is achieved by
+// sorting a node's neighbors first before visiting them.
+// If edge_filter is set then ignores edges for which edge_filter returns false.
+void DFSFrom(const Graph& g, gtl::ArraySlice<Node*> start,
+             const std::function<void(Node*)>& enter,
+             const std::function<void(Node*)>& leave,
+             const NodeComparator& stable_comparator = {},
+             const EdgeFilter& edge_filter = {});
+void DFSFrom(const Graph& g, gtl::ArraySlice<const Node*> start,
+             const std::function<void(const Node*)>& enter,
+             const std::function<void(const Node*)>& leave,
+             const NodeComparator& stable_comparator = {},
+             const EdgeFilter& edge_filter = {});
+
+// Perform a reverse depth-first-search on g starting at the sink node.
+// If enter is not empty, calls enter(n) before visiting any parents of n.
+// If leave is not empty, calls leave(n) after visiting all parents of n.
+// If stable_comparator is set, a stable ordering of visit is achieved by
+// sorting a node's neighbors first before visiting them.
+// If edge_filter is set then ignores edges for which edge_filter returns false.
+void ReverseDFS(const Graph& g, const std::function<void(Node*)>& enter,
+                const std::function<void(Node*)>& leave,
+                const NodeComparator& stable_comparator = {},
+                const EdgeFilter& edge_filter = {});
+
+// Perform a reverse depth-first-search on g starting at the 'start' nodes.
+// If enter is not empty, calls enter(n) before visiting any parents of n.
+// If leave is not empty, calls leave(n) after visiting all parents of n.
+// If stable_comparator is set, a stable ordering of visit is achieved by
+// sorting a node's neighbors first before visiting them.
+// If edge_filter is set then ignores edges for which edge_filter returns false.
+void ReverseDFSFrom(const Graph& g, gtl::ArraySlice<Node*> start,
+                    const std::function<void(Node*)>& enter,
+                    const std::function<void(Node*)>& leave,
+                    const NodeComparator& stable_comparator = {},
+                    const EdgeFilter& edge_filter = {});
+void ReverseDFSFrom(const Graph& g, gtl::ArraySlice<const Node*> start,
+                    const std::function<void(const Node*)>& enter,
+                    const std::function<void(const Node*)>& leave,
+                    const NodeComparator& stable_comparator = {},
+                    const EdgeFilter& edge_filter = {});
+
+void BreadthFirstTraversal(
+    const Graph& g, gtl::ArraySlice<const Node*> start,
+    const std::function<void(const Node*)>& visit,
+    NodeComparator stable_comparator = NodeComparatorID());
+
+void BreadthFirstTraversal(
+    Graph& g, gtl::ArraySlice<Node*> start,
+    const std::function<void(Node*)>& visit,
+    NodeComparator stable_comparator = NodeComparatorID());
+
+// Stores in *order the post-order numbering of all nodes
+// in graph found via a depth first search starting at the source node.
+//
+// Note that this is equivalent to reverse topological sorting when the
+// graph does not have cycles.
+//
+// If stable_comparator is set, a stable ordering of visit is achieved by
+// sorting a node's neighbors first before visiting them.
+//
+// If edge_filter is set then ignores edges for which edge_filter returns
+// false.
+//
+// REQUIRES: order is not NULL.
+void GetPostOrder(const Graph& g, std::vector<Node*>* order,
+                  const NodeComparator& stable_comparator = {},
+                  const EdgeFilter& edge_filter = {});
+
+// Stores in *order the reverse post-order numbering of all nodes
+// If stable_comparator is set, a stable ordering of visit is achieved by
+// sorting a node's neighbors first before visiting them.
+//
+// If edge_filter is set then ignores edges for which edge_filter returns
+// false.
+void GetReversePostOrder(const Graph& g, std::vector<Node*>* order,
+                         const NodeComparator& stable_comparator = {},
+                         const EdgeFilter& edge_filter = {});
+
+// Prune nodes in "g" that are not in some path from the source node
+// to any node in 'nodes'. Returns true if changes were made to the graph.
+// Does not fix up source and sink edges.
+bool PruneForReverseReachability(Graph* g,
+                                 std::unordered_set<const Node*> nodes);
+
+// Connect all nodes with no incoming edges to source.
+// Connect all nodes with no outgoing edges to sink.
+//
+// Returns true if and only if 'g' is mutated.
+bool FixupSourceAndSinkEdges(Graph* g);
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPH_ALGORITHM_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/collective_order.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/collective_order.h
new file mode 100644
index 0000000000000000000000000000000000000000..67a1427a96635f08d0fbe9f77f92d4d213a93dd8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/collective_order.h
@@ -0,0 +1,36 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_GRAPH_COLLECTIVE_ORDER_H_
+#define TENSORFLOW_CORE_GRAPH_COLLECTIVE_ORDER_H_
+
+#include "tensorflow/core/graph/graph.h"
+
+namespace tensorflow {
+
+enum class GraphCollectiveOrder { kNone, kEdges, kAttrs };
+
+// Introduces a deterministic execution order between potentially concurrent
+// CollectiveOps.  This may be used to execute collectives in the same order
+// across all workers in a distributed execution, if all workers are executing
+// the same graph.
+// If `order_type` is `kEdges`, introduce the ordering in the form of explicit
+// control edges between collective graph nodes.  If `order_type` is `kAttrs`,
+// add an attribute to the node which may be used by collective executor to
+// ensure the required ordering.
+Status OrderCollectives(Graph* graph, GraphCollectiveOrder order_type);
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPH_COLLECTIVE_ORDER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/colors.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/colors.h
new file mode 100644
index 0000000000000000000000000000000000000000..43d2225571f7dd86f9c3d48d2b37bee80c5d6205
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/colors.h
@@ -0,0 +1,29 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPH_COLORS_H_
+#define TENSORFLOW_CORE_GRAPH_COLORS_H_
+
+namespace tensorflow {
+
+// Return a color drawn from a palette to represent an entity
+// identified by "i".  The return value has the form "#RRGGBB" Note
+// that the palette has a limited set of colors and therefore colors
+// will be reused eventually.
+const char* ColorFor(int dindex);
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPH_COLORS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/control_flow.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/control_flow.h
new file mode 100644
index 0000000000000000000000000000000000000000..cbef1c24cb768f643ff2764b40dbe79ba6edd712
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/control_flow.h
@@ -0,0 +1,60 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPH_CONTROL_FLOW_H_
+#define TENSORFLOW_CORE_GRAPH_CONTROL_FLOW_H_
+
+#include <vector>
+
+#include "tensorflow/core/graph/graph.h"
+#include "tensorflow/core/lib/core/status.h"
+
+namespace tensorflow {
+
+// Control flow info for a graph node.
+struct ControlFlowInfo {
+  // 'frame' and 'parent_frame' are pointers to:
+  //
+  // a) One of the Enter nodes corresponding to the loop body, if the node
+  //    executes inside a loop. If multiple tensors enter the while loop, it's
+  //    undefined which Enter node will be used.
+  //
+  // b) SOURCE node (node.id() == Graph::kSourceId), if the node is not inside
+  //    any of the while loops.
+
+  const Node* frame = nullptr;         // frame of a node
+  const Node* parent_frame = nullptr;  // parent frame of a node
+  string frame_name;                   // frame name of a node
+};
+
+// Clear and populate `info` with each node's frame and the level it belongs to.
+// We check the well-formedness of the graph:
+// 1) All inputs to a node must come from the same frame and have the same
+//    "static" iteration level.
+// 2) Each frame has at most one LoopCond node.
+// 3) Each frame has a single parent frame.
+// If `unreachable_nodes` is set, return names of nodes unreachable from the
+// source node. We cannot build ControlFlowInfo for such nodes. They might be
+// pruned later.
+//
+// NOTE(yuanbyu): For now, we require all sends/recvs have iteration level 0.
+// This essentially means there can't be multiple serial Nexts in an iteration,
+// which all sane front-ends should satisfy.
+Status BuildControlFlowInfo(const Graph* g, std::vector<ControlFlowInfo>* info,
+                            std::vector<string>* unreachable_nodes = nullptr);
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPH_CONTROL_FLOW_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/costmodel.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/costmodel.h
new file mode 100644
index 0000000000000000000000000000000000000000..7778691701114def7459a03c8419acb1512d83d7
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/costmodel.h
@@ -0,0 +1,241 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPH_COSTMODEL_H_
+#define TENSORFLOW_CORE_GRAPH_COSTMODEL_H_
+
+#include <set>
+#include <unordered_map>
+#include <vector>
+
+#include "tensorflow/core/framework/cost_graph.pb.h"
+#include "tensorflow/core/framework/step_stats.pb.h"
+#include "tensorflow/core/framework/tensor_shape.pb.h"
+#include "tensorflow/core/graph/graph.h"
+#include "tensorflow/core/graph/types.h"
+#include "tensorflow/core/lib/core/stringpiece.h"
+#include "tensorflow/core/lib/gtl/array_slice.h"
+#include "tensorflow/core/platform/macros.h"
+#include "tensorflow/core/platform/protobuf.h"
+
+namespace tensorflow {
+typedef std::unordered_map<StringPiece, int32, StringPieceHasher>
+    NodeNameToCostIdMap;
+
+class StepStats;
+
+// CostModel keeps track of the following runtime statistics for nodes
+// of a single Graph:
+//    * The total number of times a node has executed.
+//    * The accumulated execution time (in microseconds) of a node.
+//    * The accumulated size (in bytes) of each node's output.
+//
+// This class is NOT thread-safe.
+class CostModel {
+ public:
+  // If "global" is true, maintains costs based on Node::cost_id, otherwise
+  // maintains costs based on Node::id.
+  explicit CostModel(bool is_global) : is_global_(is_global) {
+    unknown_shape_.set_unknown_rank(true);
+  }
+
+  // Assigns min_count_ as a function of the median count for a Node.
+  // This value is then used for suppressing the time/size costs of
+  // infrequent operations.
+  // NOTE(tucker): Maybe this should move to a subclass of CostModel.
+  void SuppressInfrequent();
+
+  bool is_global() const { return is_global_; }
+
+  inline int Id(const Node* n) const {
+    if (is_global_) {
+      return n->cost_id();
+    } else {
+      return n->id();
+    }
+  }
+
+  inline int GlobalId(const Node* n, int offset) const {
+    if (is_global_) {
+      return n->cost_id();
+    } else {
+      return n->id() + offset;
+    }
+  }
+
+  // Initializes cost model for 'g'.
+  void InitFromGraph(const Graph& g);
+
+  // Merges costs from cm.
+  // REQUIRES: is_global_ is true for this and for "cm"
+  void MergeFromGlobal(const CostModel& cm);
+
+  // Merges costs from "cm", which has been computed relative to "g".
+  // REQUIRES: is_global_ is true for this, and false for "cm".
+  void MergeFromLocal(const Graph& g, const CostModel& cm);
+
+  void MergeFromStats(const NodeNameToCostIdMap& map, const StepStats& ss);
+
+  // Sets the number of outputs of "node".
+  void SetNumOutputs(const Node* node, int num_outputs);
+
+  // Records that "node" has executed "num_count" more times.
+  void RecordCount(const Node* node, int num_count);
+
+  // Returns how many times "node" has been executed.
+  int32 TotalCount(const Node* node) const;
+
+  // Records that "output_slot" of "node" has produced tensors of
+  // aggregated "bytes".
+  void RecordSize(const Node* node, int output_slot, Bytes bytes);
+
+  // Returns total bytes of tensors produced by "node"s output slot.
+  Bytes TotalBytes(const Node* node, int output_slot) const;
+
+  // Returns a prediction for the size of the tensor at the
+  // output_slot produced by one execution of "node".
+  Bytes SizeEstimate(const Node* node, int output_slot) const;
+
+  // Records that Executions of "node" have taken "time" microseconds.
+  void RecordTime(const Node* node, Microseconds time);
+
+  // Returns the total execution time for "node".
+  Microseconds TotalTime(const Node* node) const;
+
+  // Returns a prediction for one execution of "node".
+  Microseconds TimeEstimate(const Node* node) const;
+
+  // Check that an estimate is available for every OP node in graph.
+  void CheckInitialized(const Graph& graph) const;
+
+  // Records the maximum size in bytes and optionally the corresponding shape of
+  // the tensor generated by "output_slot" of "node". If
+  void RecordMaxMemorySize(const Node* node, int output_slot, Bytes bytes,
+                           const TensorShapeProto& tensor_shape,
+                           const DataType& dtype);
+
+  // Returns the maximum size in bytes of the tensor generated by "output_slot"
+  // of "node".
+  Bytes MaxMemorySize(const Node* node, int output_slot) const;
+
+  // Returns the shape corresponding to the largest memory size of the tensor
+  // generated by "output_slot" of "node".
+  const TensorShapeProto& MaxMemoryShape(const Node* node,
+                                         int output_slot) const;
+
+  // Returns the shape corresponding to the largest memory size of the tensor
+  // generated by "output_slot" of "node".
+  DataType MaxMemoryType(const Node* node, int output_slot) const;
+
+  // Returns the size in bytes of temporary memory consumed by "node".
+  Bytes TempMemorySize(const Node* node) const;
+
+  // Returns the size of persistent memory allocated by "node".
+  Bytes PersistentMemorySize(const Node* node) const;
+
+  // Records memory stats such as temp momory and persistent memory.
+  void RecordMemoryStats(const Node* node, const MemoryStats& memory_stats);
+
+  // Records the maximum execution time (in microseconds) of "node".
+  void RecordMaxExecutionTime(const Node* node, Microseconds time);
+
+  // Returns the maximum execution time (in microseconds) of "node".
+  Microseconds MaxExecutionTime(const Node* node) const;
+
+  // Record the unique id of the tensor generated by "output_slot" of "node".
+  // Any other tensor sharing the same id will be an alias, i.e. it will share
+  // the same underlying memory storage area.
+  void RecordAllocationId(const Node* node, int output_slot, int64_t alloc_id);
+
+  // Return the unique id of the tensor generated by "output_slot" of "node".
+  int64_t AllocationId(const Node* node, int output_slot) const;
+
+  bool IsPersistentTensor(const Node* node, int64_t alloc_id) const;
+
+  // Helper routines to encapsulate static estimation heuristics
+
+  // Compute an estimate of the time to copy "b" bytes over the network,
+  // given a fixed cost of "network_latency_millis" milliseconds and
+  // an estimated bandwidth of "estimated_gbps" gigabits per second (note that
+  // this value is in gigabits, not gigabytes).
+  static Microseconds CopyTimeEstimate(Bytes b, double network_latency_millis,
+                                       double estimated_gbps);
+  static Microseconds ComputationTimeEstimate(int64_t mathops);
+
+  // Add this CostModel into the CostGraphDef.
+  void AddToCostGraphDef(const Graph* graph, CostGraphDef* cost_graph) const;
+
+  // Write the contents of the CostModel to the INFO log.
+  void WriteSummaryToLog() const;
+
+  // Increment the times that the cost model is updated.
+  void IncrementUpdateTimes();
+
+  // Get the times that the cost model is updated.
+  int32 GetUpdateTimes() const;
+
+ private:
+  static Bytes MinTensorMemoryUsage(const TensorShapeProto& tensor_shape,
+                                    const DataType& dtype);
+
+  const bool is_global_;
+
+  // Resizes vectors so that they are large enough for "id" and id's outputs.
+  void Ensure(int id, int num_outputs);
+
+  // Nodes and Edges whose count is < this value
+  // get type/byte estimates of 0.
+  int32 min_count_ = 0;
+
+  // The number of times the cost model is updated.
+  int32 update_times_ = 0;
+
+  // Number of times each Node has been executed.
+  std::vector<int32> count_;
+  // Cumulative execution time.
+  std::vector<Microseconds> time_;
+  // Cumulative Bytes output on each channel.
+  std::vector<gtl::InlinedVector<Bytes, 2>> slot_bytes_;
+
+  // Maximum execution time
+  std::vector<Microseconds> max_exec_time_;
+
+  // Maximum memory usage
+  struct MemUsage {
+    MemUsage() : temp_memory_size(0), persistent_memory_size(0) {}
+
+    // TODO(yuefengz): temp_memory_size is not being used, remove it.
+    Bytes temp_memory_size;
+    Bytes persistent_memory_size;
+
+    gtl::InlinedVector<Bytes, 2> output_port_mem;
+    gtl::InlinedVector<TensorShapeProto, 2> output_port_shape;
+    gtl::InlinedVector<DataType, 2> output_port_type;
+  };
+  std::vector<MemUsage> max_mem_usage_;
+
+  std::vector<gtl::InlinedVector<int64_t, 2>> output_port_alloc_ids_;
+
+  std::set<int64_t> persistent_alloc_ids_;
+
+  TensorShapeProto unknown_shape_;
+
+  CostModel(const CostModel&) = delete;
+  void operator=(const CostModel&) = delete;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPH_COSTMODEL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/default_device.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/default_device.h
new file mode 100644
index 0000000000000000000000000000000000000000..011b7c11cf2ecd38939734ee43fdec58ac285372
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/default_device.h
@@ -0,0 +1,41 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPH_DEFAULT_DEVICE_H_
+#define TENSORFLOW_CORE_GRAPH_DEFAULT_DEVICE_H_
+
+#include <string>
+
+#include "tensorflow/core/framework/graph.pb.h"
+#include "tensorflow/core/framework/node_def.pb.h"
+
+namespace tensorflow {
+namespace graph {
+
+// Sets the default device for all nodes in graph_def to "device",
+// only if not already set.
+inline void SetDefaultDevice(const std::string& device, GraphDef* graph_def) {
+  for (int i = 0; i < graph_def->node_size(); ++i) {
+    auto node = graph_def->mutable_node(i);
+    if (node->device().empty()) {
+      node->set_device(device);
+    }
+  }
+}
+
+}  // namespace graph
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPH_DEFAULT_DEVICE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/edgeset.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/edgeset.h
new file mode 100644
index 0000000000000000000000000000000000000000..6d6cb3ff6305913a8512f8a5a0637f73f113b646
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/edgeset.h
@@ -0,0 +1,246 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPH_EDGESET_H_
+#define TENSORFLOW_CORE_GRAPH_EDGESET_H_
+
+#include <stddef.h>
+
+#include "tensorflow/core/lib/gtl/flatset.h"
+#include "tensorflow/core/platform/logging.h"
+#include "tensorflow/core/platform/macros.h"
+#include "tensorflow/core/platform/types.h"
+namespace tensorflow {
+
+class Edge;
+
+// An unordered set of edges.  Uses very little memory for small sets.
+// Unlike gtl::FlatSet, EdgeSet does NOT allow mutations during
+// iteration.
+class EdgeSet {
+ public:
+  EdgeSet();
+  ~EdgeSet();
+
+  typedef const Edge* key_type;
+  typedef const Edge* value_type;
+  typedef size_t size_type;
+  typedef ptrdiff_t difference_type;
+
+  class const_iterator;
+  typedef const_iterator iterator;
+
+  bool empty() const;
+  size_type size() const;
+  void clear();
+  std::pair<iterator, bool> insert(value_type value);
+  size_type erase(key_type key);
+  void reserve(size_type new_size) {
+    if (new_size > kInline) {
+      auto s = new gtl::FlatSet<const Edge*>(new_size);
+      s->insert(reinterpret_cast<const Edge**>(std::begin(ptrs_)),
+                reinterpret_cast<const Edge**>(&ptrs_[0] + size()));
+      ptrs_[0] = this;
+      ptrs_[1] = s;
+    }
+  }
+
+  // Caller is not allowed to mutate the EdgeSet while iterating.
+  const_iterator begin() const;
+  const_iterator end() const;
+
+ private:
+  // Up to kInline elements are stored directly in ptrs_ (nullptr means none).
+  // If ptrs_[0] == this then ptrs_[1] points to a set<const Edge*>.
+  // kInline must be >= 2, and is chosen such that ptrs_ fills a 64 byte
+  // cacheline.
+  static constexpr int kInline = 64 / sizeof(const void*);
+  const void* ptrs_[kInline];
+
+  gtl::FlatSet<const Edge*>* get_set() const {
+    if (ptrs_[0] == this) {
+      return static_cast<gtl::FlatSet<const Edge*>*>(
+          const_cast<void*>(ptrs_[1]));
+    } else {
+      return nullptr;
+    }
+  }
+
+// To detect mutations while iterating.
+#ifdef NDEBUG
+  void RegisterMutation() {}
+#else
+  uint32 mutations_ = 0;
+  void RegisterMutation() { mutations_++; }
+#endif
+
+  EdgeSet(const EdgeSet&) = delete;
+  void operator=(const EdgeSet&) = delete;
+};
+
+class EdgeSet::const_iterator {
+ public:
+  typedef typename EdgeSet::value_type value_type;
+  typedef const typename EdgeSet::value_type& reference;
+  typedef const typename EdgeSet::value_type* pointer;
+  typedef typename EdgeSet::difference_type difference_type;
+  typedef std::forward_iterator_tag iterator_category;
+
+  const_iterator() {}
+
+  const_iterator& operator++();
+  const_iterator operator++(int /*unused*/);
+  const value_type* operator->() const;
+  value_type operator*() const;
+  bool operator==(const const_iterator& other) const;
+  bool operator!=(const const_iterator& other) const {
+    return !(*this == other);
+  }
+
+ private:
+  friend class EdgeSet;
+
+  void const* const* array_iter_ = nullptr;
+  typename gtl::FlatSet<const Edge*>::const_iterator tree_iter_;
+
+#ifdef NDEBUG
+  inline void Init(const EdgeSet* e) {}
+  inline void CheckNoMutations() const {}
+#else
+  inline void Init(const EdgeSet* e) {
+    owner_ = e;
+    init_mutations_ = e->mutations_;
+  }
+  inline void CheckNoMutations() const {
+    CHECK_EQ(init_mutations_, owner_->mutations_);
+  }
+  const EdgeSet* owner_ = nullptr;
+  uint32 init_mutations_ = 0;
+#endif
+};
+
+inline EdgeSet::EdgeSet() {
+  for (int i = 0; i < kInline; i++) {
+    ptrs_[i] = nullptr;
+  }
+}
+
+inline EdgeSet::~EdgeSet() { delete get_set(); }
+
+inline bool EdgeSet::empty() const { return size() == 0; }
+
+inline EdgeSet::size_type EdgeSet::size() const {
+  auto s = get_set();
+  if (s) {
+    return s->size();
+  } else {
+    size_t result = 0;
+    for (int i = 0; i < kInline; i++) {
+      if (ptrs_[i]) result++;
+    }
+    return result;
+  }
+}
+
+inline void EdgeSet::clear() {
+  RegisterMutation();
+  delete get_set();
+  for (int i = 0; i < kInline; i++) {
+    ptrs_[i] = nullptr;
+  }
+}
+
+inline EdgeSet::const_iterator EdgeSet::begin() const {
+  const_iterator ci;
+  ci.Init(this);
+  auto s = get_set();
+  if (s) {
+    ci.tree_iter_ = s->begin();
+  } else {
+    ci.array_iter_ = &ptrs_[0];
+  }
+  return ci;
+}
+
+inline EdgeSet::const_iterator EdgeSet::end() const {
+  const_iterator ci;
+  ci.Init(this);
+  auto s = get_set();
+  if (s) {
+    ci.tree_iter_ = s->end();
+  } else {
+    ci.array_iter_ = &ptrs_[size()];
+  }
+  return ci;
+}
+
+inline EdgeSet::const_iterator& EdgeSet::const_iterator::operator++() {
+  CheckNoMutations();
+  if (array_iter_ != nullptr) {
+    ++array_iter_;
+  } else {
+    ++tree_iter_;
+  }
+  return *this;
+}
+
+inline EdgeSet::const_iterator EdgeSet::const_iterator::operator++(
+    int /*unused*/) {
+  CheckNoMutations();
+  const_iterator tmp = *this;
+  operator++();
+  return tmp;
+}
+
+// gcc's set and multiset always use const_iterator since it will otherwise
+// allow modification of keys.
+inline const EdgeSet::const_iterator::value_type* EdgeSet::const_iterator::
+operator->() const {
+  CheckNoMutations();
+  if (array_iter_ != nullptr) {
+    return reinterpret_cast<const value_type*>(array_iter_);
+  } else {
+    return tree_iter_.operator->();
+  }
+}
+
+// gcc's set and multiset always use const_iterator since it will otherwise
+// allow modification of keys.
+inline EdgeSet::const_iterator::value_type EdgeSet::const_iterator::operator*()
+    const {
+  CheckNoMutations();
+  if (array_iter_ != nullptr) {
+    return static_cast<value_type>(*array_iter_);
+  } else {
+    return *tree_iter_;
+  }
+}
+
+inline bool EdgeSet::const_iterator::operator==(
+    const const_iterator& other) const {
+  DCHECK((array_iter_ == nullptr) == (other.array_iter_ == nullptr))
+      << "Iterators being compared must be from same set that has not "
+      << "been modified since the iterator was constructed";
+  CheckNoMutations();
+  if (array_iter_ != nullptr) {
+    return array_iter_ == other.array_iter_;
+  } else {
+    return other.array_iter_ == nullptr && tree_iter_ == other.tree_iter_;
+  }
+}
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPH_EDGESET_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/graph.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/graph.h
new file mode 100644
index 0000000000000000000000000000000000000000..85d0be75346447a411037291e884cc220f1f3959
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/graph.h
@@ -0,0 +1,1103 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// A Graph describes a set of computations that are to be
+// performed, as well as the dependencies between those
+// computations. The basic model is a DAG (directed acyclic graph) with
+// * internal nodes representing computational operations to be performed;
+// * edges represent dependencies, indicating the target may only be
+//   executed once the source has completed; and
+// * predefined "source" (start) and "sink" (finish) nodes -- the source
+//   should be the only node that doesn't depend on anything, and the sink
+//   should be the only node that nothing depends on.
+//
+// Note: Node ids are intended to be relatively dense in the
+// 0..max_id range, but there may be gaps since ids won't be reused.
+//
+// Note: Some dependencies between operations are due to one operation
+// consuming the output of another. In fact operations can produce
+// multiple outputs and consume multiple inputs, and some
+// optimizations will care about which specific outputs are connected
+// to which specific inputs.  We therefore represent data dependency
+// between output O of layer A and input I of layer B using
+// "input index" and "output index" labels per edge.
+
+#ifndef TENSORFLOW_CORE_GRAPH_GRAPH_H_
+#define TENSORFLOW_CORE_GRAPH_GRAPH_H_
+
+#include <functional>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "absl/types/optional.h"
+#include "tensorflow/core/framework/full_type.pb.h"
+#include "tensorflow/core/framework/function.h"
+#include "tensorflow/core/framework/node_def.pb.h"
+#include "tensorflow/core/framework/node_def_util.h"
+#include "tensorflow/core/framework/op.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/graph/edgeset.h"
+#include "tensorflow/core/lib/core/arena.h"
+#include "tensorflow/core/lib/core/refcount.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/lib/gtl/iterator_range.h"
+#include "tensorflow/core/platform/logging.h"
+#include "tensorflow/core/platform/macros.h"
+#include "tensorflow/core/platform/stringpiece.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+
+class Edge;
+class EdgeSetTest;
+class Graph;
+class GraphDebugInfo;
+class GraphDef;
+class GraphTest;
+class Node;
+struct OutputTensor;
+class VersionDef;
+class WhileContext;
+
+class NeighborIter;  // Declared below
+class NodeIter;      // Declared below
+
+// Indicates where the graph instance is originated from.
+enum class ConstructionContext {
+  kNotTracked,     // Not tracked.
+  kDirectSession,  // From `tensorflow::DirectSession`, TF1 session API.
+  kEagerRuntime,   // Registered from TF2 eager runtime.
+};
+
+class Node {
+ public:
+  std::string DebugString() const;
+  int id() const { return id_; }
+  int cost_id() const { return cost_id_; }
+  const std::string& name() const;
+  void set_name(std::string name);
+  const std::string& type_string() const;
+
+  // def() provides the NodeDef the user supplied, but the specifics
+  // of this Node may have changed due to placement, optimization, etc.
+  // In particular:
+  // * def().name() will match name();
+  // * def().op() will match type_string() and op_def().name();
+  // * def().input() is not reliable, use "in_edges()" below instead;
+  // * def().device() is the "user's requested device" and may not match
+  //   the actual assigned device, see assigned_device_name() below;
+  // * def().attr() is authoritative.
+  // TODO(irving): Replace with NodeInfo.
+  const NodeDef& def() const;
+  const OpDef& op_def() const;
+
+  NodeDef* mutable_def();
+
+  // input and output types
+  int32 num_inputs() const;
+  DataType input_type(int32_t i) const;
+  const DataTypeVector& input_types() const;
+
+  int32 num_outputs() const;
+  DataType output_type(int32_t o) const;
+  const DataTypeVector& output_types() const;
+
+  // The device requested by the user.  For the actual assigned device,
+  // use assigned_device_name() below.
+  const std::string& requested_device() const;
+
+  // This changes the user requested device but not necessarily the device that
+  // on which the operation will run.
+  void set_requested_device(const std::string& device);
+
+  // This gives the device the runtime has assigned this node to.  If
+  // you want the device the user requested, use def().device() instead.
+  // TODO(josh11b): Validate that the assigned_device, if not empty:
+  // fully specifies a device, and satisfies def().device().
+  // TODO(josh11b): Move assigned_device_name outside of Node into a
+  // NodeId->DeviceName map.
+  const std::string& assigned_device_name() const;
+  void set_assigned_device_name(const std::string& device_name);
+  bool has_assigned_device_name() const {
+    return assigned_device_name_index_ > 0;
+  }
+  int assigned_device_name_index() const { return assigned_device_name_index_; }
+  void set_assigned_device_name_index(int index);
+
+  // Sets 'original_node_names' field of this node's DebugInfo proto to
+  // 'names'.
+  void set_original_node_names(const std::vector<string>& names);
+  void set_original_func_names(const std::vector<string>& names);
+
+  // Read only access to attributes
+  AttrSlice attrs() const;
+
+  // Inputs requested by the NodeDef.  For the actual inputs, use in_edges.
+  const protobuf::RepeatedPtrField<string>& requested_inputs() const;
+
+  // Get the neighboring nodes via edges either in or out of this node.  This
+  // includes control edges.
+  gtl::iterator_range<NeighborIter> in_nodes() const;
+  gtl::iterator_range<NeighborIter> out_nodes() const;
+  const EdgeSet& in_edges() const { return in_edges_; }
+  const EdgeSet& out_edges() const { return out_edges_; }
+
+  // Node type helpers.
+  bool IsSource() const { return id() == 0; }
+  bool IsSink() const { return id() == 1; }
+  // Anything other than the special Source & Sink nodes.
+  bool IsOp() const { return id() > 1; }
+
+  // Node class helpers
+  bool IsSwitch() const { return class_ == NC_SWITCH; }
+  bool IsMerge() const { return class_ == NC_MERGE; }
+  bool IsEnter() const { return class_ == NC_ENTER; }
+  bool IsExit() const { return class_ == NC_EXIT; }
+  bool IsNextIteration() const { return class_ == NC_NEXT_ITERATION; }
+  bool IsLoopCond() const { return class_ == NC_LOOP_COND; }
+  bool IsControlTrigger() const { return class_ == NC_CONTROL_TRIGGER; }
+  bool IsSend() const { return class_ == NC_SEND || class_ == NC_HOST_SEND; }
+  bool IsRecv() const { return class_ == NC_RECV || class_ == NC_HOST_RECV; }
+  bool IsConstant() const { return class_ == NC_CONSTANT; }
+  bool IsVariable() const { return class_ == NC_VARIABLE; }
+  bool IsIdentity() const { return class_ == NC_IDENTITY; }
+  bool IsGetSessionHandle() const { return class_ == NC_GET_SESSION_HANDLE; }
+  bool IsGetSessionTensor() const { return class_ == NC_GET_SESSION_TENSOR; }
+  bool IsDeleteSessionTensor() const {
+    return class_ == NC_DELETE_SESSION_TENSOR;
+  }
+  bool IsControlFlow() const {
+    return (class_ != NC_OTHER) &&  // Fast path
+           (IsSwitch() || IsMerge() || IsEnter() || IsExit() ||
+            IsNextIteration());
+  }
+  bool IsHostSend() const { return class_ == NC_HOST_SEND; }
+  bool IsHostRecv() const { return class_ == NC_HOST_RECV; }
+  bool IsScopedAllocator() const { return class_ == NC_SCOPED_ALLOCATOR; }
+  bool IsCollective() const { return class_ == NC_COLLECTIVE; }
+
+  bool IsMetadata() const { return class_ == NC_METADATA; }
+  bool IsFakeParam() const { return class_ == NC_FAKE_PARAM; }
+  bool IsPartitionedCall() const { return class_ == NC_PARTITIONED_CALL; }
+
+  // Returns true if this node is any kind of function call node.
+  //
+  // NOTE: "function call nodes" include partitioned call ops, symbolic gradient
+  // ops, and ops whose type_string is the name of a function ("function ops").
+  bool IsFunctionCall() const {
+    return class_ == NC_PARTITIONED_CALL || class_ == NC_FUNCTION_OP ||
+           class_ == NC_SYMBOLIC_GRADIENT;
+  }
+
+  bool IsIfNode() const { return class_ == NC_IF; }
+  bool IsWhileNode() const { return class_ == NC_WHILE; }
+  bool IsCaseNode() const { return class_ == NC_CASE; }
+  // Is this node a function input
+  bool IsArg() const { return class_ == NC_ARG; }
+  // Is this node a function output
+  bool IsRetval() const { return class_ == NC_RETVAL; }
+
+  bool IsDistributedCommunication() const {
+    return op_def().is_distributed_communication();
+  }
+
+  template <typename T>
+  void AddAttr(const std::string& name, const T& val) {
+    SetAttrValue(val, AddAttrHelper(name));
+    UpdateProperties();
+  }
+
+  void AddAttr(const std::string& name, std::vector<string>&& val) {
+    MoveAttrValue(std::move(val), AddAttrHelper(name));
+    UpdateProperties();
+  }
+
+  void ClearAttr(const std::string& name);
+
+  // Returns into '*e' the edge connecting to the 'idx' input of this Node.
+  Status input_edge(int idx, const Edge** e) const;
+
+  // Returns into '*edges' the input data edges of this Node, indexed by input
+  // number. Does not return control edges.
+  Status input_edges(std::vector<const Edge*>* edges) const;
+
+  // Returns into '*n' the node that has an output connected to the
+  // 'idx' input of this Node.
+  Status input_node(int idx, const Node** n) const;
+  Status input_node(int idx, Node** n) const;
+
+  // Returns into '*t' the idx-th input tensor of this node, represented as the
+  // output tensor of input_node(idx).
+  Status input_tensor(int idx, OutputTensor* t) const;
+
+  WhileContext* while_ctx() const { return while_ctx_; }
+  void set_while_ctx(WhileContext* while_ctx) {
+    DCHECK(IsExit());
+    DCHECK(while_ctx_ == nullptr);
+    while_ctx_ = while_ctx;
+  }
+
+  std::shared_ptr<NodeProperties> properties() const { return props_; }
+
+  // Sets the stack trace for the node. Assumes that getting and setting the
+  // stack trace for a given node will not race.
+  void SetStackTrace(const std::shared_ptr<AbstractStackTrace>& stack_trace) {
+    stack_trace_ = stack_trace;
+  }
+
+  // Get the stack trace for when the node was instantiated.
+  const std::shared_ptr<AbstractStackTrace>& GetStackTrace() const {
+    return stack_trace_;
+  }
+
+  // Called after an attr has changed. Decides whether we need to update some
+  // property of the node (stored in props_).
+  void UpdateProperties();
+
+  // Erases type information from the node.
+  void ClearTypeInfo();
+
+  // Update type information for a node with a list of inputs and/or outputs
+  // described by its TYPE_ATTR_NAME attr when removing some of these. The keys
+  // of INDEX_MAPPING are the indexes of the inputs/outputs that are not
+  // removed. dtype information in the TYPE_ATTR_NAME attr is always updated.
+  // Use UPDATE_FULL_TYPE=true when this changes the node's outputs to also
+  // update the node's full type information (if present).
+  Status ShrinkTypeInfo(const absl::flat_hash_map<int, int>& index_mapping,
+                        const string& type_attr_name, bool update_full_type);
+
+  // Called after an incident non-control edge has changed. Does nothing if not
+  // all input edges are defined.
+  void RunForwardTypeInference();
+
+ private:
+  // TODO(mdan): Drop this.
+  friend class Graph;
+  Node();
+
+  // Stack trace for the user code for node instantiation. Can be shared across
+  // multiple nodes (e.g. when inlining).
+  std::shared_ptr<AbstractStackTrace> stack_trace_;
+
+  // Releases memory from props_, in addition to restoring *this to its
+  // uninitialized state.
+  void Clear();
+
+  // Make a copy of the Node's props_ if props_ is shared with
+  // other nodes. This must be called before mutating properties,
+  // e.g. in AddAttr.
+  void MaybeCopyOnWrite();
+
+  AttrValue* AddAttrHelper(const std::string& name);
+
+  // A set of mutually exclusive classes for different kinds of nodes,
+  // class_ is initialized in the Node::Initialize routine based on the
+  // node's type_string().
+  enum NodeClass {
+    NC_UNINITIALIZED,
+    NC_SWITCH,
+    NC_MERGE,
+    NC_ENTER,
+    NC_EXIT,
+    NC_NEXT_ITERATION,
+    NC_LOOP_COND,
+    NC_CONTROL_TRIGGER,
+    NC_SEND,
+    NC_HOST_SEND,
+    NC_RECV,
+    NC_HOST_RECV,
+    NC_CONSTANT,
+    NC_VARIABLE,
+    NC_IDENTITY,
+    NC_GET_SESSION_HANDLE,
+    NC_GET_SESSION_TENSOR,
+    NC_DELETE_SESSION_TENSOR,
+    NC_METADATA,
+    NC_SCOPED_ALLOCATOR,
+    NC_COLLECTIVE,
+    NC_FAKE_PARAM,
+    NC_PARTITIONED_CALL,
+    NC_FUNCTION_OP,
+    NC_SYMBOLIC_GRADIENT,
+    NC_IF,
+    NC_WHILE,
+    NC_CASE,
+    NC_ARG,
+    NC_RETVAL,
+    NC_OTHER  // Not a special kind of node
+  };
+
+  void Initialize(int id, int cost_id, std::shared_ptr<NodeProperties> props,
+                  NodeClass node_class);
+
+  static NodeClass GetNodeClassForOp(const std::string& ts);
+
+  int id_;       // -1 until Initialize() is called
+  int cost_id_;  // -1 if there is no corresponding cost accounting node
+  NodeClass class_;
+
+  EdgeSet in_edges_;
+  EdgeSet out_edges_;
+
+  // NOTE(skyewm): inheriting from core::RefCounted may have a slight
+  // performance benefit over using shared_ptr, at the cost of manual ref
+  // counting
+  std::shared_ptr<NodeProperties> props_;
+
+  // Index within Graph::device_names_ of the name of device assigned
+  // to perform this computation.
+  int assigned_device_name_index_;
+
+  // A back-pointer to the Graph that owns this node.  Currently, this exists
+  // solely to allow Node::[set_]assigned_device_name() to work. However, if all
+  // callers of Node::[set_]assigned_device_name() are modified to use the
+  // equivalent methods defined directly on Graph, then we can remove this
+  // field and reclaim that memory.
+  Graph* graph_;
+
+  // Set if this is an exit node of a while loop with an associated
+  // WhileContext. Otherwise null. (This is only set for exit nodes because
+  // they're the first nodes of a loop encountered while creating the gradient
+  // graph. Exit nodes that are part of while loop gradient graphs will not have
+  // this set.)
+  WhileContext* while_ctx_;
+
+  Node(const Node&) = delete;
+  void operator=(const Node&) = delete;
+};
+
+// Stores debug information associated with the Node.
+struct NodeDebugInfo {
+  const std::string name;
+  std::vector<string> original_node_names;
+  std::vector<string> original_func_names;
+
+  NodeDebugInfo(const Node& n);
+  NodeDebugInfo(const NodeDef& ndef);
+  NodeDebugInfo(StringPiece node_name, bool has_experimental_debug_info,
+                const NodeDef_ExperimentalDebugInfo& experimental_debug_info);
+};
+
+// Represents an input of a node, i.e., the `index`-th input to `node`.
+struct InputTensor {
+  Node* node;
+  int index;
+
+  InputTensor(Node* n, int i) : node(n), index(i) {}
+  InputTensor() : node(nullptr), index(0) {}
+
+  // Returns true if this InputTensor is identical to 'other'. Nodes are
+  // compared using pointer equality.
+  bool operator==(const InputTensor& other) const;
+
+  // A hash function for InputTensors. Nodes are hashed based on their pointer
+  // value.
+  struct Hash {
+    uint64 operator()(InputTensor const& s) const;
+  };
+};
+
+// Represents an output of a node, i.e., the `index`-th output of `node`. Note
+// that a single `OutputTensor` can correspond to multiple `Edge`s if the output
+// is consumed by multiple destination nodes.
+struct OutputTensor {
+  Node* node;
+  int index;
+
+  OutputTensor(Node* n, int i) : node(n), index(i) {}
+  OutputTensor() : node(nullptr), index(0) {}
+
+  // Returns true if this OutputTensor is identical to 'other'. Nodes are
+  // compared using pointer equality.
+  bool operator==(const OutputTensor& other) const;
+
+  // A hash function for OutputTensors. Nodes are hashed based on their pointer
+  // value.
+  struct Hash {
+    uint64 operator()(OutputTensor const& s) const;
+  };
+};
+
+class Edge {
+ public:
+  Node* src() const { return src_; }
+  Node* dst() const { return dst_; }
+  int id() const { return id_; }
+
+  // Return the index of the source output that produces the data
+  // carried by this edge.  The special value kControlSlot is used
+  // for control dependencies.
+  int src_output() const { return src_output_; }
+
+  // Return the index of the destination input that consumes the data
+  // carried by this edge.  The special value kControlSlot is used
+  // for control dependencies.
+  int dst_input() const { return dst_input_; }
+
+  // Return true iff this is an edge that indicates a control-flow
+  // (as opposed to a data-flow) dependency.
+  bool IsControlEdge() const;
+
+  std::string DebugString() const;
+
+ private:
+  Edge() {}
+
+  friend class EdgeSetTest;
+  friend class GraphTest;
+  friend class Graph;
+  Node* src_;
+  Node* dst_;
+  int id_;
+  int src_output_;
+  int dst_input_;
+};
+
+// Allows for iteration of the edges of a Graph, by iterating the underlying
+// Graph.edges_ vector while skipping over null entries.
+class GraphEdgesIterable {
+ private:
+  const std::vector<Edge*>& edges_;
+
+ public:
+  explicit GraphEdgesIterable(const std::vector<Edge*>& edges)
+      : edges_(edges) {}
+
+  typedef Edge* value_type;
+
+  class const_iterator {
+   private:
+    // The underlying iterator.
+    std::vector<value_type>::const_iterator iter_;
+
+    // The end of the underlying iterator.
+    std::vector<value_type>::const_iterator end_;
+
+    // Advances iter_ until it reaches a non-null item, or reaches the end.
+    void apply_filter() {
+      while (iter_ != end_ && *iter_ == nullptr) {
+        ++iter_;
+      }
+    }
+
+   public:
+    const_iterator(std::vector<value_type>::const_iterator iter,
+                   std::vector<value_type>::const_iterator end)
+        : iter_(iter), end_(end) {
+      apply_filter();
+    }
+
+    bool operator==(const const_iterator& other) const {
+      return iter_ == other.iter_;
+    }
+
+    bool operator!=(const const_iterator& other) const {
+      return iter_ != other.iter_;
+    }
+
+    // This is the prefix increment operator (++x), which is the operator
+    // used by C++ range iteration (for (x : y) ...).  We intentionally do not
+    // provide a postfix increment operator.
+    const_iterator& operator++() {
+      ++iter_;
+      apply_filter();
+      return *this;
+    }
+
+    value_type operator*() { return *iter_; }
+  };
+
+  const_iterator begin() {
+    return const_iterator(edges_.begin(), edges_.end());
+  }
+  const_iterator end() { return const_iterator(edges_.end(), edges_.end()); }
+};
+
+// Thread compatible but not thread safe.
+class Graph {
+ public:
+  // Constructs a graph with a single SOURCE (always id kSourceId) and a
+  // single SINK (always id kSinkId) node, and an edge from SOURCE->SINK.
+  //
+  // The graph can hold ops found in the registry. `ops`s lifetime must be at
+  // least that of the constructed graph's.
+  explicit Graph(const OpRegistryInterface* ops);
+
+  // Constructs a graph with a single SOURCE (always id kSourceId) and a
+  // single SINK (always id kSinkId) node, and an edge from SOURCE->SINK.
+  //
+  // The graph can hold ops found in `flib_def`. Unlike the constructor taking
+  // an OpRegistryInterface, this constructor copies the function definitions in
+  // `flib_def` so its lifetime may be shorter than that of the graph's. The
+  // OpRegistryInterface backing `flib_def` must still have the lifetime of the
+  // graph though.
+  explicit Graph(const FunctionLibraryDefinition& flib_def);
+
+  ~Graph();
+
+  // Clone the current graph into a new one.
+  std::unique_ptr<Graph> Clone();
+
+  static constexpr int kControlSlot = -1;
+
+  // The GraphDef version range of this graph (see graph.proto).
+  const VersionDef& versions() const;
+  void set_versions(const VersionDef& versions);
+
+  // Adds a new node to this graph, and returns it. Infers the Op and
+  // input/output types for the node. *this owns the returned instance.
+  // Returns nullptr and sets *status on error.
+  Node* AddNode(NodeDef node_def, Status* status);
+
+  // Same as above, but using StatusOr. This method is always preferred.
+  StatusOr<Node*> AddNode(NodeDef node_def);
+
+  // Copies *node, which may belong to another graph, to a new node,
+  // which is returned.  Does not copy any edges.  *this owns the
+  // returned instance.
+  Node* CopyNode(const Node* node);
+
+  // Removes a node from this graph, including all edges from or to it.
+  // *node should not be accessed after calling this function.
+  // REQUIRES: node->IsOp()
+  void RemoveNode(Node* node);
+
+  void Copy(const Graph& src);
+
+  // Removes all nodes from this graph, including all edges from or to them.
+  // No Node* references to the Graph are valid post.
+  void Clear();
+
+  // Adds an edge that connects the xth output of `source` to the yth input of
+  // `dest` and returns it. Does not update dest's NodeDef.
+  const Edge* AddEdge(Node* source, int x, Node* dest, int y);
+
+  // Adds a control edge (no data flows along this edge) that connects `source`
+  // to `dest`. If `dest`s NodeDef is missing the corresponding control input,
+  // adds the control input.
+  //
+  // If such a control edge already exists and `allow_duplicates` is false, no
+  // edge is added and the function returns nullptr. Otherwise the edge is
+  // unconditionally created and returned. The NodeDef is not updated if
+  // `allow_duplicates` is true.
+  // TODO(skyewm): // TODO(skyewm): allow_duplicates is needed only by
+  // graph_partition.cc. Figure out if we can do away with it.
+  const Edge* AddControlEdge(Node* source, Node* dest,
+                             bool allow_duplicates = false);
+
+  // Removes edge from the graph. Does not update the destination node's
+  // NodeDef. Does not update the full type information of the source node's
+  // NodeDef. (See ShrinkTypeInfo for an example of updating full type
+  // information when removing some outputs from a node.)
+  // REQUIRES: The edge must exist.
+  void RemoveEdge(const Edge* edge);
+
+  // Removes control edge `edge` from the graph. Note that this also updates
+  // the corresponding NodeDef to reflect the change.
+  // REQUIRES: The control edge must exist.
+  void RemoveControlEdge(const Edge* e);
+
+  // Updates the input to a node.  The existing edge to `dst` is removed and an
+  // edge from `new_src` to `dst` is created. The NodeDef associated with `dst`
+  // is also updated.
+  Status UpdateEdge(Node* new_src, int new_src_index, Node* dst, int dst_index);
+
+  // Add an input to dst that comes from the "src_slot" output of the
+  // node named by "src_name".
+  static void AddInput(NodeDef* dst, StringPiece src_name, int src_slot);
+
+  // Like AddEdge but updates dst's NodeDef. Used to add an input edge to a
+  // "While" op during gradient construction, see AddInputWhileHack in
+  // python_api.h for more details.
+  Status AddWhileInputHack(Node* new_src, int new_src_index, Node* dst);
+
+  // Adds the function and gradient definitions in `fdef_lib` to this graph's op
+  // registry. Ignores duplicate functions, and returns a bad status if an
+  // imported function differs from an existing function or op with the same
+  // name. This overload adds the function definitions with no stack traces.
+  Status AddFunctionLibrary(const FunctionDefLibrary& fdef_lib);
+  Status AddFunctionLibrary(FunctionDefLibrary&& fdef_lib);
+
+  // Adds the function and gradient definitions in `fdef_lib` to this graph's op
+  // registry. Ignores duplicate functions, and returns a bad status if an
+  // imported function differs from an existing function or op with the same
+  // name.
+  Status AddFunctionLibrary(const FunctionDefLibrary& fdef_lib,
+                            const FunctionDefLibraryStackTraces& stack_traces);
+  Status AddFunctionLibrary(FunctionDefLibrary&& fdef_lib,
+                            const FunctionDefLibraryStackTraces& stack_traces);
+
+  // Adds the function definition and its stacktraces to this graph's op
+  // registry. Ignores duplicate functions, and returns a bad status if an
+  // imported function differs from an existing function or op with the same
+  // name.
+  Status AddFunctionDef(const FunctionDef& fdef,
+                        const StackTracesMap& stack_traces);
+
+  // Adds the gradient definition to this graph's op registry. Ignores duplicate
+  // gradients of the same function, and returns a bad status if an imported
+  // gradient differs from an existing gradient of the same function name.
+  Status AddGradientDef(const GradientDef& gdef);
+
+  // The number of live nodes in the graph.
+  //
+  // Because nodes can be removed from the graph, num_nodes() is often
+  // smaller than num_node_ids(). If one needs to create an array of
+  // nodes indexed by node ids, num_node_ids() should be used as the
+  // array's size.
+  int num_nodes() const { return num_nodes_; }
+
+  // The number of live nodes in the graph, excluding the Source and Sink nodes.
+  int num_op_nodes() const {
+    DCHECK_GE(num_nodes_, 2);
+    return num_nodes_ - 2;
+  }
+
+  // The number of live edges in the graph.
+  //
+  // Because edges can be removed from the graph, num_edges() is often
+  // smaller than num_edge_ids(). If one needs to create an array of
+  // edges indexed by edge ids, num_edge_ids() should be used as the
+  // array's size.
+  int num_edges() const { return num_edges_; }
+
+  // Serialize the nodes starting at `from_node_id` to a GraphDef.
+  // `include_flib_def` indicates whether the function library will be populated
+  // in the `graph_def`. `include_flib_def` should be usually set to true so
+  // that the populated `graph_def` will be complete. Setting `include_flib_def`
+  // to false would mean that the returned `graph_def` is incomplete and may
+  // contain references to functions whose definition is not included. It can
+  // make sense to do this in cases where the caller already has a copy of the
+  // function library.
+  // If `include_debug_info` is true, the `debug_info` field of the GraphDef
+  // will be populated with stack traces from the nodes and the function
+  // library. Note that if `include_debug_info` is true and `include_flib_def`
+  // is false, then `debug_info` will contain stack traces for nodes in the
+  // function library, which will not itself be included in the GraphDef.
+  void ToGraphDefSubRange(GraphDef* graph_def, int from_node_id,
+                          bool include_flib_def = true,
+                          bool include_debug_info = false) const;
+
+  // Serialize to a GraphDef. `include_flib_def` indicates whether the function
+  // library will be populated in the `graph_def`. `include_flib_def` should be
+  // usually set to true so that the populated `graph_def` will be complete.
+  // Setting `include_flib_def` to false would mean that the returned
+  // `graph_def` is incomplete and may contain references to functions whose
+  // definition is not included. It can make sense to do this in cases where the
+  // caller already has a copy of the function library.
+  // If `include_debug_info` is true, the `debug_info` field of the GraphDef
+  // will be populated with stack traces from the nodes and the function
+  // library. Note that if `include_debug_info` is true and `include_flib_def`
+  // is false, then `debug_info` will contain stack traces for nodes in the
+  // function library, which will not itself be included in the GraphDef.
+  void ToGraphDef(GraphDef* graph_def, bool include_flib_def = true,
+                  bool include_debug_info = false) const;
+
+  // This version can be called from debugger to inspect the graph content.
+  // Use the previous version outside debug context for efficiency reasons.
+  //
+  // Note: We do not expose a DebugString() API, since GraphDef.DebugString() is
+  // not defined in some TensorFlow builds.
+  GraphDef ToGraphDefDebug() const;
+
+  // Generate new node name with the specified prefix that is unique
+  // across this graph.
+  std::string NewName(StringPiece prefix);
+
+  // Access to the list of all nodes.  Example usage:
+  //   for (Node* node : graph.nodes()) { ... }
+  gtl::iterator_range<NodeIter> nodes() const;
+
+  // Access to the list of all nodes, excluding the Source and Sink nodes.
+  gtl::iterator_range<NodeIter> op_nodes() const;
+
+  // Returns one more than the maximum id assigned to any node.
+  int num_node_ids() const { return nodes_.size(); }
+
+  // Returns the node associated with an id, or nullptr if no node
+  // with that id (the node with that id was removed and the id has
+  // not yet been re-used). *this owns the returned instance.
+  // REQUIRES: 0 <= id < num_node_ids().
+  Node* FindNodeId(int id) const { return nodes_[id]; }
+
+  // Returns one more than the maximum id assigned to any edge.
+  int num_edge_ids() const { return edges_.size(); }
+
+  // Returns the Edge associated with an id, or nullptr if no edge
+  // with that id (the edge with that id was removed and the id has
+  // not yet been re-used). *this owns the returned instance.
+  // REQUIRES: 0 <= id < num_edge_ids().
+  const Edge* FindEdgeId(int id) const { return edges_[id]; }
+
+  // Access to the set of all edges.  Example usage:
+  //   for (const Edge* e : graph.edges()) { ... }
+  GraphEdgesIterable edges() const { return GraphEdgesIterable(edges_); }
+
+  // The pre-defined nodes.
+  enum { kSourceId = 0, kSinkId = 1 };
+  Node* source_node() const { return FindNodeId(kSourceId); }
+  Node* sink_node() const { return FindNodeId(kSinkId); }
+
+  const OpRegistryInterface* op_registry() const { return &ops_; }
+  const FunctionLibraryDefinition& flib_def() const { return ops_; }
+
+  FunctionLibraryDefinition* mutable_flib_def() { return &ops_; }
+
+  void CheckDeviceNameIndex(int index) {
+    DCHECK_GE(index, 0);
+    DCHECK_LT(index, static_cast<int>(device_names_.size()));
+  }
+
+  int InternDeviceName(const std::string& device_name);
+
+  const std::string& get_assigned_device_name(const Node& node) const {
+    return device_names_[node.assigned_device_name_index()];
+  }
+
+  void set_assigned_device_name_index(Node* node, int device_name_index) {
+    CheckDeviceNameIndex(device_name_index);
+    node->assigned_device_name_index_ = device_name_index;
+  }
+
+  void set_assigned_device_name(Node* node, const std::string& device_name) {
+    node->assigned_device_name_index_ = InternDeviceName(device_name);
+  }
+
+  // Returns OK if `node` is non-null and belongs to this graph
+  Status IsValidNode(const Node* node) const;
+
+  // Returns OK if IsValidNode(`node`) and `idx` is a valid output.  Does not
+  // accept control outputs.
+  Status IsValidOutputTensor(const Node* node, int idx) const;
+
+  // Returns OK if IsValidNode(`node`) and `idx` a valid input.  Does not accept
+  // control inputs.
+  Status IsValidInputTensor(const Node* node, int idx) const;
+
+  // Create and return a new WhileContext owned by this graph. This is called
+  // when a new while loop is created. `frame_name` must be unique among
+  // WhileContexts in this graph.
+  Status AddWhileContext(StringPiece frame_name, std::vector<Node*> enter_nodes,
+                         std::vector<Node*> exit_nodes,
+                         OutputTensor cond_output,
+                         std::vector<OutputTensor> body_inputs,
+                         std::vector<OutputTensor> body_outputs,
+                         WhileContext** result);
+
+  // Builds a node name to node pointer index for all nodes in the graph.
+  std::unordered_map<string, Node*> BuildNodeNameIndex() const;
+
+  absl::optional<std::vector<bool>>& GetConstArgIndicesCache() const {
+    return const_arg_indices_cache_;
+  }
+
+  // TODO(kkb): Add to the constructor when it becomes managable.
+  // Sets the graph construction context.
+  void SetConstructionContext(ConstructionContext construction_context) {
+    construction_context_ = construction_context;
+  }
+
+  // TODO(kkb): Rename to `GetConstructionContext` once we're comfortable
+  // making this stable and make it available widely.
+  // Returns the graph construction context. It's `kUnknown` if not set.
+  ConstructionContext GetConstructionContextInternal() const {
+    return construction_context_;
+  }
+
+  // Set full type information for a node given its name.
+  // Note that if this is called in a loop iterating over all the nodes
+  // elsewhere it would be O(n^2) complexity. If this case was important in the
+  // future, an alternative method could be added that takes in a flat_hash_map
+  // of name: type and simply iterates through the graph once and annotates all
+  // nodes.
+  void SetNodeType(StringPiece name, const FullTypeDef& type);
+
+  // Get full type information for a node given its name.
+  // Note that if this is called in a loop iterating over all the nodes
+  // elsewhere it would be O(n^2) complexity. If this case was important in the
+  // future, an alternative method could be added that takes in flat_hash_map of
+  // name: type and simply iterates through the graph once and stores all the
+  // information in the map.
+  void NodeType(StringPiece name, const FullTypeDef** result);
+
+  // Builds a GraphDebugInfo from the functions and nodes in this graph. Stack
+  // traces associated with function definitions will have a key of the form
+  // <node_name> '@' <function_name>. Stack traces associated with other Nodes
+  // will use the node name as the key.
+  GraphDebugInfo BuildDebugInfo() const;
+
+  // TODO(josh11b): uint64 hash() const;
+
+ private:
+  // If cost_node is non-null, then cost accounting (in CostModel)
+  // will be associated with that node rather than the new one being
+  // created.
+  //
+  // Ownership of the returned Node is not transferred to caller.
+  Node* AllocateNode(std::shared_ptr<NodeProperties> props,
+                     const Node* cost_node, Node::NodeClass node_class);
+  void ReleaseNode(Node* node);
+  // Insert edge in free_edges_ for possible reuse.
+  void RecycleEdge(const Edge* edge);
+  // Registry of all known ops, including functions.
+  FunctionLibraryDefinition ops_;
+
+  // GraphDef versions
+  const std::unique_ptr<VersionDef> versions_;
+
+  // Allocator which will give us good locality.
+  core::Arena arena_;
+
+  // Map from node ids to allocated nodes.  nodes_[id] may be nullptr if
+  // the node with that id was removed from the graph.
+  std::vector<Node*> nodes_;
+
+  // Number of nodes alive.
+  int64_t num_nodes_ = 0;
+
+  // Map from edge ids to allocated edges.  edges_[id] may be nullptr if
+  // the edge with that id was removed from the graph.
+  std::vector<Edge*> edges_;
+
+  // The number of entries in edges_ that are not nullptr.
+  int num_edges_ = 0;
+
+  // Allocated but free nodes and edges.
+  std::vector<Node*> free_nodes_;
+  std::vector<Edge*> free_edges_;
+
+  // For generating unique names.
+  int name_counter_ = 0;
+
+  // In most graphs, the number of unique values used for the
+  // Node::assigned_device_name() property is quite small.  If the graph is
+  // large, then this duplication of values can consume a significant amount of
+  // memory.  Instead, we represent the same information using an interning
+  // table, which consists of a vector of unique strings (device_names_), as
+  // well a map (device_names_map_) from unique strings to indices within the
+  // unique string table.
+  //
+  // The InternDeviceName() method handles adding a new entry into the table,
+  // or locating the index of an existing entry.
+  //
+  // The fact that Node::assigned_device_name() is implemented using an
+  // interning table is intentionally public.  This allows algorithms that
+  // frequently access this field to do so efficiently, especially for the case
+  // where the assigned_device_name of one Node is copied directly from that
+  // of another Node.
+
+  // A table of the unique assigned device names.  Indices do NOT correspond
+  // to node IDs.  Index 0 is always the empty string.
+  std::vector<string> device_names_;
+
+  // Maps unique device names to indices within device_names_[i].
+  std::unordered_map<string, int> device_names_map_;
+
+  // All the while contexts owned by this graph, keyed by frame name,
+  // corresponding to all the while loops contained in this graph (including
+  // nested loops). The stored contexts are usually accessed via
+  // AddWhileContext() or Node::while_ctx(), but this manages the lifetime.
+  std::map<string, WhileContext> while_ctxs_;
+
+  // Cache of the indices of the arguments which need to be constant for the XLA
+  // compilation.
+  mutable absl::optional<std::vector<bool>> const_arg_indices_cache_;
+
+  // Indicates the context that this Graph instance is constructed.
+  ConstructionContext construction_context_ = ConstructionContext::kNotTracked;
+
+  Graph(const Graph&) = delete;
+  void operator=(const Graph&) = delete;
+};
+
+// TODO(josh11b): We may want to support keeping an index on various
+// node/edge attributes in a graph, particularly node names.
+
+// Helper routines
+
+inline bool IsSource(const Node* node) { return node->IsSource(); }
+inline bool IsSink(const Node* node) { return node->IsSink(); }
+inline bool IsSwitch(const Node* node) { return node->IsSwitch(); }
+inline bool IsMerge(const Node* node) { return node->IsMerge(); }
+inline bool IsEnter(const Node* node) { return node->IsEnter(); }
+inline bool IsExit(const Node* node) { return node->IsExit(); }
+inline bool IsNextIteration(const Node* n) { return n->IsNextIteration(); }
+inline bool IsLoopCond(const Node* node) { return node->IsLoopCond(); }
+inline bool IsControlTrigger(const Node* n) { return n->IsControlTrigger(); }
+inline bool IsSend(const Node* node) { return node->IsSend(); }
+inline bool IsRecv(const Node* node) { return node->IsRecv(); }
+inline bool IsHostSend(const Node* node) { return node->IsHostSend(); }
+inline bool IsHostRecv(const Node* node) { return node->IsHostRecv(); }
+
+// True for Nodes that mediate the transfer of values between processes.
+inline bool IsTransferNode(const Node* n) { return IsSend(n) || IsRecv(n); }
+
+inline bool IsConstant(const Node* node) { return node->IsConstant(); }
+inline bool IsVariable(const Node* node) { return node->IsVariable(); }
+inline bool IsIdentity(const Node* node) { return node->IsIdentity(); }
+
+// Returns true iff 'n' is a control flow node.
+inline bool IsControlFlow(const Node* n) { return n->IsControlFlow(); }
+
+// Returns true if the node only depends on its input's metadata
+// (shape).  Specifically, returns true for "Size", "Shape" and "Rank" ops.
+inline bool IsMetadata(const Node* n) { return n->IsMetadata(); }
+
+inline bool IsScopedAllocator(const Node* n) { return n->IsScopedAllocator(); }
+
+inline bool IsHostMemoryPreserving(const Node* node) {
+  return IsIdentity(node) || IsControlFlow(node);
+}
+
+inline bool IsDistributedCommunication(const Node* n) {
+  return n->IsDistributedCommunication();
+}
+
+// NOTE: We declare Reference type of NodeIter and NeighborIter as Node* (see
+// https://en.cppreference.com/w/cpp/iterator/iterator).
+
+// Iterator for stepping through the nodes of a graph.
+class NodeIter
+    : public std::iterator<std::forward_iterator_tag, Node, std::ptrdiff_t,
+                           /*Pointer*/ Node*, /*Reference*/ Node*> {
+ public:
+  NodeIter(const Graph* graph, int id);
+  bool operator==(const NodeIter& rhs) const;
+  bool operator!=(const NodeIter& rhs) const;
+  void operator++();
+  reference operator*() const;
+  pointer operator->() const;
+
+ private:
+  // Invariant: id_ == graph_->num_node_ids() || graph_->FindId(id_) != nullptr
+  const Graph* graph_;
+  int id_;
+};
+
+// Iterator for stepping through the neighbors of a node.
+class NeighborIter
+    : public std::iterator<std::forward_iterator_tag, Node, std::ptrdiff_t,
+                           /*Pointer*/ Node*, /*Reference*/ Node*> {
+ public:
+  NeighborIter(EdgeSet::const_iterator iter, bool incoming);
+  bool operator==(const NeighborIter& rhs) const;
+  bool operator!=(const NeighborIter& rhs) const;
+  void operator++();
+  reference operator*() const;
+  pointer operator->() const;
+
+ private:
+  EdgeSet::const_iterator iter_;
+  bool incoming_;
+};
+
+// IMPLEMENTATION DETAILS, PLEASE IGNORE
+
+inline NodeIter::NodeIter(const Graph* graph, int id)
+    : graph_(graph), id_(id) {}
+
+inline bool NodeIter::operator==(const NodeIter& rhs) const {
+  DCHECK(graph_ == rhs.graph_);
+  return id_ == rhs.id_;
+}
+
+inline bool NodeIter::operator!=(const NodeIter& rhs) const {
+  return !(*this == rhs);
+}
+
+inline void NodeIter::operator++() {
+  while (1) {
+    DCHECK_LE(id_, graph_->num_node_ids());
+    ++id_;
+    if (id_ >= graph_->num_node_ids() || graph_->FindNodeId(id_) != nullptr) {
+      return;
+    }
+  }
+}
+
+inline Node* NodeIter::operator*() const { return graph_->FindNodeId(id_); }
+
+inline Node* NodeIter::operator->() const { return graph_->FindNodeId(id_); }
+
+inline NeighborIter::NeighborIter(EdgeSet::const_iterator iter, bool incoming)
+    : iter_(iter), incoming_(incoming) {}
+
+inline bool NeighborIter::operator==(const NeighborIter& rhs) const {
+  return iter_ == rhs.iter_ && incoming_ == rhs.incoming_;
+}
+
+inline bool NeighborIter::operator!=(const NeighborIter& rhs) const {
+  return !(*this == rhs);
+}
+
+inline void NeighborIter::operator++() { ++iter_; }
+
+inline Node* NeighborIter::operator*() const {
+  const Edge* e = *iter_;
+  return incoming_ ? e->src() : e->dst();
+}
+
+inline Node* NeighborIter::operator->() const {
+  const Edge* e = *iter_;
+  return incoming_ ? e->src() : e->dst();
+}
+
+inline bool Edge::IsControlEdge() const {
+  // Note that if either src_output_ or dst_input_ is kControlSlot,
+  // so is the other one (AddEdge checks this).
+  return src_output_ == Graph::kControlSlot;
+}
+
+inline gtl::iterator_range<NodeIter> Graph::nodes() const {
+  // Note that NodeId 0 is always valid since we don't let the source
+  // node be removed from the graph.
+  return gtl::make_range(NodeIter(this, 0), NodeIter(this, num_node_ids()));
+}
+
+inline gtl::iterator_range<NodeIter> Graph::op_nodes() const {
+  // Note that NodeId 0 is always valid since we don't let the source
+  // node be removed from the graph.
+  //
+  // The current implementation of Graph maintains the invariant that the
+  // first two nodes are the source and sink nodes, and all other nodes are op
+  // nodes. This method (op_nodes()) relies on this invariant.
+  NodeIter begin(this, 0);
+  NodeIter end(this, num_node_ids());
+  if (begin != end) {
+    ++begin;
+  }
+  if (begin != end) {
+    ++begin;
+  }
+  return gtl::make_range(begin, end);
+}
+
+inline void Node::set_assigned_device_name_index(int index) {
+  graph_->CheckDeviceNameIndex(index);
+  assigned_device_name_index_ = index;
+}
+
+inline void Node::set_assigned_device_name(const std::string& device_name) {
+  graph_->set_assigned_device_name(this, device_name);
+}
+
+inline const std::string& Node::assigned_device_name() const {
+  return graph_->get_assigned_device_name(*this);
+}
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPH_GRAPH_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/graph_debug_info_builder.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/graph_debug_info_builder.h
new file mode 100644
index 0000000000000000000000000000000000000000..3d3f423d5a2a9f452168c474fd1357694e146393
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/graph_debug_info_builder.h
@@ -0,0 +1,206 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPH_GRAPH_DEBUG_INFO_BUILDER_H_
+#define TENSORFLOW_CORE_GRAPH_GRAPH_DEBUG_INFO_BUILDER_H_
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "absl/container/flat_hash_map.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/span.h"
+#include "tensorflow/core/framework/graph_debug_info.pb.h"
+#include "tensorflow/core/platform/stack_frame.h"
+#include "tsl/platform/macros.h"
+
+namespace tensorflow {
+
+// Language agnostic stack traces.
+class AbstractStackTrace {
+ public:
+  struct TracePrintingOptions {
+    // Show inline the contents of each stack line.
+    bool show_line_contents = false;
+
+    // Drop the common largest prefix of all filenames in stack frames.
+    bool filter_common_prefix = false;
+
+    // Do not show internal frames.
+    bool drop_internal_frames = false;
+  };
+
+  virtual ~AbstractStackTrace() = default;
+
+  // The returned span is alive as long as the AbstractStackTrace is alive.
+  virtual absl::Span<StackFrame const> ToFrames() const = 0;
+
+  // Returns the last stack frame from user code, attempting to ignore the
+  // framework code. Returns an empty frame if no such stack frame was found.
+  virtual StackFrame LastUserFrame() const = 0;
+
+  // Returns stack trace from user code (instead of op creation ones returned in
+  // ToFrames).
+  virtual std::vector<StackFrame> GetUserFrames(int limit) const = 0;
+
+  virtual std::string ToString(const TracePrintingOptions& opts) const = 0;
+};
+
+// A frozen sequence of StackFrames; an adapter for a span of StackFrames that
+// conforms to the AbstractStackTrace contract.
+class FrozenStackTrace : public AbstractStackTrace {
+ public:
+  // Constructs a FrozenStackTrace from a span of StackFrames by making a copy
+  // of each stack frame.
+  explicit FrozenStackTrace(absl::Span<StackFrame const> frames,
+                            absl::Span<StackFrame const> user_frames = {});
+
+  explicit FrozenStackTrace(std::vector<StackFrame>&& frames)
+      : frames_(std::move(frames)), user_frames_({}) {}
+
+  FrozenStackTrace(FrozenStackTrace&&) = default;
+
+  // Constructs a FrozenStackTrace from serialized proto data.
+  FrozenStackTrace(const GraphDebugInfo::StackTrace& stack_trace,
+                   const GraphDebugInfo& debug_info);
+
+  ~FrozenStackTrace() override = default;
+
+  absl::Span<StackFrame const> ToFrames() const override;
+
+  StackFrame LastUserFrame() const override;
+
+  std::vector<StackFrame> GetUserFrames(int limit) const override;
+
+  std::string ToString(const TracePrintingOptions& opts) const override;
+
+ private:
+  std::vector<StackFrame> frames_;
+  std::vector<StackFrame> user_frames_;
+};
+
+// Builder for GraphDebugInfo protos from either an existing map of string keys
+// to stack traces, or individual stack traces, or both. All stack traces in a
+// GraphDebugInfo are stored with a string key in the `traces` field. In the
+// case of an existing map, its keys are used, appended with a key suffix,
+// which may be empty. If it is not empty, it is conventionally of the form
+// "@function_name", although this class doesn't care. In the case of an
+// individual stack trace, a key for `traces` must be provided.
+//
+// This builder will create a list of the unique file names across all stack
+// traces and store it in the `files` field. When storing stack traces into the
+// proto, file names are replaced by their index into `files`.
+//
+// Typical usage is to call one or both of the accumulate methods one or more
+// times and then to call the Build().
+
+// Holder type to use `AbstractStackTrace` as a key.
+struct StackTracePointer {
+  std::shared_ptr<AbstractStackTrace> trace;
+
+  template <class H>
+  friend H AbslHashValue(H h, const StackTracePointer& p) {
+    for (const auto& frame : p.trace->ToFrames()) {
+      h = H::combine(std::move(h), frame);
+    }
+    return h;
+  }
+
+  bool operator==(const StackTracePointer& other) const {
+    absl::Span<StackFrame const> other_frames = other.trace->ToFrames();
+    absl::Span<StackFrame const> frames = trace->ToFrames();
+    return frames == other_frames;
+  }
+};
+
+using StackTracesMap =
+    absl::flat_hash_map<std::string,
+                        std::shared_ptr<tensorflow::AbstractStackTrace>>;
+
+// Load all stack traces from `debug_info`.
+StackTracesMap LoadTracesFromDebugInfo(const GraphDebugInfo& debug_info);
+absl::StatusOr<StackTracesMap> LoadTracesFromDebugInfoStr(
+    absl::string_view debug_info_str);
+
+// Generates a GraphDebugInfo proto from a StackTracesMap object. Returns user
+// frames by default. If `user_frames` is false, returns all frames.
+GraphDebugInfo StackTracesMapToGraphDebugInfo(const StackTracesMap& map,
+                                              bool user_frames = true);
+
+class GraphDebugInfoBuilder {
+ public:
+  struct Options {
+    // Call the AbstractTraceMap GetUserFrames method rather than ToFrames
+    bool user_frames;
+    // Value of `limit` to pass to GetUserFrames if `user_frames` is true,
+    // otherwise ignored
+    int user_frames_limit;
+  };
+
+  GraphDebugInfoBuilder();
+  virtual ~GraphDebugInfoBuilder() = default;
+
+  // Adds a map of stack traces to the GraphDebugInfo proto. For each key (node
+  // id) and stack traces entry in `stack_traces_map`, combine the key with
+  // `key_suffix` to form a new key and use that to add the stack traces to the
+  // `traces` field of the proto. If not empty, the suffix is typically of the
+  // form "@function_name", although this function doesn't care.
+  void AccumulateStackTracesMap(const StackTracesMap& stack_traces_map,
+                                absl::string_view key_suffix = "",
+                                const GraphDebugInfoBuilder::Options& options =
+                                    GraphDebugInfoBuilder::Options());
+
+  // Adds one stack trace to the GraphDebugInfo proto, using `traces_key` as the
+  // key for the `traces` field of the proto.
+  void AccumulateStackTrace(std::shared_ptr<AbstractStackTrace> trace,
+                            absl::string_view traces_key,
+                            const GraphDebugInfoBuilder::Options& options =
+                                GraphDebugInfoBuilder::Options());
+
+  void AppendGraphDebugInfo(absl::string_view prefix,
+                            const GraphDebugInfo& new_info);
+
+  // These string methods are used in the Python bindings  to avoid symbol
+  // resolution errors with pybind on Windows.
+  absl::Status AppendGraphDebugInfoStr(absl::string_view prefix,
+                                       absl::string_view new_info_str);
+
+  std::string ToGraphDebugInfoStr() const;
+
+  // Returns the GraphDebugInfo proto.
+  GraphDebugInfo Build() const;
+
+ private:
+  void AppendToStackTraceProto(const StackFrame& stack_frame,
+                               GraphDebugInfo::StackTrace& stack_trace_proto);
+
+  std::unique_ptr<GraphDebugInfo> debug_info_;
+  absl::flat_hash_map<std::string, int> file_name_to_index_;
+
+  absl::flat_hash_map<StackTracePointer, int> trace_to_index_;
+  absl::flat_hash_map<StackFrame, int> frame_to_index_;
+  int new_name_index_ = 0;
+
+  GraphDebugInfoBuilder(const GraphDebugInfoBuilder&) = delete;
+  void operator=(const GraphDebugInfoBuilder&) = delete;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPH_GRAPH_DEBUG_INFO_BUILDER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/graph_def_builder.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/graph_def_builder.h
new file mode 100644
index 0000000000000000000000000000000000000000..f7fc2549b3ea6262bad6f73120c30db4ed5c0b79
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/graph_def_builder.h
@@ -0,0 +1,216 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPH_GRAPH_DEF_BUILDER_H_
+#define TENSORFLOW_CORE_GRAPH_GRAPH_DEF_BUILDER_H_
+
+#include <string>
+#include <vector>
+
+#include "tensorflow/core/framework/function.pb.h"
+#include "tensorflow/core/framework/graph.pb.h"
+#include "tensorflow/core/framework/op.h"
+#include "tensorflow/core/graph/graph.h"
+#include "tensorflow/core/graph/node_builder.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/lib/core/stringpiece.h"
+#include "tensorflow/core/lib/gtl/array_slice.h"
+
+namespace tensorflow {
+
+// Given a function like:
+//   namespace ops {
+//   Node* Identity(NodeOut input, const GraphDefBuilder::Options& opts) {
+//     if (opts.HaveError()) return nullptr;
+//     static const string kOpName = "Identity";
+//     NodeBuilder node_builder(opts.GetNameForOp(kOpName), kOpName,
+//                              opts.op_registry());
+//     node_builder.Input(input);
+//     return opts.FinalizeBuilder(&node_builder);
+//   }
+//   }  // namespace ops
+//
+//   // Or, alternatively:
+//   namespace ops {
+//   Node* Identity(NodeOut input, const GraphDefBuilder::Options& opts) {
+//     static const string kOpName = "Identity";
+//     return UnaryOp(kOpName, input, opts);
+//   }
+//   }  // namespace ops
+//
+// You call it like:
+//   GraphDefBuilder b;
+//   using namespace ::tensorflow::ops;  // NOLINT(build/namespaces)
+//   Node* na = Const(7, b.opts());
+//   // Note: WithName() returns a copy, opts is unchanged.
+//   Node* nb = Const(5, b.opts().WithName("control-input"));
+//   Node* nc = Identity(na, b.opts().WithControlInput(nb));
+//   GraphDef graph_def;
+//   Status status = b.ToGraphDef(&graph_def);
+//   if (!status.ok()) { /* Handle error */ }
+//
+// In tests you can skip the status handling via:
+//   GraphDefBuilder b(GraphDefBuilder::kFailImmediately);
+//   ...
+//   b.ToGraphDef(&graph_def);
+
+class GraphDefBuilder {
+ public:
+  // Options for adding a Node to a Graph.
+  class Options {
+   public:
+    // Sets the Graph (that Nodes will be added to) and the status.  The
+    // status may be set to nullptr, in which case errors cause CHECK
+    // failures.  The graph and status must outlive *this.
+    Options(Graph* graph, Status* status);
+    ~Options();
+
+    // Methods for setting options.  These are const methods: they
+    // return a copy of *this with the option set.
+    Options WithName(StringPiece name) const;
+    Options WithDevice(StringPiece device) const;
+    Options WithControlInput(Node* control_input) const;
+    Options WithControlInputs(gtl::ArraySlice<Node*> control_inputs) const;
+
+    // Override the default value for an optional attr.
+    template <class T>
+    Options WithAttr(StringPiece attr_name, T&& value) const {
+      return Options(*this).WithAttrImpl(attr_name, std::forward<T>(value));
+    }
+    // Note: overload needed to allow {...} expressions for value.
+    template <class T>
+    Options WithAttr(StringPiece attr_name,
+                     std::initializer_list<T> value) const {
+      return WithAttr<std::initializer_list<T>>(attr_name, std::move(value));
+    }
+
+    // Methods for using options from a function that creates a Node.
+
+    // Returns true if the status associated with *this has an error.
+    // Use this to skip processing that may depend on prior results.
+    bool HaveError() const { return status_ != nullptr && !status_->ok(); }
+
+    // Returns a string representation of the status associated with *this.
+    // Returns the string `"OK"` if the status doesn't have any error.
+    string StatusToString() const {
+      return status_->ok() ? "OK" : std::string(status_->message());
+    }
+
+    // Given the Op type name, return a name for a node of that type.
+    // Uses the value set in WithName() if that has been called.  Otherwise,
+    // returns a name built out of the Op type name.
+    string GetNameForOp(StringPiece op) const;
+
+    // Sets the device, adds control inputs, adds attrs, and calls Finalize().
+    // If Finalize returns an error, it is saved and this function returns
+    // nullptr.
+    Node* FinalizeBuilder(NodeBuilder* builder) const;
+
+    // Updates the associated status, if any, or calls TF_CHECK_OK if none.
+    void UpdateStatus(const Status& status) const;
+
+    // Accessor
+    const OpRegistryInterface* op_registry() const {
+      return graph_->op_registry();
+    }
+
+   private:
+    Options WithNameImpl(StringPiece name);
+    Options WithDeviceImpl(StringPiece device);
+    Options WithControlInputImpl(Node* control_input);
+    Options WithControlInputsImpl(gtl::ArraySlice<Node*> control_inputs);
+    template <class T>
+    Options WithAttrImpl(StringPiece name, T&& value) {
+      attrs_.emplace_back(string(name), AttrValue());
+      SetAttrValue(std::forward<T>(value), &attrs_.back().second);
+      return *this;
+    }
+
+    Graph* const graph_;
+    Status* const status_;
+    string name_;
+    string device_;
+    std::vector<Node*> control_inputs_;
+    std::vector<std::pair<string, AttrValue>> attrs_;
+  };
+
+  // Start building a new graph.
+  explicit GraphDefBuilder(
+      const OpRegistryInterface* op_registry = OpRegistry::Global())
+      : graph_(op_registry), flib_def_(op_registry), opts_(&graph_, &status_) {}
+
+  // For use in tests, where you want to fail immediately on error instead
+  // of checking the status at the end.
+  enum TestFailImmediatelyType { kFailImmediately };
+  explicit GraphDefBuilder(
+      TestFailImmediatelyType,
+      const OpRegistryInterface* op_registry = OpRegistry::Global())
+      : graph_(op_registry), flib_def_(op_registry), opts_(&graph_, nullptr) {}
+
+  // Gets the Options with the associated Graph and Status.
+  const Options& opts() const { return opts_; }
+
+  // Once all the nodes have been added, call this to get whether it was
+  // successful, and if so fill *graph_def.
+  Status ToGraphDef(GraphDef* graph_def) const;
+
+  // Adds the function and gradient definitions in `fdef_lib` to this graph's op
+  // registry. Ignores duplicate functions, and returns a bad status if an
+  // imported function differs from an existing function or op with the same
+  // name.
+  Status AddFunctionLibrary(const FunctionDefLibrary& fdef_lib) {
+    return flib_def_.AddLibrary(fdef_lib);
+  }
+
+  // Returns whether a user-defined function with `name` already exists in the
+  // graph.
+  bool HasFunction(const string& name) {
+    return flib_def_.Find(name) != nullptr;
+  }
+
+ private:
+  Graph graph_;
+  FunctionLibraryDefinition flib_def_;
+  Status status_;
+  Options opts_;
+};
+
+namespace ops {
+
+// A NodeOut may either be a regular input or back input.  Regular
+// inputs are specified via either a Node* or a Node* and an output
+// index.  Back inputs are specified by a node name, output index, and
+// output type.
+typedef NodeBuilder::NodeOut NodeOut;
+
+// For adding an Op with no inputs to a GraphDefBuilder.
+Node* SourceOp(const string& op_name, const GraphDefBuilder::Options& opts);
+
+// For adding an Op with one input to a GraphDefBuilder.
+Node* UnaryOp(const string& op_name, NodeOut input,
+              const GraphDefBuilder::Options& opts);
+
+// For adding an Op with two inputs to a GraphDefBuilder.
+Node* BinaryOp(const string& op_name, NodeOut a, NodeOut b,
+               const GraphDefBuilder::Options& opts);
+
+// For adding an Op with three inputs to a GraphDefBuilder.
+Node* TernaryOp(const string& op_name, NodeOut a, NodeOut b, NodeOut c,
+                const GraphDefBuilder::Options& opts);
+
+}  // namespace ops
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPH_GRAPH_DEF_BUILDER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/graph_node_util.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/graph_node_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..f78564c91b0ffa3eb4068995da158518ac14d503
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/graph_node_util.h
@@ -0,0 +1,64 @@
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_GRAPH_GRAPH_NODE_UTIL_H_
+#define TENSORFLOW_CORE_GRAPH_GRAPH_NODE_UTIL_H_
+
+#include "tensorflow/core/framework/node_def_util.h"
+#include "tensorflow/core/lib/core/stringpiece.h"
+#include "tensorflow/core/platform/status.h"
+
+namespace tensorflow {
+class Node;
+struct NodeDebugInfo;
+
+// We forward declare protos so that kernels don't need to depend on them
+class NodeDef;
+class OpDef;
+
+// Produce a human-readable version of a Node or NodeDef that is more concise
+// than a text-format proto.
+string SummarizeNode(const Node& node);
+
+// Produces a formatted string pattern from the node which can uniquely identify
+// this node upstream to produce an informative error message. The pattern
+// followed is: {{node <node_name>}}
+string FormatNodeForError(const Node& node);
+
+// Merges the original node names from the debug information of 'from' to the
+// debug information of 'to'.
+void MergeDebugInfo(const NodeDebugInfo& from, Node* to);
+void MergeDebugInfo(const NodeDebugInfo& from, NodeDef* to);
+void MergeDebugInfo(const NodeDef& from, NodeDef* to);
+
+// Computes the mapping from input/output argument name to the
+// corresponding input/output index range.  For example,
+// input "foo" corresponds to input indices
+//   [ (*inputs)["foo"].first, (*inputs)["foo"].second ).
+// NOTE(mrry): To reduce allocations when the map is used and save
+// space, the returned `NameRangeMap` objects borrow the input/output
+// argument names from `op_def`. The `op_def` must outlive the
+// returned `NameRangeMap` objects.
+Status NameRangesForNode(const Node& node, const OpDef& op_def,
+                         NameRangeMap* inputs, NameRangeMap* outputs);
+
+// Returns "status" with formatted Node attached as additional text
+// in the error message. If 'allow_multiple_formatted_node' is false and there
+// is already a formatted Node present in 'status', we simply attach the name
+// of the Node instead of the formatted string.
+Status AttachDef(const Status& status, const Node& node,
+                 bool allow_multiple_formatted_node = false);
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPH_GRAPH_NODE_UTIL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/graph_partition.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/graph_partition.h
new file mode 100644
index 0000000000000000000000000000000000000000..f7656d8c8aef957d9d1a7ce623109cfc0b7caeee
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/graph_partition.h
@@ -0,0 +1,102 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPH_GRAPH_PARTITION_H_
+#define TENSORFLOW_CORE_GRAPH_GRAPH_PARTITION_H_
+
+#include <functional>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include "tensorflow/core/framework/function.h"
+#include "tensorflow/core/framework/graph.pb.h"
+#include "tensorflow/core/graph/costmodel.h"
+#include "tensorflow/core/graph/graph.h"
+
+namespace tensorflow {
+
+struct PartitionOptions {
+  // A function that returns a location for the execution of a given
+  // Node.
+  typedef std::function<string(const Node*)> NodeToLocFunc;
+  NodeToLocFunc node_to_loc = nullptr;
+
+  // A function that returns a unique graph node name with the given
+  // prefix.
+  typedef std::function<string(const string&)> NewNameFunc;
+  NewNameFunc new_name = nullptr;
+
+  // A function that returns the incarnation of a device given the
+  // device's fullname. If not found, GetIncarnationFunc should return
+  // kIllegalIncarnation.
+  static constexpr uint64 kIllegalIncarnation = 0;
+  typedef std::function<uint64(const string&)> GetIncarnationFunc;
+  GetIncarnationFunc get_incarnation = nullptr;
+
+  // If specified, flib_def defines a function library that should be
+  // partitioned and replicated into each resulting partition graphs.
+  const FunctionLibraryDefinition* flib_def = nullptr;
+
+  // True if all the control flow "code" has already been added. The
+  // control flow code needs to be added when we still have the entire
+  // graph before any partitioning. So this flag should be false for
+  // the first partitioning but true for all subsequent partitioning.
+  //
+  // TODO(yuanbyu): We could also make the addition of the control
+  // flow code incremental based on 'node_to_loc'. This makes the
+  // communication a broadcast tree, which could be more efficient when
+  // the number of participating devices is large.
+  bool control_flow_added = false;
+
+  // A function that returns the data type into which the tensor
+  // should be cast before sent over the wire.
+  typedef std::function<DataType(const Edge*)> ShouldCastFunc;
+  ShouldCastFunc should_cast = nullptr;
+
+  // Schedule the execution of the recvs based on their start times
+  // computed by some scheduling algorithm. The recvs are divided into
+  // epochs based on their start times. A recv is enabled only when
+  // execution reaches its epoch - N for some predefined N.
+  bool scheduling_for_recvs = false;
+  // The start time for each node in the graph computed by some scheduling
+  // algorithm. If 'need_to_record_start_times' is true, we record them
+  // in the graph as a node attribute.
+  bool need_to_record_start_times = false;
+  std::vector<Microseconds> start_times;
+
+  // Optional customized function to compute the "tensor_name" attr value of
+  // Send/Recv ops inserted during partitioning.
+  std::function<string(const Edge*)> get_tensor_name_attr = nullptr;
+};
+
+// Partition "input" graph into a set of graphs, one per location.
+// The location for node n is derived by calling opts.node_to_loc(n).
+// New nodes added by Partition use "opts.new_name(old_name)" to
+// generate node names.
+//
+// Stores the partitions in *partitions.
+Status Partition(const PartitionOptions& opts, Graph* input,
+                 std::unordered_map<string, GraphDef>* partitions);
+
+// Add control edges to the partitions to control the ordering
+// and timing of the recv nodes based on the start times calculated
+// using some scheduling algorithm.
+Status AddControlEdges(const PartitionOptions& opts,
+                       std::unordered_map<string, GraphDef>* partitions);
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPH_GRAPH_PARTITION_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/mkl_graph_util.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/mkl_graph_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..993a66feca7a5456467861a26e7441c04cb42358
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/mkl_graph_util.h
@@ -0,0 +1,296 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPH_MKL_GRAPH_UTIL_H_
+#define TENSORFLOW_CORE_GRAPH_MKL_GRAPH_UTIL_H_
+#ifdef INTEL_MKL
+
+#include "absl/base/call_once.h"
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/types.pb.h"
+#include "tensorflow/core/graph/graph.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/platform/cpu_info.h"
+#include "tensorflow/core/util/env_var.h"
+#include "tensorflow/core/util/util.h"
+
+namespace tensorflow {
+// Since our ops are going to produce and also consume N addition tensors
+// (Mkl) for N Tensorflow tensors, we can have following different
+// orderings among these 2N tensors.
+//
+// E.g., for Tensorflow tensors A, B, and C, our ops will produce and
+// consume A_m, B_m, and C_m additionally.
+//
+// INTERLEAVED: in this case 2N tensors are interleaved. So for above
+//              example, the ordering looks like: A, A_m, B, B_m, C, C_m.
+//
+// CONTIGUOUS: in thi case N Tensorflow tensors are contiguous followed
+//             by N Mkl tensors. So for above example, the ordering looks
+//             like: A, B, C, A_m, B_m, C_m
+//
+// Following APIs map index of original Tensorflow tensors to their
+// appropriate position based on selected ordering. For contiguous ordering,
+// we need to know the total number of tensors (parameter total).
+//
+typedef enum { TENSORS_INTERLEAVED, TENSORS_CONTIGUOUS } MklTfTensorOrdering;
+// NOTE: Currently, we use contiguous ordering. If you change this, then you
+// would need to change Mkl op definitions in nn_ops.cc.
+static const MklTfTensorOrdering kTensorOrdering = TENSORS_CONTIGUOUS;
+
+// Get index of MetaData tensor from index 'n' of Data tensor.
+inline int DataIndexToMetaDataIndex(int n, int total_tensors) {
+  if (kTensorOrdering == MklTfTensorOrdering::TENSORS_INTERLEAVED) {
+    // For interleaved ordering, Mkl tensor follows immediately after
+    // Tensorflow tensor.
+    return n + 1;
+  } else {
+    CHECK_EQ(kTensorOrdering, MklTfTensorOrdering::TENSORS_CONTIGUOUS);
+    // For contiguous ordering, Mkl tensor is n+total_tensors / 2 away.
+    return n + total_tensors / 2;
+  }
+}
+
+int inline GetTensorDataIndex(int n, int total_tensors) {
+  if (kTensorOrdering == MklTfTensorOrdering::TENSORS_INTERLEAVED) {
+    return 2 * n;  // index corresponding to nth input/output tensor
+  } else {
+    CHECK_EQ(kTensorOrdering, MklTfTensorOrdering::TENSORS_CONTIGUOUS);
+    return n;
+  }
+}
+
+int inline GetTensorMetaDataIndex(int n, int total_tensors) {
+  // Get index for TensorData first and then use mapping function
+  // to get TensorMetaData index from TensorData index.
+  int tidx = GetTensorDataIndex(n, total_tensors);
+  return DataIndexToMetaDataIndex(tidx, total_tensors);
+}
+
+// check if the control between src and dst nodes already exists
+bool inline DoesControlEdgeExist(const Node* src, const Node* dst) {
+  for (const Edge* edge : src->out_edges()) {
+    if (edge->IsControlEdge() && edge->dst() == dst) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// In TF 2.8, oneDNN blocked format will not be supported.
+// TODO(intel_tf): Cleanup shall be done in future:
+//                 (1) Remove this method;
+//                 (2) Update related code wherever it is called.
+bool inline NativeFormatEnabled() { return true; }
+
+// Check if the data_format attribute in the node def represents 5D tensor
+bool inline Check5DFormat(const NodeDef& ndef) {
+  string data_format;
+  TF_CHECK_OK(GetNodeAttr(ndef, "data_format", &data_format));
+  if (data_format.compare("NCDHW") == 0 || data_format.compare("NDHWC") == 0) {
+    return true;
+  }
+  return false;
+}
+
+namespace mkl_op_registry {
+// MKL operators whose kernels are registered with 'MklLayoutDependentOp' label
+// (e.g., MklConv2D) understand input tensors in MKL layout. These operators
+// get additional meta-tensors for actual input tensors.
+static const char* kMklLayoutDependentOpLabel = "MklLayoutDependentOp";
+static const char* kMklLayoutDependentOpLabelPattern =
+    "label='MklLayoutDependentOp'";
+// MKL operators whose kernels are registered with 'MklNameChangeOp' label
+// (e.g., MklMatMul, MklTranspose) do not understand input tensors in MKL
+// layout. These operators do not get additional meta-tensors. The signatures of
+// these operators are the same as the original TensorFlow operators that they
+// correspond to. So these ops just go through a name change during graph
+// rewrite pass.
+static const char* kMklNameChangeOpLabel = "MklNameChangeOp";
+static const char* kMklNameChangeOpLabelPattern = "label='MklNameChangeOp'";
+static const char* kMklQuantizedOpLabel = "QuantizedMklOp";
+static const char* kMklQuantizedOpLabelPattern = "label='QuantizedMklOp'";
+
+// Prefix that we add to Tensorflow op name to construct Mkl op name.
+static const char* const kMklOpPrefix = "_Mkl";
+// TODO(intel-tf): PR review feedback (penpornk)
+// Can we add eager_mode (or is_eager) as an op attribute instead?
+// This way we don't need to rename the op just to pass eager_mode
+// through template parameter.
+static const char* const kMklEagerOpPrefix = "_MklEager";
+
+// Prefix that we add to TF op name to construct MKL op that does not
+// depend on layout propagation. It will be used in both Eager and graph
+// modes unless there is a reason to have additional op name with
+// _MklEager prefix.
+static const char* const kMklNativeOpPrefix = "_MklNative";
+
+// Get the name of Mkl Native (does not depend on layout propagation) op
+// from original TensorFlow op.
+inline string GetMklNativeOpName(const string& name) {
+  // There are few operators that don't depend on layout propagation but are
+  // prefixed with _Mkl instead of _MklNative.
+  bool result =
+      (0 == name.compare("ConjugateTranspose") ||
+       0 == name.compare("BatchMatMul") || 0 == name.compare("BatchMatMulV2") ||
+       0 == name.compare("Einsum") || 0 == name.compare("MatMul") ||
+       0 == name.compare("Transpose") || 0 == name.compare("QuantizeV2") ||
+       0 == name.compare("Dequantize") || 0 == name.compare("Softmax") ||
+       0 == name.rfind("Quantized", 0));
+
+  if (result) {
+    return string(kMklOpPrefix) + name;
+  } else {
+    return string(kMklNativeOpPrefix) + name;
+  }
+}
+
+// Get the name of Mkl op from original TensorFlow op
+// We prefix the original op with _Mkl or _MklNative to get Mkl op.
+inline string GetMklOpName(const string& name) {
+  if (!NativeFormatEnabled()) {
+    return string(kMklOpPrefix) + name;
+  } else {
+    return GetMklNativeOpName(name);
+  }
+}
+
+// Get the name of Mkl Eager op from original TensorFlow op
+// We prefix 'MklEager' to the original op to get Mkl Eager op.
+inline string GetMklEagerOpName(const string& name) {
+  return string(kMklEagerOpPrefix) + name;
+}
+
+static inline void BF16UnsupportedWarning() {
+  static absl::once_flag cpu_bfloat16_warn_once_flag;
+  absl::call_once(cpu_bfloat16_warn_once_flag, [] {
+    LOG(ERROR) << "oneDNN BFloat16 support are only on platforms with AVX512. "
+                  "Falling back to default implementation if present.";
+  });
+}
+
+// Check whether opname with type T is registered as MKL operator
+// that will go through name change or layout change pass.
+//
+// @input: name of the op
+// @input: T datatype to be used for checking op
+// @return: true if opname is registered as MKL op that will go through name
+// change or layout change pass; false otherwise
+static inline bool IsMklOp(const string& op_name, DataType T,
+                           bool is_native_op) {
+  string label = is_native_op ? kMklNameChangeOpLabelPattern
+                              : kMklLayoutDependentOpLabelPattern;
+  string registered_kernels_key = op_name + label + std::to_string(T);
+  thread_local static auto registered_kernels_map =
+      std::make_unique<absl::flat_hash_map<string, bool>>();
+  auto kernel_element = registered_kernels_map->find(registered_kernels_key);
+  bool kernel_registered = false;
+
+  if (kernel_element == registered_kernels_map->end()) {
+    string registered_kernels = KernelsRegisteredForOp(op_name);
+    // String returned by KernelsRegisteredForOp looks like below:
+    //
+    // Op = _MklMatMul, kernels =
+    // device='CPU'; label='MklNameChangeOp'; T in [DT_COMPLEX128]
+    // device='CPU'; label='MklNameChangeOp'; T in [DT_COMPLEX64]
+    // device='CPU'; label='MklNameChangeOp'; T in [DT_DOUBLE]
+    // device='CPU'; label='MklNameChangeOp'; T in [DT_FLOAT]
+
+    if (is_native_op &&
+        registered_kernels.find(kMklQuantizedOpLabelPattern) != string::npos) {
+      // Restrict quantized ops to QUINT8, QINT8 and DT_QINT32
+      kernel_registered = (T == DT_QUINT8 || T == DT_QINT8 || T == DT_QINT32);
+    }
+
+    // Now we just construct a search string to match what we are looking for.
+    string search_string =
+        label + string("; T in [") + DataType_Name(T) + string("]");
+
+    if (registered_kernels.find(search_string) != string::npos) {
+      kernel_registered = is_native_op
+                              ? (T == DT_COMPLEX128 || T == DT_COMPLEX64 ||
+                                 T == DT_DOUBLE || T == DT_FLOAT)
+                              : T == DT_FLOAT;
+      if (!kernel_registered) {
+        if (T == DT_BFLOAT16) {
+          if (IsBF16SupportedByOneDNNOnThisCPU()) {
+            kernel_registered = true;
+          } else {
+            // Restrict bfloat16 ops to platforms with at least AVX512 support,
+            // fall back to Eigen implementation otherwise.
+            BF16UnsupportedWarning();
+            kernel_registered = false;
+          }
+        }
+      }
+    }
+    registered_kernels_map->insert(
+        std::make_pair(registered_kernels_key, kernel_registered));
+  } else {
+    // Kernel is visited at least once. Return stored registration result.
+    kernel_registered = kernel_element->second;
+  }
+  return kernel_registered;
+}
+
+// TODO(intel-tf): QuantizedConv2D is registered with input: QUINT8
+// filter:QINT8 for oneDNN integration. First a dummy kernel is created
+// and then it is replaced by an actual kernel.
+static inline bool IsMklQuantizedOp(const string& op_name, DataType Tinput,
+                                    DataType Tfilter) {
+  // Restrict quantized ops to QUINT8 and QINT8 for now
+  if (IsMklOp(op_name, Tinput, kMklQuantizedOpLabelPattern)) {
+    return (Tfilter == DT_QINT8);
+  }
+  return false;
+}
+
+// Check if the operator with 'op_name' and type 'T' is an MKL operator that
+// will either understand input tensors in MKL layout or will go through name
+// rewrite that some operators go through.
+static inline bool IsMklOp(const string& op_name, DataType T) {
+  return IsMklOp(op_name, T, true) || IsMklOp(op_name, T, false);
+}
+
+static inline bool IsMklOp(const Node* n) {
+  DataType T;
+  return GetNodeAttr(n->def(), "T", &T).ok() && IsMklOp(n->type_string(), T);
+}
+
+// Check whether opname with type T is registered as MKL-compliant and
+// is element-wise.
+//
+// @input: name of the op
+// @input: T datatype to be used for checking op
+// @return: true if opname is registered as element-wise Mkl op;
+// false otherwise
+static inline bool IsMklElementWiseOp(const string& op_name, DataType T) {
+  if (!IsMklOp(op_name, T)) {
+    return false;
+  }
+  bool result = (0 == op_name.compare(GetMklOpName("Add")) ||
+                 0 == op_name.compare(GetMklOpName("AddV2")) ||
+                 0 == op_name.compare(GetMklOpName("Sub")) ||
+                 0 == op_name.compare(GetMklOpName("Mul")) ||
+                 0 == op_name.compare(GetMklOpName("Maximum")) ||
+                 0 == op_name.compare(GetMklOpName("Sigmoid")) ||
+                 0 == op_name.compare(GetMklOpName("SquaredDifference")));
+
+  return result;
+}
+}  // namespace mkl_op_registry
+}  // namespace tensorflow
+#endif  // INTEL_MKL
+#endif  // TENSORFLOW_CORE_GRAPH_MKL_GRAPH_UTIL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/node_builder.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/node_builder.h
new file mode 100644
index 0000000000000000000000000000000000000000..c8325e3934fda20ed2f52089afd43b4a4cd2c78f
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/node_builder.h
@@ -0,0 +1,179 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPH_NODE_BUILDER_H_
+#define TENSORFLOW_CORE_GRAPH_NODE_BUILDER_H_
+
+#include <vector>
+#include "tensorflow/core/framework/node_def_builder.h"
+#include "tensorflow/core/framework/op.h"
+#include "tensorflow/core/framework/op_def.pb.h"
+#include "tensorflow/core/graph/graph.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/lib/core/stringpiece.h"
+#include "tensorflow/core/lib/gtl/array_slice.h"
+
+namespace tensorflow {
+
+// This is a helper for creating a Node and adding it to a Graph.
+// Internally, it uses a NodeDefBuilder to automatically set attrs
+// that can be inferred from the inputs, and use default values
+// (where they exist) for unspecified attrs.  Example usage:
+//
+//  Node* node;
+//  Status status = NodeBuilder(node_name, op_name)
+//                           .Input(...)
+//                           .Attr(...)
+//                           .Finalize(&graph, &node);
+//  if (!status.ok()) return status;
+//  // Use node here.
+class NodeBuilder {
+ public:
+  // For specifying the output of a Node to provide to one of the Input()
+  // functions below.  It supports both regular inputs (where you are
+  // connecting to an existing Node*), and inputs from outside the graph
+  // (or haven't been added to the graph yet, like back edges, where
+  // you don't have a Node*). Both types can be mixed, e.g. in an
+  // ArraySlice.
+  struct NodeOut {
+    // For referencing an existing Node.
+    NodeOut(Node* n, int32_t i = 0);
+    NodeOut(OutputTensor t);
+
+    // For referencing Nodes not in the graph being built. It is
+    // useful when preparing a graph for ExtendSession or creating a
+    // back edge to a node that hasn't been added to the graph yet,
+    // but will be.
+    NodeOut(StringPiece name, int32_t i, DataType t);
+
+    // Default constructor for std::vector<NodeOut>.
+    NodeOut();
+
+    Node* node;
+    // error is set to true if:
+    // * the NodeOut was default constructed and never overwritten,
+    // * a nullptr Node* was passed to the NodeOut constructor, or
+    // * an out-of-range index was passed to the NodeOut constructor.
+    bool error;
+    string name;
+    int32 index;
+    DataType dt;
+  };
+
+  // Specify the name and the Op (either via an OpDef or the name of
+  // the Op plus a registry) for the Node.  Other fields are
+  // specified by calling the methods below.
+  // REQUIRES: The OpDef must satisfy ValidateOpDef().
+  NodeBuilder(StringPiece name, StringPiece op_name,
+              const OpRegistryInterface* op_registry = OpRegistry::Global(),
+              const NodeDebugInfo* debug = nullptr);
+  NodeBuilder(StringPiece name, const OpDef* op_def);
+
+  // Create a NodeBuilder from an existing NodeDefBuilder.
+  NodeBuilder(const NodeDefBuilder& def_builder);
+
+  // You must call one Input() function per input_arg in the Op,
+  // *and in the same order as the input_args appear in the OpDef.*
+
+  // For inputs that take a single tensor.
+  NodeBuilder& Input(Node* src_node, int src_index = 0);
+  NodeBuilder& Input(NodeOut src);
+
+  // For inputs that take a list of tensors.
+  NodeBuilder& Input(gtl::ArraySlice<NodeOut> src_list);
+
+  // Require that this node run after src_node(s).
+  NodeBuilder& ControlInput(Node* src_node);
+  NodeBuilder& ControlInputs(gtl::ArraySlice<Node*> src_nodes);
+
+  // Sets the "requested device spec" in the NodeDef (not the
+  // "assigned device" in the Node).
+  NodeBuilder& Device(StringPiece device_spec);
+
+  // Sets the device name in the "assigned device" field in tensorflow::Node.
+  NodeBuilder& AssignedDevice(StringPiece device);
+
+  // Sets the _XlaCluster attribute in created node to `xla_cluster`.
+  NodeBuilder& XlaCluster(StringPiece xla_cluster);
+
+  // Set the value of an attr.  attr_name must match the name of one of
+  // attrs defined by the Op, and value must have the corresponding type
+  // (see SetAttrValue() in ../framework/attr_value_util.h for legal
+  // types for value).  Note that attrs will be set automatically if
+  // they can be determined by the inputs.
+  template <class T>
+  NodeBuilder& Attr(StringPiece attr_name, T&& value);
+  template <class T>
+  NodeBuilder& Attr(StringPiece attr_name, std::initializer_list<T> value);
+
+  // Validates the described node and adds it to *graph, adding edges
+  // for all (non-back) inputs.  If created_node is not nullptr,
+  // *created_node will be set to the new node (or nullptr on error).
+  // If `consume` is true, the builder state will be moved into `node_def`,
+  // and the builder will be left in an undefined state.
+  Status Finalize(Graph* graph, Node** created_node, bool consume = false);
+
+  // Same as `Finalize` above, but using StatusOr to return value. Preferred
+  // form.
+  StatusOr<Node*> Finalize(Graph* graph, bool consume = false);
+
+  // Accessors for the values set in the constructor.
+  const string& node_name() const { return def_builder_.node_name(); }
+  const OpDef& op_def() const { return def_builder_.op_def(); }
+
+ private:
+  static DataType SafeGetOutput(const Node* node, int i, bool* error) {
+    if (node != nullptr && i >= 0 && i < node->num_outputs()) {
+      *error = false;
+      return node->output_type(i);
+    } else {
+      *error = true;
+      return DT_FLOAT;
+    }
+  }
+
+  // If SafeGetOutput indicates a range error, add it to errors_.
+  void AddIndexError(const Node* node, int i);
+
+  // Set *dt and returns true if i is in range. Combines
+  // SafeGetOutput() and AddIndexError().
+  bool GetOutputType(const Node* node, int i, DataType* dt);
+
+  NodeDefBuilder def_builder_;
+  const OpRegistryInterface* op_registry_;
+  std::vector<NodeOut> inputs_;
+  std::vector<Node*> control_inputs_;
+  std::vector<string> errors_;
+  string assigned_device_;
+};
+
+// IMPLEMENTATION -------------------------------------------------------------
+
+template <class T>
+NodeBuilder& NodeBuilder::Attr(StringPiece attr_name, T&& value) {
+  def_builder_.Attr(attr_name, std::forward<T>(value));
+  return *this;
+}
+
+template <class T>
+NodeBuilder& NodeBuilder::Attr(StringPiece attr_name,
+                               std::initializer_list<T> value) {
+  def_builder_.Attr(attr_name, value);
+  return *this;
+}
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPH_NODE_BUILDER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/optimizer_cse.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/optimizer_cse.h
new file mode 100644
index 0000000000000000000000000000000000000000..ef466fb7880d4ece046d0c4006c8f06a3f2d518c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/optimizer_cse.h
@@ -0,0 +1,37 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// An optimization pass that performs common subexpression elimination.
+
+#ifndef TENSORFLOW_CORE_GRAPH_OPTIMIZER_CSE_H_
+#define TENSORFLOW_CORE_GRAPH_OPTIMIZER_CSE_H_
+
+#include <sys/types.h>
+#include "tensorflow/core/graph/graph.h"
+
+namespace tensorflow {
+
+// Perform common-subexpression elimination on the graph "*g".  If
+// "consider_fn" is not nullptr, then only nodes for which
+// consider_fn(node) returns true will be considered for combining
+// during the common subexpression elimination.
+//
+// Returns true if and only if 'g' is mutated.
+extern bool OptimizeCSE(Graph* g,
+                        const std::function<bool(const Node*)>& consider_fn);
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPH_OPTIMIZER_CSE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/regularization/util.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/regularization/util.h
new file mode 100644
index 0000000000000000000000000000000000000000..6769ad34acb498766f5892e3dc4628b43b79c7bc
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/regularization/util.h
@@ -0,0 +1,35 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPH_REGULARIZATION_UTIL_H_
+#define TENSORFLOW_CORE_GRAPH_REGULARIZATION_UTIL_H_
+
+#include <cstdint>
+
+#include "tensorflow/core/framework/graph.pb.h"
+#include "tensorflow/core/platform/statusor.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow::graph_regularization {
+
+// Computes the Fingerprint64 hash of the GraphDef.
+uint64 ComputeHash(const GraphDef& graph_def);
+
+// Returns the suffix UID of `function_name`, returns an error if there is none.
+StatusOr<int64_t> GetSuffixUID(absl::string_view function_name);
+
+}  // namespace tensorflow::graph_regularization
+
+#endif  // TENSORFLOW_CORE_GRAPH_REGULARIZATION_UTIL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/subgraph.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/subgraph.h
new file mode 100644
index 0000000000000000000000000000000000000000..76e7ea178227834d56faa765d0ddd5b3f6b0a525
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/subgraph.h
@@ -0,0 +1,165 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPH_SUBGRAPH_H_
+#define TENSORFLOW_CORE_GRAPH_SUBGRAPH_H_
+
+#include <string>
+
+#include "tensorflow/core/framework/device_attributes.pb.h"
+#include "tensorflow/core/graph/graph.h"
+#include "tensorflow/core/graph/node_builder.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/lib/gtl/array_slice.h"
+#include "tensorflow/core/protobuf/config.pb.h"
+
+namespace tensorflow {
+namespace subgraph {
+
+// Information about a graph rewritten by `RewriteGraphForExecution()`.
+struct RewriteGraphMetadata {
+  // The element type of each tensor fed to this subgraph. The order
+  // of types corresponds to the order of tensor names in
+  // `fed_outputs` when calling `RewriteGraphForExecution()`.
+  DataTypeVector feed_types;
+  // The element type of each tensor fetched from this subgraph. The
+  // order of types corresponds to the order of tensor names in
+  // `fetch_outputs` when calling `RewriteGraphForExecution()`.
+  DataTypeVector fetch_types;
+};
+
+// Describes the action to take on a particular tensor endpoint (described by
+// a "<node_name>:<output_index>" pair) when pruning the graph.
+//
+// The `AddNode()` method must be overridden to describe this action. The method
+// will be invoked once during `RewriteGraphForExecution()` with tensor endpoint
+// named by `endpoint_name`, and it may either create a single new node, or fail
+// with an error if the resulting graph would be invalid.
+class PruneRewrite {
+ public:
+  // `endpoint_name` and `device_info` must outlive this object.
+  PruneRewrite(const string* endpoint_name, const DeviceAttributes* device_info)
+      : endpoint_name_(endpoint_name), device_info_(device_info) {}
+  virtual ~PruneRewrite() {}
+
+  // Creates a new node whose output replaces the given `tensor` in graph `g`.
+  // The node will be assigned to the device named in `device_info`.
+  virtual Status AddNode(Graph* g, NodeBuilder::NodeOut tensor,
+                         Node** out_node) = 0;
+
+  // Returns the name of the tensor to which this rewrite applies.
+  const string& endpoint_name() { return *endpoint_name_; }
+
+ protected:
+  // The device on which the new node will be created.
+  const DeviceAttributes& device_info() { return *device_info_; }
+
+ private:
+  const string* const endpoint_name_;          // Not owned.
+  const DeviceAttributes* const device_info_;  // Not owned.
+};
+
+// Rewrite the graph structure of "*g" to deal with feeding node
+// outputs, fetching node outputs, and only running a subset of the
+// graph.  "fed_outputs" and "fetch_outputs" are both lists of
+// output tensor identifiers in the form of
+// "<name>[:<optional_output_index>]", and "target_nodes_str" is a
+// lists of target node names in "*g" "g".
+//
+// In the resulting graph "*g", output edges in "fed_outputs" have
+// been redirected to special "_recv" nodes introduced into the graph.
+// If these fed nodes are not needed in order to compute the effects
+// of the nodes in "target_node_names" and "fetch_outputs", then these may
+// be omitted from the graph.
+//
+// In the resulting graph "*g", additional "_send" nodes are connected
+// to every output in "fetch_outputs".  These "_send" nodes are set up
+// to execute on the device described by device_info.
+//
+// On success, returns OK, and sets "*g" to a version of "*g"
+// that represents the portions of the graph necessary for producing
+// the output of all nodes listed in "target_node_names" and fetching the
+// specific node outputs specified in "fetch_outputs".
+//
+// On failure, returns the error status. Possible errors include:
+//    - fed output "node:output_index" does not exist in "*g"
+//    - fetch output "node:output_index" does not exist in "*g"
+//    - target node "node" does not exist in "*g"
+Status RewriteGraphForExecution(
+    Graph* g, const gtl::ArraySlice<string>& fed_outputs,
+    const gtl::ArraySlice<string>& fetch_outputs,
+    const gtl::ArraySlice<string>& target_node_names,
+    const DeviceAttributes& device_info, bool use_function_convention,
+    RewriteGraphMetadata* out_metadata);
+
+// A more general version of the above function that supports
+// customizable rewriting actions for each fed and fetched tensor.
+Status RewriteGraphForExecution(
+    Graph* g, const std::vector<std::unique_ptr<PruneRewrite>>& feed_rewrites,
+    const std::vector<std::unique_ptr<PruneRewrite>>& fetch_rewrites,
+    const gtl::ArraySlice<string>& target_node_names,
+    RewriteGraphMetadata* out_metadata);
+
+/////////////////////////////////////////////////////////
+// Custom rewrite actions for fed and fetched tensors. //
+/////////////////////////////////////////////////////////
+
+// A rewrite action that adds an _Arg node for a fed tensor.
+class ArgFeedRewrite : public PruneRewrite {
+ public:
+  ArgFeedRewrite(const string* endpoint_name,
+                 const DeviceAttributes* device_info, int32_t arg_index)
+      : PruneRewrite(endpoint_name, device_info), arg_index_(arg_index) {}
+  Status AddNode(Graph* g, NodeBuilder::NodeOut feed_tensor,
+                 Node** out_node) override;
+
+ private:
+  const int32 arg_index_;
+};
+
+// A rewrite action that adds a client-terminated _Recv node for a fed tensor.
+class RecvFeedRewrite : public PruneRewrite {
+ public:
+  using PruneRewrite::PruneRewrite;
+  Status AddNode(Graph* g, NodeBuilder::NodeOut feed_tensor,
+                 Node** out_node) override;
+};
+
+// A rewrite action that adds a _Retval node for a fetched tensor.
+class RetvalFetchRewrite : public PruneRewrite {
+ public:
+  RetvalFetchRewrite(const string* endpoint_name,
+                     const DeviceAttributes* device_info, int32_t retval_index)
+      : PruneRewrite(endpoint_name, device_info), retval_index_(retval_index) {}
+  Status AddNode(Graph* g, NodeBuilder::NodeOut fetch_tensor,
+                 Node** out_node) override;
+
+ private:
+  const int32 retval_index_;
+};
+
+// A rewrite action that adds a client-terminated _Send node for a
+// fetched tensor.
+class SendFetchRewrite : public PruneRewrite {
+ public:
+  using PruneRewrite::PruneRewrite;
+  Status AddNode(Graph* g, NodeBuilder::NodeOut fetch_tensor,
+                 Node** out_node) override;
+};
+
+}  // namespace subgraph
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPH_SUBGRAPH_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/tensor_id.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/tensor_id.h
new file mode 100644
index 0000000000000000000000000000000000000000..c593f96b0b329d348b9c174f45fbe42584373427
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/tensor_id.h
@@ -0,0 +1,94 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPH_TENSOR_ID_H_
+#define TENSORFLOW_CORE_GRAPH_TENSOR_ID_H_
+
+#include <string>
+
+#include "tensorflow/core/graph/graph.h"
+#include "tensorflow/core/lib/core/stringpiece.h"
+#include "tensorflow/core/lib/hash/hash.h"
+#include "tensorflow/core/lib/strings/strcat.h"
+
+namespace tensorflow {
+
+struct SafeTensorId;
+
+// Identifier for a tensor within a step.
+// first == operation_name, second == output_index
+// Note: does not own backing storage for name.
+struct TensorId : public std::pair<StringPiece, int> {
+  typedef std::pair<StringPiece, int> Base;
+
+  // Inherit the set of constructors.
+  using Base::pair;
+
+  // NOTE(skyewm): this is required on some platforms. I'm not sure why the
+  // using statement above isn't always sufficient.
+  TensorId() : Base() {}
+  TensorId(const SafeTensorId& id);
+
+  const StringPiece node() const { return first; }
+  int index() const { return second; }
+
+  string ToString() const {
+    if (second == Graph::kControlSlot) return strings::StrCat("^", first);
+    return strings::StrCat(first, ":", second);
+  }
+
+  struct Hasher {
+   public:
+    std::size_t operator()(const TensorId& x) const {
+      return Hash32(x.first.data(), x.first.size(), x.second);
+    }
+  };
+};
+
+TensorId ParseTensorName(const string& name);
+TensorId ParseTensorName(StringPiece name);
+
+bool IsTensorIdControl(const TensorId& tensor_id);
+
+// Same as TensorId, except owns the backing storage for the op name. This makes
+// the memory management simpler at the expense of a copy.
+struct SafeTensorId : public std::pair<string, int> {
+  typedef std::pair<string, int> Base;
+
+  // NOTE(skyewm): this is required on some platforms. I'm not sure why the
+  // using "using Base::pair;" isn't always sufficient.
+  SafeTensorId() : Base() {}
+  SafeTensorId(const string& str, int idx) : Base(str, idx) {}
+  SafeTensorId(const TensorId& id);
+
+  const string& node() const { return first; }
+  int index() const { return second; }
+
+  string ToString() const {
+    if (second == Graph::kControlSlot) return strings::StrCat("^", first);
+    return strings::StrCat(first, ":", second);
+  }
+
+  struct Hasher {
+   public:
+    std::size_t operator()(const TensorId& x) const {
+      return Hash32(x.first.data(), x.first.size(), x.second);
+    }
+  };
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPH_TENSOR_ID_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/testlib.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/testlib.h
new file mode 100644
index 0000000000000000000000000000000000000000..185ad3f92b0d0780cc2072e782a8fef038d31704
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/testlib.h
@@ -0,0 +1,230 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// DEPRECATED: Use the C++ API defined in tensorflow/cc instead.
+
+#ifndef TENSORFLOW_CORE_GRAPH_TESTLIB_H_
+#define TENSORFLOW_CORE_GRAPH_TESTLIB_H_
+
+#include <string>
+#include <vector>
+
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/tensor_shape.h"
+#include "tensorflow/core/graph/graph.h"
+#include "tensorflow/core/graph/types.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+namespace test {
+namespace graph {
+
+// Converts "g" into its corresponding GraphDef "def".
+ABSL_DEPRECATED("Call g->ToGraphDef(def) instead.")
+void ToGraphDef(Graph* g, GraphDef* def);
+
+// A few helpers to construct a graph.
+
+// Adds a node in "g" producing a constant "tensor".
+Node* Constant(Graph* g, const Tensor& tensor);
+Node* Constant(Graph* g, const Tensor& tensor, const string& name);
+
+// Adds a node in "g" producing a constant "tensor" on the host.
+// The given node which, unlike the regular Constant above, always
+// stores its output on the host.  This is necessary for use
+// in GPU tests where the test Op in question runs on the device
+// but requires some arguments to be pinned to the host.
+Node* HostConstant(Graph* g, const Tensor& tensor);
+Node* HostConstant(Graph* g, const Tensor& tensor, const string& name);
+
+// Adds a variable in "g" of the given "shape" and "dtype".
+Node* Var(Graph* g, const DataType dtype, const TensorShape& shape);
+Node* Var(Graph* g, const DataType dtype, const TensorShape& shape,
+          const string& name);
+
+// Adds an assign node in "g" which assigns "val" into "var".
+Node* Assign(Graph* g, Node* var, Node* val);
+
+// Adds a send node "g" sending "input" as a named "tensor" from
+// "sender" to "receiver".
+Node* Send(Graph* g, Node* input, const string& tensor, const string& sender,
+           const uint64 sender_incarnation, const string& receiver);
+
+// Adds a recv node in "g" receiving a named "tensor" from "sender"
+// to "receiver".
+Node* Recv(Graph* g, const string& tensor, const string& type,
+           const string& sender, const uint64 sender_incarnation,
+           const string& receiver);
+
+// Adds a cumsum "node" in "g" doing cumsum(data, axes).
+Node* Cumsum(Graph* g, Node* data, Node* axes, bool exclusive = false,
+             bool reverse = false);
+
+// Adds a reduction "node" in "g" doing sum(data, axes).  "reduce" is
+// a reduction, e.g., Sum, Max, Min, Mean, etc.
+Node* Reduce(Graph* g, const string& reduce, Node* data, Node* axes,
+             bool keep_dims = false);
+
+// Adds a Matmul node in g doing in0.contract(in1).
+Node* Matmul(Graph* g, Node* in0, Node* in1, bool transpose_a,
+             bool transpose_b);
+
+// Adds a Matmul node in g doing in0.contract(in1).
+Node* BatchMatmul(Graph* g, Node* in0, Node* in1, bool adj_x, bool adj_y);
+
+// Adds a Quantize node into g that quantize floats into QUINT8. The range of
+// the input float tensor is assumed to be [-1, 1].
+Node* QuantizeToUINT8(Graph* g, Node* data);
+
+// Adds a unary function "func" "node" in "g" taking "input".
+Node* Unary(Graph* g, const string& func, Node* input, int index = 0);
+
+// Adds an identity node in "g" taking "input" and producing an
+// identity copy.
+Node* Identity(Graph* g, Node* input, int index = 0);
+
+// Adds a binary function "func" node in "g" taking "in0" and "in1".
+Node* Binary(Graph* g, const string& func, Node* in0, Node* in1);
+
+// Adds a function "func" node in "g" taking inputs "ins".
+Node* Multi(Graph* g, const string& func, gtl::ArraySlice<Node*> ins);
+
+// Adds a binary add node in "g" doing in0 + in1.
+Node* Add(Graph* g, Node* in0, Node* in1);
+
+// Reverses <axis> dimensions of <tensor>>
+Node* Reverse(Graph* g, Node* tensor, Node* axis);
+
+// Generates random unit uniform distribution of the input shape.
+Node* RandomUniform(Graph* g, Node* input, DataType dtype);
+
+// Generates random unit normal distribution of the input shape.
+Node* RandomGaussian(Graph* g, Node* input, DataType dtype);
+
+// Generates random gamma distribution with the given shape and alpha[s].
+// Output dtype determined by alpha.
+Node* RandomGamma(Graph* g, Node* shape, Node* alpha);
+
+// Generates random poisson distribution with the given shape and lam[s].
+// Output dtype determined by lam.
+Node* RandomPoisson(Graph* g, Node* shape, Node* lam);
+
+// Rolls tensor by an offset of <shift> along the corresponding
+// <axis> dimensions.
+Node* Roll(Graph* g, Node* input, Node* shift, Node* axis);
+
+// Generates random parameters from the truncated standard normal distribution
+// of the input shape
+Node* TruncatedNormal(Graph* g, Node* input, DataType dtype);
+
+// Adds an error node in "g". The node's computation always
+// generates an error with the given error message "errmsg".
+Node* Error(Graph* g, Node* input, const string& errmsg,
+            bool log_error = false);
+
+// Adds a node that generates a invalid ref output.
+Node* InvalidRefType(Graph* g, DataType out_type, DataType invalid_type);
+
+// Adds a node in "g". Its Compute() sleeps a while and outputs the
+// input (i.e., same as identity).
+Node* Delay(Graph* g, Node* input, Microseconds delay_micros);
+
+// Adds a no-op "node" in "g", with control inputs from all nodes in
+// control_inputs vector.
+Node* NoOp(Graph* g, const std::vector<Node*>& control_inputs);
+
+// Adds a Switch node in "g". If "in1" is true, it forwards "in0" to
+// output 1. Otherwise, it forwards "in0" to output 0.
+Node* Switch(Graph* g, Node* in0, Node* in1);
+
+// Adds an Enter node in "g", which enters a new frame.
+Node* Enter(Graph* g, Node* input, const string& frame_name);
+
+// Adds an Exit node in "g", which exits a frame.
+Node* Exit(Graph* g, Node* input);
+
+// Adds a Merge node in "g" with two inputs "in0" and "in1".
+Node* Merge(Graph* g, Node* in0, Node* in1);
+
+// Adds a Merge node in "g". The first input is "in0", the remaining
+// inputs are only given by their names in remaining_in.
+Node* Merge(Graph* g, Node* in0, gtl::ArraySlice<string> remaining_in);
+
+// Adds a NextIteration node in "g", which makes its input available
+// to the next iteration.
+Node* Next(Graph* g, const string& name, Node* input);
+
+// Adds a LoopCond node in "g", representing the "pivot" termination
+// condition of a loop.
+Node* LoopCond(Graph* g, Node* input);
+
+// Adds a less node in "g", which returns true iff "in0" < "in1".
+Node* Less(Graph* g, Node* in0, Node* in1);
+
+// Adds a select node in "g", which outputs either "inx" or "iny"
+// depending on the boolean value of "c".
+Node* Select(Graph* g, Node* c, Node* inx, Node* iny);
+
+// Casts "in" into data type "dst".
+Node* Cast(Graph* g, Node* in, DataType dst);
+
+// Perform gather op on params "in0" with indices "in1" and axis "axis".
+Node* Gather(Graph* g, Node* in0, Node* in1, Node* axis);
+
+// Gets a tensor stored in the session state.
+Node* GetSessionTensor(Graph* g, Node* in);
+
+// Adds a Concat node in "g". The first input is "concat_dim", the
+// dimension to concatenate on, and the tensors to concatenate are
+// given in "tensors".
+Node* Concat(Graph* g, Node* concat_dim, gtl::ArraySlice<Node*> tensors);
+
+// Adds a ConcatV2 node in "g". The last input is "concat_dim", the
+// dimension to concatenate on, and the tensors to concatenate are
+// given in "tensors".
+Node* ConcatV2(Graph* g, gtl::ArraySlice<Node*> tensors, Node* concat_dim);
+
+// Add a Relu node in "g".
+Node* Relu(Graph* g, Node* in);
+
+// Add a Relu6 node in "g".
+Node* Relu6(Graph* g, Node* in);
+
+// Add a BiasAdd node in "g".
+Node* BiasAdd(Graph* g, Node* value, Node* bias);
+
+// Add a Conv2D node in "g".
+Node* Conv2D(Graph* g, Node* in0, Node* in1);
+
+// Add a Diag node in "g".
+Node* Diag(Graph* g, Node* in, DataType type);
+
+// Add a DiagPart node in "g".
+Node* DiagPart(Graph* g, Node* in, DataType type);
+
+// Add a CheckNumerics node in "g".
+Node* CheckNumerics(Graph* g, Node* in, const string& message);
+
+// Add an _Arg node in "g".
+Node* Arg(Graph* g, int64_t index, DataType type);
+
+// Add a _Retval node in "g".
+Node* Retval(Graph* g, int64_t index, Node* in, int64_t in_index = 0);
+
+}  // end namespace graph
+}  // end namespace test
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPH_TESTLIB_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/types.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/types.h
new file mode 100644
index 0000000000000000000000000000000000000000..05dd03ab4ecdc629101ac09c5d9b8b5a2d0b31b6
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/types.h
@@ -0,0 +1,35 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPH_TYPES_H_
+#define TENSORFLOW_CORE_GRAPH_TYPES_H_
+
+#include "tensorflow/core/lib/gtl/int_type.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+
+// We model running time in microseconds.
+TSL_LIB_GTL_DEFINE_INT_TYPE(Microseconds, int64_t);
+
+// We can also model running time in nanoseconds for more accuracy.
+TSL_LIB_GTL_DEFINE_INT_TYPE(Nanoseconds, int64_t);
+
+// We model size in bytes.
+TSL_LIB_GTL_DEFINE_INT_TYPE(Bytes, int64_t);
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPH_TYPES_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/validate.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/validate.h
new file mode 100644
index 0000000000000000000000000000000000000000..bfb3a25ac91761449b1762fa2125d7758cc8c560
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/validate.h
@@ -0,0 +1,68 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPH_VALIDATE_H_
+#define TENSORFLOW_CORE_GRAPH_VALIDATE_H_
+
+#include "tensorflow/core/framework/graph.pb.h"
+#include "tensorflow/core/framework/op.h"
+#include "tensorflow/core/graph/graph.h"
+#include "tensorflow/core/lib/core/status.h"
+
+namespace tensorflow {
+namespace graph {
+
+// Returns OK if every NodeDef in `graph_def` is valid with respect to
+// its corresponding OpDef (as defined by ValidateNodeDef()) as
+// registered in `op_registry`.  Also checks for deprecated ops.
+//
+// REQUIRES:
+//  * `op_registry` is not nullptr.
+//  * `graph_def` has default attrs filled in (see AddDefaultAttrsToGraphDef()).
+Status ValidateGraphDef(const GraphDef& graph_def,
+                        const OpRegistryInterface& op_registry);
+
+// Like ValidateGraphDef() except it makes a copy of `graph_def` and calls
+// AddDefaultAttrsToGraphDef() on the copy, removing that requirement from the
+// caller.
+Status ValidateGraphDefAgainstOpRegistry(
+    const GraphDef& graph_def, const OpRegistryInterface& op_registry);
+
+// Like ValidateGraphDefAgainstOpRegistry() except it takes an OpList
+// instead of an OpRegistryInterface.  Note that the OpList need not
+// have descriptions, which can be a big space savings, see
+// GetOpListForValidation() below.
+Status ValidateGraphDefAgainstOpList(const GraphDef& graph_def,
+                                     const OpList& op_list);
+
+// Get an OpList from `*op_registry` with all the descriptions removed.
+void GetOpListForValidation(
+    OpList* op_list, const OpRegistry& op_registry = *OpRegistry::Global());
+
+// Validate that the graph has no cycle except for legal while loop cycles.
+// This traverses the specified nodes in topological order to verify there are
+// no cycles. Starting with inputless nodes, it visits nodes whose inputs have
+// all been visited, and counts the total number of visited nodes. If there is a
+// cycle, nodes in the cycle will never be visited, and the visited count will
+// be less than the total node count.
+Status ValidateGraphHasNoCycle(const Graph& graph);
+
+// Returns OK if the graph has no duplicate node names.
+Status VerifyNoDuplicateNodeNames(const GraphDef& graph);
+
+}  // namespace graph
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPH_VALIDATE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/while_context.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/while_context.h
new file mode 100644
index 0000000000000000000000000000000000000000..5405e62be2f3c579a9444cd77665633456d2c2f8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/while_context.h
@@ -0,0 +1,76 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPH_WHILE_CONTEXT_H_
+#define TENSORFLOW_CORE_GRAPH_WHILE_CONTEXT_H_
+
+#include "tensorflow/core/graph/graph.h"
+
+namespace tensorflow {
+
+// Information about a while loop. Every user-defined while loop has an
+// associated WhileContext, i.e., there is a WhileContext for every execution
+// frame. Created with the while loop and used during gradient
+// construction. Note that the gradient graph of while loop contains while loops
+// itself, but these do not generate separate WhileContexts.
+//
+// TODO(skyewm): this is currently insufficient to handle nested loops and
+// conditionals (and possibly other requirements). This may change a lot in the
+// future to support these features.
+//
+// TODO(skyewm): de/serialize in MetaGraphDef so imported while loops will be
+// differentiable. Figure out backwards compatibility story.
+class WhileContext {
+ public:
+  WhileContext(StringPiece frame_name, std::vector<Node*> enter_nodes,
+               std::vector<Node*> exit_nodes, OutputTensor cond_output,
+               std::vector<OutputTensor> body_inputs,
+               std::vector<OutputTensor> body_outputs);
+
+  const string& frame_name() const { return frame_name_; }
+  const std::vector<Node*>& enter_nodes() const { return enter_nodes_; }
+  const std::vector<Node*>& exit_nodes() const { return exit_nodes_; }
+  const OutputTensor& cond_output() const { return cond_output_; }
+  const std::vector<OutputTensor>& body_inputs() const { return body_inputs_; }
+  const std::vector<OutputTensor>& body_outputs() const {
+    return body_outputs_;
+  }
+
+ private:
+  // Each user-defined while loop defines a new execution frame, which is
+  // uniquely identified by its frame name. Frames are used by the executor to
+  // manage the iterations of a loop. See the FrameState comment in
+  // core/common_runtime/executor.cc for more details.
+  const string frame_name_;
+
+  // The enter nodes defining the input loop variables to the while loop. This
+  // vector defines the order of the loop variables.
+  const std::vector<Node*> enter_nodes_;
+
+  // The exit nodes defining the outputs of the while loop. These are in loop
+  // variable order.
+  const std::vector<Node*> exit_nodes_;
+
+  // The boolean output of the loop predicate.
+  const OutputTensor cond_output_;
+
+  // The inputs and outputs to the loop body.
+  const std::vector<OutputTensor> body_inputs_;
+  const std::vector<OutputTensor> body_outputs_;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPH_WHILE_CONTEXT_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/zen_graph_util.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/zen_graph_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..7dc23fbc345790c4c95fb4d3af18d24ccb0e452e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/graph/zen_graph_util.h
@@ -0,0 +1,83 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPH_ZEN_GRAPH_UTIL_H_
+#define TENSORFLOW_CORE_GRAPH_ZEN_GRAPH_UTIL_H_
+#ifdef AMD_ZENDNN
+
+#include <string>
+#include <utility>
+
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/types.pb.h"
+#include "tensorflow/core/graph/graph.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/platform/cpu_info.h"
+#include "tensorflow/core/util/env_var.h"
+
+namespace tensorflow {
+
+namespace zen_op_registry {
+
+// Prefix that we add to Tensorflow op name to construct Zen op name.
+static const char* const kZenNodePrefix = "_Zen";
+
+// Get the name of Zen op from original TensorFlow op.
+// We prefix the original op with "Zen" to get Zen op.
+inline string GetZenOpName(const string& name) {
+  return string(kZenNodePrefix) + name;
+}
+
+// Check whether op name with type T is registered as Zen operator
+// that will go through name change or layout change pass.
+//
+// @input  op_name - name of the op.
+// @input  T - datatype to be used for checking op.
+// @return true if op name is registered as Zen op that will go through name
+// change or layout change pass; false otherwise.
+static inline bool IsZenOpKernelRegistered(const string& op_name, DataType T) {
+  string registered_kernels_key = op_name + string(DataType_Name(T));
+  thread_local static auto* registered_kernels_map =
+      new absl::flat_hash_map<string, bool>();
+  auto kernel_element = registered_kernels_map->find(registered_kernels_key);
+  bool kernel_registered = false;
+
+  if (kernel_element == registered_kernels_map->end()) {
+    string registered_kernels = KernelsRegisteredForOp(op_name);
+    // String returned by KernelsRegisteredForOp looks like below:
+    //
+    // Op = ZenMatMul, kernels =
+    // device='CPU'; T in [DT_FLOAT]
+    // device='CPU'; T in [DT_DOUBLE]
+
+    // If we have multiple kernels registered for the op. We need to verify
+    // our datatype
+    if (registered_kernels.find(string(DataType_Name(T))) != string::npos) {
+      kernel_registered = true;
+    }
+    registered_kernels_map->insert(
+        std::make_pair(registered_kernels_key, kernel_registered));
+  } else {
+    // Kernel is visited at least once. Return stored registration result.
+    kernel_registered = kernel_element->second;
+  }
+  return kernel_registered;
+}
+
+}  // namespace zen_op_registry
+}  // namespace tensorflow
+
+#endif  // AMD_ZENDNN
+#endif  // TENSORFLOW_CORE_GRAPH_ZEN_GRAPH_UTIL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/clusters/cluster.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/clusters/cluster.h
new file mode 100644
index 0000000000000000000000000000000000000000..11b62675b299c9794291db15da44584809798ebe
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/clusters/cluster.h
@@ -0,0 +1,147 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_CLUSTERS_CLUSTER_H_
+#define TENSORFLOW_CORE_GRAPPLER_CLUSTERS_CLUSTER_H_
+
+#include <string>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include "absl/status/status.h"
+#include "tensorflow/core/common_runtime/device_set.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/grappler/grappler_item.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/lib/strings/strcat.h"
+#include "tensorflow/core/protobuf/device_properties.pb.h"
+#include "tensorflow/core/public/session_options.h"
+
+namespace tensorflow {
+namespace grappler {
+
+// A cluster represents of collection of hardware resources available to run
+// the TensorFlow model.
+// A process can only create a single cluster at a time.
+class Cluster {
+ public:
+  explicit Cluster(int timeout_s);
+  virtual ~Cluster();
+
+  // Returns a string that represent the type of cluster that was instantiated.
+  virtual string type() const = 0;
+
+  // Provision the hardware resources needed to run TensorFlow and start a
+  // TensorFlow session that can take advantage of these resources.
+  // The actual resources that are leveraged depend on the type of cluster
+  // instantiated.
+  // Returns OK iff all the requested resources could be reserved and a
+  // TensorFlow session successfully created. Returns an error otherwise.
+  // There is no graceful degradation to handle the case where only a subset
+  // of the requested resources are available.
+  virtual Status Provision() = 0;
+
+  // Attempts to shutdown the cluster.
+  // Returns OK iff there are no pending calls to the Run() method and all the
+  // resources used by the cluster could be released. Returns an error
+  // otherwise.
+  virtual Status Shutdown() { return OkStatus(); }
+
+  // Whether soft placement is allowed. If allow_soft_placement is true,
+  // an op will be placed on CPU if there's no GPU implementation for the OP
+  // or if no GPU devices are known or registered or if we need to co-locate
+  // with reftype input(s) which are from CPU.
+  void AllowSoftPlacement(bool soft_placement_state);
+
+  // Update the number of inter-op threads for each per-session threadpool
+  void SetNumInterOpThreads(int num_threads);
+
+  // Set the number of steps required to warmup TensorFlow. Must be called
+  // before Provision().
+  void SetNumWarmupSteps(int num_steps);
+
+  // Set executor type to instantiate
+  void SetExecutorType(const string* executor_type);
+
+  // Returns the number of warmup steps.
+  int NumWarmupSteps() const;
+
+  // Disable the collection of detailed statistics. Must be called
+  // before Provision().
+  void DisableDetailedStats(bool disable);
+
+  // Returns true iff the collection of detailed statistics is enabled.
+  bool DetailedStatsEnabled() const;
+
+  // Disable the TensorFlow optimizer. This ensures that the graph that TF
+  // executes is similar to the input graph. Must be called before Provision().
+  void DisableOptimizer(bool disable);
+
+  // Return the list of TensorFlow devices that are available to execute a
+  // graph. This is empty until provision() is called.
+  const std::unordered_map<string, DeviceProperties>& GetDevices() const {
+    return devices_;
+  }
+
+  // Convenience method that returns the set of device names. These names are
+  // sorted alphabetically.
+  const std::vector<string> GetDeviceNames() const;
+
+  // The DeviceSet is not always available, but when it is it contains a
+  // superset of the devices listed in GetDevices/GetDeviceNames().
+  virtual const DeviceSet* GetDeviceSet() const { return nullptr; }
+
+  // Enables collecting the allocator stats. If called, must be called before
+  // Provision().
+  virtual Status EnablePeakMemoryStats() {
+    return absl::UnimplementedError(strings ::StrCat(
+        "Peak Memory Stats are not supported on ", type(), " clusters"));
+  }
+
+  // Returns peak memory of all devices during the session creation and session
+  // runs.
+  virtual Status GetPeakMemoryUsage(
+      std::unordered_map<string, uint64>* device_peak_memory) const {
+    return absl::UnimplementedError(
+        "GetPeakMemoryUsage is not implemented for this type of cluster.");
+  }
+
+  // Prepare the session to run the specified grappler item. This include
+  // initializing all the model variables.
+  virtual Status Initialize(const GrapplerItem& item) = 0;
+
+  // Run the specified graph_def and return the corresponding metadata.
+  virtual Status Run(const GraphDef& graph_def,
+                     const std::vector<std::pair<string, Tensor>>& feed,
+                     const std::vector<string>& fetch,
+                     RunMetadata* metadata) = 0;
+
+  // Run the specified GrapplerItem and return the corresponding metadata.
+  virtual Status Run(const GrapplerItem& item, RunMetadata* metadata) {
+    return Run(item.graph, item.feed, item.fetch, metadata);
+  }
+
+ protected:
+  std::unordered_map<string, DeviceProperties> devices_;
+  const int timeout_s_;
+  SessionOptions options_;
+  RunOptions run_options_;
+};
+
+}  // end namespace grappler
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_CLUSTERS_CLUSTER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/clusters/single_machine.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/clusters/single_machine.h
new file mode 100644
index 0000000000000000000000000000000000000000..2a78bce91464868c4fcfd73f1f52e58c693a678a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/clusters/single_machine.h
@@ -0,0 +1,91 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_CLUSTERS_SINGLE_MACHINE_H_
+#define TENSORFLOW_CORE_GRAPPLER_CLUSTERS_SINGLE_MACHINE_H_
+
+#include "tensorflow/cc/training/coordinator.h"
+#include "tensorflow/core/framework/allocator.h"
+#include "tensorflow/core/grappler/clusters/cluster.h"
+#include "tensorflow/core/lib/core/threadpool.h"
+#include "tensorflow/core/platform/mutex.h"
+#include "tensorflow/core/public/session.h"
+
+namespace tensorflow {
+namespace grappler {
+
+// Create a simple cluster that makes available to grappler a subset of the
+// nodes available on a single local computer.
+class SingleMachine : public Cluster {
+ public:
+  SingleMachine(int timeout_s, int num_cpu_cores, int num_gpus);
+  ~SingleMachine() override;
+
+  string type() const override { return "single_machine"; }
+
+  Status Provision() override;
+  Status Shutdown() override;
+
+  Status Initialize(const GrapplerItem& item) override;
+  Status Run(const GraphDef& item,
+             const std::vector<std::pair<string, Tensor>>& feed,
+             const std::vector<string>& fetch, RunMetadata* metadata) override;
+
+  const DeviceSet* GetDeviceSet() const override { return device_set_.get(); }
+
+  Status EnablePeakMemoryStats() override;
+
+  // It requires EnableAllocatorStats(true) be called before Provision().
+  Status GetPeakMemoryUsage(
+      std::unordered_map<string, uint64>* device_peak_memory) const override;
+
+ private:
+  Status RunWithTimeout(const std::vector<std::pair<string, Tensor>>& feed,
+                        const std::vector<string>& fetch,
+                        RunMetadata* run_metadata);
+  Status RunWithTimeout(const std::vector<std::pair<string, Tensor>>& feed,
+                        const std::vector<string>& fetch,
+                        RunMetadata* run_metadata, int64_t timeout_s);
+  Status ResetSession();
+  Status CloseSession(bool use_timeout);
+  Status ShutdownSession();
+  void MergeCosts(CostGraphDef* graph_costs, const CostGraphDef& init_costs,
+                  const CostGraphDef& queue_costs);
+
+  Status ClearAllocatorStats() const;
+
+  std::unique_ptr<Session> session_;
+  std::vector<QueueRunnerDef> queue_runner_defs_;
+  string last_graph_id_;
+  mutex last_graph_mu_;
+  const GraphDef* last_graph_ TF_GUARDED_BY(last_graph_mu_) = nullptr;
+  std::vector<string> init_ops_;
+  int64_t expected_init_time_s_;
+  std::unique_ptr<Coordinator> coordinator_;
+  std::unique_ptr<thread::ThreadPool> thread_pool_;
+  std::unique_ptr<DeviceSet> device_set_;
+
+  RunMetadata init_metadata_;
+
+  mutex close_mu_;
+  bool closing_ TF_GUARDED_BY(close_mu_);
+
+  bool cpu_allocator_stats_enabled_ = false;
+};
+
+}  // end namespace grappler
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_CLUSTERS_SINGLE_MACHINE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/clusters/utils.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/clusters/utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..8a5978541a9364120aa3da72fc696c5938c77b53
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/clusters/utils.h
@@ -0,0 +1,39 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_CLUSTERS_UTILS_H_
+#define TENSORFLOW_CORE_GRAPPLER_CLUSTERS_UTILS_H_
+
+#include "tensorflow/core/common_runtime/gpu/gpu_id.h"
+#include "tensorflow/core/protobuf/device_properties.pb.h"
+#include "tensorflow/core/util/device_name_utils.h"
+
+namespace tensorflow {
+namespace grappler {
+
+// Returns the DeviceProperties of the CPU on which grappler is running.
+DeviceProperties GetLocalCPUInfo();
+
+// Returns the DeviceProperties for the specified GPU attached to the server on
+// which grappler is running.
+DeviceProperties GetLocalGPUInfo(PlatformDeviceId platform_device_id);
+
+// Returns the DeviceProperties of the specified device
+DeviceProperties GetDeviceInfo(const DeviceNameUtils::ParsedName& device);
+
+}  // end namespace grappler
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_CLUSTERS_UTILS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/clusters/virtual_cluster.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/clusters/virtual_cluster.h
new file mode 100644
index 0000000000000000000000000000000000000000..fa547a4ed2faf3130f171a520d677290cb33f06e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/clusters/virtual_cluster.h
@@ -0,0 +1,63 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_CLUSTERS_VIRTUAL_CLUSTER_H_
+#define TENSORFLOW_CORE_GRAPPLER_CLUSTERS_VIRTUAL_CLUSTER_H_
+
+#include <unordered_map>
+
+#include "tensorflow/core/common_runtime/device_set.h"
+#include "tensorflow/core/grappler/clusters/cluster.h"
+#include "tensorflow/core/grappler/costs/analytical_cost_estimator.h"
+#include "tensorflow/core/grappler/costs/op_level_cost_estimator.h"
+#include "tensorflow/core/grappler/costs/virtual_scheduler.h"
+#include "tensorflow/core/protobuf/device_properties.pb.h"
+
+namespace tensorflow {
+namespace grappler {
+
+// Create a simple cluster that lists the devices (and their properties)
+// available in a TensorFlow session. This cluster simulates the execution of
+// actual graphs.
+class VirtualCluster : public Cluster {
+ public:
+  explicit VirtualCluster(
+      const std::unordered_map<string, DeviceProperties>& devices);
+  VirtualCluster(const std::unordered_map<string, DeviceProperties>& devices,
+                 std::unique_ptr<OpLevelCostEstimator> node_estimator,
+                 std::unique_ptr<ReadyNodeManager> node_manager);
+  explicit VirtualCluster(const DeviceSet* device_set);
+
+  ~VirtualCluster() override;
+
+  string type() const override { return "virtual"; }
+
+  Status Provision() override;
+  Status Initialize(const GrapplerItem& item) override;
+  Status Run(const GraphDef& graph,
+             const std::vector<std::pair<string, Tensor>>& feed,
+             const std::vector<string>& fetch, RunMetadata* metadata) override;
+  Status Run(const GrapplerItem& item, RunMetadata* metadata) override;
+  const DeviceSet* GetDeviceSet() const override { return device_set_; }
+
+ private:
+  std::unique_ptr<AnalyticalCostEstimator> estimator_;
+  const DeviceSet* device_set_ = nullptr;
+};
+
+}  // end namespace grappler
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_CLUSTERS_VIRTUAL_CLUSTER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/costs/analytical_cost_estimator.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/costs/analytical_cost_estimator.h
new file mode 100644
index 0000000000000000000000000000000000000000..8387a886c6784dcc56af7bf15cc23e12ff032e27
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/costs/analytical_cost_estimator.h
@@ -0,0 +1,82 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_COSTS_ANALYTICAL_COST_ESTIMATOR_H_
+#define TENSORFLOW_CORE_GRAPPLER_COSTS_ANALYTICAL_COST_ESTIMATOR_H_
+
+#include "tensorflow/core/grappler/costs/cost_estimator.h"
+#include "tensorflow/core/grappler/costs/op_level_cost_estimator.h"
+#include "tensorflow/core/grappler/costs/virtual_scheduler.h"
+#include "tensorflow/core/grappler/grappler_item.h"
+#include "tensorflow/core/lib/core/status.h"
+
+namespace tensorflow {
+class CostGraphDef;
+class GraphDef;
+}  // namespace tensorflow
+
+namespace tensorflow {
+namespace grappler {
+
+class Cluster;
+struct GrapplerItem;
+
+// Estimate the cost of running a Grappler item based on the theoretical
+// performance of the hardware that will run the model. Note that this
+// internally uses static shape inference. An option for aggressive shape
+// inference is provided to minimize unknown shapes, and this is only applicable
+// with static shape inference.
+class AnalyticalCostEstimator : public CostEstimator {
+ public:
+  AnalyticalCostEstimator(Cluster* cluster, bool use_static_shapes,
+                          bool use_aggressive_shape_inference);
+  AnalyticalCostEstimator(Cluster* cluster,
+                          std::unique_ptr<OpLevelCostEstimator> node_estimator,
+                          std::unique_ptr<ReadyNodeManager> node_manager,
+                          bool use_static_shapes,
+                          bool use_aggressive_shape_inference);
+  AnalyticalCostEstimator(Cluster* cluster,
+                          std::unique_ptr<OpLevelCostEstimator> node_estimator,
+                          std::unique_ptr<ReadyNodeManager> node_manager,
+                          std::unique_ptr<VirtualPlacer> placer,
+                          bool use_static_shapes,
+                          bool use_aggressive_shape_inference);
+  ~AnalyticalCostEstimator() override {}
+
+  // This implementation always returns OK.
+  Status Initialize(const GrapplerItem& item) override;
+
+  // Predict the performance of each node of the optimized graph and annotate
+  // the RunMetadata with the corresponding estimates. Also returns the
+  // expected cost for the whole graph.
+  Status PredictCosts(const GraphDef& optimized_graph,
+                      RunMetadata* run_metadata, Costs* cost) const override;
+
+  const VirtualScheduler* GetScheduler() const { return scheduler_.get(); }
+
+ private:
+  const GrapplerItem* item_;
+  std::unique_ptr<OpLevelCostEstimator> node_estimator_;
+  std::unique_ptr<ReadyNodeManager> node_manager_;
+  std::unique_ptr<VirtualScheduler> scheduler_;
+
+  bool use_static_shapes_;
+  bool use_aggressive_shape_inference_;
+};
+
+}  // end namespace grappler
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_COSTS_ANALYTICAL_COST_ESTIMATOR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/costs/cost_estimator.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/costs/cost_estimator.h
new file mode 100644
index 0000000000000000000000000000000000000000..22b273986421ce2e04bac1a725d9c3ae8cb3c86f
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/costs/cost_estimator.h
@@ -0,0 +1,258 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_COSTS_COST_ESTIMATOR_H_
+#define TENSORFLOW_CORE_GRAPPLER_COSTS_COST_ESTIMATOR_H_
+
+#include <cmath>
+#include <limits>
+#include <string>
+#include <unordered_map>
+
+#include "absl/container/flat_hash_map.h"
+#include "absl/container/flat_hash_set.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/protobuf/config.pb.h"
+
+namespace tensorflow {
+class GraphDef;
+class CostGraphDef;
+
+namespace grappler {
+struct GrapplerItem;
+
+constexpr uint64_t kMemoryUnknown = std::numeric_limits<uint64_t>::max();
+constexpr uint64_t kZeroMemory = 0ULL;
+
+struct DeviceInfo {
+  // Billions of operations executed per second.
+  double gigaops;
+
+  // Bandwidth to main memory in GB per second.
+  double gb_per_sec;
+
+  // Read bandwidth to intermediate memory in GB per second.
+  double intermediate_read_gb_per_sec;
+
+  // Write bandwidth to intermediate memory in GB per second.
+  double intermediate_write_gb_per_sec;
+
+  DeviceInfo()
+      : gigaops(INFINITY),
+        gb_per_sec(INFINITY),
+        intermediate_read_gb_per_sec(INFINITY),
+        intermediate_write_gb_per_sec(INFINITY) {}
+
+  DeviceInfo(const DeviceInfo& input)
+      : gigaops(input.gigaops),
+        gb_per_sec(input.gb_per_sec),
+        intermediate_read_gb_per_sec(input.intermediate_read_gb_per_sec),
+        intermediate_write_gb_per_sec(input.intermediate_write_gb_per_sec) {}
+
+  DeviceInfo(double gigaops, double gb_per_sec,
+             double intermediate_read_gb_per_sec = INFINITY,
+             double intermediate_write_gb_per_sec = INFINITY)
+      : gigaops(gigaops),
+        gb_per_sec(gb_per_sec),
+        intermediate_read_gb_per_sec(intermediate_read_gb_per_sec),
+        intermediate_write_gb_per_sec(intermediate_write_gb_per_sec) {}
+};
+
+// Holds the set of things we might want to estimate or measure in Grappler.
+// Always produce execution time. Other fields are optional depending on the
+// estimator being used.
+struct Costs {
+  // Returns a Costs structure with default values for all of the fields.
+  inline Costs();
+
+  // Builds a Costs structure with all zero values, rather than unknowns.
+  static inline Costs ZeroCosts(bool inaccurate = false);
+
+  struct MilliSeconds : std::chrono::milliseconds {
+    MilliSeconds() : std::chrono::milliseconds(0) {}
+    MilliSeconds(double d)
+        : std::chrono::milliseconds(static_cast<int64_t>(d)) {}
+    MilliSeconds(const std::chrono::milliseconds& d)
+        : std::chrono::milliseconds(d) {}
+    MilliSeconds& operator=(const std::chrono::milliseconds& d) {
+      std::chrono::milliseconds::operator=(d);
+      return *this;
+    }
+  };
+  struct MicroSeconds : std::chrono::microseconds {
+    MicroSeconds() : std::chrono::microseconds(0) {}
+    MicroSeconds(double d)
+        : std::chrono::microseconds(static_cast<int64_t>(d)) {}
+    MicroSeconds(const std::chrono::microseconds& d)
+        : std::chrono::microseconds(d) {}
+    MicroSeconds& operator=(const std::chrono::microseconds& d) {
+      std::chrono::microseconds::operator=(d);
+      return *this;
+    }
+    MilliSeconds asMilliSeconds() const {
+      return std::chrono::duration_cast<std::chrono::milliseconds>(*this);
+    }
+  };
+  struct NanoSeconds : std::chrono::nanoseconds {
+    NanoSeconds() : std::chrono::nanoseconds(0) {}
+    NanoSeconds(double d) : std::chrono::nanoseconds(static_cast<int64_t>(d)) {}
+    NanoSeconds(const std::chrono::nanoseconds& d)
+        : std::chrono::nanoseconds(d) {}
+    NanoSeconds& operator=(const std::chrono::nanoseconds& d) {
+      std::chrono::nanoseconds::operator=(d);
+      return *this;
+    }
+    MicroSeconds asMicroSeconds() const {
+      return std::chrono::duration_cast<std::chrono::microseconds>(*this);
+    }
+    MilliSeconds asMilliSeconds() const {
+      return std::chrono::duration_cast<std::chrono::milliseconds>(*this);
+    }
+    static NanoSeconds infinity() {
+      return NanoSeconds(std::chrono::nanoseconds::max());
+    }
+  };
+
+  // We store all our times in nanoseconds. If needs be, we can always switch to
+  // picoseconds in the future by updating this typedef.
+  typedef NanoSeconds Duration;
+
+  // Overall cost of running the graph; latency.
+  Duration execution_time;
+
+  // Computation cost of running the graph.
+  Duration compute_time;
+
+  // Memory access cost of running the graph.
+  Duration memory_time;
+
+  // Intermediate memory access cost of running the graph
+  Duration intermediate_memory_time;
+  Duration intermediate_memory_read_time;   // Intermediate memory read cost.
+  Duration intermediate_memory_write_time;  // Intermediate memory write cost.
+
+  // Network time (colelctived ops - all gather, all reduce, etc.)
+  Duration network_time;
+
+  // This field can be a very pessimistic estimate of the main memory
+  // requirements of a graph. For example, it might assume that all activations
+  // are live for all of a graph's execution.
+  uint64_t max_memory;  // Max main memory requirement in bytes over all ops.
+  uint64_t persistent_memory;
+  uint64_t temporary_memory;
+
+  // Output memory usage per port.
+  absl::flat_hash_map<int32_t, int64_t> output_tensor_size_bytes;
+
+  // Track persistent versus temporary memory.
+  absl::flat_hash_set<int32_t> persistent_output_ports;
+
+  // These fields are used for TPU-related estimations. They are per-op
+  // maximums, so each op is evaluated independently, but we want the maximum of
+  // the value over all ops.
+  int64_t max_per_op_buffers;    // Sum of all buffers used by the ops.
+  int64_t max_per_op_streaming;  // Ignore largest input buffer, assuming it
+                                 // streams from main memory.
+
+  // Number of ops included in this Costs in total.
+  // Default initialized to be one.
+  int64_t num_ops_total = 1;
+  // If the time estimation is inaccurate.
+  bool inaccurate = false;
+  // Number of ops that are estimated with unknown shapes.
+  int64_t num_ops_with_unknown_shapes = 0;
+  // TODO(pcma): include a counter for total inaccurate ops and counters for
+  // other reasons causing the inaccuracy
+
+  // Max possible memory usage per device.
+  std::unordered_map<string, uint64> estimated_max_memory_per_device;
+};
+
+inline std::ostream& operator<<(std::ostream& os, const Costs::MilliSeconds d) {
+  os << d.count() << "ms";
+  return os;
+}
+inline std::ostream& operator<<(std::ostream& os, const Costs::MicroSeconds d) {
+  os << d.count() << "us";
+  return os;
+}
+inline std::ostream& operator<<(std::ostream& os, const Costs::NanoSeconds d) {
+  os << d.count() << "ns";
+  return os;
+}
+
+Costs::Costs() {
+  execution_time = Duration::zero();
+  compute_time = Duration::zero();
+  memory_time = Duration::zero();
+  intermediate_memory_time = Duration::zero();
+  network_time = Duration::zero();
+  max_memory = kMemoryUnknown;
+  persistent_memory = kMemoryUnknown;
+  temporary_memory = kMemoryUnknown;
+  max_per_op_buffers = kMemoryUnknown;
+  max_per_op_streaming = kMemoryUnknown;
+}
+
+Costs Costs::ZeroCosts(bool inaccurate) {
+  Costs costs;
+  costs.execution_time = Duration::zero();
+  costs.compute_time = Duration::zero();
+  costs.memory_time = Duration::zero();
+  costs.intermediate_memory_time = Duration::zero();
+  costs.network_time = Duration::zero();
+  costs.max_memory = kZeroMemory;
+  costs.persistent_memory = kZeroMemory;
+  costs.temporary_memory = kZeroMemory;
+  costs.max_per_op_buffers = kZeroMemory;
+  costs.max_per_op_streaming = kZeroMemory;
+  costs.inaccurate = inaccurate;
+  return costs;
+}
+
+Costs CombineCosts(const Costs& left, const Costs& right);
+
+// Multiplies Costs by a scalar.
+// Equivalent to applying CombineCosts "multiplier" times.
+Costs MultiplyCosts(const Costs& costs, int multiplier);
+
+// Given a GrapperItem and an optimized implementation of the corresponding
+// TensorFlow graph, the CostEstimator attempts to predicts the actual cost of
+// running the graph.
+class CostEstimator {
+ public:
+  virtual ~CostEstimator() {}
+
+  // Initializes the estimator for the specified grappler item.
+  // The estimator shouldn't be used if this function returns any status other
+  // that OK.
+  virtual Status Initialize(const GrapplerItem& item) = 0;
+
+  // Predicts the cost of running the given optimized version of the grappler
+  // item.
+  // If a RunMetadata is passed, it will be populated with detailed information
+  // about the cost of running each operation of the optimized graph.
+  // if a double value is passed, it will be set to a value that reflects the
+  // overall cost of running the graph (e.g. the latency of the computation).
+  // Returns a status that indicate is the performance could be estimated or
+  // not.
+  virtual Status PredictCosts(const GraphDef& optimized_graph,
+                              RunMetadata* run_metadata, Costs* cost) const = 0;
+};
+
+}  // end namespace grappler
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_COSTS_COST_ESTIMATOR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/costs/graph_memory.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/costs/graph_memory.h
new file mode 100644
index 0000000000000000000000000000000000000000..6e2520cf4f73e32d7444b37471de91858d685c38
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/costs/graph_memory.h
@@ -0,0 +1,81 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_COSTS_GRAPH_MEMORY_H_
+#define TENSORFLOW_CORE_GRAPPLER_COSTS_GRAPH_MEMORY_H_
+
+#include "tensorflow/core/framework/node_def.pb.h"
+#include "tensorflow/core/grappler/clusters/cluster.h"
+#include "tensorflow/core/grappler/costs/cost_estimator.h"
+#include "tensorflow/core/grappler/costs/graph_properties.h"
+#include "tensorflow/core/grappler/grappler_item.h"
+
+namespace tensorflow {
+namespace grappler {
+
+// Infer the worst case memory usage for a given grappler item.
+class GraphMemory {
+ public:
+  struct LiveTensor {
+    string node;
+    int output_id;
+    size_t memory_used;
+    Costs::Duration allocation_time;
+    Costs::Duration deallocation_time;
+  };
+  struct MemoryUsage {
+    int64_t used_memory;
+    std::vector<LiveTensor> live_tensors;
+  };
+
+  explicit GraphMemory(const GrapplerItem& item)
+      : item_(item), unknown_usage_({-1, {}}) {}
+
+  Status InferStatically(
+      const std::unordered_map<string, DeviceProperties>& devices);
+  Status InferDynamically(Cluster* cluster);
+
+  // Worst case memory usage in bytes, or -1 if the usage is unknown. If there
+  // are multiple devices, returns the highest per device memory usage.
+  int64_t GetWorstCaseMemoryUsage() const;
+
+  // Returns the peak memory usage for the specified device.
+  const MemoryUsage& GetPeakMemoryUsage(const string& device) const {
+    auto it = peak_usage_.find(device);
+    if (it == peak_usage_.end()) {
+      return unknown_usage_;
+    }
+    return it->second;
+  }
+
+ private:
+  void InferMemUsageForNodes(const std::vector<const NodeDef*>& nodes,
+                             GraphProperties* properties, int64_t* worst_case,
+                             int64_t* best_case) const;
+  int64_t InferMemUsageForNeighbors(
+      const std::vector<OpInfo::TensorProperties>& props) const;
+
+  void InferFromTrace(const StepStats& timeline);
+
+  const GrapplerItem& item_;
+  std::unordered_map<string, int64_t> worst_case_memory_usage_;
+  std::unordered_map<string, MemoryUsage> peak_usage_;
+  const MemoryUsage unknown_usage_;
+};
+
+}  // end namespace grappler
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_COSTS_GRAPH_MEMORY_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/costs/graph_properties.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/costs/graph_properties.h
new file mode 100644
index 0000000000000000000000000000000000000000..fbe8096d40e3b73bcfdcf8d23e28654d20b2a059
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/costs/graph_properties.h
@@ -0,0 +1,225 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_COSTS_GRAPH_PROPERTIES_H_
+#define TENSORFLOW_CORE_GRAPPLER_COSTS_GRAPH_PROPERTIES_H_
+
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+#include "absl/container/flat_hash_map.h"
+#include "tensorflow/core/framework/shape_inference.h"
+#include "tensorflow/core/grappler/clusters/cluster.h"
+#include "tensorflow/core/grappler/costs/op_performance_data.pb.h"
+#include "tensorflow/core/grappler/grappler_item.h"
+
+namespace tensorflow {
+
+namespace grappler {
+
+// Optional attributes that tell about node output information.
+// We use these side information, if provided, for static shape inference
+// and VirtualScheduler scheduling.
+
+// Switch op attribute as a vector of int that tells which branch the
+// Switch output is taken on every round of execution.
+// Used for scheduling ops after Switch correctly (e.g., While loop).
+ABSL_CONST_INIT const char kOutputSlots[] = "_output_slot_vector";
+
+// Example:
+// Assume a node has two outputs and iterated for three times. Then it has:
+// _execution_count = 3
+// _output_sizes_vector = [2, 2, 2]
+// _output_dtype_vector.size = 6
+// _output_shape_vector.size = 6
+
+// If all the iterations have same output shapes, then
+// _execution_count = 3
+// _same_output_for_iterations = true
+// _output_sizes_vector = [2]
+// _output_dtype_vector.size = 2
+// _output_shape_vector.size = 2
+
+// How many times this node has been executed.
+ABSL_CONST_INIT const char kExecutionCount[] = "_execution_count";
+
+// Records the output sizes for each round of execution.
+ABSL_CONST_INIT const char kOutputSizes[] = "_output_sizes_vector";
+
+// The node has been scheduled multiple times with outputs that have the same
+// shape.
+ABSL_CONST_INIT const char kOutputSame[] = "_same_output_for_iterations";
+
+// Outputs DataType vector.
+ABSL_CONST_INIT const char kOutputTypes[] = "_output_dtype_vector";
+
+// Outputs TensorShapeProto vector.
+ABSL_CONST_INIT const char kOutputShapes[] = "_output_shape_vector";
+
+class SymbolicShapeRefiner;
+class TopoQueue;
+
+// Infer OpInfo::TensorProperties for graph nodes inputs/outputs.
+//
+// Typical use case, is to infer tensor properties from a graph, before doing
+// optimization pass. Nodes modified during optimization pass have to be
+// invalidated, to prevent further incorrect optimizations based on wrong shape
+// and data type properties.
+class GraphProperties {
+ public:
+  // The item must outlive the properties
+  explicit GraphProperties(const GrapplerItem& item) : item_(item) {}
+
+  // Infer the shapes through abstract interpretation. Feed information can be
+  // incorrect so it should be discarded to ensure correctness of the analysis.
+  // However, it can help infer shapes in the fanout of fed nodes (even though
+  // the correctness of these shapes can't be guaranteed), so in some cases
+  // (such as simulation or scheduling) it makes sense of keep these shapes.
+  // aggressive_shape_inference option executes nodes on the host to identify
+  // output values when possible and does other aggressive strategies.
+  // Similar to assuming_valid_feeds, this may cause incorrectness in graph
+  // analyses, but is useful for simulation or scheduling.
+  // If include_input_tensor_values is true, the values of constant tensors
+  // will included in the input properties.
+  // If include_output_tensor_values is true, the values of constant tensors
+  // will be included in the output properties.
+  Status InferStatically(bool assume_valid_feeds,
+                         bool aggressive_shape_inference,
+                         bool include_input_tensor_values,
+                         bool include_output_tensor_values);
+  Status InferStatically(bool assume_valid_feeds,
+                         bool aggressive_shape_inference,
+                         bool include_tensor_values) {
+    return InferStatically(
+        assume_valid_feeds,
+        /*aggressive_shape_inference=*/aggressive_shape_inference,
+        /*include_input_tensor_values=*/include_tensor_values,
+        /*include_output_tensor_values=*/include_tensor_values);
+  }
+  Status InferStatically(bool assume_valid_feeds) {
+    return InferStatically(assume_valid_feeds,
+                           /*aggressive_shape_inference=*/false,
+                           /*include_tensor_values=*/true);
+  }
+  // Infer the shape by running the graph on the specified cluster and recording
+  // the shapes of the processed tensors.
+  Status InferDynamically(Cluster* cluster);
+  // Extract the properties from a cost graph. For testing only since there is
+  // no way to ensure that the cost graph match the item.
+  Status InferFromCostGraph(const CostGraphDef& cost_graph);
+
+  // Stores `item_.graph` with the inferred output shapes to `output_graph_def`.
+  Status AnnotateOutputShapes(GraphDef* output_graph_def) const;
+
+  // Return the properties of node inputs/outputs, including data types and
+  // shapes. Note that the dimensions in the shapes can be negative. We use the
+  // -1 value to denote that we don't know anything about a dimension. We use
+  // values strictly less than -1 to encode symbolic dimensions: although we
+  // don't know the actual value of the symbolic dimension, we know that all the
+  // dimensions denoted by the same negative value are the equal.
+  bool HasInputProperties(const string& node_name) const;
+  bool HasOutputProperties(const string& node_name) const;
+  const std::vector<OpInfo::TensorProperties>& GetInputProperties(
+      const string& node_name) const;
+  const std::vector<OpInfo::TensorProperties>& GetOutputProperties(
+      const string& node_name) const;
+
+  // Invalidate input/output properties for nodes modified during graph
+  // optimization pass, to prevent potential optimizations, based on incorrect
+  // shape information.
+  void ClearInputProperties(const string& node_name);
+  void ClearOutputProperties(const string& node_name);
+  // Returns true if we have *any* properties.
+  bool has_properties() const {
+    return !input_properties_.empty() || !output_properties_.empty();
+  }
+
+  bool CheckShapeIncompatible(const string& node_name) const {
+    return incompatible_shape_nodes_.find(node_name) !=
+           incompatible_shape_nodes_.end();
+  }
+
+  // Clear all infered properties.
+  void Clear() {
+    input_properties_.clear();
+    output_properties_.clear();
+  }
+
+ private:
+  // Relaxes shapes <shapes_and_types>, determined from an EnqueueV2 node, into
+  // <*queue_shapes_and_types>.
+  static Status RelaxEnqueueShapesAndMergeTypes(
+      SymbolicShapeRefiner* shape_refiner, const NodeDef* qnode,
+      const std::vector<shape_inference::ShapeAndType>& shapes_and_types,
+      std::vector<shape_inference::ShapeAndType>* queue_shapes_and_types);
+
+  // Update the shapes of the enqueue node, port them over to the corresponding
+  // queue, and schedule the reprocessing of the queue if needed.
+  static Status UpdateEnqueue(
+      const NodeDef* enqueue_node,
+      const absl::flat_hash_map<const NodeDef*, const NodeDef*>&
+          resource_handles,
+      SymbolicShapeRefiner* shape_refiner, bool* new_shapes);
+
+  // Update the shapes and types of the Queue node, if not set by Enqueue node.
+  static Status UpdateQueue(const NodeDef* queue_node,
+                            SymbolicShapeRefiner* shape_refiner,
+                            bool* new_shapes);
+
+  // Update the output shapes of a Merge node, and enqueue its fanout in
+  // new_shapes if needed.
+  Status UpdateMerge(SymbolicShapeRefiner* shape_refiner, const NodeDef* node,
+                     bool* new_shapes) const;
+  // Process the Enter node, and enqueue its fanout in new_shapes if needed.
+  static Status UpdateEnter(SymbolicShapeRefiner* shape_refiner,
+                            const NodeDef* node, bool* new_shapes);
+  // Update the shapes for node 'n'. If output shapes for n have changed,
+  // enqueue its fanout in 'new_shapes'.
+  Status UpdateShapes(SymbolicShapeRefiner* shape_refiner,
+                      const absl::flat_hash_map<const NodeDef*, const NodeDef*>&
+                          resource_handles,
+                      const NodeDef* n, bool* new_shapes) const;
+  // Propagate the shapes for the nodes enqueued in new_shapes and their
+  // transitive fanout until a fixed point is reached.
+  Status PropagateShapes(
+      SymbolicShapeRefiner* shape_refiner, TopoQueue* new_shapes,
+      const absl::flat_hash_map<const NodeDef*, const NodeDef*>&
+          resource_handles,
+      int num_loops) const;
+
+  // Data members
+  const GrapplerItem& item_;
+  absl::flat_hash_map<string, std::vector<OpInfo::TensorProperties>>
+      input_properties_;
+  absl::flat_hash_map<string, std::vector<OpInfo::TensorProperties>>
+      output_properties_;
+  const std::vector<OpInfo::TensorProperties> missing_properties_;
+
+  // Nodes with output shape incompatible between shape inference and
+  // annotation.
+  std::unordered_set<string> incompatible_shape_nodes_;
+};
+
+// Helper function for GraphProperties.
+bool IsShapeFullyDefinedIntegerVectorOrScalar(
+    shape_inference::InferenceContext* ic,
+    const shape_inference::ShapeHandle& shape,
+    const shape_inference::ShapeHandle& tensor_as_shape, const DataType& dtype);
+
+}  // end namespace grappler
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_COSTS_GRAPH_PROPERTIES_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/costs/op_context.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/costs/op_context.h
new file mode 100644
index 0000000000000000000000000000000000000000..900633335a01b48007ca987d604fff443a42c1e3
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/costs/op_context.h
@@ -0,0 +1,44 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_COSTS_OP_CONTEXT_H_
+#define TENSORFLOW_CORE_GRAPPLER_COSTS_OP_CONTEXT_H_
+
+#include "absl/container/flat_hash_map.h"
+#include "tensorflow/core/framework/function.pb.h"
+#include "tensorflow/core/grappler/costs/op_performance_data.pb.h"
+
+namespace tensorflow {
+namespace grappler {
+
+// A structure to keep the context of op execution, including its shape,
+// execution context, and other relevant information.
+struct OpContext {
+  std::string name;
+  std::string device_name;
+  OpInfo op_info;
+  const FunctionDefLibrary* function_library;  // Not owned.
+  // This map is used to stash meta attributes so that they may be
+  // communicated, for instance, from the scheduler that creates them to the
+  // CostEstimator or EventCostManager that uses them.
+  absl::flat_hash_map<std::string, absl::variant<int64_t, std::string>>
+      op_meta_attributes;
+  OpContext() { function_library = nullptr; }
+};
+
+}  // end namespace grappler
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_COSTS_OP_CONTEXT_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/costs/op_level_cost_estimator.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/costs/op_level_cost_estimator.h
new file mode 100644
index 0000000000000000000000000000000000000000..cd160d6deb866be66d57e3a18d5d387b40b0b3ae
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/costs/op_level_cost_estimator.h
@@ -0,0 +1,346 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_COSTS_OP_LEVEL_COST_ESTIMATOR_H_
+#define TENSORFLOW_CORE_GRAPPLER_COSTS_OP_LEVEL_COST_ESTIMATOR_H_
+
+#include <cstdint>
+#include <functional>
+#include <map>
+#include <numeric>
+#include <set>
+#include <vector>
+
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "tensorflow/core/grappler/costs/cost_estimator.h"
+#include "tensorflow/core/grappler/costs/op_context.h"
+#include "tensorflow/core/grappler/costs/op_performance_data.pb.h"
+#include "tensorflow/core/platform/types.h"
+#include "tensorflow/core/util/padding.h"
+
+namespace tensorflow {
+namespace grappler {
+
+bool GetTensorShapeProtoFromTensorProto(const TensorProto& tensor_proto,
+                                        TensorShapeProto* tensor_shape_proto);
+std::vector<int64_t> MaybeGetMinimumShape(
+    const TensorShapeProto& original_shape, int rank,
+    bool* found_unknown_shapes);
+
+// Node costs; an intermediate structure used within op level cost estimator.
+struct NodeCosts {
+  // If this FLAG is true, override calculated compute time with a minimum
+  // value, instead of calculating it from num_compute_ops and compute ops/sec.
+  // For example, PredictIdentity, PredictVariable, PredictMetadata set this
+  // FLAG.
+  bool minimum_cost_op = false;
+
+  // Compute ops.
+  int64_t num_compute_ops = 0;
+
+  // Memory bytes accessed; note that these may be different to the size of
+  // tensors.
+  std::vector<int64_t> num_input_bytes_accessed;   // ordered by input tensors.
+  std::vector<int64_t> num_output_bytes_accessed;  // ordered by output ports.
+  int64_t internal_read_bytes = 0;
+  int64_t internal_write_bytes = 0;
+
+  // Convenience functions.
+  int64_t num_total_input_bytes() const {
+    return std::accumulate(num_input_bytes_accessed.begin(),
+                           num_input_bytes_accessed.end(), 0LL);
+  }
+  int64_t num_total_read_bytes() const {
+    return num_total_input_bytes() + internal_read_bytes;
+  }
+  int64_t num_total_output_bytes() const {
+    return std::accumulate(num_output_bytes_accessed.begin(),
+                           num_output_bytes_accessed.end(), 0LL);
+  }
+  int64_t num_total_write_bytes() const {
+    return num_total_output_bytes() + internal_write_bytes;
+  }
+  int64_t num_bytes_accessed() const {
+    return num_total_read_bytes() + num_total_write_bytes();
+  }
+
+  // Memory usage.
+  int64_t max_memory = 0;
+  int64_t persistent_memory = 0;
+  int64_t temporary_memory = 0;
+
+  // Stats.
+  int64_t num_nodes = 1;
+  int64_t num_nodes_with_unknown_shapes = 0;
+  int64_t num_nodes_with_unknown_op_type = 0;
+  int64_t num_nodes_with_pure_memory_op = 0;
+  bool inaccurate = false;
+
+  // TODO(dyoon): this is added for compatibility; some old code is hard to
+  // migrate; hence, using these as a backup. Once we clean up, we'll delete
+  // these fields. New code should not use these.
+  bool has_costs = false;
+  Costs costs;
+};
+
+class OpLevelCostEstimator {
+ public:
+  OpLevelCostEstimator();
+  virtual ~OpLevelCostEstimator() {}
+
+  virtual Costs PredictCosts(const OpContext& op_context) const;
+
+  // Returns basic device performance info.
+  virtual DeviceInfo GetDeviceInfo(const DeviceProperties& device) const;
+
+ protected:
+  // TODO(dyoon): Consider to remove PredictOpCountBasedCosts() with OpInfo.
+  // Naive cost estimate based on the given operations count and total
+  // input/output tensor sizes of the given op_info combined.
+  Costs PredictOpCountBasedCost(double operations, const OpInfo& op_info) const;
+
+  // Naive cost estimate based on the given operations count and the given total
+  // io size in bytes. Sizes of op_info inputs and outputs are not taken into
+  // consideration.
+  Costs PredictOpCountBasedCost(double operations, double input_io_bytes,
+                                double output_io_bytes,
+                                const OpInfo& op_info) const;
+
+  // Top-level method cost function (PredictCosts calls this method to get
+  // NodeCosts, and then converts it to Costs). PredictNodeCosts() calls other
+  // Predict methods depending on op types.
+  absl::Status PredictNodeCosts(const OpContext& op_context,
+                                NodeCosts* node_costs) const;
+
+  // Predict cost of an op for which no accurate estimator is defined.
+  absl::Status PredictCostOfAnUnknownOp(const OpContext& op_context,
+                                        NodeCosts* node_costs) const;
+
+  // This family of routines predicts the costs to
+  // perform the specified TensorFlow Op on the
+  // device represented by a subclass. The default
+  // implementation just divides the operations to
+  // perform the op (from the "Count" routines,
+  // above) by the device peak operations per
+  // second.
+  // Implementation of costs other than
+  // execution_time is optional, depending on the
+  // device.
+  absl::Status PredictNaryOp(const OpContext& op_context,
+                             NodeCosts* node_costs) const;
+  absl::Status PredictConv2D(const OpContext& op_context,
+                             NodeCosts* node_costs) const;
+  absl::Status PredictCwiseOp(const OpContext& op_context,
+                              NodeCosts* node_costs) const;
+  absl::Status PredictConv2DBackpropInput(const OpContext& op_context,
+                                          NodeCosts* node_costs) const;
+  absl::Status PredictConv2DBackpropFilter(const OpContext& op_context,
+                                           NodeCosts* node_costs) const;
+  absl::Status PredictFusedConv2DBiasActivation(const OpContext& op_context,
+                                                NodeCosts* node_costs) const;
+  absl::Status PredictMatMul(const OpContext& op_context,
+                             NodeCosts* node_costs) const;
+  absl::Status PredictSparseTensorDenseMatMul(const OpContext& op_context,
+                                              NodeCosts* node_costs) const;
+  absl::Status PredictNoOp(const OpContext& op_context,
+                           NodeCosts* node_costs) const;
+  absl::Status PredictIdentity(const OpContext& op_context,
+                               NodeCosts* node_costs) const;
+  absl::Status PredictVariable(const OpContext& op_context,
+                               NodeCosts* node_costs) const;
+  absl::Status PredictBatchMatMul(const OpContext& op_context,
+                                  NodeCosts* node_costs) const;
+  absl::Status PredictMetadata(const OpContext& op_context,
+                               NodeCosts* node_costs) const;
+  absl::Status PredictGatherOrSlice(const OpContext& op_context,
+                                    NodeCosts* node_costs) const;
+  absl::Status PredictScatter(const OpContext& op_context,
+                              NodeCosts* node_costs) const;
+  absl::Status PredictMaxPool(const OpContext& op_context,
+                              NodeCosts* node_costs) const;
+  absl::Status PredictMaxPoolGrad(const OpContext& op_context,
+                                  NodeCosts* node_costs) const;
+  absl::Status PredictAvgPool(const OpContext& op_context,
+                              NodeCosts* node_costs) const;
+  absl::Status PredictAvgPoolGrad(const OpContext& op_context,
+                                  NodeCosts* node_costs) const;
+  absl::Status PredictFusedBatchNorm(const OpContext& op_context,
+                                     NodeCosts* node_costs) const;
+  absl::Status PredictFusedBatchNormGrad(const OpContext& op_context,
+                                         NodeCosts* node_costs) const;
+  absl::Status PredictEinsum(const OpContext& op_context,
+                             NodeCosts* node_costs) const;
+  absl::Status PredictAssignVariableOps(const OpContext& op_context,
+                                        NodeCosts* node_costs) const;
+  absl::Status PredictPureMemoryOp(const OpContext& op_context,
+                                   NodeCosts* node_costs) const;
+  absl::Status PredictSoftmax(const OpContext& op_context,
+                              NodeCosts* node_costs) const;
+  absl::Status PredictResizeBilinear(const OpContext& op_context,
+                                     NodeCosts* node_costs) const;
+  absl::Status PredictCropAndResize(const OpContext& op_context,
+                                    NodeCosts* node_costs) const;
+
+  int64_t GetSoftmaxComputeOps(const OpContext& op_context) const;
+
+  // Generic cost prediction method for fused operations.
+  absl::Status PredictFusedOp(const OpContext& op_context,
+                              const std::vector<OpContext>& fused_op_contexts,
+                              NodeCosts* node_costs) const;
+
+  // Utility function for safe division. Returns 0
+  // if rhs is 0 or negative.
+  static double SafeDiv(const double lhs, const double rhs) {
+    if (rhs > 0) {
+      return lhs / rhs;
+    } else {
+      return 0.0;
+    }
+  }
+
+  // This family of routines counts the number of operations to perform the
+  // specified TensorFlow Op.
+  struct MatMulDimensions {
+    int m;
+    int n;
+    int k;
+  };
+  struct BatchMatMulDimensions {
+    std::vector<int> batch_dims;
+    MatMulDimensions matmul_dims;
+  };
+  struct ConvolutionDimensions {
+    int64_t batch;  // Batch size.
+    int64_t ix;     // Input size x.
+    int64_t iy;     // Input size y.
+    int64_t iz;     // Input depth.
+    int64_t kx;     // Kernel x.
+    int64_t ky;     // Kernel y.
+    int64_t kz;     // Kernel depth (in case of group convolution, this will be
+                    // smaller than input depth).
+    int64_t oz;     // Output depth.
+    int64_t ox;     // Output size x.
+    int64_t oy;     // Output size y.
+    int64_t sx;     // Stride x.
+    int64_t sy;     // Stride y.
+    Padding padding;  // SAME or VALID.
+  };
+  static int64_t CountConv2DOperations(const OpInfo& op_info,
+                                       bool* found_unknown_shapes);
+  static int64_t CountConv2DOperations(const OpInfo& op_info,
+                                       ConvolutionDimensions* conv_info,
+                                       bool* found_unknown_shapes);
+  static int64_t CountMatMulOperations(const OpInfo& op_info,
+                                       bool* found_unknown_shapes);
+  static int64_t CountMatMulOperations(const OpInfo& op_info,
+                                       MatMulDimensions* mat_mul,
+                                       bool* found_unknown_shapes);
+  static int64_t CountMatMulOperations(const OpInfo& op_info, bool transpose_a,
+                                       bool transpose_b,
+                                       MatMulDimensions* mat_mul,
+                                       bool* found_unknown_shapes);
+  bool GenerateBatchMatmulContextFromEinsum(const OpContext& einsum_context,
+                                            OpContext* batch_matmul_context,
+                                            bool* found_unknown_shapes) const;
+  static int64_t CountBatchMatMulOperations(const OpInfo& op_info,
+                                            bool* found_unknown_shapes);
+  static int64_t CountBatchMatMulOperations(
+      const OpInfo& op_info, BatchMatMulDimensions* batch_mat_mul,
+      bool* found_unknown_shapes);
+  static int64_t CountConv2DBackpropInputOperations(
+      const OpInfo& op_info, ConvolutionDimensions* returned_conv_dims,
+      bool* found_unknown_shapes);
+  static int64_t CountConv2DBackpropFilterOperations(
+      const OpInfo& op_info, ConvolutionDimensions* returned_conv_dims,
+      bool* found_unknown_shapes);
+
+  // Calculate the element count of an input/output tensor.
+  static int64_t CalculateTensorElementCount(
+      const OpInfo::TensorProperties& tensor, bool* found_unknown_shapes);
+
+  // Calculate the total size in bytes of an input/output tensor.
+  static int64_t CalculateTensorSize(const OpInfo::TensorProperties& tensor,
+                                     bool* found_unknown_shapes);
+
+  // Calculate the element count of the largest
+  // input of specified TensorFlow op.
+  static int64_t CalculateLargestInputCount(const OpInfo& op_info,
+                                            bool* found_unknown_shapes);
+
+  // Calculate the total size in bytes of the all
+  // the inputs of specified TensorFlow op.
+  static int64_t CalculateInputSize(const OpInfo& op_info,
+                                    bool* found_unknown_shapes);
+
+  // Same, but a vector format: one for each input.
+  static std::vector<int64_t> CalculateInputTensorSize(
+      const OpInfo& op_info, bool* found_unknown_shapes);
+
+  // Calculate the total size in bytes of the all
+  // the outputs of specified TensorFlow op.
+  static int64_t CalculateOutputSize(const OpInfo& op_info,
+                                     bool* found_unknown_shapes);
+
+  // Same, but a vector format: one for each output.
+  static std::vector<int64_t> CalculateOutputTensorSize(
+      const OpInfo& op_info, bool* found_unknown_shapes);
+
+  // For convolution and its grad ops.
+  static ConvolutionDimensions ConvolutionDimensionsFromInputs(
+      const TensorShapeProto& original_image_shape,
+      const TensorShapeProto& original_filter_shape, const OpInfo& op_info,
+      bool* found_unknown_shapes);
+
+  // For Pooling, FusedBatchNorm, and their grad ops.
+  static absl::StatusOr<ConvolutionDimensions> OpDimensionsFromInputs(
+      const TensorShapeProto& original_image_shape, const OpInfo& op_info,
+      bool* found_unknown_shapes);
+
+  // Helper to construct child operation contexts for the component operations
+  // of fused ops.
+  static OpContext FusedChildContext(
+      const OpContext& parent, const string& op_name,
+      const OpInfo::TensorProperties& output,
+      const std::vector<OpInfo::TensorProperties>& inputs);
+
+  // Helper to construct tensor shapes.
+  static OpInfo::TensorProperties DescribeTensor(
+      DataType type, const std::vector<int64_t>& dims);
+
+  // Helper method for building common case NodeCosts.
+  static absl::Status PredictDefaultNodeCosts(int64_t num_compute_ops,
+                                              const OpContext& op_context,
+                                              bool* found_unknown_shapes,
+                                              NodeCosts* node_costs);
+
+ protected:
+  std::map<string, int> elementwise_ops_;
+  typedef std::function<absl::Status(const OpContext& op_context, NodeCosts*)>
+      CostImpl;
+  std::map<string, CostImpl> device_cost_impl_;
+  // If true, assume compute and memory overlap; hence, the op cost is max of
+  // compute_time and memory_time, instead of sum of those two.
+  bool compute_memory_overlap_;
+  std::set<string> persistent_ops_;
+
+ private:
+  friend class OpLevelCostEstimatorTest;
+};
+
+}  // end namespace grappler
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_COSTS_OP_LEVEL_COST_ESTIMATOR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/costs/op_performance_data.pb.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/costs/op_performance_data.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..7d291b005249bca273ac60ebb464789e515a5030
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/costs/op_performance_data.pb.h
@@ -0,0 +1,3193 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: tensorflow/core/grappler/costs/op_performance_data.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fgrappler_2fcosts_2fop_5fperformance_5fdata_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fgrappler_2fcosts_2fop_5fperformance_5fdata_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3021000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3021009 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/map.h>  // IWYU pragma: export
+#include <google/protobuf/map_entry.h>
+#include <google/protobuf/map_field_inl.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "tensorflow/core/framework/tensor.pb.h"
+#include "tensorflow/core/framework/tensor_shape.pb.h"
+#include "tensorflow/core/framework/types.pb.h"
+#include "tensorflow/core/framework/attr_value.pb.h"
+#include "tensorflow/core/protobuf/device_properties.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_tensorflow_2fcore_2fgrappler_2fcosts_2fop_5fperformance_5fdata_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_tensorflow_2fcore_2fgrappler_2fcosts_2fop_5fperformance_5fdata_2eproto {
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_tensorflow_2fcore_2fgrappler_2fcosts_2fop_5fperformance_5fdata_2eproto;
+namespace tensorflow {
+class LogNormalDistribution;
+struct LogNormalDistributionDefaultTypeInternal;
+extern LogNormalDistributionDefaultTypeInternal _LogNormalDistribution_default_instance_;
+class NormalDistribution;
+struct NormalDistributionDefaultTypeInternal;
+extern NormalDistributionDefaultTypeInternal _NormalDistribution_default_instance_;
+class OpInfo;
+struct OpInfoDefaultTypeInternal;
+extern OpInfoDefaultTypeInternal _OpInfo_default_instance_;
+class OpInfo_AttrEntry_DoNotUse;
+struct OpInfo_AttrEntry_DoNotUseDefaultTypeInternal;
+extern OpInfo_AttrEntry_DoNotUseDefaultTypeInternal _OpInfo_AttrEntry_DoNotUse_default_instance_;
+class OpInfo_TensorProperties;
+struct OpInfo_TensorPropertiesDefaultTypeInternal;
+extern OpInfo_TensorPropertiesDefaultTypeInternal _OpInfo_TensorProperties_default_instance_;
+class OpPerformance;
+struct OpPerformanceDefaultTypeInternal;
+extern OpPerformanceDefaultTypeInternal _OpPerformance_default_instance_;
+class OpPerformanceList;
+struct OpPerformanceListDefaultTypeInternal;
+extern OpPerformanceListDefaultTypeInternal _OpPerformanceList_default_instance_;
+class OpPerformance_OpMemory;
+struct OpPerformance_OpMemoryDefaultTypeInternal;
+extern OpPerformance_OpMemoryDefaultTypeInternal _OpPerformance_OpMemory_default_instance_;
+class SessionInfo;
+struct SessionInfoDefaultTypeInternal;
+extern SessionInfoDefaultTypeInternal _SessionInfo_default_instance_;
+}  // namespace tensorflow
+PROTOBUF_NAMESPACE_OPEN
+template<> ::tensorflow::LogNormalDistribution* Arena::CreateMaybeMessage<::tensorflow::LogNormalDistribution>(Arena*);
+template<> ::tensorflow::NormalDistribution* Arena::CreateMaybeMessage<::tensorflow::NormalDistribution>(Arena*);
+template<> ::tensorflow::OpInfo* Arena::CreateMaybeMessage<::tensorflow::OpInfo>(Arena*);
+template<> ::tensorflow::OpInfo_AttrEntry_DoNotUse* Arena::CreateMaybeMessage<::tensorflow::OpInfo_AttrEntry_DoNotUse>(Arena*);
+template<> ::tensorflow::OpInfo_TensorProperties* Arena::CreateMaybeMessage<::tensorflow::OpInfo_TensorProperties>(Arena*);
+template<> ::tensorflow::OpPerformance* Arena::CreateMaybeMessage<::tensorflow::OpPerformance>(Arena*);
+template<> ::tensorflow::OpPerformanceList* Arena::CreateMaybeMessage<::tensorflow::OpPerformanceList>(Arena*);
+template<> ::tensorflow::OpPerformance_OpMemory* Arena::CreateMaybeMessage<::tensorflow::OpPerformance_OpMemory>(Arena*);
+template<> ::tensorflow::SessionInfo* Arena::CreateMaybeMessage<::tensorflow::SessionInfo>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace tensorflow {
+
+// ===================================================================
+
+class SessionInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.SessionInfo) */ {
+ public:
+  inline SessionInfo() : SessionInfo(nullptr) {}
+  ~SessionInfo() override;
+  explicit PROTOBUF_CONSTEXPR SessionInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SessionInfo(const SessionInfo& from);
+  SessionInfo(SessionInfo&& from) noexcept
+    : SessionInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline SessionInfo& operator=(const SessionInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SessionInfo& operator=(SessionInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SessionInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SessionInfo* internal_default_instance() {
+    return reinterpret_cast<const SessionInfo*>(
+               &_SessionInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(SessionInfo& a, SessionInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SessionInfo* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SessionInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SessionInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SessionInfo>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SessionInfo& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const SessionInfo& from) {
+    SessionInfo::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SessionInfo* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.SessionInfo";
+  }
+  protected:
+  explicit SessionInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kIntraOpParallelismFieldNumber = 1,
+  };
+  // int64 intra_op_parallelism = 1;
+  void clear_intra_op_parallelism();
+  int64_t intra_op_parallelism() const;
+  void set_intra_op_parallelism(int64_t value);
+  private:
+  int64_t _internal_intra_op_parallelism() const;
+  void _internal_set_intra_op_parallelism(int64_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.SessionInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    int64_t intra_op_parallelism_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fgrappler_2fcosts_2fop_5fperformance_5fdata_2eproto;
+};
+// -------------------------------------------------------------------
+
+class OpInfo_AttrEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<OpInfo_AttrEntry_DoNotUse, 
+    std::string, ::tensorflow::AttrValue,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> {
+public:
+  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<OpInfo_AttrEntry_DoNotUse, 
+    std::string, ::tensorflow::AttrValue,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
+  OpInfo_AttrEntry_DoNotUse();
+  explicit PROTOBUF_CONSTEXPR OpInfo_AttrEntry_DoNotUse(
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+  explicit OpInfo_AttrEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  void MergeFrom(const OpInfo_AttrEntry_DoNotUse& other);
+  static const OpInfo_AttrEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const OpInfo_AttrEntry_DoNotUse*>(&_OpInfo_AttrEntry_DoNotUse_default_instance_); }
+  static bool ValidateKey(std::string* s) {
+    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "tensorflow.OpInfo.AttrEntry.key");
+ }
+  static bool ValidateValue(void*) { return true; }
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+  friend struct ::TableStruct_tensorflow_2fcore_2fgrappler_2fcosts_2fop_5fperformance_5fdata_2eproto;
+};
+
+// -------------------------------------------------------------------
+
+class OpInfo_TensorProperties final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.OpInfo.TensorProperties) */ {
+ public:
+  inline OpInfo_TensorProperties() : OpInfo_TensorProperties(nullptr) {}
+  ~OpInfo_TensorProperties() override;
+  explicit PROTOBUF_CONSTEXPR OpInfo_TensorProperties(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  OpInfo_TensorProperties(const OpInfo_TensorProperties& from);
+  OpInfo_TensorProperties(OpInfo_TensorProperties&& from) noexcept
+    : OpInfo_TensorProperties() {
+    *this = ::std::move(from);
+  }
+
+  inline OpInfo_TensorProperties& operator=(const OpInfo_TensorProperties& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline OpInfo_TensorProperties& operator=(OpInfo_TensorProperties&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const OpInfo_TensorProperties& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const OpInfo_TensorProperties* internal_default_instance() {
+    return reinterpret_cast<const OpInfo_TensorProperties*>(
+               &_OpInfo_TensorProperties_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(OpInfo_TensorProperties& a, OpInfo_TensorProperties& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(OpInfo_TensorProperties* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(OpInfo_TensorProperties* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  OpInfo_TensorProperties* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<OpInfo_TensorProperties>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const OpInfo_TensorProperties& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const OpInfo_TensorProperties& from) {
+    OpInfo_TensorProperties::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(OpInfo_TensorProperties* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.OpInfo.TensorProperties";
+  }
+  protected:
+  explicit OpInfo_TensorProperties(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kShapeFieldNumber = 2,
+    kValueFieldNumber = 3,
+    kDtypeFieldNumber = 1,
+  };
+  // .tensorflow.TensorShapeProto shape = 2;
+  bool has_shape() const;
+  private:
+  bool _internal_has_shape() const;
+  public:
+  void clear_shape();
+  const ::tensorflow::TensorShapeProto& shape() const;
+  PROTOBUF_NODISCARD ::tensorflow::TensorShapeProto* release_shape();
+  ::tensorflow::TensorShapeProto* mutable_shape();
+  void set_allocated_shape(::tensorflow::TensorShapeProto* shape);
+  private:
+  const ::tensorflow::TensorShapeProto& _internal_shape() const;
+  ::tensorflow::TensorShapeProto* _internal_mutable_shape();
+  public:
+  void unsafe_arena_set_allocated_shape(
+      ::tensorflow::TensorShapeProto* shape);
+  ::tensorflow::TensorShapeProto* unsafe_arena_release_shape();
+
+  // .tensorflow.TensorProto value = 3;
+  bool has_value() const;
+  private:
+  bool _internal_has_value() const;
+  public:
+  void clear_value();
+  const ::tensorflow::TensorProto& value() const;
+  PROTOBUF_NODISCARD ::tensorflow::TensorProto* release_value();
+  ::tensorflow::TensorProto* mutable_value();
+  void set_allocated_value(::tensorflow::TensorProto* value);
+  private:
+  const ::tensorflow::TensorProto& _internal_value() const;
+  ::tensorflow::TensorProto* _internal_mutable_value();
+  public:
+  void unsafe_arena_set_allocated_value(
+      ::tensorflow::TensorProto* value);
+  ::tensorflow::TensorProto* unsafe_arena_release_value();
+
+  // .tensorflow.DataType dtype = 1;
+  void clear_dtype();
+  ::tensorflow::DataType dtype() const;
+  void set_dtype(::tensorflow::DataType value);
+  private:
+  ::tensorflow::DataType _internal_dtype() const;
+  void _internal_set_dtype(::tensorflow::DataType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.OpInfo.TensorProperties)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::tensorflow::TensorShapeProto* shape_;
+    ::tensorflow::TensorProto* value_;
+    int dtype_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fgrappler_2fcosts_2fop_5fperformance_5fdata_2eproto;
+};
+// -------------------------------------------------------------------
+
+class OpInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.OpInfo) */ {
+ public:
+  inline OpInfo() : OpInfo(nullptr) {}
+  ~OpInfo() override;
+  explicit PROTOBUF_CONSTEXPR OpInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  OpInfo(const OpInfo& from);
+  OpInfo(OpInfo&& from) noexcept
+    : OpInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline OpInfo& operator=(const OpInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline OpInfo& operator=(OpInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const OpInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const OpInfo* internal_default_instance() {
+    return reinterpret_cast<const OpInfo*>(
+               &_OpInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  friend void swap(OpInfo& a, OpInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(OpInfo* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(OpInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  OpInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<OpInfo>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const OpInfo& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const OpInfo& from) {
+    OpInfo::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(OpInfo* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.OpInfo";
+  }
+  protected:
+  explicit OpInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef OpInfo_TensorProperties TensorProperties;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kAttrFieldNumber = 2,
+    kInputsFieldNumber = 3,
+    kOutputsFieldNumber = 5,
+    kOpFieldNumber = 1,
+    kDeviceFieldNumber = 4,
+    kSessionInfoFieldNumber = 6,
+  };
+  // map<string, .tensorflow.AttrValue> attr = 2;
+  int attr_size() const;
+  private:
+  int _internal_attr_size() const;
+  public:
+  void clear_attr();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::AttrValue >&
+      _internal_attr() const;
+  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::AttrValue >*
+      _internal_mutable_attr();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::AttrValue >&
+      attr() const;
+  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::AttrValue >*
+      mutable_attr();
+
+  // repeated .tensorflow.OpInfo.TensorProperties inputs = 3;
+  int inputs_size() const;
+  private:
+  int _internal_inputs_size() const;
+  public:
+  void clear_inputs();
+  ::tensorflow::OpInfo_TensorProperties* mutable_inputs(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpInfo_TensorProperties >*
+      mutable_inputs();
+  private:
+  const ::tensorflow::OpInfo_TensorProperties& _internal_inputs(int index) const;
+  ::tensorflow::OpInfo_TensorProperties* _internal_add_inputs();
+  public:
+  const ::tensorflow::OpInfo_TensorProperties& inputs(int index) const;
+  ::tensorflow::OpInfo_TensorProperties* add_inputs();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpInfo_TensorProperties >&
+      inputs() const;
+
+  // repeated .tensorflow.OpInfo.TensorProperties outputs = 5;
+  int outputs_size() const;
+  private:
+  int _internal_outputs_size() const;
+  public:
+  void clear_outputs();
+  ::tensorflow::OpInfo_TensorProperties* mutable_outputs(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpInfo_TensorProperties >*
+      mutable_outputs();
+  private:
+  const ::tensorflow::OpInfo_TensorProperties& _internal_outputs(int index) const;
+  ::tensorflow::OpInfo_TensorProperties* _internal_add_outputs();
+  public:
+  const ::tensorflow::OpInfo_TensorProperties& outputs(int index) const;
+  ::tensorflow::OpInfo_TensorProperties* add_outputs();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpInfo_TensorProperties >&
+      outputs() const;
+
+  // string op = 1;
+  void clear_op();
+  const std::string& op() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_op(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_op();
+  PROTOBUF_NODISCARD std::string* release_op();
+  void set_allocated_op(std::string* op);
+  private:
+  const std::string& _internal_op() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_op(const std::string& value);
+  std::string* _internal_mutable_op();
+  public:
+
+  // .tensorflow.DeviceProperties device = 4;
+  bool has_device() const;
+  private:
+  bool _internal_has_device() const;
+  public:
+  void clear_device();
+  const ::tensorflow::DeviceProperties& device() const;
+  PROTOBUF_NODISCARD ::tensorflow::DeviceProperties* release_device();
+  ::tensorflow::DeviceProperties* mutable_device();
+  void set_allocated_device(::tensorflow::DeviceProperties* device);
+  private:
+  const ::tensorflow::DeviceProperties& _internal_device() const;
+  ::tensorflow::DeviceProperties* _internal_mutable_device();
+  public:
+  void unsafe_arena_set_allocated_device(
+      ::tensorflow::DeviceProperties* device);
+  ::tensorflow::DeviceProperties* unsafe_arena_release_device();
+
+  // .tensorflow.SessionInfo session_info = 6;
+  bool has_session_info() const;
+  private:
+  bool _internal_has_session_info() const;
+  public:
+  void clear_session_info();
+  const ::tensorflow::SessionInfo& session_info() const;
+  PROTOBUF_NODISCARD ::tensorflow::SessionInfo* release_session_info();
+  ::tensorflow::SessionInfo* mutable_session_info();
+  void set_allocated_session_info(::tensorflow::SessionInfo* session_info);
+  private:
+  const ::tensorflow::SessionInfo& _internal_session_info() const;
+  ::tensorflow::SessionInfo* _internal_mutable_session_info();
+  public:
+  void unsafe_arena_set_allocated_session_info(
+      ::tensorflow::SessionInfo* session_info);
+  ::tensorflow::SessionInfo* unsafe_arena_release_session_info();
+
+  // @@protoc_insertion_point(class_scope:tensorflow.OpInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::MapField<
+        OpInfo_AttrEntry_DoNotUse,
+        std::string, ::tensorflow::AttrValue,
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> attr_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpInfo_TensorProperties > inputs_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpInfo_TensorProperties > outputs_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr op_;
+    ::tensorflow::DeviceProperties* device_;
+    ::tensorflow::SessionInfo* session_info_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fgrappler_2fcosts_2fop_5fperformance_5fdata_2eproto;
+};
+// -------------------------------------------------------------------
+
+class NormalDistribution final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.NormalDistribution) */ {
+ public:
+  inline NormalDistribution() : NormalDistribution(nullptr) {}
+  ~NormalDistribution() override;
+  explicit PROTOBUF_CONSTEXPR NormalDistribution(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  NormalDistribution(const NormalDistribution& from);
+  NormalDistribution(NormalDistribution&& from) noexcept
+    : NormalDistribution() {
+    *this = ::std::move(from);
+  }
+
+  inline NormalDistribution& operator=(const NormalDistribution& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline NormalDistribution& operator=(NormalDistribution&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const NormalDistribution& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const NormalDistribution* internal_default_instance() {
+    return reinterpret_cast<const NormalDistribution*>(
+               &_NormalDistribution_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    4;
+
+  friend void swap(NormalDistribution& a, NormalDistribution& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(NormalDistribution* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(NormalDistribution* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  NormalDistribution* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<NormalDistribution>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const NormalDistribution& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const NormalDistribution& from) {
+    NormalDistribution::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(NormalDistribution* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.NormalDistribution";
+  }
+  protected:
+  explicit NormalDistribution(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kMuFieldNumber = 1,
+    kSigmaFieldNumber = 2,
+  };
+  // double mu = 1;
+  void clear_mu();
+  double mu() const;
+  void set_mu(double value);
+  private:
+  double _internal_mu() const;
+  void _internal_set_mu(double value);
+  public:
+
+  // double sigma = 2;
+  void clear_sigma();
+  double sigma() const;
+  void set_sigma(double value);
+  private:
+  double _internal_sigma() const;
+  void _internal_set_sigma(double value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.NormalDistribution)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    double mu_;
+    double sigma_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fgrappler_2fcosts_2fop_5fperformance_5fdata_2eproto;
+};
+// -------------------------------------------------------------------
+
+class LogNormalDistribution final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.LogNormalDistribution) */ {
+ public:
+  inline LogNormalDistribution() : LogNormalDistribution(nullptr) {}
+  ~LogNormalDistribution() override;
+  explicit PROTOBUF_CONSTEXPR LogNormalDistribution(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  LogNormalDistribution(const LogNormalDistribution& from);
+  LogNormalDistribution(LogNormalDistribution&& from) noexcept
+    : LogNormalDistribution() {
+    *this = ::std::move(from);
+  }
+
+  inline LogNormalDistribution& operator=(const LogNormalDistribution& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline LogNormalDistribution& operator=(LogNormalDistribution&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const LogNormalDistribution& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const LogNormalDistribution* internal_default_instance() {
+    return reinterpret_cast<const LogNormalDistribution*>(
+               &_LogNormalDistribution_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    5;
+
+  friend void swap(LogNormalDistribution& a, LogNormalDistribution& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(LogNormalDistribution* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(LogNormalDistribution* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  LogNormalDistribution* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<LogNormalDistribution>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const LogNormalDistribution& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const LogNormalDistribution& from) {
+    LogNormalDistribution::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(LogNormalDistribution* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.LogNormalDistribution";
+  }
+  protected:
+  explicit LogNormalDistribution(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kMuFieldNumber = 1,
+    kSigmaFieldNumber = 2,
+  };
+  // double mu = 1;
+  void clear_mu();
+  double mu() const;
+  void set_mu(double value);
+  private:
+  double _internal_mu() const;
+  void _internal_set_mu(double value);
+  public:
+
+  // double sigma = 2;
+  void clear_sigma();
+  double sigma() const;
+  void set_sigma(double value);
+  private:
+  double _internal_sigma() const;
+  void _internal_set_sigma(double value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.LogNormalDistribution)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    double mu_;
+    double sigma_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fgrappler_2fcosts_2fop_5fperformance_5fdata_2eproto;
+};
+// -------------------------------------------------------------------
+
+class OpPerformance_OpMemory final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.OpPerformance.OpMemory) */ {
+ public:
+  inline OpPerformance_OpMemory() : OpPerformance_OpMemory(nullptr) {}
+  ~OpPerformance_OpMemory() override;
+  explicit PROTOBUF_CONSTEXPR OpPerformance_OpMemory(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  OpPerformance_OpMemory(const OpPerformance_OpMemory& from);
+  OpPerformance_OpMemory(OpPerformance_OpMemory&& from) noexcept
+    : OpPerformance_OpMemory() {
+    *this = ::std::move(from);
+  }
+
+  inline OpPerformance_OpMemory& operator=(const OpPerformance_OpMemory& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline OpPerformance_OpMemory& operator=(OpPerformance_OpMemory&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const OpPerformance_OpMemory& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const OpPerformance_OpMemory* internal_default_instance() {
+    return reinterpret_cast<const OpPerformance_OpMemory*>(
+               &_OpPerformance_OpMemory_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    6;
+
+  friend void swap(OpPerformance_OpMemory& a, OpPerformance_OpMemory& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(OpPerformance_OpMemory* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(OpPerformance_OpMemory* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  OpPerformance_OpMemory* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<OpPerformance_OpMemory>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const OpPerformance_OpMemory& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const OpPerformance_OpMemory& from) {
+    OpPerformance_OpMemory::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(OpPerformance_OpMemory* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.OpPerformance.OpMemory";
+  }
+  protected:
+  explicit OpPerformance_OpMemory(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kOutputMemoryFieldNumber = 1,
+    kTempMemoryFieldNumber = 2,
+    kDeviceTempMemoryFieldNumber = 3,
+    kPersistentMemoryFieldNumber = 4,
+    kDevicePersistentMemoryFieldNumber = 5,
+  };
+  // repeated int64 output_memory = 1;
+  int output_memory_size() const;
+  private:
+  int _internal_output_memory_size() const;
+  public:
+  void clear_output_memory();
+  private:
+  int64_t _internal_output_memory(int index) const;
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
+      _internal_output_memory() const;
+  void _internal_add_output_memory(int64_t value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
+      _internal_mutable_output_memory();
+  public:
+  int64_t output_memory(int index) const;
+  void set_output_memory(int index, int64_t value);
+  void add_output_memory(int64_t value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
+      output_memory() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
+      mutable_output_memory();
+
+  // int64 temp_memory = 2;
+  void clear_temp_memory();
+  int64_t temp_memory() const;
+  void set_temp_memory(int64_t value);
+  private:
+  int64_t _internal_temp_memory() const;
+  void _internal_set_temp_memory(int64_t value);
+  public:
+
+  // int64 device_temp_memory = 3 [deprecated = true];
+  PROTOBUF_DEPRECATED void clear_device_temp_memory();
+  PROTOBUF_DEPRECATED int64_t device_temp_memory() const;
+  PROTOBUF_DEPRECATED void set_device_temp_memory(int64_t value);
+  private:
+  int64_t _internal_device_temp_memory() const;
+  void _internal_set_device_temp_memory(int64_t value);
+  public:
+
+  // int64 persistent_memory = 4;
+  void clear_persistent_memory();
+  int64_t persistent_memory() const;
+  void set_persistent_memory(int64_t value);
+  private:
+  int64_t _internal_persistent_memory() const;
+  void _internal_set_persistent_memory(int64_t value);
+  public:
+
+  // int64 device_persistent_memory = 5 [deprecated = true];
+  PROTOBUF_DEPRECATED void clear_device_persistent_memory();
+  PROTOBUF_DEPRECATED int64_t device_persistent_memory() const;
+  PROTOBUF_DEPRECATED void set_device_persistent_memory(int64_t value);
+  private:
+  int64_t _internal_device_persistent_memory() const;
+  void _internal_set_device_persistent_memory(int64_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:tensorflow.OpPerformance.OpMemory)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > output_memory_;
+    mutable std::atomic<int> _output_memory_cached_byte_size_;
+    int64_t temp_memory_;
+    int64_t device_temp_memory_;
+    int64_t persistent_memory_;
+    int64_t device_persistent_memory_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fgrappler_2fcosts_2fop_5fperformance_5fdata_2eproto;
+};
+// -------------------------------------------------------------------
+
+class OpPerformance final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.OpPerformance) */ {
+ public:
+  inline OpPerformance() : OpPerformance(nullptr) {}
+  ~OpPerformance() override;
+  explicit PROTOBUF_CONSTEXPR OpPerformance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  OpPerformance(const OpPerformance& from);
+  OpPerformance(OpPerformance&& from) noexcept
+    : OpPerformance() {
+    *this = ::std::move(from);
+  }
+
+  inline OpPerformance& operator=(const OpPerformance& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline OpPerformance& operator=(OpPerformance&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const OpPerformance& default_instance() {
+    return *internal_default_instance();
+  }
+  enum ExecutionTimeCase {
+    kExecutionTimeNormal = 10,
+    kExecutionTimeLogNormal = 11,
+    EXECUTION_TIME_NOT_SET = 0,
+  };
+
+  static inline const OpPerformance* internal_default_instance() {
+    return reinterpret_cast<const OpPerformance*>(
+               &_OpPerformance_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    7;
+
+  friend void swap(OpPerformance& a, OpPerformance& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(OpPerformance* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(OpPerformance* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  OpPerformance* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<OpPerformance>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const OpPerformance& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const OpPerformance& from) {
+    OpPerformance::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(OpPerformance* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.OpPerformance";
+  }
+  protected:
+  explicit OpPerformance(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef OpPerformance_OpMemory OpMemory;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNodeFieldNumber = 5,
+    kOpFieldNumber = 1,
+    kOpMemoryFieldNumber = 9,
+    kSessionInfoFieldNumber = 12,
+    kTemporaryMemorySizeFieldNumber = 2,
+    kComputeCostFieldNumber = 3,
+    kComputeEfficiencyFieldNumber = 4,
+    kComputeTimeFieldNumber = 6,
+    kMemoryTimeFieldNumber = 7,
+    kMemoryEfficiencyFieldNumber = 8,
+    kExecutionTimeNormalFieldNumber = 10,
+    kExecutionTimeLogNormalFieldNumber = 11,
+  };
+  // string node = 5;
+  void clear_node();
+  const std::string& node() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_node(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_node();
+  PROTOBUF_NODISCARD std::string* release_node();
+  void set_allocated_node(std::string* node);
+  private:
+  const std::string& _internal_node() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_node(const std::string& value);
+  std::string* _internal_mutable_node();
+  public:
+
+  // .tensorflow.OpInfo op = 1;
+  bool has_op() const;
+  private:
+  bool _internal_has_op() const;
+  public:
+  void clear_op();
+  const ::tensorflow::OpInfo& op() const;
+  PROTOBUF_NODISCARD ::tensorflow::OpInfo* release_op();
+  ::tensorflow::OpInfo* mutable_op();
+  void set_allocated_op(::tensorflow::OpInfo* op);
+  private:
+  const ::tensorflow::OpInfo& _internal_op() const;
+  ::tensorflow::OpInfo* _internal_mutable_op();
+  public:
+  void unsafe_arena_set_allocated_op(
+      ::tensorflow::OpInfo* op);
+  ::tensorflow::OpInfo* unsafe_arena_release_op();
+
+  // .tensorflow.OpPerformance.OpMemory op_memory = 9;
+  bool has_op_memory() const;
+  private:
+  bool _internal_has_op_memory() const;
+  public:
+  void clear_op_memory();
+  const ::tensorflow::OpPerformance_OpMemory& op_memory() const;
+  PROTOBUF_NODISCARD ::tensorflow::OpPerformance_OpMemory* release_op_memory();
+  ::tensorflow::OpPerformance_OpMemory* mutable_op_memory();
+  void set_allocated_op_memory(::tensorflow::OpPerformance_OpMemory* op_memory);
+  private:
+  const ::tensorflow::OpPerformance_OpMemory& _internal_op_memory() const;
+  ::tensorflow::OpPerformance_OpMemory* _internal_mutable_op_memory();
+  public:
+  void unsafe_arena_set_allocated_op_memory(
+      ::tensorflow::OpPerformance_OpMemory* op_memory);
+  ::tensorflow::OpPerformance_OpMemory* unsafe_arena_release_op_memory();
+
+  // .tensorflow.SessionInfo session_info = 12 [deprecated = true];
+  PROTOBUF_DEPRECATED bool has_session_info() const;
+  private:
+  bool _internal_has_session_info() const;
+  public:
+  PROTOBUF_DEPRECATED void clear_session_info();
+  PROTOBUF_DEPRECATED const ::tensorflow::SessionInfo& session_info() const;
+  PROTOBUF_NODISCARD PROTOBUF_DEPRECATED ::tensorflow::SessionInfo* release_session_info();
+  PROTOBUF_DEPRECATED ::tensorflow::SessionInfo* mutable_session_info();
+  PROTOBUF_DEPRECATED void set_allocated_session_info(::tensorflow::SessionInfo* session_info);
+  private:
+  const ::tensorflow::SessionInfo& _internal_session_info() const;
+  ::tensorflow::SessionInfo* _internal_mutable_session_info();
+  public:
+  PROTOBUF_DEPRECATED void unsafe_arena_set_allocated_session_info(
+      ::tensorflow::SessionInfo* session_info);
+  PROTOBUF_DEPRECATED ::tensorflow::SessionInfo* unsafe_arena_release_session_info();
+
+  // int64 temporary_memory_size = 2;
+  void clear_temporary_memory_size();
+  int64_t temporary_memory_size() const;
+  void set_temporary_memory_size(int64_t value);
+  private:
+  int64_t _internal_temporary_memory_size() const;
+  void _internal_set_temporary_memory_size(int64_t value);
+  public:
+
+  // int64 compute_cost = 3;
+  void clear_compute_cost();
+  int64_t compute_cost() const;
+  void set_compute_cost(int64_t value);
+  private:
+  int64_t _internal_compute_cost() const;
+  void _internal_set_compute_cost(int64_t value);
+  public:
+
+  // double compute_efficiency = 4;
+  void clear_compute_efficiency();
+  double compute_efficiency() const;
+  void set_compute_efficiency(double value);
+  private:
+  double _internal_compute_efficiency() const;
+  void _internal_set_compute_efficiency(double value);
+  public:
+
+  // int64 compute_time = 6;
+  void clear_compute_time();
+  int64_t compute_time() const;
+  void set_compute_time(int64_t value);
+  private:
+  int64_t _internal_compute_time() const;
+  void _internal_set_compute_time(int64_t value);
+  public:
+
+  // int64 memory_time = 7;
+  void clear_memory_time();
+  int64_t memory_time() const;
+  void set_memory_time(int64_t value);
+  private:
+  int64_t _internal_memory_time() const;
+  void _internal_set_memory_time(int64_t value);
+  public:
+
+  // double memory_efficiency = 8;
+  void clear_memory_efficiency();
+  double memory_efficiency() const;
+  void set_memory_efficiency(double value);
+  private:
+  double _internal_memory_efficiency() const;
+  void _internal_set_memory_efficiency(double value);
+  public:
+
+  // .tensorflow.NormalDistribution execution_time_normal = 10;
+  bool has_execution_time_normal() const;
+  private:
+  bool _internal_has_execution_time_normal() const;
+  public:
+  void clear_execution_time_normal();
+  const ::tensorflow::NormalDistribution& execution_time_normal() const;
+  PROTOBUF_NODISCARD ::tensorflow::NormalDistribution* release_execution_time_normal();
+  ::tensorflow::NormalDistribution* mutable_execution_time_normal();
+  void set_allocated_execution_time_normal(::tensorflow::NormalDistribution* execution_time_normal);
+  private:
+  const ::tensorflow::NormalDistribution& _internal_execution_time_normal() const;
+  ::tensorflow::NormalDistribution* _internal_mutable_execution_time_normal();
+  public:
+  void unsafe_arena_set_allocated_execution_time_normal(
+      ::tensorflow::NormalDistribution* execution_time_normal);
+  ::tensorflow::NormalDistribution* unsafe_arena_release_execution_time_normal();
+
+  // .tensorflow.LogNormalDistribution execution_time_log_normal = 11;
+  bool has_execution_time_log_normal() const;
+  private:
+  bool _internal_has_execution_time_log_normal() const;
+  public:
+  void clear_execution_time_log_normal();
+  const ::tensorflow::LogNormalDistribution& execution_time_log_normal() const;
+  PROTOBUF_NODISCARD ::tensorflow::LogNormalDistribution* release_execution_time_log_normal();
+  ::tensorflow::LogNormalDistribution* mutable_execution_time_log_normal();
+  void set_allocated_execution_time_log_normal(::tensorflow::LogNormalDistribution* execution_time_log_normal);
+  private:
+  const ::tensorflow::LogNormalDistribution& _internal_execution_time_log_normal() const;
+  ::tensorflow::LogNormalDistribution* _internal_mutable_execution_time_log_normal();
+  public:
+  void unsafe_arena_set_allocated_execution_time_log_normal(
+      ::tensorflow::LogNormalDistribution* execution_time_log_normal);
+  ::tensorflow::LogNormalDistribution* unsafe_arena_release_execution_time_log_normal();
+
+  void clear_execution_time();
+  ExecutionTimeCase execution_time_case() const;
+  // @@protoc_insertion_point(class_scope:tensorflow.OpPerformance)
+ private:
+  class _Internal;
+  void set_has_execution_time_normal();
+  void set_has_execution_time_log_normal();
+
+  inline bool has_execution_time() const;
+  inline void clear_has_execution_time();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr node_;
+    ::tensorflow::OpInfo* op_;
+    ::tensorflow::OpPerformance_OpMemory* op_memory_;
+    ::tensorflow::SessionInfo* session_info_;
+    int64_t temporary_memory_size_;
+    int64_t compute_cost_;
+    double compute_efficiency_;
+    int64_t compute_time_;
+    int64_t memory_time_;
+    double memory_efficiency_;
+    union ExecutionTimeUnion {
+      constexpr ExecutionTimeUnion() : _constinit_{} {}
+        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+      ::tensorflow::NormalDistribution* execution_time_normal_;
+      ::tensorflow::LogNormalDistribution* execution_time_log_normal_;
+    } execution_time_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    uint32_t _oneof_case_[1];
+
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fgrappler_2fcosts_2fop_5fperformance_5fdata_2eproto;
+};
+// -------------------------------------------------------------------
+
+class OpPerformanceList final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.OpPerformanceList) */ {
+ public:
+  inline OpPerformanceList() : OpPerformanceList(nullptr) {}
+  ~OpPerformanceList() override;
+  explicit PROTOBUF_CONSTEXPR OpPerformanceList(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  OpPerformanceList(const OpPerformanceList& from);
+  OpPerformanceList(OpPerformanceList&& from) noexcept
+    : OpPerformanceList() {
+    *this = ::std::move(from);
+  }
+
+  inline OpPerformanceList& operator=(const OpPerformanceList& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline OpPerformanceList& operator=(OpPerformanceList&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const OpPerformanceList& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const OpPerformanceList* internal_default_instance() {
+    return reinterpret_cast<const OpPerformanceList*>(
+               &_OpPerformanceList_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    8;
+
+  friend void swap(OpPerformanceList& a, OpPerformanceList& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(OpPerformanceList* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(OpPerformanceList* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  OpPerformanceList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<OpPerformanceList>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const OpPerformanceList& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const OpPerformanceList& from) {
+    OpPerformanceList::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(OpPerformanceList* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "tensorflow.OpPerformanceList";
+  }
+  protected:
+  explicit OpPerformanceList(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kOpPerformanceFieldNumber = 1,
+  };
+  // repeated .tensorflow.OpPerformance op_performance = 1;
+  int op_performance_size() const;
+  private:
+  int _internal_op_performance_size() const;
+  public:
+  void clear_op_performance();
+  ::tensorflow::OpPerformance* mutable_op_performance(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpPerformance >*
+      mutable_op_performance();
+  private:
+  const ::tensorflow::OpPerformance& _internal_op_performance(int index) const;
+  ::tensorflow::OpPerformance* _internal_add_op_performance();
+  public:
+  const ::tensorflow::OpPerformance& op_performance(int index) const;
+  ::tensorflow::OpPerformance* add_op_performance();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpPerformance >&
+      op_performance() const;
+
+  // @@protoc_insertion_point(class_scope:tensorflow.OpPerformanceList)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpPerformance > op_performance_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_tensorflow_2fcore_2fgrappler_2fcosts_2fop_5fperformance_5fdata_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// SessionInfo
+
+// int64 intra_op_parallelism = 1;
+inline void SessionInfo::clear_intra_op_parallelism() {
+  _impl_.intra_op_parallelism_ = int64_t{0};
+}
+inline int64_t SessionInfo::_internal_intra_op_parallelism() const {
+  return _impl_.intra_op_parallelism_;
+}
+inline int64_t SessionInfo::intra_op_parallelism() const {
+  // @@protoc_insertion_point(field_get:tensorflow.SessionInfo.intra_op_parallelism)
+  return _internal_intra_op_parallelism();
+}
+inline void SessionInfo::_internal_set_intra_op_parallelism(int64_t value) {
+  
+  _impl_.intra_op_parallelism_ = value;
+}
+inline void SessionInfo::set_intra_op_parallelism(int64_t value) {
+  _internal_set_intra_op_parallelism(value);
+  // @@protoc_insertion_point(field_set:tensorflow.SessionInfo.intra_op_parallelism)
+}
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// OpInfo_TensorProperties
+
+// .tensorflow.DataType dtype = 1;
+inline void OpInfo_TensorProperties::clear_dtype() {
+  _impl_.dtype_ = 0;
+}
+inline ::tensorflow::DataType OpInfo_TensorProperties::_internal_dtype() const {
+  return static_cast< ::tensorflow::DataType >(_impl_.dtype_);
+}
+inline ::tensorflow::DataType OpInfo_TensorProperties::dtype() const {
+  // @@protoc_insertion_point(field_get:tensorflow.OpInfo.TensorProperties.dtype)
+  return _internal_dtype();
+}
+inline void OpInfo_TensorProperties::_internal_set_dtype(::tensorflow::DataType value) {
+  
+  _impl_.dtype_ = value;
+}
+inline void OpInfo_TensorProperties::set_dtype(::tensorflow::DataType value) {
+  _internal_set_dtype(value);
+  // @@protoc_insertion_point(field_set:tensorflow.OpInfo.TensorProperties.dtype)
+}
+
+// .tensorflow.TensorShapeProto shape = 2;
+inline bool OpInfo_TensorProperties::_internal_has_shape() const {
+  return this != internal_default_instance() && _impl_.shape_ != nullptr;
+}
+inline bool OpInfo_TensorProperties::has_shape() const {
+  return _internal_has_shape();
+}
+inline const ::tensorflow::TensorShapeProto& OpInfo_TensorProperties::_internal_shape() const {
+  const ::tensorflow::TensorShapeProto* p = _impl_.shape_;
+  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::TensorShapeProto&>(
+      ::tensorflow::_TensorShapeProto_default_instance_);
+}
+inline const ::tensorflow::TensorShapeProto& OpInfo_TensorProperties::shape() const {
+  // @@protoc_insertion_point(field_get:tensorflow.OpInfo.TensorProperties.shape)
+  return _internal_shape();
+}
+inline void OpInfo_TensorProperties::unsafe_arena_set_allocated_shape(
+    ::tensorflow::TensorShapeProto* shape) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.shape_);
+  }
+  _impl_.shape_ = shape;
+  if (shape) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.OpInfo.TensorProperties.shape)
+}
+inline ::tensorflow::TensorShapeProto* OpInfo_TensorProperties::release_shape() {
+  
+  ::tensorflow::TensorShapeProto* temp = _impl_.shape_;
+  _impl_.shape_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::tensorflow::TensorShapeProto* OpInfo_TensorProperties::unsafe_arena_release_shape() {
+  // @@protoc_insertion_point(field_release:tensorflow.OpInfo.TensorProperties.shape)
+  
+  ::tensorflow::TensorShapeProto* temp = _impl_.shape_;
+  _impl_.shape_ = nullptr;
+  return temp;
+}
+inline ::tensorflow::TensorShapeProto* OpInfo_TensorProperties::_internal_mutable_shape() {
+  
+  if (_impl_.shape_ == nullptr) {
+    auto* p = CreateMaybeMessage<::tensorflow::TensorShapeProto>(GetArenaForAllocation());
+    _impl_.shape_ = p;
+  }
+  return _impl_.shape_;
+}
+inline ::tensorflow::TensorShapeProto* OpInfo_TensorProperties::mutable_shape() {
+  ::tensorflow::TensorShapeProto* _msg = _internal_mutable_shape();
+  // @@protoc_insertion_point(field_mutable:tensorflow.OpInfo.TensorProperties.shape)
+  return _msg;
+}
+inline void OpInfo_TensorProperties::set_allocated_shape(::tensorflow::TensorShapeProto* shape) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.shape_);
+  }
+  if (shape) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(shape));
+    if (message_arena != submessage_arena) {
+      shape = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, shape, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.shape_ = shape;
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.OpInfo.TensorProperties.shape)
+}
+
+// .tensorflow.TensorProto value = 3;
+inline bool OpInfo_TensorProperties::_internal_has_value() const {
+  return this != internal_default_instance() && _impl_.value_ != nullptr;
+}
+inline bool OpInfo_TensorProperties::has_value() const {
+  return _internal_has_value();
+}
+inline const ::tensorflow::TensorProto& OpInfo_TensorProperties::_internal_value() const {
+  const ::tensorflow::TensorProto* p = _impl_.value_;
+  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::TensorProto&>(
+      ::tensorflow::_TensorProto_default_instance_);
+}
+inline const ::tensorflow::TensorProto& OpInfo_TensorProperties::value() const {
+  // @@protoc_insertion_point(field_get:tensorflow.OpInfo.TensorProperties.value)
+  return _internal_value();
+}
+inline void OpInfo_TensorProperties::unsafe_arena_set_allocated_value(
+    ::tensorflow::TensorProto* value) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.value_);
+  }
+  _impl_.value_ = value;
+  if (value) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.OpInfo.TensorProperties.value)
+}
+inline ::tensorflow::TensorProto* OpInfo_TensorProperties::release_value() {
+  
+  ::tensorflow::TensorProto* temp = _impl_.value_;
+  _impl_.value_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::tensorflow::TensorProto* OpInfo_TensorProperties::unsafe_arena_release_value() {
+  // @@protoc_insertion_point(field_release:tensorflow.OpInfo.TensorProperties.value)
+  
+  ::tensorflow::TensorProto* temp = _impl_.value_;
+  _impl_.value_ = nullptr;
+  return temp;
+}
+inline ::tensorflow::TensorProto* OpInfo_TensorProperties::_internal_mutable_value() {
+  
+  if (_impl_.value_ == nullptr) {
+    auto* p = CreateMaybeMessage<::tensorflow::TensorProto>(GetArenaForAllocation());
+    _impl_.value_ = p;
+  }
+  return _impl_.value_;
+}
+inline ::tensorflow::TensorProto* OpInfo_TensorProperties::mutable_value() {
+  ::tensorflow::TensorProto* _msg = _internal_mutable_value();
+  // @@protoc_insertion_point(field_mutable:tensorflow.OpInfo.TensorProperties.value)
+  return _msg;
+}
+inline void OpInfo_TensorProperties::set_allocated_value(::tensorflow::TensorProto* value) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.value_);
+  }
+  if (value) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(value));
+    if (message_arena != submessage_arena) {
+      value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, value, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.value_ = value;
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.OpInfo.TensorProperties.value)
+}
+
+// -------------------------------------------------------------------
+
+// OpInfo
+
+// string op = 1;
+inline void OpInfo::clear_op() {
+  _impl_.op_.ClearToEmpty();
+}
+inline const std::string& OpInfo::op() const {
+  // @@protoc_insertion_point(field_get:tensorflow.OpInfo.op)
+  return _internal_op();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void OpInfo::set_op(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.op_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.OpInfo.op)
+}
+inline std::string* OpInfo::mutable_op() {
+  std::string* _s = _internal_mutable_op();
+  // @@protoc_insertion_point(field_mutable:tensorflow.OpInfo.op)
+  return _s;
+}
+inline const std::string& OpInfo::_internal_op() const {
+  return _impl_.op_.Get();
+}
+inline void OpInfo::_internal_set_op(const std::string& value) {
+  
+  _impl_.op_.Set(value, GetArenaForAllocation());
+}
+inline std::string* OpInfo::_internal_mutable_op() {
+  
+  return _impl_.op_.Mutable(GetArenaForAllocation());
+}
+inline std::string* OpInfo::release_op() {
+  // @@protoc_insertion_point(field_release:tensorflow.OpInfo.op)
+  return _impl_.op_.Release();
+}
+inline void OpInfo::set_allocated_op(std::string* op) {
+  if (op != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.op_.SetAllocated(op, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.op_.IsDefault()) {
+    _impl_.op_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.OpInfo.op)
+}
+
+// map<string, .tensorflow.AttrValue> attr = 2;
+inline int OpInfo::_internal_attr_size() const {
+  return _impl_.attr_.size();
+}
+inline int OpInfo::attr_size() const {
+  return _internal_attr_size();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::AttrValue >&
+OpInfo::_internal_attr() const {
+  return _impl_.attr_.GetMap();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::AttrValue >&
+OpInfo::attr() const {
+  // @@protoc_insertion_point(field_map:tensorflow.OpInfo.attr)
+  return _internal_attr();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::AttrValue >*
+OpInfo::_internal_mutable_attr() {
+  return _impl_.attr_.MutableMap();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::AttrValue >*
+OpInfo::mutable_attr() {
+  // @@protoc_insertion_point(field_mutable_map:tensorflow.OpInfo.attr)
+  return _internal_mutable_attr();
+}
+
+// repeated .tensorflow.OpInfo.TensorProperties inputs = 3;
+inline int OpInfo::_internal_inputs_size() const {
+  return _impl_.inputs_.size();
+}
+inline int OpInfo::inputs_size() const {
+  return _internal_inputs_size();
+}
+inline void OpInfo::clear_inputs() {
+  _impl_.inputs_.Clear();
+}
+inline ::tensorflow::OpInfo_TensorProperties* OpInfo::mutable_inputs(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.OpInfo.inputs)
+  return _impl_.inputs_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpInfo_TensorProperties >*
+OpInfo::mutable_inputs() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.OpInfo.inputs)
+  return &_impl_.inputs_;
+}
+inline const ::tensorflow::OpInfo_TensorProperties& OpInfo::_internal_inputs(int index) const {
+  return _impl_.inputs_.Get(index);
+}
+inline const ::tensorflow::OpInfo_TensorProperties& OpInfo::inputs(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.OpInfo.inputs)
+  return _internal_inputs(index);
+}
+inline ::tensorflow::OpInfo_TensorProperties* OpInfo::_internal_add_inputs() {
+  return _impl_.inputs_.Add();
+}
+inline ::tensorflow::OpInfo_TensorProperties* OpInfo::add_inputs() {
+  ::tensorflow::OpInfo_TensorProperties* _add = _internal_add_inputs();
+  // @@protoc_insertion_point(field_add:tensorflow.OpInfo.inputs)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpInfo_TensorProperties >&
+OpInfo::inputs() const {
+  // @@protoc_insertion_point(field_list:tensorflow.OpInfo.inputs)
+  return _impl_.inputs_;
+}
+
+// repeated .tensorflow.OpInfo.TensorProperties outputs = 5;
+inline int OpInfo::_internal_outputs_size() const {
+  return _impl_.outputs_.size();
+}
+inline int OpInfo::outputs_size() const {
+  return _internal_outputs_size();
+}
+inline void OpInfo::clear_outputs() {
+  _impl_.outputs_.Clear();
+}
+inline ::tensorflow::OpInfo_TensorProperties* OpInfo::mutable_outputs(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.OpInfo.outputs)
+  return _impl_.outputs_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpInfo_TensorProperties >*
+OpInfo::mutable_outputs() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.OpInfo.outputs)
+  return &_impl_.outputs_;
+}
+inline const ::tensorflow::OpInfo_TensorProperties& OpInfo::_internal_outputs(int index) const {
+  return _impl_.outputs_.Get(index);
+}
+inline const ::tensorflow::OpInfo_TensorProperties& OpInfo::outputs(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.OpInfo.outputs)
+  return _internal_outputs(index);
+}
+inline ::tensorflow::OpInfo_TensorProperties* OpInfo::_internal_add_outputs() {
+  return _impl_.outputs_.Add();
+}
+inline ::tensorflow::OpInfo_TensorProperties* OpInfo::add_outputs() {
+  ::tensorflow::OpInfo_TensorProperties* _add = _internal_add_outputs();
+  // @@protoc_insertion_point(field_add:tensorflow.OpInfo.outputs)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpInfo_TensorProperties >&
+OpInfo::outputs() const {
+  // @@protoc_insertion_point(field_list:tensorflow.OpInfo.outputs)
+  return _impl_.outputs_;
+}
+
+// .tensorflow.DeviceProperties device = 4;
+inline bool OpInfo::_internal_has_device() const {
+  return this != internal_default_instance() && _impl_.device_ != nullptr;
+}
+inline bool OpInfo::has_device() const {
+  return _internal_has_device();
+}
+inline const ::tensorflow::DeviceProperties& OpInfo::_internal_device() const {
+  const ::tensorflow::DeviceProperties* p = _impl_.device_;
+  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::DeviceProperties&>(
+      ::tensorflow::_DeviceProperties_default_instance_);
+}
+inline const ::tensorflow::DeviceProperties& OpInfo::device() const {
+  // @@protoc_insertion_point(field_get:tensorflow.OpInfo.device)
+  return _internal_device();
+}
+inline void OpInfo::unsafe_arena_set_allocated_device(
+    ::tensorflow::DeviceProperties* device) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.device_);
+  }
+  _impl_.device_ = device;
+  if (device) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.OpInfo.device)
+}
+inline ::tensorflow::DeviceProperties* OpInfo::release_device() {
+  
+  ::tensorflow::DeviceProperties* temp = _impl_.device_;
+  _impl_.device_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::tensorflow::DeviceProperties* OpInfo::unsafe_arena_release_device() {
+  // @@protoc_insertion_point(field_release:tensorflow.OpInfo.device)
+  
+  ::tensorflow::DeviceProperties* temp = _impl_.device_;
+  _impl_.device_ = nullptr;
+  return temp;
+}
+inline ::tensorflow::DeviceProperties* OpInfo::_internal_mutable_device() {
+  
+  if (_impl_.device_ == nullptr) {
+    auto* p = CreateMaybeMessage<::tensorflow::DeviceProperties>(GetArenaForAllocation());
+    _impl_.device_ = p;
+  }
+  return _impl_.device_;
+}
+inline ::tensorflow::DeviceProperties* OpInfo::mutable_device() {
+  ::tensorflow::DeviceProperties* _msg = _internal_mutable_device();
+  // @@protoc_insertion_point(field_mutable:tensorflow.OpInfo.device)
+  return _msg;
+}
+inline void OpInfo::set_allocated_device(::tensorflow::DeviceProperties* device) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.device_);
+  }
+  if (device) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(device));
+    if (message_arena != submessage_arena) {
+      device = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, device, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.device_ = device;
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.OpInfo.device)
+}
+
+// .tensorflow.SessionInfo session_info = 6;
+inline bool OpInfo::_internal_has_session_info() const {
+  return this != internal_default_instance() && _impl_.session_info_ != nullptr;
+}
+inline bool OpInfo::has_session_info() const {
+  return _internal_has_session_info();
+}
+inline void OpInfo::clear_session_info() {
+  if (GetArenaForAllocation() == nullptr && _impl_.session_info_ != nullptr) {
+    delete _impl_.session_info_;
+  }
+  _impl_.session_info_ = nullptr;
+}
+inline const ::tensorflow::SessionInfo& OpInfo::_internal_session_info() const {
+  const ::tensorflow::SessionInfo* p = _impl_.session_info_;
+  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::SessionInfo&>(
+      ::tensorflow::_SessionInfo_default_instance_);
+}
+inline const ::tensorflow::SessionInfo& OpInfo::session_info() const {
+  // @@protoc_insertion_point(field_get:tensorflow.OpInfo.session_info)
+  return _internal_session_info();
+}
+inline void OpInfo::unsafe_arena_set_allocated_session_info(
+    ::tensorflow::SessionInfo* session_info) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.session_info_);
+  }
+  _impl_.session_info_ = session_info;
+  if (session_info) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.OpInfo.session_info)
+}
+inline ::tensorflow::SessionInfo* OpInfo::release_session_info() {
+  
+  ::tensorflow::SessionInfo* temp = _impl_.session_info_;
+  _impl_.session_info_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::tensorflow::SessionInfo* OpInfo::unsafe_arena_release_session_info() {
+  // @@protoc_insertion_point(field_release:tensorflow.OpInfo.session_info)
+  
+  ::tensorflow::SessionInfo* temp = _impl_.session_info_;
+  _impl_.session_info_ = nullptr;
+  return temp;
+}
+inline ::tensorflow::SessionInfo* OpInfo::_internal_mutable_session_info() {
+  
+  if (_impl_.session_info_ == nullptr) {
+    auto* p = CreateMaybeMessage<::tensorflow::SessionInfo>(GetArenaForAllocation());
+    _impl_.session_info_ = p;
+  }
+  return _impl_.session_info_;
+}
+inline ::tensorflow::SessionInfo* OpInfo::mutable_session_info() {
+  ::tensorflow::SessionInfo* _msg = _internal_mutable_session_info();
+  // @@protoc_insertion_point(field_mutable:tensorflow.OpInfo.session_info)
+  return _msg;
+}
+inline void OpInfo::set_allocated_session_info(::tensorflow::SessionInfo* session_info) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.session_info_;
+  }
+  if (session_info) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(session_info);
+    if (message_arena != submessage_arena) {
+      session_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, session_info, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.session_info_ = session_info;
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.OpInfo.session_info)
+}
+
+// -------------------------------------------------------------------
+
+// NormalDistribution
+
+// double mu = 1;
+inline void NormalDistribution::clear_mu() {
+  _impl_.mu_ = 0;
+}
+inline double NormalDistribution::_internal_mu() const {
+  return _impl_.mu_;
+}
+inline double NormalDistribution::mu() const {
+  // @@protoc_insertion_point(field_get:tensorflow.NormalDistribution.mu)
+  return _internal_mu();
+}
+inline void NormalDistribution::_internal_set_mu(double value) {
+  
+  _impl_.mu_ = value;
+}
+inline void NormalDistribution::set_mu(double value) {
+  _internal_set_mu(value);
+  // @@protoc_insertion_point(field_set:tensorflow.NormalDistribution.mu)
+}
+
+// double sigma = 2;
+inline void NormalDistribution::clear_sigma() {
+  _impl_.sigma_ = 0;
+}
+inline double NormalDistribution::_internal_sigma() const {
+  return _impl_.sigma_;
+}
+inline double NormalDistribution::sigma() const {
+  // @@protoc_insertion_point(field_get:tensorflow.NormalDistribution.sigma)
+  return _internal_sigma();
+}
+inline void NormalDistribution::_internal_set_sigma(double value) {
+  
+  _impl_.sigma_ = value;
+}
+inline void NormalDistribution::set_sigma(double value) {
+  _internal_set_sigma(value);
+  // @@protoc_insertion_point(field_set:tensorflow.NormalDistribution.sigma)
+}
+
+// -------------------------------------------------------------------
+
+// LogNormalDistribution
+
+// double mu = 1;
+inline void LogNormalDistribution::clear_mu() {
+  _impl_.mu_ = 0;
+}
+inline double LogNormalDistribution::_internal_mu() const {
+  return _impl_.mu_;
+}
+inline double LogNormalDistribution::mu() const {
+  // @@protoc_insertion_point(field_get:tensorflow.LogNormalDistribution.mu)
+  return _internal_mu();
+}
+inline void LogNormalDistribution::_internal_set_mu(double value) {
+  
+  _impl_.mu_ = value;
+}
+inline void LogNormalDistribution::set_mu(double value) {
+  _internal_set_mu(value);
+  // @@protoc_insertion_point(field_set:tensorflow.LogNormalDistribution.mu)
+}
+
+// double sigma = 2;
+inline void LogNormalDistribution::clear_sigma() {
+  _impl_.sigma_ = 0;
+}
+inline double LogNormalDistribution::_internal_sigma() const {
+  return _impl_.sigma_;
+}
+inline double LogNormalDistribution::sigma() const {
+  // @@protoc_insertion_point(field_get:tensorflow.LogNormalDistribution.sigma)
+  return _internal_sigma();
+}
+inline void LogNormalDistribution::_internal_set_sigma(double value) {
+  
+  _impl_.sigma_ = value;
+}
+inline void LogNormalDistribution::set_sigma(double value) {
+  _internal_set_sigma(value);
+  // @@protoc_insertion_point(field_set:tensorflow.LogNormalDistribution.sigma)
+}
+
+// -------------------------------------------------------------------
+
+// OpPerformance_OpMemory
+
+// repeated int64 output_memory = 1;
+inline int OpPerformance_OpMemory::_internal_output_memory_size() const {
+  return _impl_.output_memory_.size();
+}
+inline int OpPerformance_OpMemory::output_memory_size() const {
+  return _internal_output_memory_size();
+}
+inline void OpPerformance_OpMemory::clear_output_memory() {
+  _impl_.output_memory_.Clear();
+}
+inline int64_t OpPerformance_OpMemory::_internal_output_memory(int index) const {
+  return _impl_.output_memory_.Get(index);
+}
+inline int64_t OpPerformance_OpMemory::output_memory(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.OpPerformance.OpMemory.output_memory)
+  return _internal_output_memory(index);
+}
+inline void OpPerformance_OpMemory::set_output_memory(int index, int64_t value) {
+  _impl_.output_memory_.Set(index, value);
+  // @@protoc_insertion_point(field_set:tensorflow.OpPerformance.OpMemory.output_memory)
+}
+inline void OpPerformance_OpMemory::_internal_add_output_memory(int64_t value) {
+  _impl_.output_memory_.Add(value);
+}
+inline void OpPerformance_OpMemory::add_output_memory(int64_t value) {
+  _internal_add_output_memory(value);
+  // @@protoc_insertion_point(field_add:tensorflow.OpPerformance.OpMemory.output_memory)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
+OpPerformance_OpMemory::_internal_output_memory() const {
+  return _impl_.output_memory_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
+OpPerformance_OpMemory::output_memory() const {
+  // @@protoc_insertion_point(field_list:tensorflow.OpPerformance.OpMemory.output_memory)
+  return _internal_output_memory();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
+OpPerformance_OpMemory::_internal_mutable_output_memory() {
+  return &_impl_.output_memory_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
+OpPerformance_OpMemory::mutable_output_memory() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.OpPerformance.OpMemory.output_memory)
+  return _internal_mutable_output_memory();
+}
+
+// int64 temp_memory = 2;
+inline void OpPerformance_OpMemory::clear_temp_memory() {
+  _impl_.temp_memory_ = int64_t{0};
+}
+inline int64_t OpPerformance_OpMemory::_internal_temp_memory() const {
+  return _impl_.temp_memory_;
+}
+inline int64_t OpPerformance_OpMemory::temp_memory() const {
+  // @@protoc_insertion_point(field_get:tensorflow.OpPerformance.OpMemory.temp_memory)
+  return _internal_temp_memory();
+}
+inline void OpPerformance_OpMemory::_internal_set_temp_memory(int64_t value) {
+  
+  _impl_.temp_memory_ = value;
+}
+inline void OpPerformance_OpMemory::set_temp_memory(int64_t value) {
+  _internal_set_temp_memory(value);
+  // @@protoc_insertion_point(field_set:tensorflow.OpPerformance.OpMemory.temp_memory)
+}
+
+// int64 persistent_memory = 4;
+inline void OpPerformance_OpMemory::clear_persistent_memory() {
+  _impl_.persistent_memory_ = int64_t{0};
+}
+inline int64_t OpPerformance_OpMemory::_internal_persistent_memory() const {
+  return _impl_.persistent_memory_;
+}
+inline int64_t OpPerformance_OpMemory::persistent_memory() const {
+  // @@protoc_insertion_point(field_get:tensorflow.OpPerformance.OpMemory.persistent_memory)
+  return _internal_persistent_memory();
+}
+inline void OpPerformance_OpMemory::_internal_set_persistent_memory(int64_t value) {
+  
+  _impl_.persistent_memory_ = value;
+}
+inline void OpPerformance_OpMemory::set_persistent_memory(int64_t value) {
+  _internal_set_persistent_memory(value);
+  // @@protoc_insertion_point(field_set:tensorflow.OpPerformance.OpMemory.persistent_memory)
+}
+
+// int64 device_temp_memory = 3 [deprecated = true];
+inline void OpPerformance_OpMemory::clear_device_temp_memory() {
+  _impl_.device_temp_memory_ = int64_t{0};
+}
+inline int64_t OpPerformance_OpMemory::_internal_device_temp_memory() const {
+  return _impl_.device_temp_memory_;
+}
+inline int64_t OpPerformance_OpMemory::device_temp_memory() const {
+  // @@protoc_insertion_point(field_get:tensorflow.OpPerformance.OpMemory.device_temp_memory)
+  return _internal_device_temp_memory();
+}
+inline void OpPerformance_OpMemory::_internal_set_device_temp_memory(int64_t value) {
+  
+  _impl_.device_temp_memory_ = value;
+}
+inline void OpPerformance_OpMemory::set_device_temp_memory(int64_t value) {
+  _internal_set_device_temp_memory(value);
+  // @@protoc_insertion_point(field_set:tensorflow.OpPerformance.OpMemory.device_temp_memory)
+}
+
+// int64 device_persistent_memory = 5 [deprecated = true];
+inline void OpPerformance_OpMemory::clear_device_persistent_memory() {
+  _impl_.device_persistent_memory_ = int64_t{0};
+}
+inline int64_t OpPerformance_OpMemory::_internal_device_persistent_memory() const {
+  return _impl_.device_persistent_memory_;
+}
+inline int64_t OpPerformance_OpMemory::device_persistent_memory() const {
+  // @@protoc_insertion_point(field_get:tensorflow.OpPerformance.OpMemory.device_persistent_memory)
+  return _internal_device_persistent_memory();
+}
+inline void OpPerformance_OpMemory::_internal_set_device_persistent_memory(int64_t value) {
+  
+  _impl_.device_persistent_memory_ = value;
+}
+inline void OpPerformance_OpMemory::set_device_persistent_memory(int64_t value) {
+  _internal_set_device_persistent_memory(value);
+  // @@protoc_insertion_point(field_set:tensorflow.OpPerformance.OpMemory.device_persistent_memory)
+}
+
+// -------------------------------------------------------------------
+
+// OpPerformance
+
+// .tensorflow.OpInfo op = 1;
+inline bool OpPerformance::_internal_has_op() const {
+  return this != internal_default_instance() && _impl_.op_ != nullptr;
+}
+inline bool OpPerformance::has_op() const {
+  return _internal_has_op();
+}
+inline void OpPerformance::clear_op() {
+  if (GetArenaForAllocation() == nullptr && _impl_.op_ != nullptr) {
+    delete _impl_.op_;
+  }
+  _impl_.op_ = nullptr;
+}
+inline const ::tensorflow::OpInfo& OpPerformance::_internal_op() const {
+  const ::tensorflow::OpInfo* p = _impl_.op_;
+  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::OpInfo&>(
+      ::tensorflow::_OpInfo_default_instance_);
+}
+inline const ::tensorflow::OpInfo& OpPerformance::op() const {
+  // @@protoc_insertion_point(field_get:tensorflow.OpPerformance.op)
+  return _internal_op();
+}
+inline void OpPerformance::unsafe_arena_set_allocated_op(
+    ::tensorflow::OpInfo* op) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.op_);
+  }
+  _impl_.op_ = op;
+  if (op) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.OpPerformance.op)
+}
+inline ::tensorflow::OpInfo* OpPerformance::release_op() {
+  
+  ::tensorflow::OpInfo* temp = _impl_.op_;
+  _impl_.op_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::tensorflow::OpInfo* OpPerformance::unsafe_arena_release_op() {
+  // @@protoc_insertion_point(field_release:tensorflow.OpPerformance.op)
+  
+  ::tensorflow::OpInfo* temp = _impl_.op_;
+  _impl_.op_ = nullptr;
+  return temp;
+}
+inline ::tensorflow::OpInfo* OpPerformance::_internal_mutable_op() {
+  
+  if (_impl_.op_ == nullptr) {
+    auto* p = CreateMaybeMessage<::tensorflow::OpInfo>(GetArenaForAllocation());
+    _impl_.op_ = p;
+  }
+  return _impl_.op_;
+}
+inline ::tensorflow::OpInfo* OpPerformance::mutable_op() {
+  ::tensorflow::OpInfo* _msg = _internal_mutable_op();
+  // @@protoc_insertion_point(field_mutable:tensorflow.OpPerformance.op)
+  return _msg;
+}
+inline void OpPerformance::set_allocated_op(::tensorflow::OpInfo* op) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.op_;
+  }
+  if (op) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(op);
+    if (message_arena != submessage_arena) {
+      op = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, op, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.op_ = op;
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.OpPerformance.op)
+}
+
+// .tensorflow.SessionInfo session_info = 12 [deprecated = true];
+inline bool OpPerformance::_internal_has_session_info() const {
+  return this != internal_default_instance() && _impl_.session_info_ != nullptr;
+}
+inline bool OpPerformance::has_session_info() const {
+  return _internal_has_session_info();
+}
+inline void OpPerformance::clear_session_info() {
+  if (GetArenaForAllocation() == nullptr && _impl_.session_info_ != nullptr) {
+    delete _impl_.session_info_;
+  }
+  _impl_.session_info_ = nullptr;
+}
+inline const ::tensorflow::SessionInfo& OpPerformance::_internal_session_info() const {
+  const ::tensorflow::SessionInfo* p = _impl_.session_info_;
+  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::SessionInfo&>(
+      ::tensorflow::_SessionInfo_default_instance_);
+}
+inline const ::tensorflow::SessionInfo& OpPerformance::session_info() const {
+  // @@protoc_insertion_point(field_get:tensorflow.OpPerformance.session_info)
+  return _internal_session_info();
+}
+inline void OpPerformance::unsafe_arena_set_allocated_session_info(
+    ::tensorflow::SessionInfo* session_info) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.session_info_);
+  }
+  _impl_.session_info_ = session_info;
+  if (session_info) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.OpPerformance.session_info)
+}
+inline ::tensorflow::SessionInfo* OpPerformance::release_session_info() {
+  
+  ::tensorflow::SessionInfo* temp = _impl_.session_info_;
+  _impl_.session_info_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::tensorflow::SessionInfo* OpPerformance::unsafe_arena_release_session_info() {
+  // @@protoc_insertion_point(field_release:tensorflow.OpPerformance.session_info)
+  
+  ::tensorflow::SessionInfo* temp = _impl_.session_info_;
+  _impl_.session_info_ = nullptr;
+  return temp;
+}
+inline ::tensorflow::SessionInfo* OpPerformance::_internal_mutable_session_info() {
+  
+  if (_impl_.session_info_ == nullptr) {
+    auto* p = CreateMaybeMessage<::tensorflow::SessionInfo>(GetArenaForAllocation());
+    _impl_.session_info_ = p;
+  }
+  return _impl_.session_info_;
+}
+inline ::tensorflow::SessionInfo* OpPerformance::mutable_session_info() {
+  ::tensorflow::SessionInfo* _msg = _internal_mutable_session_info();
+  // @@protoc_insertion_point(field_mutable:tensorflow.OpPerformance.session_info)
+  return _msg;
+}
+inline void OpPerformance::set_allocated_session_info(::tensorflow::SessionInfo* session_info) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.session_info_;
+  }
+  if (session_info) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(session_info);
+    if (message_arena != submessage_arena) {
+      session_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, session_info, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.session_info_ = session_info;
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.OpPerformance.session_info)
+}
+
+// string node = 5;
+inline void OpPerformance::clear_node() {
+  _impl_.node_.ClearToEmpty();
+}
+inline const std::string& OpPerformance::node() const {
+  // @@protoc_insertion_point(field_get:tensorflow.OpPerformance.node)
+  return _internal_node();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void OpPerformance::set_node(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.node_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:tensorflow.OpPerformance.node)
+}
+inline std::string* OpPerformance::mutable_node() {
+  std::string* _s = _internal_mutable_node();
+  // @@protoc_insertion_point(field_mutable:tensorflow.OpPerformance.node)
+  return _s;
+}
+inline const std::string& OpPerformance::_internal_node() const {
+  return _impl_.node_.Get();
+}
+inline void OpPerformance::_internal_set_node(const std::string& value) {
+  
+  _impl_.node_.Set(value, GetArenaForAllocation());
+}
+inline std::string* OpPerformance::_internal_mutable_node() {
+  
+  return _impl_.node_.Mutable(GetArenaForAllocation());
+}
+inline std::string* OpPerformance::release_node() {
+  // @@protoc_insertion_point(field_release:tensorflow.OpPerformance.node)
+  return _impl_.node_.Release();
+}
+inline void OpPerformance::set_allocated_node(std::string* node) {
+  if (node != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.node_.SetAllocated(node, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.node_.IsDefault()) {
+    _impl_.node_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.OpPerformance.node)
+}
+
+// int64 temporary_memory_size = 2;
+inline void OpPerformance::clear_temporary_memory_size() {
+  _impl_.temporary_memory_size_ = int64_t{0};
+}
+inline int64_t OpPerformance::_internal_temporary_memory_size() const {
+  return _impl_.temporary_memory_size_;
+}
+inline int64_t OpPerformance::temporary_memory_size() const {
+  // @@protoc_insertion_point(field_get:tensorflow.OpPerformance.temporary_memory_size)
+  return _internal_temporary_memory_size();
+}
+inline void OpPerformance::_internal_set_temporary_memory_size(int64_t value) {
+  
+  _impl_.temporary_memory_size_ = value;
+}
+inline void OpPerformance::set_temporary_memory_size(int64_t value) {
+  _internal_set_temporary_memory_size(value);
+  // @@protoc_insertion_point(field_set:tensorflow.OpPerformance.temporary_memory_size)
+}
+
+// int64 compute_cost = 3;
+inline void OpPerformance::clear_compute_cost() {
+  _impl_.compute_cost_ = int64_t{0};
+}
+inline int64_t OpPerformance::_internal_compute_cost() const {
+  return _impl_.compute_cost_;
+}
+inline int64_t OpPerformance::compute_cost() const {
+  // @@protoc_insertion_point(field_get:tensorflow.OpPerformance.compute_cost)
+  return _internal_compute_cost();
+}
+inline void OpPerformance::_internal_set_compute_cost(int64_t value) {
+  
+  _impl_.compute_cost_ = value;
+}
+inline void OpPerformance::set_compute_cost(int64_t value) {
+  _internal_set_compute_cost(value);
+  // @@protoc_insertion_point(field_set:tensorflow.OpPerformance.compute_cost)
+}
+
+// int64 compute_time = 6;
+inline void OpPerformance::clear_compute_time() {
+  _impl_.compute_time_ = int64_t{0};
+}
+inline int64_t OpPerformance::_internal_compute_time() const {
+  return _impl_.compute_time_;
+}
+inline int64_t OpPerformance::compute_time() const {
+  // @@protoc_insertion_point(field_get:tensorflow.OpPerformance.compute_time)
+  return _internal_compute_time();
+}
+inline void OpPerformance::_internal_set_compute_time(int64_t value) {
+  
+  _impl_.compute_time_ = value;
+}
+inline void OpPerformance::set_compute_time(int64_t value) {
+  _internal_set_compute_time(value);
+  // @@protoc_insertion_point(field_set:tensorflow.OpPerformance.compute_time)
+}
+
+// int64 memory_time = 7;
+inline void OpPerformance::clear_memory_time() {
+  _impl_.memory_time_ = int64_t{0};
+}
+inline int64_t OpPerformance::_internal_memory_time() const {
+  return _impl_.memory_time_;
+}
+inline int64_t OpPerformance::memory_time() const {
+  // @@protoc_insertion_point(field_get:tensorflow.OpPerformance.memory_time)
+  return _internal_memory_time();
+}
+inline void OpPerformance::_internal_set_memory_time(int64_t value) {
+  
+  _impl_.memory_time_ = value;
+}
+inline void OpPerformance::set_memory_time(int64_t value) {
+  _internal_set_memory_time(value);
+  // @@protoc_insertion_point(field_set:tensorflow.OpPerformance.memory_time)
+}
+
+// double compute_efficiency = 4;
+inline void OpPerformance::clear_compute_efficiency() {
+  _impl_.compute_efficiency_ = 0;
+}
+inline double OpPerformance::_internal_compute_efficiency() const {
+  return _impl_.compute_efficiency_;
+}
+inline double OpPerformance::compute_efficiency() const {
+  // @@protoc_insertion_point(field_get:tensorflow.OpPerformance.compute_efficiency)
+  return _internal_compute_efficiency();
+}
+inline void OpPerformance::_internal_set_compute_efficiency(double value) {
+  
+  _impl_.compute_efficiency_ = value;
+}
+inline void OpPerformance::set_compute_efficiency(double value) {
+  _internal_set_compute_efficiency(value);
+  // @@protoc_insertion_point(field_set:tensorflow.OpPerformance.compute_efficiency)
+}
+
+// double memory_efficiency = 8;
+inline void OpPerformance::clear_memory_efficiency() {
+  _impl_.memory_efficiency_ = 0;
+}
+inline double OpPerformance::_internal_memory_efficiency() const {
+  return _impl_.memory_efficiency_;
+}
+inline double OpPerformance::memory_efficiency() const {
+  // @@protoc_insertion_point(field_get:tensorflow.OpPerformance.memory_efficiency)
+  return _internal_memory_efficiency();
+}
+inline void OpPerformance::_internal_set_memory_efficiency(double value) {
+  
+  _impl_.memory_efficiency_ = value;
+}
+inline void OpPerformance::set_memory_efficiency(double value) {
+  _internal_set_memory_efficiency(value);
+  // @@protoc_insertion_point(field_set:tensorflow.OpPerformance.memory_efficiency)
+}
+
+// .tensorflow.NormalDistribution execution_time_normal = 10;
+inline bool OpPerformance::_internal_has_execution_time_normal() const {
+  return execution_time_case() == kExecutionTimeNormal;
+}
+inline bool OpPerformance::has_execution_time_normal() const {
+  return _internal_has_execution_time_normal();
+}
+inline void OpPerformance::set_has_execution_time_normal() {
+  _impl_._oneof_case_[0] = kExecutionTimeNormal;
+}
+inline void OpPerformance::clear_execution_time_normal() {
+  if (_internal_has_execution_time_normal()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete _impl_.execution_time_.execution_time_normal_;
+    }
+    clear_has_execution_time();
+  }
+}
+inline ::tensorflow::NormalDistribution* OpPerformance::release_execution_time_normal() {
+  // @@protoc_insertion_point(field_release:tensorflow.OpPerformance.execution_time_normal)
+  if (_internal_has_execution_time_normal()) {
+    clear_has_execution_time();
+    ::tensorflow::NormalDistribution* temp = _impl_.execution_time_.execution_time_normal_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    _impl_.execution_time_.execution_time_normal_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::tensorflow::NormalDistribution& OpPerformance::_internal_execution_time_normal() const {
+  return _internal_has_execution_time_normal()
+      ? *_impl_.execution_time_.execution_time_normal_
+      : reinterpret_cast< ::tensorflow::NormalDistribution&>(::tensorflow::_NormalDistribution_default_instance_);
+}
+inline const ::tensorflow::NormalDistribution& OpPerformance::execution_time_normal() const {
+  // @@protoc_insertion_point(field_get:tensorflow.OpPerformance.execution_time_normal)
+  return _internal_execution_time_normal();
+}
+inline ::tensorflow::NormalDistribution* OpPerformance::unsafe_arena_release_execution_time_normal() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.OpPerformance.execution_time_normal)
+  if (_internal_has_execution_time_normal()) {
+    clear_has_execution_time();
+    ::tensorflow::NormalDistribution* temp = _impl_.execution_time_.execution_time_normal_;
+    _impl_.execution_time_.execution_time_normal_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void OpPerformance::unsafe_arena_set_allocated_execution_time_normal(::tensorflow::NormalDistribution* execution_time_normal) {
+  clear_execution_time();
+  if (execution_time_normal) {
+    set_has_execution_time_normal();
+    _impl_.execution_time_.execution_time_normal_ = execution_time_normal;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.OpPerformance.execution_time_normal)
+}
+inline ::tensorflow::NormalDistribution* OpPerformance::_internal_mutable_execution_time_normal() {
+  if (!_internal_has_execution_time_normal()) {
+    clear_execution_time();
+    set_has_execution_time_normal();
+    _impl_.execution_time_.execution_time_normal_ = CreateMaybeMessage< ::tensorflow::NormalDistribution >(GetArenaForAllocation());
+  }
+  return _impl_.execution_time_.execution_time_normal_;
+}
+inline ::tensorflow::NormalDistribution* OpPerformance::mutable_execution_time_normal() {
+  ::tensorflow::NormalDistribution* _msg = _internal_mutable_execution_time_normal();
+  // @@protoc_insertion_point(field_mutable:tensorflow.OpPerformance.execution_time_normal)
+  return _msg;
+}
+
+// .tensorflow.LogNormalDistribution execution_time_log_normal = 11;
+inline bool OpPerformance::_internal_has_execution_time_log_normal() const {
+  return execution_time_case() == kExecutionTimeLogNormal;
+}
+inline bool OpPerformance::has_execution_time_log_normal() const {
+  return _internal_has_execution_time_log_normal();
+}
+inline void OpPerformance::set_has_execution_time_log_normal() {
+  _impl_._oneof_case_[0] = kExecutionTimeLogNormal;
+}
+inline void OpPerformance::clear_execution_time_log_normal() {
+  if (_internal_has_execution_time_log_normal()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete _impl_.execution_time_.execution_time_log_normal_;
+    }
+    clear_has_execution_time();
+  }
+}
+inline ::tensorflow::LogNormalDistribution* OpPerformance::release_execution_time_log_normal() {
+  // @@protoc_insertion_point(field_release:tensorflow.OpPerformance.execution_time_log_normal)
+  if (_internal_has_execution_time_log_normal()) {
+    clear_has_execution_time();
+    ::tensorflow::LogNormalDistribution* temp = _impl_.execution_time_.execution_time_log_normal_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    _impl_.execution_time_.execution_time_log_normal_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::tensorflow::LogNormalDistribution& OpPerformance::_internal_execution_time_log_normal() const {
+  return _internal_has_execution_time_log_normal()
+      ? *_impl_.execution_time_.execution_time_log_normal_
+      : reinterpret_cast< ::tensorflow::LogNormalDistribution&>(::tensorflow::_LogNormalDistribution_default_instance_);
+}
+inline const ::tensorflow::LogNormalDistribution& OpPerformance::execution_time_log_normal() const {
+  // @@protoc_insertion_point(field_get:tensorflow.OpPerformance.execution_time_log_normal)
+  return _internal_execution_time_log_normal();
+}
+inline ::tensorflow::LogNormalDistribution* OpPerformance::unsafe_arena_release_execution_time_log_normal() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.OpPerformance.execution_time_log_normal)
+  if (_internal_has_execution_time_log_normal()) {
+    clear_has_execution_time();
+    ::tensorflow::LogNormalDistribution* temp = _impl_.execution_time_.execution_time_log_normal_;
+    _impl_.execution_time_.execution_time_log_normal_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void OpPerformance::unsafe_arena_set_allocated_execution_time_log_normal(::tensorflow::LogNormalDistribution* execution_time_log_normal) {
+  clear_execution_time();
+  if (execution_time_log_normal) {
+    set_has_execution_time_log_normal();
+    _impl_.execution_time_.execution_time_log_normal_ = execution_time_log_normal;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.OpPerformance.execution_time_log_normal)
+}
+inline ::tensorflow::LogNormalDistribution* OpPerformance::_internal_mutable_execution_time_log_normal() {
+  if (!_internal_has_execution_time_log_normal()) {
+    clear_execution_time();
+    set_has_execution_time_log_normal();
+    _impl_.execution_time_.execution_time_log_normal_ = CreateMaybeMessage< ::tensorflow::LogNormalDistribution >(GetArenaForAllocation());
+  }
+  return _impl_.execution_time_.execution_time_log_normal_;
+}
+inline ::tensorflow::LogNormalDistribution* OpPerformance::mutable_execution_time_log_normal() {
+  ::tensorflow::LogNormalDistribution* _msg = _internal_mutable_execution_time_log_normal();
+  // @@protoc_insertion_point(field_mutable:tensorflow.OpPerformance.execution_time_log_normal)
+  return _msg;
+}
+
+// .tensorflow.OpPerformance.OpMemory op_memory = 9;
+inline bool OpPerformance::_internal_has_op_memory() const {
+  return this != internal_default_instance() && _impl_.op_memory_ != nullptr;
+}
+inline bool OpPerformance::has_op_memory() const {
+  return _internal_has_op_memory();
+}
+inline void OpPerformance::clear_op_memory() {
+  if (GetArenaForAllocation() == nullptr && _impl_.op_memory_ != nullptr) {
+    delete _impl_.op_memory_;
+  }
+  _impl_.op_memory_ = nullptr;
+}
+inline const ::tensorflow::OpPerformance_OpMemory& OpPerformance::_internal_op_memory() const {
+  const ::tensorflow::OpPerformance_OpMemory* p = _impl_.op_memory_;
+  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::OpPerformance_OpMemory&>(
+      ::tensorflow::_OpPerformance_OpMemory_default_instance_);
+}
+inline const ::tensorflow::OpPerformance_OpMemory& OpPerformance::op_memory() const {
+  // @@protoc_insertion_point(field_get:tensorflow.OpPerformance.op_memory)
+  return _internal_op_memory();
+}
+inline void OpPerformance::unsafe_arena_set_allocated_op_memory(
+    ::tensorflow::OpPerformance_OpMemory* op_memory) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.op_memory_);
+  }
+  _impl_.op_memory_ = op_memory;
+  if (op_memory) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.OpPerformance.op_memory)
+}
+inline ::tensorflow::OpPerformance_OpMemory* OpPerformance::release_op_memory() {
+  
+  ::tensorflow::OpPerformance_OpMemory* temp = _impl_.op_memory_;
+  _impl_.op_memory_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::tensorflow::OpPerformance_OpMemory* OpPerformance::unsafe_arena_release_op_memory() {
+  // @@protoc_insertion_point(field_release:tensorflow.OpPerformance.op_memory)
+  
+  ::tensorflow::OpPerformance_OpMemory* temp = _impl_.op_memory_;
+  _impl_.op_memory_ = nullptr;
+  return temp;
+}
+inline ::tensorflow::OpPerformance_OpMemory* OpPerformance::_internal_mutable_op_memory() {
+  
+  if (_impl_.op_memory_ == nullptr) {
+    auto* p = CreateMaybeMessage<::tensorflow::OpPerformance_OpMemory>(GetArenaForAllocation());
+    _impl_.op_memory_ = p;
+  }
+  return _impl_.op_memory_;
+}
+inline ::tensorflow::OpPerformance_OpMemory* OpPerformance::mutable_op_memory() {
+  ::tensorflow::OpPerformance_OpMemory* _msg = _internal_mutable_op_memory();
+  // @@protoc_insertion_point(field_mutable:tensorflow.OpPerformance.op_memory)
+  return _msg;
+}
+inline void OpPerformance::set_allocated_op_memory(::tensorflow::OpPerformance_OpMemory* op_memory) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.op_memory_;
+  }
+  if (op_memory) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(op_memory);
+    if (message_arena != submessage_arena) {
+      op_memory = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, op_memory, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.op_memory_ = op_memory;
+  // @@protoc_insertion_point(field_set_allocated:tensorflow.OpPerformance.op_memory)
+}
+
+inline bool OpPerformance::has_execution_time() const {
+  return execution_time_case() != EXECUTION_TIME_NOT_SET;
+}
+inline void OpPerformance::clear_has_execution_time() {
+  _impl_._oneof_case_[0] = EXECUTION_TIME_NOT_SET;
+}
+inline OpPerformance::ExecutionTimeCase OpPerformance::execution_time_case() const {
+  return OpPerformance::ExecutionTimeCase(_impl_._oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// OpPerformanceList
+
+// repeated .tensorflow.OpPerformance op_performance = 1;
+inline int OpPerformanceList::_internal_op_performance_size() const {
+  return _impl_.op_performance_.size();
+}
+inline int OpPerformanceList::op_performance_size() const {
+  return _internal_op_performance_size();
+}
+inline void OpPerformanceList::clear_op_performance() {
+  _impl_.op_performance_.Clear();
+}
+inline ::tensorflow::OpPerformance* OpPerformanceList::mutable_op_performance(int index) {
+  // @@protoc_insertion_point(field_mutable:tensorflow.OpPerformanceList.op_performance)
+  return _impl_.op_performance_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpPerformance >*
+OpPerformanceList::mutable_op_performance() {
+  // @@protoc_insertion_point(field_mutable_list:tensorflow.OpPerformanceList.op_performance)
+  return &_impl_.op_performance_;
+}
+inline const ::tensorflow::OpPerformance& OpPerformanceList::_internal_op_performance(int index) const {
+  return _impl_.op_performance_.Get(index);
+}
+inline const ::tensorflow::OpPerformance& OpPerformanceList::op_performance(int index) const {
+  // @@protoc_insertion_point(field_get:tensorflow.OpPerformanceList.op_performance)
+  return _internal_op_performance(index);
+}
+inline ::tensorflow::OpPerformance* OpPerformanceList::_internal_add_op_performance() {
+  return _impl_.op_performance_.Add();
+}
+inline ::tensorflow::OpPerformance* OpPerformanceList::add_op_performance() {
+  ::tensorflow::OpPerformance* _add = _internal_add_op_performance();
+  // @@protoc_insertion_point(field_add:tensorflow.OpPerformanceList.op_performance)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpPerformance >&
+OpPerformanceList::op_performance() const {
+  // @@protoc_insertion_point(field_list:tensorflow.OpPerformanceList.op_performance)
+  return _impl_.op_performance_;
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace tensorflow
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fgrappler_2fcosts_2fop_5fperformance_5fdata_2eproto
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/costs/op_performance_data.proto b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/costs/op_performance_data.proto
new file mode 100644
index 0000000000000000000000000000000000000000..5ef5fd927b8580b55539d98014ba1af4c079ae0d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/costs/op_performance_data.proto
@@ -0,0 +1,123 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+syntax = "proto3";
+
+package tensorflow;
+option cc_enable_arenas = true;
+
+import "tensorflow/core/framework/tensor.proto";
+import "tensorflow/core/framework/tensor_shape.proto";
+import "tensorflow/core/framework/types.proto";
+import "tensorflow/core/framework/attr_value.proto";
+import "tensorflow/core/protobuf/device_properties.proto";
+
+// Description of the session when an op is run.
+message SessionInfo {
+  int64 intra_op_parallelism = 1;
+}
+
+// Description of an operation as well as the parameters expected to impact its
+// performance.
+message OpInfo {
+  // The operation name.  There may be custom parameters in attrs.
+  string op = 1;
+
+  // Custom parameters impacting the behavior of the op.
+  map<string, AttrValue> attr = 2;
+
+  // Input data types, shapes and values if known.
+  message TensorProperties {
+    DataType dtype = 1;
+    TensorShapeProto shape = 2;
+    TensorProto value = 3;
+  };
+  repeated TensorProperties inputs = 3;
+
+  // Optional description of the op outputs
+  repeated TensorProperties outputs = 5;
+
+  // Device on which the operation is run.
+  DeviceProperties device = 4;
+
+  // Information about the session configs.
+  SessionInfo session_info = 6;
+}
+
+message NormalDistribution {
+  double mu = 1;
+  double sigma = 2;
+}
+
+message LogNormalDistribution {
+  double mu = 1;
+  double sigma = 2;
+}
+
+// Performance data for tensorflow operations
+message OpPerformance {
+  // The op
+  OpInfo op = 1;
+
+  // Information about the session configs.
+  SessionInfo session_info = 12 [deprecated = true];
+
+  // The node name (optional). Makes it easier to associate the performance data
+  // with a specific graph node.
+  string node = 5;
+
+  // Temporary memory used by this node (in bytes).
+  int64 temporary_memory_size = 2;
+
+  // Time it takes to run the op (in nanoseconds).
+  int64 compute_cost = 3;
+
+  // Analytical compute cost (in nanoseconds).
+  int64 compute_time = 6;
+
+  // Analytical memory access cost (in nanoseconds).
+  int64 memory_time = 7;
+
+  // Percentage of theoretical compute performance.
+  double compute_efficiency = 4;
+
+  // Percentage of theoretical memory performance.
+  double memory_efficiency = 8;
+
+  // Expected execution time, modeled using one of 2 possible distributions.
+  oneof execution_time {
+    NormalDistribution execution_time_normal = 10;
+    LogNormalDistribution execution_time_log_normal = 11;
+  };
+
+  // Memory usage data for a tensorflow operation.
+  message OpMemory {
+    // The output information may have memory usage and output shapes.
+    repeated int64 output_memory = 1;
+
+    // Temp and persistent memory allocated by this node.
+    int64 temp_memory = 2;
+    int64 persistent_memory = 4;
+
+    int64 device_temp_memory = 3 [deprecated = true];
+    int64 device_persistent_memory = 5 [deprecated = true];
+  }
+  OpMemory op_memory = 9;
+}
+
+// A collection of OpPerformance data points.
+message OpPerformanceList {
+  repeated OpPerformance op_performance = 1;
+}
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/costs/utils.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/costs/utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..94f5c24032a4a139cdf575f07d1a0a1670a94500
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/costs/utils.h
@@ -0,0 +1,132 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_COSTS_UTILS_H_
+#define TENSORFLOW_CORE_GRAPPLER_COSTS_UTILS_H_
+
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include "tensorflow/core/framework/cost_graph.pb.h"
+#include "tensorflow/core/framework/graph.pb.h"
+#include "tensorflow/core/framework/node_def.pb.h"
+#include "tensorflow/core/framework/op_def.pb.h"
+#include "tensorflow/core/graph/types.h"
+#include "tensorflow/core/grappler/costs/cost_estimator.h"
+#include "tensorflow/core/grappler/costs/op_performance_data.pb.h"
+#include "tensorflow/core/platform/types.h"
+#include "tensorflow/core/protobuf/config.pb.h"
+#include "tensorflow/core/protobuf/device_properties.pb.h"
+
+namespace tensorflow {
+namespace grappler {
+
+// Returns a vector of InputProperties for 'node'. The vector will contain one
+// entry for each input of 'node'.
+// For each node in the graph, the 'name_to_cost' map stores a pointer to the
+// corresponding cost graph node indexed by node name. The 'name_to_node' maps a
+// node name to its node definition.
+std::vector<OpInfo::TensorProperties> FindInputFeatures(
+    const NodeDef& node,
+    const std::unordered_map<string, const CostGraphDef::Node*>& name_to_cost,
+    const std::unordered_map<string, const NodeDef*>& name_to_node);
+
+// Returns the size of tensor (unit: bytes). For tensor shape with unknown rank,
+// it assumes the tensor to be scalar. For any unknown dimension, it assumes
+// size one.
+int64_t CalculateTensorSize(const OpInfo::TensorProperties& prop);
+
+// Returns the size of output at port_num (unit: bytes). A special case is
+// port_num -1, which is for control dependency and assumed to be 4 bytes.
+int64_t CalculateOutputSize(
+    const std::vector<OpInfo::TensorProperties>& output_properties,
+    int port_num);
+
+// Returns the DeviceProperties of the device on which 'node' runs.
+DeviceProperties GetDeviceInfo(const CostGraphDef::Node& node);
+DeviceProperties GetDeviceInfo(const string& device_str);
+
+// Return a string describing a node given a nodeinfo.
+string GetOpDescription(const OpInfo& op_info);
+
+// Builds the OpInfo for node without filling its device information, given all
+// nodes in the graph and its input properties.
+OpInfo BuildOpInfoWithoutDevice(
+    const NodeDef& node,
+    const std::unordered_map<string, const NodeDef*>& name_to_node,
+    const std::vector<OpInfo::TensorProperties>& inputs);
+
+// Gather performance data from a cost graph.
+OpPerformanceList CostGraphToOpPerformanceData(const CostGraphDef& cost_graph,
+                                               const GraphDef& graph);
+
+// Simple histogram for profiling Tensor size; histogram uses logarithmic
+// buckets.
+class TensorSizeHistogram {
+ public:
+  TensorSizeHistogram() : buckets_(kMaxBuckets, 0) {}
+
+  void Add(const uint64 value);
+  void Merge(const TensorSizeHistogram& src);
+  double Average() const {
+    if (num_elem_ > 0) {
+      return static_cast<double>(sum_elem_) / num_elem_;
+    } else {
+      return 0.0;
+    }
+  }
+  uint64 Min() const { return min_; }
+  uint64 Max() const { return max_; }
+  uint64 NumElem() const { return num_elem_; }
+  uint64 SumElem() const { return sum_elem_; }
+  string ToString() const;
+
+ protected:
+  const int Index(const uint64 value) const;
+  const std::vector<uint64>& GetBuckets() const { return buckets_; }
+
+ private:
+  const int kMaxBuckets = 64;
+  uint64 num_elem_ = 0;
+  uint64 sum_elem_ = 0;
+  // min_ and max_ are initialized to a very large value and zero, respectively,
+  // so that any value added can replace the initial min_ and max_.
+  uint64 min_ = kuint64max;
+  uint64 max_ = 0;
+  // Buckets are logarithmic:
+  // 0B, 1B, 2-3B, 4-7B, 8-15B, ..., 2^N - 2^(N+1)-1B, ...
+  std::vector<uint64> buckets_;
+};
+
+// Helper functions for aggregating per-device stats into per-device-class
+// stats.
+string GetDeviceClassForNonChannelDevice(const string& device_name);
+string GetDeviceClass(const string& device_name);
+
+// Get stats in string format from RunMetadata.
+string GetStatsStringFromRunMetadata(const RunMetadata& run_metadata,
+                                     bool verbosity);
+
+// This method calculates the execution time depending on whether IO can
+// overlap with computation. It assumes the memory and the compute times have
+// already been calculated.
+void CombineCostsAndUpdateExecutionTime(bool compute_memory_overlap,
+                                        Costs* costs);
+
+}  // end namespace grappler
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_COSTS_UTILS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/costs/virtual_placer.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/costs/virtual_placer.h
new file mode 100644
index 0000000000000000000000000000000000000000..5f6119ed1e5ae8797c1720346dd088af5335fbc9
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/costs/virtual_placer.h
@@ -0,0 +1,62 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_COSTS_VIRTUAL_PLACER_H_
+#define TENSORFLOW_CORE_GRAPPLER_COSTS_VIRTUAL_PLACER_H_
+
+#include <unordered_map>
+
+#include "tensorflow/core/platform/types.h"
+#include "tensorflow/core/protobuf/device_properties.pb.h"
+
+namespace tensorflow {
+class NodeDef;
+
+namespace grappler {
+class Cluster;
+
+// The virtual placer emulates the behavior of the TF placer.
+class VirtualPlacer {
+ public:
+  explicit VirtualPlacer(
+      const std::unordered_map<string, DeviceProperties>& devices);
+
+  const DeviceProperties& get_device(const NodeDef& node) const;
+
+  // Returns device name from cluster, which best matches the node.device()
+  // specification. Returns default device if no match was found or the
+  // node.device() could not be parsed.
+  string get_canonical_device_name(const NodeDef& node) const;
+
+ private:
+  // Converts given device name to Lowercase Fully-Qualified Name (LFQN) string.
+  // This helps us disambiguate device names internally and simplify matching.
+  // If device_name couldn't be parsed successfully, returns empty string.
+  string to_lfqn_or_empty(const string& device_name) const;
+
+  // Map based on the cluster info: cluster device name -> device properties.
+  std::unordered_map<string, DeviceProperties> devices_;
+
+  // Maps LFQN to original device name as it was declared in cluster.
+  std::unordered_map<string, string> lfqn_map_;
+
+  string default_device_name_;
+  string default_job_name_lowercase_;
+};
+
+}  // namespace grappler
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_COSTS_VIRTUAL_PLACER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/costs/virtual_scheduler.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/costs/virtual_scheduler.h
new file mode 100644
index 0000000000000000000000000000000000000000..fe33b8eeda04a78226aed20237618ebc1b9d86a5
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/costs/virtual_scheduler.h
@@ -0,0 +1,542 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_COSTS_VIRTUAL_SCHEDULER_H_
+#define TENSORFLOW_CORE_GRAPPLER_COSTS_VIRTUAL_SCHEDULER_H_
+
+#include <functional>
+#include <list>
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+
+#include "tensorflow/core/framework/node_def.pb.h"
+#include "tensorflow/core/framework/step_stats.pb.h"
+#include "tensorflow/core/grappler/costs/cost_estimator.h"
+#include "tensorflow/core/grappler/costs/graph_properties.h"
+#include "tensorflow/core/grappler/costs/op_context.h"
+#include "tensorflow/core/grappler/costs/virtual_placer.h"
+#include "tensorflow/core/grappler/grappler_item.h"
+
+namespace tensorflow {
+namespace grappler {
+
+ABSL_CONST_INIT extern const char kAttrInputSrc[];
+ABSL_CONST_INIT extern const char kAttrSrcDevice[];
+ABSL_CONST_INIT extern const char kAttrDstDevice[];
+ABSL_CONST_INIT extern const char kAttrTensorName[];
+ABSL_CONST_INIT extern const char kChannelDevice[];
+ABSL_CONST_INIT extern const char kStreaming[];
+
+struct NodeState {
+  // A node (i.e., an op) takes a set of input:port pairs and produces
+  // a set of output ports.
+
+  // Cross references to input and output nodes from graphdef.
+  std::vector<std::pair<const NodeDef*, int>> inputs;  // Input, port pairs.
+  // List of output nodes (a list of nodes that takes this output port as input)
+  // keyed by port_num. Note that port_num -1 is used for control dependency.
+  std::unordered_map<int, std::vector<const NodeDef*>> outputs;
+
+  // Info from GraphProperties.
+  std::vector<OpInfo::TensorProperties> input_properties;
+  std::vector<OpInfo::TensorProperties> output_properties;
+
+  // Canonical device name used within VirtualScheduler.
+  string device_name;
+
+  // States updated as scheduling nodes.
+  int num_inputs_ready;
+  std::unordered_map<int, int> num_outputs_executed;
+  Costs::Duration time_ready;
+  Costs::Duration time_scheduled;
+  Costs::Duration time_finished;
+  // Time that all the consumers are executed (hence, no need to keep this
+  // output in memory), keyed by port_num.
+  std::unordered_map<int, Costs::Duration> time_no_references;
+
+  // Note that a node may have multiple output ports. The length of outputs,
+  // num_outputs_executed, and time_no_references should be
+  // identical when a NodeState is fully initialized.
+  // They should be 1 + output_properties.size() as we add [-1] for control
+  // dependency.
+
+  // Node will be ready to be executed at time_ready, scheduled at
+  // time_scheduled, and finishes execution at time_finished.
+  // Each output port uses up memory space from time_scheduled to its
+  // time_no_references.
+
+  Costs node_costs;  // Node costs per execution
+  Costs TotalNodeCosts() const {
+    return MultiplyCosts(node_costs, execution_count);
+  }
+  // How many times this node has been executed, e.g. in a while loop.
+  int execution_count;
+
+  // Output shape incompatible between shape annotation and shape inference.
+  bool shape_incompatible;
+
+  NodeState() {
+    num_inputs_ready = 0;
+    time_ready = Costs::Duration::max();
+    time_scheduled = Costs::Duration::max();
+    time_finished = Costs::Duration::max();
+    execution_count = 0;
+    shape_incompatible = false;
+    // Note that num_outputs_executed and time_no_references are not initialized
+    // here, since we don't know the size (i.e., # outputs for this node).
+  }
+};
+
+struct DeviceState {
+  // Nodes executed on this device in execution order.
+  std::vector<const NodeDef*> nodes_executed;
+
+  struct NodePairHash {
+   public:
+    const std::size_t operator()(
+        const std::pair<const NodeDef*, int>& element) const {
+      return std::hash<const NodeDef*>()(element.first);
+    }
+  };
+
+  // Nodes currently allocated in memory: set of NodeDef* and port_num pairs
+  // so that we can track which output of the node is in memory.
+  std::unordered_set<std::pair<const NodeDef*, int>, NodePairHash>
+      nodes_in_memory;
+
+  // Nodes allocated in memory persistently: e.g., Variables.
+  std::unordered_set<std::pair<const NodeDef*, int>, NodePairHash>
+      persistent_nodes;
+
+  // Snapshot of nodes_in_memory, when memory usage is at peak.
+  // Same to nodes_in_memory, it's a set of NodeDef* and port_num pairs.
+  std::unordered_set<std::pair<const NodeDef*, int>, NodePairHash>
+      mem_usage_snapshot_at_peak;
+
+  // Vector of temporary memory usage trace in execution order.
+  // Each pair represents the current node name and current (accumulated)
+  // temporary memory usage of the device when the node is scheduled.
+  // Only enabled when mem_usage_tracking is enabled.
+  // Note: CPU uses an inter-op threadpool, so the execution order on CPU may
+  // not be deterministic.
+  std::vector<std::pair<std::string, int64_t>> temporary_memory_usage_trace;
+
+  Costs device_costs;
+  std::map<string, Costs> op_to_cost;  // Per-op cost.
+
+  int64_t memory_usage;      // Current temporary memory usage
+  int64_t max_memory_usage;  // Max temporary memory usage
+
+  // Shape annotation statistics.
+  struct ShapeAnnotationStats {
+    // Number of ops with shape annotated.
+    int64_t num_ops_annotated = 0;
+    // Number of ops executed multiple times (e.g. in a loop).
+    int64_t num_ops_executed_more_than_once = 0;
+    // Number of ops executed: account for execution count.
+    int64_t num_ops_executed = 0;
+    // Number of ops with dynamic shapes (e.g. shape changes in a loop).
+    int64_t num_ops_with_dynamic_shapes = 0;
+    // Number of ops with incompatible shapes between annotation and shape
+    // inference.
+    int64_t num_ops_with_incompatible_shapes = 0;
+  } shape_annotation_stats;
+
+  DeviceState() {
+    device_costs = Costs::ZeroCosts();
+    device_costs.num_ops_total = 0;
+    memory_usage = 0;
+    max_memory_usage = 0;
+  }
+
+  Costs::Duration GetCurrTime() const { return device_costs.execution_time; }
+};
+
+// ReadyNodeManager (abstract class):
+// Keeps ready nodes and picks the best one to be scheduled.
+class ReadyNodeManager {
+ public:
+  ReadyNodeManager() {}
+  virtual ~ReadyNodeManager() {}
+  virtual Status Init(
+      const std::unordered_map<const NodeDef*, NodeState>* node_map) {
+    return OkStatus();
+  }
+  virtual void AddNode(const NodeDef* node) = 0;
+  virtual const NodeDef* GetCurrNode() = 0;
+  virtual void RemoveCurrNode() = 0;
+  virtual bool Empty() const = 0;
+};
+
+class FIFOManager : public ReadyNodeManager {
+ public:
+  FIFOManager() : ReadyNodeManager() {}
+  ~FIFOManager() override {}
+  void AddNode(const NodeDef* node) override { nodes_.push_back(node); }
+  const NodeDef* GetCurrNode() override {
+    CHECK(!nodes_.empty()) << "GetCurrNode(), but there's no ready node";
+    return nodes_.front();
+  }
+  void RemoveCurrNode() override { nodes_.pop_front(); }
+  bool Empty() const override { return nodes_.empty(); }
+
+ private:
+  std::list<const NodeDef*> nodes_;
+};
+
+// The LIFOManager schedules nodes by returning the last one added to the
+// scheduler. A node is executed and then its ready outputs are newly added to
+// the scheduler, so the LIFOManager will return outputs to a node following
+// that node's execution.
+class LIFOManager : public ReadyNodeManager {
+ public:
+  LIFOManager() : ReadyNodeManager() {}
+  ~LIFOManager() override {}
+  void AddNode(const NodeDef* node) override;
+  const NodeDef* GetCurrNode() override;
+  void RemoveCurrNode() override;
+  bool Empty() const override { return nodes_.empty(); }
+
+ private:
+  std::list<const NodeDef*> nodes_;
+  // Keep track of the current node being executed by saving its position.
+  // Necessary because nodes may be added to the end of the list while a node is
+  // executing, and we want to remove the correct node (the one that is
+  // executing) rather than the new ones being added.
+  std::list<const NodeDef*>::iterator curr_pos_ = nodes_.end();
+};
+
+// Abstract class that maintains a heap/priority queue for scheduling ready
+// nodes. Derived class needs to implement the Greater() function which returns
+// the comparator for the heap.
+class HeapReadyManager : public ReadyNodeManager {
+ public:
+  HeapReadyManager();
+  Status Init(
+      const std::unordered_map<const NodeDef*, NodeState>* node_map) override;
+  ~HeapReadyManager() override {}
+  void AddNode(const NodeDef* node) override;
+  const NodeDef* GetCurrNode() override;
+  void RemoveCurrNode() override;
+  bool Empty() const override;
+
+ protected:
+  virtual std::function<bool(const NodeDef*, const NodeDef*)> Greater() = 0;
+
+  // nodes_ is the main queue, where we construct heap, and the front is the
+  // current node.
+  std::vector<const NodeDef*> nodes_;
+
+  // Comparator functor for heap; stl heap is max heap, so we use "greater than"
+  // functor for keeping the smallest time_ready node at the front of heap.
+  std::function<bool(const NodeDef*, const NodeDef*)> greater_;
+
+  // NodeState structure from SchedulerState to get time_ready of ready nodes.
+  // Not owned by FirstReadyManager.
+  const std::unordered_map<const NodeDef*, NodeState>* node_map_;
+
+  // Cached curr node. Set back to nullptr from RemoveCurrNode().
+  const NodeDef* curr_node_;
+};
+
+// FirstReadyManager picks a node with the minimum time_ready value.
+// Behavior is deterministic when there are more than one nodes with the minimum
+// time_ready value with unique node names as the tie-breaker.
+class FirstReadyManager : public HeapReadyManager {
+ public:
+  FirstReadyManager() : HeapReadyManager() {}
+  ~FirstReadyManager() override {}
+
+ protected:
+  std::function<bool(const NodeDef*, const NodeDef*)> Greater() override;
+};
+
+// PriorityReadyManager uses the given node priorities when picking up next node
+// from all the ready nodes.
+class PriorityReadyManager : public HeapReadyManager {
+ public:
+  PriorityReadyManager() : HeapReadyManager() {}
+  ~PriorityReadyManager() override {}
+  void AddNode(const NodeDef* node) override;
+
+  // Note this should be called after Init().
+  Status SetPriority(const std::unordered_map<string, int>& node_priority);
+
+ protected:
+  std::function<bool(const NodeDef*, const NodeDef*)> Greater() override;
+
+ private:
+  // A map from unique node name to priority. Lower number means higher
+  // priority.
+  std::unordered_map<string, int> node_priority_;
+};
+
+// CompositeNodeManager has a few other NodeManagers: per-device LIFO for normal
+// ops (neither _Send nor _Recv) and FirstReadyManagers for _Send ops and _Recv
+// ops, and then it chooses FirstReady among the ops chosen from each
+// internal NodeManagers. The objective is to maximize producer-consumer
+// locality within device, while processing nodes across devices, including
+// _Send and _Recv, fairly, in terms of their time_ready.
+class CompositeNodeManager : public ReadyNodeManager {
+ public:
+  CompositeNodeManager();
+  ~CompositeNodeManager() override {}
+
+  Status Init(
+      const std::unordered_map<const NodeDef*, NodeState>* node_map) override;
+  void AddNode(const NodeDef* node) override;
+  const NodeDef* GetCurrNode() override;
+  void RemoveCurrNode() override;
+  bool Empty() const override;
+
+ private:
+  // Internal ready node managers:
+  // LIFO for normal ops to maximize producer consumer locality.
+  // One LIFO per device.
+  std::unordered_map<string, LIFOManager> ops_lifo_map_;
+  // FirstReady for send and recv. Handle send and recv separately ensures that
+  // send and recv do not block previously read ops with LIFO schedule.
+  FirstReadyManager send_manager_;
+  FirstReadyManager recv_manager_;
+
+  // NodeState structure from SchedulerState to get time_ready of ready nodes.
+  // Not owned by CompositeReadyManager.
+  const std::unordered_map<const NodeDef*, NodeState>* node_map_;
+
+  // Cached curr node. Set back to nullptr from RemoveCurrNode().
+  const NodeDef* curr_node_;
+};
+
+// Constructs a ready node manager from the given string.
+std::unique_ptr<ReadyNodeManager> ReadyNodeManagerFactory(
+    const string& ready_node_manager);
+
+// Encapsulates all of the various pieces uses to track state of a scheduler;
+// enables reuse of all scheduler state-related utilities across different
+// scheduler implementations.
+class SchedulerState {
+ public:
+  SchedulerState(const bool use_static_shapes,
+                 const bool use_aggressive_shape_inference, Cluster* cluster,
+                 std::unique_ptr<VirtualPlacer> placer);
+  // Move constructor. Explicitly defined because it otherwise gets implicitly
+  // deleted. SchedulerState is a move-only class, as we have a <unique_ptr>
+  // for it in VirtualScheduler. A derivative of VirtualScheduler can move a
+  // <unique_ptr> SchedulerState to VirtualScheduler when it is constructed,
+  // which is where this move constructor is needed.
+  SchedulerState(SchedulerState&& arg) = default;
+  // We explicitly delete assinment and copy operators, this is done implicitly,
+  // but we state it here explicitly for clarity.
+  SchedulerState& operator=(SchedulerState&& arg) = delete;
+  SchedulerState(const SchedulerState&) = delete;
+  SchedulerState& operator=(const SchedulerState&) = delete;
+  // Destructor. Must be defined such that a derivative class can override it
+  // and allow proper desctruction of the derivative class. If this is not done
+  // properly, memory leaks can occur.
+  virtual ~SchedulerState();
+  // Sets up the graph while also performing some necessary transformations
+  // initial_nodes is the set of nodes (primary inputs) discovered by Init()
+  // which may be added by a ReadyNodeManager (or related/derivative scheduler)
+  // to begin node schedule and graph simulation.
+  Status Init(const GrapplerItem* item,
+              std::vector<const NodeDef*>* initial_nodes,
+              bool create_explicit_channel_device = true);
+
+  virtual Costs Summary() const;
+  // Like the above, but writes detailed stats to RunMetadata.
+  // If metadata is nullptr, then just calls and return Summary().
+  virtual Costs Summary(RunMetadata* metadata);
+  // Generates RunMetadata's step_stats and partition_graphs fields from results
+  // of the virtual execution of the graph.
+  // TODO(rdegruijl) See if we can make this function and caller Summary()
+  // const.
+  void GenerateRunMetadata(RunMetadata* metadata);
+
+  // Returns per device memory usage.
+  const std::unordered_map<string, int64_t> GetPeakMemoryUsage() const;
+  const std::unordered_map<string, int64_t> GetPersistentMemoryUsage() const;
+  void enable_mem_usage_tracking() { track_mem_usage_snapshot_ = true; }
+  // Returns (read only) device and node states.
+  const std::unordered_map<string, DeviceState>* GetDeviceStates() const {
+    return &device_;
+  }
+
+  const std::unordered_map<const NodeDef*, NodeState>* GetNodeStates() const {
+    return &node_map_;
+  }
+
+  virtual OpContext CreateOpContext(const NodeDef* node) const;
+  std::vector<const NodeDef*> MarkNodeExecuted(
+      const NodeDef* node, const Costs& node_costs, const OpContext& op_context,
+      bool extract_execution_count_attr = true,
+      const std::string& override_device_name = "");
+
+  // Some getter functions.
+  const GrapplerItem* GetGrapplerItem() { return grappler_item_; }
+  Costs GetGraphCost() { return graph_costs_; }
+  Cluster* GetCluster() { return cluster_; }
+  bool GetUseStaticShape() { return use_static_shapes_; }
+  bool GetUseAggressiveShapeInference() {
+    return use_aggressive_shape_inference_;
+  }
+  const std::unordered_map<const NodeDef*, NodeState>& GetNodeMap() {
+    return node_map_;
+  }
+
+ protected:
+  // Assigns the time_scheduled in the NodeState of node to the current
+  // execution_time of the device executing this node.
+  void SetNodeStateTimeScheduled(const NodeDef* node);
+
+  // This method can be used by a class derived from SchedulerState to
+  // access the device state map.
+  std::unordered_map<string, DeviceState>* GetMutableDeviceState() {
+    return &device_;
+  }
+
+ private:
+  // Methods called from Init(). Fails if initialize_ is set.
+
+  void MaybeUpdateInputOutput(const NodeDef* node);
+  NodeState& GetNodeStateOrCreateIt(const NodeDef* node);
+  // Creates a Send_ and Recv_ pair between from and to. The argument
+  // create_channel_device tells the function to create an explicit device for
+  // the channel.
+  std::pair<const NodeDef*, const NodeDef*> CreateSendRecv(
+      const NodeDef* from, const NodeDef* to, const NodeDef* input_node,
+      const string& input_name, bool create_channel_device);
+  string DeviceName(const NodeDef* node) const;
+  string SanitizedDeviceName(const NodeDef* node) const;
+  string ChannelDeviceName(const NodeDef* from, const NodeDef* to) const;
+
+  // Helper methods.
+  void GetOutputNodes(const NodeDef* node, const Costs::Duration& curr_time,
+                      std::vector<const NodeDef*>* output_nodes);
+  // Retrieves output size from node_cost at a port_num.  If the output size has
+  // not been set, defaults back to CalculateOutputSize.
+  int64_t GetOrCalculateOutputSize(const NodeState& node_state,
+                                   int port_num) const;
+
+  std::unordered_map<const NodeDef*, NodeState> node_map_;
+  std::unordered_map<string, DeviceState> device_;
+
+  // Pool of NodeDefs for SendRecv and Identity ops created.
+  std::vector<std::unique_ptr<NodeDef>> additional_nodes_;
+
+  // Stats:
+  // Op counts with key with input shape.
+  // Example key: "[Op=AssignSub, input_shapes=[[7,1,160,160][7,1,160,160]]"
+  std::map<string, int> op_counts_;
+  // Individual op costs with key with input shape.
+  // Integer field for execution time in micro seconds.
+  // Boolean field for whether the cost is accurate.
+  std::map<string, std::pair<int, bool>> op_costs_;
+
+  Costs graph_costs_;                   // Graph cost.
+  std::map<string, Costs> op_to_cost_;  // Per-op cost.
+
+  // Auxiliary data structures for constructing NodeState and DeviceState.
+  std::unique_ptr<GraphProperties> graph_properties_;  // Initialized in Init().
+  Cluster* cluster_;                                   // Not owned.
+  const GrapplerItem* grappler_item_;                  // Not owned.
+  bool use_static_shapes_;
+  bool initialized_;
+  bool track_mem_usage_snapshot_;
+  const bool use_aggressive_shape_inference_;
+  std::unique_ptr<VirtualPlacer> placer_;
+};
+
+// The virtual scheduler emulates execution of nodes in a graph, considering
+// dependencies, device, etc.
+class VirtualScheduler {
+ public:
+  // Does not take ownership of cluster or ready_nodes.
+  VirtualScheduler(const bool use_static_shapes,
+                   const bool use_aggressive_shape_inference, Cluster* cluster,
+                   ReadyNodeManager* ready_nodes,
+                   std::unique_ptr<VirtualPlacer> placer);
+  // This constructor can be called by a derivative of VirtualScheduler to
+  // construct the base class. It lets VirtualScheduler take ownership of
+  // a new SchedulerState or a derivative thereof.
+  // Note that this constructor does not set a VirtualPlacer, in this
+  // constructor the VirtialPlacer is passed as a member of the SchedulerState
+  // that is passed as an argument.
+  VirtualScheduler(ReadyNodeManager* ready_nodes,
+                   std::unique_ptr<SchedulerState> scheduler_state);
+  virtual ~VirtualScheduler();
+
+  // Initializes the scheduler for the specific grappler item.
+  // Should be called immediately after the c'tor or when the scheduler will be
+  // reused for a new grappler item. All internal states of the scheduler
+  // related to the previous grappler item will be reset/cleared.
+  //
+  // This function should be called at least once after the scheduler is
+  // constructed. An uninitialized or failed-to-initialize scheduler will cause
+  // undefined behavior.
+  virtual Status Init(const GrapplerItem* item);
+
+  // Gets the current scheduled node for execution; the caller of this function
+  // can accordingly simulate the execution of the current scheduled node.
+  virtual OpContext GetCurrNode();
+  // Marks the current scheduled node as executed. Note that we should call this
+  // function only after the execution of the node has been simulated;
+  // node_costs_ capture the simulated costs of the node.
+  // Returns true if there is any node to be scheduled.
+  virtual bool MarkCurrNodeExecuted(const Costs& node_costs);
+
+  // Prints out summary of execution (timing, memory usage, etc.)
+  Costs Summary() const { return scheduler_state_->Summary(); }
+  // Like the above, but writes detailed stats to RunMetadata.
+  // If metadata is nullptr, then just calls and return Summary().
+  Costs Summary(RunMetadata* metadata) {
+    return scheduler_state_->Summary(metadata);
+  }
+  // Generates RunMetadata's step_stats and partition_graphs fields from results
+  // of the virtual execution of the graph.
+  void GenerateRunMetadata(RunMetadata* metadata) {
+    scheduler_state_->GenerateRunMetadata(metadata);
+  }
+  // Returns per device memory usage.
+  const std::unordered_map<string, int64_t> GetPeakMemoryUsage() const {
+    return scheduler_state_->GetPeakMemoryUsage();
+  }
+  const std::unordered_map<string, int64_t> GetPersistentMemoryUsage() const {
+    return scheduler_state_->GetPersistentMemoryUsage();
+  }
+  // Returns VirtualScheduler (read only) device and node states.
+  const std::unordered_map<string, DeviceState>* GetDeviceStates() const {
+    return scheduler_state_->GetDeviceStates();
+  }
+  const std::unordered_map<const NodeDef*, NodeState>* GetNodeStates() const {
+    return scheduler_state_->GetNodeStates();
+  }
+  void enable_mem_usage_tracking() {
+    scheduler_state_->enable_mem_usage_tracking();
+  }
+
+ protected:
+  // The state of the scheduler and the execution of the graph is encapsulated
+  // by the scheduler_state_ object.
+  std::unique_ptr<SchedulerState> scheduler_state_;
+  // ready_nodes_ is responsible for ordering the traversal of the graph.
+  ReadyNodeManager* ready_nodes_;  // Not owned.
+};
+
+}  // namespace grappler
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_COSTS_VIRTUAL_SCHEDULER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/devices.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/devices.h
new file mode 100644
index 0000000000000000000000000000000000000000..a9bc76c3dbb87f30855832ae3a8550d27ed3c64b
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/devices.h
@@ -0,0 +1,45 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_DEVICES_H_
+#define TENSORFLOW_CORE_GRAPPLER_DEVICES_H_
+
+#include <functional>
+#include <utility>
+
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/lib/core/threadpool.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+namespace grappler {
+
+// Get the number of available GPUs whose number of multiprocessors is no less
+// than 8 and whose CUDA compute capability is no less than
+// min_cuda_compute_capability.
+int GetNumAvailableGPUs(
+    const std::pair<int, int>& min_cuda_compute_capability = {0, 0});
+
+// Maximum amount of gpu memory available per gpu. gpu_id must be in the range
+// [0, num_available_gpu)
+int64_t AvailableGPUMemory(int gpu_id);
+
+// Get the number of logical CPU cores (aka hyperthreads) available.
+int GetNumAvailableLogicalCPUCores();
+
+}  // end namespace grappler
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_DEVICES_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/graph_topology_view.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/graph_topology_view.h
new file mode 100644
index 0000000000000000000000000000000000000000..cdb2eeb92a9726b77cca59a5ed8debf94c53d640
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/graph_topology_view.h
@@ -0,0 +1,115 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_GRAPH_TOPOLOGY_VIEW_H_
+#define TENSORFLOW_CORE_GRAPPLER_GRAPH_TOPOLOGY_VIEW_H_
+
+#include "absl/container/flat_hash_map.h"
+#include "absl/container/inlined_vector.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+#include "absl/types/span.h"
+#include "tensorflow/core/graph/tensor_id.h"
+#include "tensorflow/core/grappler/graph_view.h"
+
+namespace tensorflow {
+namespace grappler {
+
+// GraphTopologyView is a helper class to simplify `node-to-node` connectivity
+// traversals. Regular `GraphView` simplifies `tensor-to-tensor` traversals:
+// connections between output tensors and inputs of a consumer nodes. For the
+// topology view we are focused on nodes connected to nodes, and it's irrelevant
+// if this connection is formed by one or multiple individual tensors.
+//
+// Example:
+//   a = Placeholder(..)
+//   b = Placeholder(..)
+//   c = AddN([a, a, b])
+//
+// GraphView edges:         [a:0 -> c:0, a:0 -> c:1, b:0 -> c:2]
+// GraphTopologyView edges: [a -> c, b -> c]
+//
+// GraphView is used for exploring single node fanins and fanouts, and
+// GraphTopologyView is focused on efficient full graph traversals (computing
+// graph node properties from transitive fanouts, etc...).
+class GraphTopologyView {
+ public:
+  GraphTopologyView() = default;
+  explicit GraphTopologyView(bool skip_invalid_edges)
+      : skip_invalid_edges_(skip_invalid_edges) {}
+
+  // Initialize graph topology view from the graph. It's possible to pass
+  // additional edges that do not exist in a graph, but must be respected when
+  // computing graph topology. Example: Tensorflow runtime allows concurrent
+  // execution of dequeue/enqueue ops from the same queue resource, but we might
+  // want to enforce ordering between them for the purpose of graph analysis.
+  Status InitializeFromGraph(const GraphDef& graph,
+                             absl::Span<const GraphView::Edge> ephemeral_edges,
+                             bool ignore_control_edges);
+  Status InitializeFromGraph(const GraphDef& graph,
+                             absl::Span<const GraphView::Edge> ephemeral_edges);
+  Status InitializeFromGraph(const GraphDef& graph, bool ignore_control_edges);
+  Status InitializeFromGraph(const GraphDef& graph);
+
+  bool is_initialized() const { return graph_ != nullptr; }
+  int num_nodes() const { return num_nodes_; }
+  const GraphDef* graph() const { return graph_; }
+
+  // Returns true iff the node exists in the underlying graph.
+  bool HasNode(absl::string_view node_name) const;
+
+  // Finds a node by name or returns `nullptr` if it's not in the graph.
+  const NodeDef* GetNode(absl::string_view node_name) const;
+  // Returns a node corresponding to the given node index.
+  const NodeDef* GetNode(int node_idx) const;
+
+  // Returns a node index for the given node name, if the name exists in the
+  // underlying graph. Otherwise returns empty optional.
+  const absl::optional<int> GetNodeIndex(absl::string_view node_name) const;
+  // Returns a node index for the given node, if the node belongs to the
+  // underlying graph. Otherwise returns empty optional.
+  const absl::optional<int> GetNodeIndex(const NodeDef& node) const;
+
+  // Returns all the node indexes that are in the direct fanin of the given
+  // node. If the `node_idx` is outside of [0, num_nodes_) returns empty vector.
+  const absl::InlinedVector<int, 4>& GetFanin(int node_idx) const;
+  // Returns all the node indexes that are in the direct fanout of the given
+  // node. If the `node_idx` is outside of [0, num_nodes_) returns empty vector.
+  const absl::InlinedVector<int, 2>& GetFanout(int node_idx) const;
+
+ private:
+  // If true, all invalid edges and inputs (srd, dst or input node not found in
+  // a graph) will be skipped, otherwise initialization will fail with error.
+  bool skip_invalid_edges_ = false;
+
+  // WARN: `graph_` must outlive this object and graph nodes must not be
+  // destructed, because node names captured with absl::string_view.
+  const GraphDef* graph_ = nullptr;  // do not own
+  int num_nodes_ = 0;
+  std::vector<absl::string_view> index_to_node_name_;
+  absl::flat_hash_map<absl::string_view, int> node_name_to_index_;
+  std::vector<absl::InlinedVector<int, 4>> fanins_;   // node_idx->input nodes
+  std::vector<absl::InlinedVector<int, 2>> fanouts_;  // node_idx->output nodes
+
+  // We need a valid reference to return from GetFanin/GetFanout if the
+  // `node_idx` argument is outside of the [0, num_nodes_) range.
+  absl::InlinedVector<int, 4> empty_fanin_;
+  absl::InlinedVector<int, 2> empty_fanout_;
+};
+
+}  // end namespace grappler
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_GRAPH_TOPOLOGY_VIEW_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/graph_view.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/graph_view.h
new file mode 100644
index 0000000000000000000000000000000000000000..a7775aaeb31c7ddb6c192b406c532d26350138ba
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/graph_view.h
@@ -0,0 +1,427 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_GRAPH_VIEW_H_
+#define TENSORFLOW_CORE_GRAPPLER_GRAPH_VIEW_H_
+
+#include <unordered_map>
+#include <unordered_set>
+
+#include "absl/container/flat_hash_map.h"
+#include "absl/container/flat_hash_set.h"
+#include "absl/hash/hash.h"
+#include "absl/status/status.h"
+#include "absl/strings/string_view.h"
+#include "tensorflow/core/framework/graph.pb.h"
+#include "tensorflow/core/framework/node_def.pb.h"
+#include "tensorflow/core/framework/op_def.pb.h"
+#include "tensorflow/core/graph/tensor_id.h"
+#include "tensorflow/core/grappler/utils.h"
+#include "tensorflow/core/lib/gtl/map_util.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+namespace grappler {
+
+// Map a node/op's input/output port_id to arg_id.
+//
+// The port_id refers to the n-th tensor of the node, while the arg_id refers to
+// the n-th arg of the op. These two can be different if an op's arg is a list
+// of tensors.
+//
+// We return -1 for any invalid port_id (i.e., no corresponding arg_id).
+int OpOutputPortIdToArgId(const NodeDef& node, const OpDef& op, int port_id);
+int OpInputPortIdToArgId(const NodeDef& node, const OpDef& op, int port_id);
+
+namespace internal {
+
+// GraphViewInternal is a helper class to simplify graph traversal. It creates
+// an immutable view of the nodes and edges represented by a GraphDef protocol
+// buffer.
+//
+// There are two public classes implementing GraphViewInternal:
+//
+// - GraphView: constructed from the `const GraphDef` and doesn't allow
+//   to mutate underlying graph via input/output ports lookup functions (ports
+//   have const pointers to nodes).
+//
+// - MutableGraphView: constructed from the 'GraphDef` and allows to mutate
+//   the graph via input/output ports lookup functions (ports have non-const
+//   pointers to nodes), and also have couple additional functions to
+//   add/remove/replace nodes in the graph.
+//
+// --------------------------- !!! WARNING !!! ---------------------------------
+//     Removing nodes from the graph outside of MutableGraphView will
+//     lead to segfaults! Guaranteed by absl::string_view!
+// -----------------------------------------------------------------------------
+//
+template <typename GraphDefT, typename NodeDefT>
+class GraphViewInternal {
+ public:
+  struct Port {
+    Port() : node(nullptr), port_id(0) {}
+    Port(NodeDefT* n, int port) : node(n), port_id(port) {}
+
+    bool operator==(const Port& other) const {
+      return node == other.node && port_id == other.port_id;
+    }
+
+    template <typename H>
+    friend H AbslHashValue(H h, const Port& p) {
+      return H::combine(std::move(h), p.node, p.port_id);
+    }
+
+    NodeDefT* node;
+    int port_id;
+  };
+
+  struct InputPort : public Port {
+    using Port::Port;
+  };
+
+  struct OutputPort : public Port {
+    using Port::Port;
+  };
+
+  struct Edge {
+    Edge(OutputPort s, InputPort d) : src(s), dst(d) {}
+
+    bool operator==(const Edge& other) const {
+      return src == other.src && dst == other.dst;
+    }
+
+    template <typename H>
+    friend H AbslHashValue(H h, const Edge& e) {
+      return H::combine(std::move(h), e.src, e.dst);
+    }
+
+    OutputPort src;
+    InputPort dst;
+  };
+
+  GraphDefT* graph() const { return graph_; }
+
+  // Finds a node by name or return `nullptr` if it's not in the graph view.
+  NodeDefT* GetNode(absl::string_view node_name) const {
+    return gtl::FindWithDefault(nodes_, node_name, nullptr);
+  }
+
+  // Checks if a node by name is in the graph view.
+  bool HasNode(absl::string_view node_name) const {
+    return GetNode(node_name) != nullptr;
+  }
+
+  // Gets the specified input port. Note that the special '-1' port_id can be
+  // used to access the controlling nodes (i.e. the nodes connected to node_name
+  // through an incoming control dependency).
+  InputPort GetInputPort(absl::string_view node_name, int port_id) const {
+    return InputPort(GetNode(node_name), port_id);
+  }
+
+  // Gets the specified output port. Note that the special '-1' port_id can be
+  // used to access the controlled nodes (i.e. the nodes connected to node_name
+  // through an outgoing control dependency).
+  OutputPort GetOutputPort(absl::string_view node_name, int port_id) const {
+    return OutputPort(GetNode(node_name), port_id);
+  }
+
+  // Gets the input port(s) in the immediate fanout of an output port.
+  const absl::flat_hash_set<InputPort>& GetFanout(
+      const OutputPort& port) const {
+    return gtl::FindWithDefault(fanouts_, port, fanout_not_found_value_);
+  }
+
+  // Gets the output port(s) in the immediate fanin of an input port.
+  absl::flat_hash_set<OutputPort> GetFanin(const InputPort& port) const {
+    if (port.port_id >= 0) {
+      OutputPort regular_fanin = GetRegularFanin(port);
+      if (regular_fanin.node == nullptr) {
+        return {};
+      }
+      return {regular_fanin};
+    }
+
+    // Collect fanin for the control input.
+    absl::flat_hash_set<OutputPort> result;
+    const int first_control_port =
+        gtl::FindWithDefault(max_regular_input_port_, port.node, -1) + 1;
+    for (int i = first_control_port; i < port.node->input_size(); ++i) {
+      TensorId tensor_id = ParseTensorName(port.node->input(i));
+
+      auto it = nodes_.find(tensor_id.node());
+      if (it != nodes_.end()) result.emplace(it->second, tensor_id.index());
+    }
+    return result;
+  }
+
+  // Special case: regular (i.e. non-control) input ports can only have one
+  // fanin. If port.port_id is out of range or is a control dependency, then an
+  // empty OutputPort is returned.
+  const OutputPort GetRegularFanin(const InputPort& port) const {
+    if (port.port_id < 0 ||
+        port.port_id >
+            gtl::FindWithDefault(max_regular_input_port_, port.node, -1)) {
+      return OutputPort();
+    }
+
+    TensorId tensor_id = ParseTensorName(port.node->input(port.port_id));
+    return GetOutputPort(tensor_id.node(), tensor_id.index());
+  }
+
+  // Checks if a tensor id is a fanin of the node.
+  bool HasFanin(const NodeDefT& node, const TensorId& fanin) const {
+    int end = node.input_size();
+    if (end == 0 || fanin.index() < -1) {
+      return false;
+    }
+
+    const int num_regular_fanins =
+        gtl::FindWithDefault(max_regular_input_port_, &node, -1) + 1;
+    int start = 0;
+    if (fanin.index() > -1) {
+      end = num_regular_fanins;
+    } else {
+      start = num_regular_fanins;
+    }
+    for (int i = start; i < end; ++i) {
+      if (ParseTensorName(node.input(i)) == fanin) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  // Gets all the input ports in the immediate fanout of a node. Include the
+  // controlled nodes iff include_controlled_nodes is true.
+  absl::flat_hash_set<InputPort> GetFanouts(
+      const NodeDefT& node, bool include_controlled_nodes) const {
+    absl::flat_hash_set<InputPort> result;
+
+    OutputPort port;
+    port.node = const_cast<NodeDefT*>(&node);
+    const int first_port_id = include_controlled_nodes ? -1 : 0;
+    const int last_port_id =
+        gtl::FindWithDefault(max_regular_output_port_, &node, -1);
+
+    for (int i = first_port_id; i <= last_port_id; ++i) {
+      port.port_id = i;
+      auto it = fanouts_.find(port);
+      if (it != fanouts_.end()) {
+        result.insert(it->second.begin(), it->second.end());
+      }
+    }
+    return result;
+  }
+
+  // Gets all the output ports in the immediate fanin of a node. Include the
+  // controlling nodes iff include_controlling_nodes is true.
+  absl::flat_hash_set<OutputPort> GetFanins(
+      const NodeDefT& node, bool include_controlling_nodes) const {
+    absl::flat_hash_set<OutputPort> result;
+    const int max_input_port =
+        include_controlling_nodes
+            ? node.input_size() - 1
+            : gtl::FindWithDefault(max_regular_input_port_, &node, -1);
+    for (int i = 0; i <= max_input_port; ++i) {
+      TensorId tensor_id = ParseTensorName(node.input(i));
+
+      auto it = nodes_.find(tensor_id.node());
+      if (it != nodes_.end()) result.emplace(it->second, tensor_id.index());
+    }
+    return result;
+  }
+
+  // Gets the number of ports in the immediate fanin of a node. Count the
+  // controlling nodes iff include_controlling_nodes is true.
+  int NumFanins(const NodeDefT& node, bool include_controlling_nodes) const {
+    if (include_controlling_nodes) {
+      return node.input_size();
+    }
+    return gtl::FindWithDefault(max_regular_input_port_, &node, -1) + 1;
+  }
+
+  // Gets the number of ports in the immediate fanout of a node. Count the
+  // controlled nodes iff include_controlled_nodes is true.
+  int NumFanouts(const NodeDefT& node, bool include_controlled_nodes) const {
+    int count = 0;
+
+    OutputPort port;
+    port.node = const_cast<NodeDefT*>(&node);
+    const int first_port_id = include_controlled_nodes ? -1 : 0;
+    const int last_port_id =
+        gtl::FindWithDefault(max_regular_output_port_, &node, -1);
+
+    for (int i = first_port_id; i <= last_port_id; ++i) {
+      port.port_id = i;
+      auto it = fanouts_.find(port);
+      if (it != fanouts_.end()) count += it->second.size();
+    }
+
+    return count;
+  }
+
+  // Gets all the edges in the immediate fanout of a node. Include the
+  // controlled edges iff include_controlled_edges is true.
+  absl::flat_hash_set<Edge> GetFanoutEdges(
+      const NodeDefT& node, bool include_controlled_edges) const {
+    absl::flat_hash_set<Edge> result;
+
+    OutputPort port;
+    port.node = const_cast<NodeDefT*>(&node);
+    const int first_port_id = include_controlled_edges ? -1 : 0;
+    const int last_port_id =
+        gtl::FindWithDefault(max_regular_output_port_, &node, -1);
+
+    for (int i = first_port_id; i <= last_port_id; ++i) {
+      port.port_id = i;
+      auto it = fanouts_.find(port);
+      if (it != fanouts_.end()) {
+        for (auto itr = it->second.begin(); itr != it->second.end(); ++itr) {
+          result.emplace(/*src=*/port, /*dst=*/*itr);
+        }
+      }
+    }
+    return result;
+  }
+
+  // Gets all the edges in the immediate fanin of a node. Include the
+  // controlling edges iff include_controlling_edges is true.
+  absl::flat_hash_set<Edge> GetFaninEdges(
+      const NodeDefT& node, bool include_controlling_edges) const {
+    absl::flat_hash_set<Edge> result;
+    const int max_input_port =
+        include_controlling_edges
+            ? node.input_size() - 1
+            : gtl::FindWithDefault(max_regular_input_port_, &node, -1);
+    for (int i = 0; i <= max_input_port; ++i) {
+      TensorId tensor_id = ParseTensorName(node.input(i));
+
+      auto it = nodes_.find(tensor_id.node());
+      if (it != nodes_.end()) {
+        result.emplace(/*src=*/OutputPort(it->second, tensor_id.index()),
+                       /*dst=*/InputPort(const_cast<NodeDefT*>(&node), i));
+      }
+    }
+    return result;
+  }
+
+ protected:
+  explicit GraphViewInternal(GraphDefT* graph) : graph_(graph) {}
+
+  Status AddUniqueNode(NodeDefT* node) {
+    auto inserted = nodes_.emplace(node->name(), node);
+    return inserted.second
+               ? OkStatus()
+               : absl::InvalidArgumentError(absl::StrCat(
+                     "Non unique node name detected: ", node->name()));
+  }
+
+  // TODO(ezhulenev): Remove this function.
+  void AddUniqueNodeOrDie(NodeDefT* node) {
+    Status st = AddUniqueNode(node);
+    CHECK(st.ok()) << st.message();
+  }
+
+  // TODO(lyandy): Checks for self loops, Switch control dependencies, fanins
+  // exist, and all regular fanins come before controlling fanins.
+  void AddFanouts(NodeDefT* node) {
+    int max_input_port = -1;
+    for (int i = 0; i < node->input_size(); ++i) {
+      TensorId tensor_id = ParseTensorName(node->input(i));
+      OutputPort output(nodes_[tensor_id.node()], tensor_id.index());
+
+      if (output.port_id < 0) {
+        fanouts_[output].emplace(node, -1);
+      } else {
+        max_input_port = i;
+        max_regular_output_port_[output.node] =
+            std::max(max_regular_output_port_[output.node], output.port_id);
+        fanouts_[output].emplace(node, i);
+      }
+    }
+    if (max_input_port > -1) {
+      max_regular_input_port_[node] = max_input_port;
+    }
+  }
+
+  // Access to the mutable internal state for MutableGraphView.
+  absl::flat_hash_map<absl::string_view, NodeDefT*>& nodes() { return nodes_; }
+
+  absl::flat_hash_map<OutputPort, absl::flat_hash_set<InputPort>>& fanouts() {
+    return fanouts_;
+  }
+
+  absl::flat_hash_map<const NodeDefT*, int>& max_regular_input_port() {
+    return max_regular_input_port_;
+  }
+
+  absl::flat_hash_map<const NodeDefT*, int>& max_regular_output_port() {
+    return max_regular_output_port_;
+  }
+
+ private:
+  GraphDefT* graph_;  // must outlive the graph view
+
+  // A mapping from the node name to the node itself.
+  absl::flat_hash_map<absl::string_view, NodeDefT*> nodes_;
+
+  // A mapping from the output port to all inputs that read from it.
+  absl::flat_hash_map<OutputPort, absl::flat_hash_set<InputPort>> fanouts_;
+
+  // Keep a maximum index of input tensors of the node.
+  absl::flat_hash_map<const NodeDefT*, int> max_regular_input_port_;
+
+  // Keep a maximum index of tensor fetched from the node. It doesn't guarantee
+  // that all tensors in the [0, max_regular_output_port] range are actually
+  // fetched by other nodes.
+  absl::flat_hash_map<const NodeDefT*, int> max_regular_output_port_;
+
+  // If the node has no fanouts at given output port (output tensor consumers)
+  // we return a reference to this set from `GetFanout` (we can't construct new
+  // empty set every time, because we need a non-dangling reference).
+  absl::flat_hash_set<InputPort> fanout_not_found_value_;
+};
+
+}  // namespace internal
+
+// Immutable GraphView that keeps the constness of the GraphDef. If you need to
+// mutate the graph or the nodes via the graph view lookup functions, see
+// MutableGraphView.
+class GraphView
+    : public internal::GraphViewInternal<const GraphDef, const NodeDef> {
+ public:
+  explicit GraphView(const GraphDef* graph) : GraphViewInternal(graph) {
+    for (const NodeDef& node : graph->node()) AddUniqueNodeOrDie(&node);
+    for (const NodeDef& node : graph->node()) AddFanouts(&node);
+  }
+};
+
+// Returns true if node has one (or zero) fanout nodes at given output port.
+bool HasSingleFanoutNode(const GraphView& graph_view, const NodeDef* node,
+                         int port = 0);
+
+// Returns true if node has at least one fanout node at given output port.
+bool HasFanouts(const GraphView& graph_view, const NodeDef* node, int port = 0);
+// Returns true if the node has at least one input control dependency.
+bool HasControlFanin(const GraphView& graph_view, const NodeDef* node);
+// Returns true if the node has at least one output control dependency.
+bool HasControlFanout(const GraphView& graph_view, const NodeDef* node);
+// Returns true if the node has at least one input or output control dependency.
+bool HasControlFaninOrFanout(const GraphView& graph_view, const NodeDef* node);
+
+}  // end namespace grappler
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_GRAPH_VIEW_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/grappler_item.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/grappler_item.h
new file mode 100644
index 0000000000000000000000000000000000000000..6778d1f3047335910a383b337c491313655f6892
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/grappler_item.h
@@ -0,0 +1,145 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_GRAPPLER_ITEM_H_
+#define TENSORFLOW_CORE_GRAPPLER_GRAPPLER_ITEM_H_
+
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+#include "tensorflow/core/framework/graph.pb.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/variable.pb.h"
+#include "tensorflow/core/protobuf/queue_runner.pb.h"
+#include "tsl/platform/cpu_info.h"
+
+namespace tensorflow {
+namespace grappler {
+
+// A TensorFlow model to optimize.
+// Models are represented by the combination of a graph, one of more fetch
+// nodes, and potentially a set of nodes to feed.
+struct GrapplerItem {
+  GrapplerItem() = default;
+  GrapplerItem(const GrapplerItem& other) = default;
+  GrapplerItem(GrapplerItem&& other) = default;
+  GrapplerItem& operator=(const GrapplerItem& other) = default;
+  GrapplerItem& operator=(GrapplerItem&& other) = default;
+  virtual ~GrapplerItem() = default;
+
+  // Create a copy of this GrapplerItem with graph swapped with the argument.
+  GrapplerItem WithGraph(GraphDef&& graph) const;
+
+  string id;  // A unique id for this item
+
+  // Inputs
+  GraphDef graph;
+  std::vector<std::pair<string, Tensor>> feed;
+  std::vector<string> fetch;
+
+  // Initialization op(s).
+  std::vector<string> init_ops;
+  // Expected initialization time in seconds, or 0 if unknown
+  int64_t expected_init_time = 0;
+
+  // Save/restore ops (if any)
+  string save_op;
+  string restore_op;
+  string save_restore_loc_tensor;
+
+  // Queue runner(s) required to run the queue(s) of this model.
+  std::vector<QueueRunnerDef> queue_runners;
+
+  // List of op names to keep in the graph. This includes nodes that are
+  // referenced in various collections, and therefore must be preserved to
+  // ensure that the optimized metagraph can still be loaded.
+  std::vector<string> keep_ops;
+
+  // Return the set of node evaluated during a regular train/inference step.
+  std::vector<const NodeDef*> MainOpsFanin() const;
+  // Return the set of node run to populate the queues (if any).
+  std::vector<const NodeDef*> EnqueueOpsFanin() const;
+  // Return the set nodes used by TensorFlow to initialize the graph.
+  std::vector<const NodeDef*> InitOpsFanin() const;
+  // Return the set of variables accessed during a regular train/inference step.
+  std::vector<const NodeDef*> MainVariables() const;
+  // Return a set of node names that must be preserved. This includes feed and
+  // fetch nodes, keep_ops, init_ops.
+  std::unordered_set<string> NodesToPreserve() const;
+
+  struct OptimizationOptions {
+    // Is it allowed to add nodes to the graph that do not have registered
+    // gradient function.
+    bool allow_non_differentiable_rewrites = true;
+
+    // Tensorflow function execution semantics is slightly different from the
+    // main Tensorflow graph, and we need to make sure that we do not change it
+    // by running Grappler optimizer passes. One main difference is that
+    // functions do not prune ops with side-effects and dataset-output ops (see
+    // PruneFunctionBody in common_runtime/function.cc).
+    bool allow_pruning_stateful_and_dataset_ops = true;
+
+    // If true Grappler will optimize the main graph, and also all functions in
+    // the graph function library (function can't be polymorphic, it can't have
+    // undefined type parameters in the function signature, or placeholder
+    // attributes in the function body).
+    bool optimize_function_library = true;
+
+    // Mark the grapper optimization run in eager mode or not.
+    bool is_eager_mode = false;
+
+    // Number of intra threads used to run operation.
+    int intra_op_parallelism_threads = tsl::port::MaxParallelism();
+  };
+
+  const std::unordered_set<string>& devices() const;
+  // Adds a device to a set of available devices, only if it's a valid fully
+  // defined device name. Returns `OkStatus()` if successfully added a device,
+  // and an error otherwise.
+  Status AddDevice(const string& device);
+  // Adds all valid devices from the other Grappler item to the device set.
+  Status AddDevices(const GrapplerItem& other);
+  // Adds all valid devices from the nodes of the graph to the device set.
+  // Returns `OkStatus()` if all device annotations found in a graph are valid
+  // fully defined device names, and an error otherwise.
+  Status InferDevicesFromGraph();
+  // Clears a set of available devices.
+  void ClearDevices();
+
+  const OptimizationOptions& optimization_options() const;
+  OptimizationOptions& optimization_options();
+
+ private:
+  // TODO(ezhulenev) Make GrapplerItem a class and hide all public data members.
+  // TODO(ezhulenev): Migrate all unordered collections to absl.
+
+  // A set of fully defined device names that can be used to place the nodes of
+  // the `graph`.
+  // Example of a fully defined name: "/job:work/replica:1/task:1/device:CPU:0"
+  std::unordered_set<string> devices_;
+
+  OptimizationOptions optimization_options_;
+};
+
+GrapplerItem::OptimizationOptions CreateOptOptionsForEager();
+
+}  // end namespace grappler
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_GRAPPLER_ITEM_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/grappler_item_builder.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/grappler_item_builder.h
new file mode 100644
index 0000000000000000000000000000000000000000..d967fa180aad2183aad2661caf45a0a63bea27f5
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/grappler_item_builder.h
@@ -0,0 +1,84 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_GRAPPLER_ITEM_BUILDER_H_
+#define TENSORFLOW_CORE_GRAPPLER_GRAPPLER_ITEM_BUILDER_H_
+
+#include <memory>
+#include <set>
+#include <string>
+
+#include "tensorflow/core/framework/attr_value.pb.h"
+#include "tensorflow/core/grappler/grappler_item.h"
+
+namespace tensorflow {
+
+class MetaGraphDef;
+
+namespace grappler {
+
+struct ItemConfig {
+  ItemConfig() {}
+
+  // If true, ignore all user specified node placement.
+  bool ignore_user_placement = true;
+  // If true, ignore all user specified colocation attributes.
+  bool ignore_colocation = true;
+  // Dimension to use if a placeholder node has an _output_shapes attribute with
+  // a dimension of -1.
+  int placeholder_unknown_output_shape_dim = -1;
+  // If true, erases all "_noinline" attributes from user-defined functions.
+  // Has no effect if "inline_functions" is disabled.
+  bool erase_noinline_attributes = false;
+  // If non-empty, override the directory of asset paths.
+  string assets_directory_override;
+  // If true, runs ModelPruner on the graph.
+  bool prune_graph = false;
+  // Override feed nodes list.
+  std::set<string> feed_nodes;
+  // Override fetch nodes list.
+  std::set<string> fetch_nodes;
+
+  // Configs for graph optimizations from common_runtime. This is NOT Grappler
+  // function optimizer. When Grappler is invoked at runtime, it is typically
+  // running after common_runtime pass.
+  //
+  // If true, does L1 optimizations.
+  bool apply_optimizations = false;
+  // If true, does function inlining.
+  bool inline_functions = false;
+};
+
+// Method for optimizing the graph def (including function inlining and other
+// optimizations). This is optimizations from common_runtime, NOT Grappler
+// function optimizer.
+Status RuntimeGraphOptimizer(const GraphDef& graph_def_arg,
+                             GraphDef* output_graph_def, const ItemConfig& cfg);
+
+// Factory method for creating a GrapplerItem from a MetaGraphDef.
+// Returns nullptr if the given meta_graph cannot be converted.
+std::unique_ptr<GrapplerItem> GrapplerItemFromMetaGraphDef(
+    const string& id, const MetaGraphDef& meta_graph, const ItemConfig& cfg);
+
+// Factory method for creating a GrapplerItem from a file
+// containing a MetaGraphDef in either binary or text format.
+// Returns nullptr if the given meta_graph cannot be converted.
+std::unique_ptr<GrapplerItem> GrapplerItemFromMetaGraphDefFile(
+    const string& id, const string& meta_graph_file, const ItemConfig& cfg);
+
+}  // end namespace grappler
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_GRAPPLER_ITEM_BUILDER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/inputs/utils.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/inputs/utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..2588e380fed231067ea75cdafb2217543f0e3812
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/inputs/utils.h
@@ -0,0 +1,46 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_INPUTS_UTILS_H_
+#define TENSORFLOW_CORE_GRAPPLER_INPUTS_UTILS_H_
+
+#include <set>
+#include <vector>
+
+#include "tensorflow/core/framework/graph.pb.h"
+#include "tensorflow/core/framework/node_def.pb.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/protobuf/meta_graph.pb.h"
+
+namespace tensorflow {
+namespace grappler {
+
+bool FilesExist(const std::vector<string>& files,
+                std::vector<Status>* status = nullptr);
+bool FilesExist(const std::set<string>& files);
+
+bool FileExists(const string& file, Status* status);
+
+// Reads GraphDef from file in either text or raw serialized format.
+Status ReadGraphDefFromFile(const string& graph_def_path, GraphDef* result);
+
+// Reads MetaGraphDef from file in either text or raw serialized format.
+Status ReadMetaGraphDefFromFile(const string& meta_graph_def_path,
+                                MetaGraphDef* result);
+
+}  // end namespace grappler
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_INPUTS_UTILS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/mutable_graph_view.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/mutable_graph_view.h
new file mode 100644
index 0000000000000000000000000000000000000000..68946a65ab4d49a66b29280c0dd2a497e98b2a23
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/mutable_graph_view.h
@@ -0,0 +1,331 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_MUTABLE_GRAPH_VIEW_H_
+#define TENSORFLOW_CORE_GRAPPLER_MUTABLE_GRAPH_VIEW_H_
+
+#include <set>
+#include <string>
+
+#include "absl/container/flat_hash_set.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/span.h"
+#include "tensorflow/core/framework/graph.pb.h"
+#include "tensorflow/core/framework/node_def.pb.h"
+#include "tensorflow/core/graph/graph.h"
+#include "tensorflow/core/graph/tensor_id.h"
+#include "tensorflow/core/grappler/graph_view.h"
+#include "tensorflow/core/grappler/op_types.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+namespace grappler {
+
+const char kMutableGraphViewCtrl[] = "ConstantFoldingCtrl";
+
+// A utility class to simplify the traversal of a GraphDef that, unlike
+// GraphView, supports updating the graph.  Note that you should not modify the
+// graph separately, because the view will get out of sync.
+
+class MutableGraphView : public internal::GraphViewInternal<GraphDef, NodeDef> {
+ public:
+  explicit MutableGraphView(GraphDef* graph) : GraphViewInternal(graph) {
+    for (NodeDef& node : *graph->mutable_node()) AddUniqueNodeOrDie(&node);
+    for (NodeDef& node : *graph->mutable_node()) AddAndDedupFanouts(&node);
+  }
+
+  // Lookup fanouts/fanins using immutable ports.
+  using GraphViewInternal::GetFanout;
+  const absl::flat_hash_set<InputPort>& GetFanout(
+      const GraphView::OutputPort& port) const;
+
+  using GraphViewInternal::GetFanin;
+  absl::flat_hash_set<OutputPort> GetFanin(
+      const GraphView::InputPort& port) const;
+
+  using GraphViewInternal::GetRegularFanin;
+  const OutputPort GetRegularFanin(const GraphView::InputPort& port) const;
+
+  // Adds a new node to graph and updates the view. Returns a pointer to the
+  // node in graph.
+  NodeDef* AddNode(NodeDef&& node);
+
+  // Adds all nodes from the `subgraph` to the underlying graph and updates the
+  // view. `subgraph` doesn't have to be a valid graph definition on it's own,
+  // it can have edges to the nodes that are not in it, however after adding
+  // it to the underlying graph, final graph must be valid.
+  //
+  // If subgraph function library is not empty, all new functions will be added
+  // to the graph. Functions that appear with the same name in both subgraph and
+  // the graph represented by *this, must have identical function definitions.
+  //
+  // IMPORTANT: All nodes and functions of the given subgraph moved into the
+  // underlying graph, which leaves subgraph in valid but undefined state.
+  Status AddSubgraph(GraphDef&& subgraph);
+
+  // Updates node `node_name` op, device, and attributes. This will clear any
+  // existing attributes. If it is not possible to update the node or if the
+  // node does not exist, an error will be returned and nothing will be modified
+  // in the graph.
+  Status UpdateNode(absl::string_view node_name, absl::string_view op,
+                    absl::string_view device,
+                    absl::Span<const std::pair<string, AttrValue>> attrs);
+
+  // Updates node `from_node_name` name to `to_node_name`. If `to_node_name` is
+  // in use, node `from_node_name` does not exist, or node `from_node_name` has
+  // fanouts and `update_fanouts` is set to false, an error will be returned and
+  // nothing will be modified in the graph.
+  Status UpdateNodeName(absl::string_view from_node_name,
+                        absl::string_view to_node_name, bool update_fanouts);
+
+  // Swap node names `from_node_name` and `to_node_name`. Self loops of one node
+  // are removed by updating the inputs introducing self loops to use the other
+  // node's name. Setting `update_fanouts` to false will exclude other fanouts
+  // from having their inputs updated, but inputs introducing self loops will
+  // always be updated regardless of `update_fanouts.
+  //
+  // Example:
+  //   1. foo(other:3, bar:2, ^bar)
+  //   2. bar(foo:3, other:1, foo:1, ^foo)
+  //   3. other(foo:5, bar:6)
+  //
+  // After calling SwapNodeNames("foo", "bar", false):
+  //   1. bar(other:3, foo:2, ^foo)
+  //   2. foo(bar:3, other:1, bar:1, ^bar)
+  //   3. other(foo:5, bar:6)
+  //
+  // After calling SwapNodeNames("foo", "bar", true):
+  //   1. bar(other:3, foo:2, ^foo)
+  //   2. foo(bar:3, other:1, bar:1, ^bar)
+  //   3. other(bar:5, foo:6)
+  //
+  // If it is not possible to swap node names (i.e. nodes do not exist or Switch
+  // control dependency may be introduced), an error will be returned and
+  // nothing will be modified in the graph.
+  Status SwapNodeNames(absl::string_view from_node_name,
+                       absl::string_view to_node_name, bool update_fanouts);
+
+  // Updates all fanouts (input ports fetching output tensors) from
+  // `from_node_name` to the `to_node_name`, including control dependencies.
+  //
+  // Example: We have 3 nodes that use `bar` node output tensors as inputs:
+  //   1. foo1(bar:0, bar:1, other:0)
+  //   2. foo2(bar:1, other:1)
+  //   3. foo3(other:2, ^bar)
+  //
+  // After calling UpdateFanouts(bar, new_bar):
+  //   1. foo1(new_bar:0, new_bar:1, other:0)
+  //   2. foo2(new_bar:1, other:1)
+  //   3. foo3(other:2, ^new_bar)
+  Status UpdateFanouts(absl::string_view from_node_name,
+                       absl::string_view to_node_name);
+
+  // Adds regular fanin `fanin` to node `node_name`. If the node or fanin do not
+  // exist in the graph, nothing will be modified in the graph. Otherwise fanin
+  // will be added after existing non control dependency fanins. Control
+  // dependencies will be deduped. To add control dependencies, use
+  // AddControllingFanin.
+  Status AddRegularFanin(absl::string_view node_name, const TensorId& fanin);
+
+  // Adds regular fanin `fanin` to node `node_name` at port `port`. If the node
+  // or fanin do not exist in the graph, nothing will be modified in the graph.
+  // Otherwise fanin will be inserted at port `port`. Control dependencies will
+  // be deduped. To add control dependencies, use AddControllingFanin.
+  //
+  // If the port is not a valid port (less than 0 or greater than the number of
+  // regular fanins), this will result in an error and the node will not be
+  // modified.
+  Status AddRegularFaninByPort(absl::string_view node_name, int port,
+                               const TensorId& fanin);
+
+  // Adds control dependency `fanin` to the target node named `node_name`. To
+  // add regular fanins, use AddRegularFanin.
+  //
+  // Case 1: If the fanin is not a Switch node, the control dependency is simply
+  // added to the target node:
+  //
+  //   fanin -^> target node.
+  //
+  // Case 2: If the fanin is a Switch node, we cannot anchor a control
+  // dependency on it, because unlike other nodes, only one of its outputs will
+  // be generated when the node is activated. In this case, we try to find an
+  // Identity/IdentityN node in the fanout of the relevant port of the Switch
+  // and add it as a fanin to the target node. If no such Identity/IdentityN
+  // node can be found, a new Identity node will be created. In both cases, we
+  // end up with:
+  //
+  //   fanin -> Identity{N} -^> target node.
+  //
+  // If the control dependency being added is redundant (control dependency
+  // already exists or control dependency can be deduped from regular fanins),
+  // this will not result in an error and the node will not be modified.
+  Status AddControllingFanin(absl::string_view node_name,
+                             const TensorId& fanin);
+
+  // Removes regular fanin `fanin` from node `node_name`. If the node or fanin
+  // do not exist in the graph, nothing will be modified in the graph. If there
+  // are multiple inputs that match the fanin, all of them will be removed. To
+  // remove controlling fanins, use RemoveControllingFanin.
+  //
+  // If the fanin being removed doesn't exist in the node's inputs, this will
+  // not result in an error and the node will not be modified.
+  Status RemoveRegularFanin(absl::string_view node_name, const TensorId& fanin);
+
+  // Removes regular fanin at port `port` from node `node_name`. If the node
+  // does not exist in the graph, nothing will be modified in the graph.
+  // To remove controlling fanins, use RemoveControllingFanin.
+  //
+  // If the port is not a valid port (less than 0 or greater than the last index
+  // of the regular fanins), this will result in an error and the node will not
+  // be modified.
+  Status RemoveRegularFaninByPort(absl::string_view node_name, int port);
+
+  // Removes control dependency `fanin_node_name` from the target node named
+  // `node_name`. If the node or fanin do not exist in the graph, nothing will
+  // be modified in the graph. To remove regular fanins, use RemoveRegularFanin.
+  //
+  // If the fanin being removed doesn't exist in the node's inputs, this will
+  // not result in an error and the node will not be modified.
+  Status RemoveControllingFanin(absl::string_view node_name,
+                                absl::string_view fanin_node_name);
+
+  // Removes all fanins from node `node_name`. Control dependencies will be
+  // retained if keep_controlling_fanins is true.
+  //
+  // If no fanins are removed, this will not result in an error and the node
+  // will not be modified.
+  Status RemoveAllFanins(absl::string_view node_name,
+                         bool keep_controlling_fanins);
+
+  // Replaces all fanins `from_fanin` with `to_fanin` in node `node_name`. If
+  // the fanins or node do not exist, nothing will be modified in the graph.
+  // Control dependencies will be deduped.
+  //
+  // If the fanin being updated doesn't exist in the node's inputs, this will
+  // not result in an error and the node will not be modified.
+  Status UpdateFanin(absl::string_view node_name, const TensorId& from_fanin,
+                     const TensorId& to_fanin);
+
+  // Replaces fanin at port `port` in node `node_name` with fanin `fanin`. If
+  // the fanins or node do not exist, nothing will be modified in the graph.
+  // Control dependencies will be deduped.
+  //
+  // If the port is not a valid port (less than 0 or greater than the last index
+  // of the regular fanins), this will result in an error and the node will not
+  // be modified.
+  Status UpdateRegularFaninByPort(absl::string_view node_name, int port,
+                                  const TensorId& fanin);
+
+  // Swaps fanins at ports `from_port` and `to_port` in node `node_name`. If the
+  // node does not exist, nothing will be modified in the graph.
+  //
+  // If the ports are not a valid port (less than 0 or greater than the last
+  // index of the regular fanins), this will result in an error and the node
+  // will not be modified.
+  Status SwapRegularFaninsByPorts(absl::string_view node_name, int from_port,
+                                  int to_port);
+
+  // Updates all regular fanins to equivalent controlling fanins. If it is not
+  // possible, an error will be returned and nothing will be modified in the
+  // graph.
+  Status UpdateAllRegularFaninsToControlling(absl::string_view node_name);
+
+  // Deletes nodes from the graph. If a node can't be safely removed,
+  // specifically if a node still has fanouts, an error will be returned. Nodes
+  // that can't be found are ignored.
+  Status DeleteNodes(const absl::flat_hash_set<string>& nodes_to_delete);
+
+ private:
+  // Adds fanouts for fanins of node to graph, while deduping control
+  // dependencies from existing control dependencies and regular fanins. Note,
+  // node inputs will be mutated if control dependencies can be deduped.
+  void AddAndDedupFanouts(NodeDef* node);
+
+  // Finds next output port smaller than fanin.port_id and update. The
+  // max_regular_output_port is only updated if fanin.port_id is the same as the
+  // current max_regular_output_port and if the fanouts set is empty. If there
+  // are no regular outputs, max_regular_output_port will be erased.
+  void UpdateMaxRegularOutputPortForRemovedFanin(
+      const OutputPort& fanin,
+      const absl::flat_hash_set<InputPort>& fanin_fanouts);
+
+  // Updates max regular output port for newly added fanin by checking the
+  // current max and updating if the newly added fanin is of a larger port.
+  void UpdateMaxRegularOutputPortForAddedFanin(const OutputPort& fanin);
+
+  // Updates all fanouts (input ports fetching output tensors) from `from_node`
+  // to the `to_node`, including control dependencies.
+  //
+  // Example: We have 3 nodes that use `bar` node output tensors as inputs:
+  //   1. foo1(bar:0, bar:1, other:0)
+  //   2. foo2(bar:1, other:1)
+  //   3. foo3(other:2, ^bar)
+  //
+  // After calling UpdateFanouts(bar, new_bar):
+  //   1. foo1(new_bar:0, new_bar:1, other:0)
+  //   2. foo2(new_bar:1, other:1)
+  //   3. foo3(other:2, ^new_bar)
+  //
+  // IMPORTANT: If `from_node` or `to_node` is not in the underlying graph, the
+  // behavior is undefined.
+  Status UpdateFanoutsInternal(NodeDef* from_node, NodeDef* to_node);
+
+  // Adds fanin to node. If fanin is a control dependency, existing control
+  // dependencies will be checked first before adding. Otherwise fanin will be
+  // added after existing non control dependency inputs.
+  bool AddFaninInternal(NodeDef* node, const OutputPort& fanin);
+
+  // Finds control dependency node to be used based on fanin. If fanin is not a
+  // Switch node, fanin.node is simply returned. Otherwise this will try to find
+  // a candidate Identity node consuming fanin, as the control dependency. If it
+  // is not possible or will introduce a self loop, an error message will be
+  // set. If nullptr is returned with no error
+  // GetOrCreateIdentityConsumingSwitch should be called to generate the new
+  // Identity node.
+  NodeDef* GetControllingFaninToAdd(absl::string_view node_name,
+                                    const OutputPort& fanin, string* error_msg);
+
+  // Finds a generated Identity node consuming Switch node `fanin.node` at port
+  // `fanin.port_id`. If such a node does not exist, a new Identity node will be
+  // created.
+  NodeDef* GetOrCreateIdentityConsumingSwitch(const OutputPort& fanin);
+
+  // Removes all instances of regular fanin `fanin` from node `node`.
+  bool RemoveRegularFaninInternal(NodeDef* node, const OutputPort& fanin);
+
+  // Removes controlling fanin `fanin_node` from node if such controlling fanin
+  // exists.
+  bool RemoveControllingFaninInternal(NodeDef* node, NodeDef* fanin_node);
+
+  // Checks if nodes to be deleted are missing or have any fanouts that will
+  // remain in the graph. If node is removed in either case, the graph will
+  // enter an invalid state.
+  Status CheckNodesCanBeDeleted(
+      const absl::flat_hash_set<string>& nodes_to_delete);
+
+  // Removes fanins of the deleted node from internal state. Control
+  // dependencies are retained iff keep_controlling_fanins is true.
+  void RemoveFaninsInternal(NodeDef* deleted_node,
+                            bool keep_controlling_fanins);
+
+  // Removes fanouts of the deleted node from internal state.
+  void RemoveFanoutsInternal(NodeDef* deleted_node);
+};
+
+}  // end namespace grappler
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_MUTABLE_GRAPH_VIEW_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/op_types.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/op_types.h
new file mode 100644
index 0000000000000000000000000000000000000000..c233b6e9c6b61a2ffa878eda4849a436d3b35ddd
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/op_types.h
@@ -0,0 +1,284 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_OP_TYPES_H_
+#define TENSORFLOW_CORE_GRAPPLER_OP_TYPES_H_
+
+#include "tensorflow/core/framework/node_def.pb.h"
+#include "tensorflow/core/framework/op.h"
+#include "tensorflow/core/lib/core/status.h"
+
+namespace tensorflow {
+namespace grappler {
+bool IsAdd(const NodeDef& node);
+bool IsAddN(const NodeDef& node);
+bool IsAll(const NodeDef& node);
+bool IsAngle(const NodeDef& node);
+bool IsAny(const NodeDef& node);
+bool IsAnyDiv(const NodeDef& node);
+bool IsAnyBatchMatMul(const NodeDef& node);
+bool IsAnyMatMul(const NodeDef& node);
+bool IsAnyMax(const NodeDef& node);
+bool IsAnyMaxPool(const NodeDef& node);
+bool IsAnyMin(const NodeDef& node);
+bool IsAnyMul(const NodeDef& node);
+bool IsAnySparseSegmentReduction(const NodeDef& node);
+bool IsApproximateEqual(const NodeDef& node);
+bool IsArg(const NodeDef& node);
+bool IsArgMax(const NodeDef& node);
+bool IsArgMin(const NodeDef& node);
+bool IsAssert(const NodeDef& node);
+bool IsAssign(const NodeDef& node);
+bool IsAsString(const NodeDef& node);
+bool IsAtan2(const NodeDef& node);
+bool IsAvgPoolGrad(const NodeDef& node);
+bool IsBetainc(const NodeDef& node);
+bool IsBiasAdd(const NodeDef& node);
+bool IsBiasAddV2(const NodeDef& node);
+bool IsBiasAddGrad(const NodeDef& node);
+bool IsBitcast(const NodeDef& node);
+bool IsBroadcastTo(const NodeDef& node);
+bool IsCast(const NodeDef& node);
+bool IsCheckNumerics(const NodeDef& node);
+bool IsCollective(const NodeDef& node);
+bool IsComplex(const NodeDef& node);
+bool IsComplexAbs(const NodeDef& node);
+bool IsConcat(const NodeDef& node);
+bool IsConcatOffset(const NodeDef& node);
+bool IsConj(const NodeDef& node);
+bool IsConjugateTranspose(const NodeDef& node);
+bool IsConstant(const NodeDef& node);
+bool IsControlFlow(const NodeDef& node);
+bool IsConv2D(const NodeDef& node);
+bool IsConv2DBackpropFilter(const NodeDef& node);
+bool IsConv2DBackpropInput(const NodeDef& node);
+bool IsConv3D(const NodeDef& node);
+bool IsConv3DBackpropFilterV2(const NodeDef& node);
+bool IsConv3DBackpropInputV2(const NodeDef& node);
+bool IsDepthwiseConv2dNative(const NodeDef& node);
+bool IsDepthwiseConv2dNativeBackpropFilter(const NodeDef& node);
+bool IsDepthwiseConv2dNativeBackpropInput(const NodeDef& node);
+bool IsDequeueOp(const NodeDef& node);
+bool IsDiv(const NodeDef& node);
+bool IsDivNoNan(const NodeDef& node);
+bool IsElementWiseMonotonic(const NodeDef& node, bool* is_non_decreasing);
+bool IsElu(const NodeDef& node);
+bool IsEluGrad(const NodeDef& node);
+bool IsQuantizationEmulation(const NodeDef& node);
+bool IsEnter(const NodeDef& node);
+bool IsEqual(const NodeDef& node);
+bool IsExit(const NodeDef& node);
+bool IsExp(const NodeDef& node);
+bool IsFakeParam(const NodeDef& node);
+bool IsFill(const NodeDef& node);
+bool IsFloorDiv(const NodeDef& node);
+bool IsFloorMod(const NodeDef& node);
+bool IsFusedBatchNorm(const NodeDef& node);
+bool IsFusedBatchNormEx(const NodeDef& node);
+bool IsFusedBatchNormGrad(const NodeDef& node);
+bool IsGather(const NodeDef& node);
+bool IsGreater(const NodeDef& node);
+bool IsGreaterEqual(const NodeDef& node);
+bool IsHistogramSummary(const NodeDef& node);
+bool IsHostConstant(const NodeDef& node);
+bool IsIdentity(const NodeDef& node);
+bool IsIdentityN(const NodeDef& node);
+bool IsIdentityNSingleInput(const NodeDef& node);
+bool IsIf(const NodeDef& node);
+bool IsIgamma(const NodeDef& node);
+bool IsIgammac(const NodeDef& node);
+bool IsImag(const NodeDef& node);
+bool IsImmutableConst(const NodeDef& node);
+bool IsInvGrad(const NodeDef& node);
+bool IsLeakyRelu(const NodeDef& node);
+bool IsLeakyReluGrad(const NodeDef& node);
+bool IsLess(const NodeDef& node);
+bool IsLessEqual(const NodeDef& node);
+bool IsLog(const NodeDef& node);
+bool IsLogicalAnd(const NodeDef& node);
+bool IsLogicalNot(const NodeDef& node);
+bool IsLogicalOr(const NodeDef& node);
+bool IsLoopCond(const NodeDef& node);
+bool IsMatMul(const NodeDef& node);
+bool IsMax(const NodeDef& node);
+bool IsMaxPoolGrad(const NodeDef& node);
+bool IsMaximum(const NodeDef& node);
+bool IsMean(const NodeDef& node);
+bool IsMerge(const NodeDef& node);
+bool IsMin(const NodeDef& node);
+bool IsMinimum(const NodeDef& node);
+bool IsMirrorPad(const NodeDef& node);
+bool IsMirrorPadGrad(const NodeDef& node);
+bool IsMklFusedMish(const NodeDef& node);
+bool IsMod(const NodeDef& node);
+bool IsMul(const NodeDef& node);
+bool IsMulNoNan(const NodeDef& node);
+bool IsNeg(const NodeDef& node);
+bool IsNextIteration(const NodeDef& node);
+bool IsNoOp(const NodeDef& node);
+bool IsNotEqual(const NodeDef& node);
+bool IsOnesLike(const NodeDef& node);
+bool IsPack(const NodeDef& node);
+bool IsPack(const NodeDef& node);
+bool IsPad(const NodeDef& node);
+bool IsPartitionedCall(const NodeDef& node);
+bool IsPlaceholder(const NodeDef& node);
+bool IsPolygamma(const NodeDef& node);
+bool IsPow(const NodeDef& node);
+bool IsPrint(const NodeDef& node);
+bool IsProd(const NodeDef& node);
+bool IsQuantizedMatMul(const NodeDef& node);
+bool IsQueue(const NodeDef& node);
+bool IsRandomShuffle(const NodeDef& node);
+bool IsRank(const NodeDef& node);
+bool IsReadVariableOp(const NodeDef& node);
+bool IsReadVariablesOp(const NodeDef& node);
+bool IsReal(const NodeDef& node);
+bool IsRealDiv(const NodeDef& node);
+bool IsReciprocalGrad(const NodeDef& node);
+bool IsRecv(const NodeDef& node);
+bool IsReduction(const NodeDef& node);
+bool IsRelu(const NodeDef& node);
+bool IsRelu6(const NodeDef& node);
+bool IsRelu6Grad(const NodeDef& node);
+bool IsReluGrad(const NodeDef& node);
+bool IsReshape(const NodeDef& node);
+bool IsRestore(const NodeDef& node);
+bool IsRetval(const NodeDef& node);
+bool IsReverse(const NodeDef& node);
+bool IsReverseV2(const NodeDef& node);
+bool IsRsqrt(const NodeDef& node);
+bool IsRsqrtGrad(const NodeDef& node);
+bool IsSelect(const NodeDef& node);
+bool IsSeluGrad(const NodeDef& node);
+bool IsSend(const NodeDef& node);
+bool IsShape(const NodeDef& node);
+bool IsShapeN(const NodeDef& node);
+bool IsShuffle(const NodeDef& node);
+bool IsSigmoid(const NodeDef& node);
+bool IsSigmoidGrad(const NodeDef& node);
+bool IsSize(const NodeDef& node);
+bool IsSlice(const NodeDef& node);
+bool IsSnapshot(const NodeDef& node);
+bool IsSoftmax(const NodeDef& node);
+bool IsSoftplusGrad(const NodeDef& node);
+bool IsSoftsignGrad(const NodeDef& node);
+bool IsSplit(const NodeDef& node);
+bool IsSplitV(const NodeDef& node);
+bool IsSqrt(const NodeDef& node);
+bool IsSqrtGrad(const NodeDef& node);
+bool IsSquare(const NodeDef& node);
+bool IsSquaredDifference(const NodeDef& node);
+bool IsSqueeze(const NodeDef& node);
+bool IsStackCloseOp(const NodeDef& node);
+bool IsStackOp(const NodeDef& node);
+bool IsStackPopOp(const NodeDef& node);
+bool IsStackPushOp(const NodeDef& node);
+bool IsStatefulPartitionedCall(const NodeDef& node);
+bool IsStopGradient(const NodeDef& node);
+bool IsStridedSlice(const NodeDef& node);
+bool IsStridedSliceGrad(const NodeDef& node);
+bool IsStringToHashBucketFast(const NodeDef& node);
+bool IsSub(const NodeDef& node);
+bool IsSum(const NodeDef& node);
+bool IsSwitch(const NodeDef& node);
+bool IsSymbolicGradient(const NodeDef& node);
+bool IsTanh(const NodeDef& node);
+bool IsTanhGrad(const NodeDef& node);
+bool IsTensorArray(const NodeDef& node);
+bool IsTile(const NodeDef& node);
+bool IsTranspose(const NodeDef& node);
+bool IsTruncateDiv(const NodeDef& node);
+bool IsTruncateMod(const NodeDef& node);
+bool IsUnique(const NodeDef& node);
+bool IsUnpack(const NodeDef& node);
+bool IsVariable(const NodeDef& node);
+bool IsWhile(const NodeDef& node);
+bool IsXdivy(const NodeDef& node);
+bool IsXlaLaunch(const NodeDef& node);
+bool IsZerosLike(const NodeDef& node);
+bool IsZeta(const NodeDef& node);
+
+// Return true if the op is an aggregation (e.g. Add, AddN).
+// Returns false if it could not be determined to be so.
+bool IsAggregate(const NodeDef& node);
+
+// Return true if the op is commutative (e.g. Mul, Add).
+// Returns false if it could not be determined to be so.
+bool IsCommutative(const NodeDef& node);
+
+// Returns true if the node is known to use persistent memory to store its
+// value.
+bool IsPersistent(const NodeDef& node);
+
+// Returns true if the node belongs to the NC_DATASET class (see graph/graph.h).
+bool IsDataset(const NodeDef& node);
+
+// Returns true if the node op is marked as stateful, or if it was not found in
+// op_registry.
+bool IsStateful(const NodeDef node, const OpRegistryInterface* op_registry);
+bool IsStateful(const NodeDef node);  // use OpRegistry::Global()
+
+bool IsFreeOfSideEffect(const NodeDef& node,
+                        const OpRegistryInterface* op_registry);
+bool IsFreeOfSideEffect(const NodeDef& node);  // use OpRegistry::Global()
+
+// Returns true if the takes a tensor reference as input.
+// Returns false if the op type is unknown.
+bool HasRefInput(const NodeDef& node);
+
+bool ModifiesFrameInfo(const NodeDef& node);
+
+// Returns true if the op is known to write to one or more of its inputs.
+bool ModifiesInputsInPlace(const NodeDef& node);
+
+// Returns true if the op is an element-wise involution, i.e. if it is its
+// own inverse such that f(f(x)) == x.
+bool IsInvolution(const NodeDef& node);
+
+// Returns true if the op preserves the order and value of elements
+// and shape of its first input tensor.
+bool IsValueAndOrderAndShapePreserving(const NodeDef& node);
+
+// Returns true if the op preserves the order and value of elements in its
+// first input tensor and possible changes its shape.
+bool IsValueAndOrderPreserving(const NodeDef& node);
+
+// Returns true if the op in node only rearranges the order of elements in its
+// first input tensor and possible changes its shape. More precisely, this
+// function returns true if the op commutes with all element-wise operations.
+bool IsValuePreserving(const NodeDef& node);
+
+// Returns true if node is idempotent w.r.t. its first input, i.e. if
+// Op(Op(x, y, z), y, z) = Op(x, y, z).
+bool IsIdempotent(const NodeDef& node);
+
+bool IsUnaryElementWise(const NodeDef& node);
+
+// Returns true if we can find an opdef corresponding to the op of the node.
+bool HasOpDef(const NodeDef& node);
+
+// Returns true if the op changes the scalar type of its first input elements
+// and preserves the number of elements.
+bool IsCastLike(const NodeDef& node);
+
+// Returns true if this op never forwards any of its inputs, i.e. always
+// allocates buffers for its inputs.
+bool NeverForwardsInputs(const NodeDef& node);
+
+}  // end namespace grappler
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_OP_TYPES_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/arithmetic_optimizer.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/arithmetic_optimizer.h
new file mode 100644
index 0000000000000000000000000000000000000000..363759cde9ec21c93b77355af73f469c27c3cb13
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/arithmetic_optimizer.h
@@ -0,0 +1,146 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_ARITHMETIC_OPTIMIZER_H_
+#define TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_ARITHMETIC_OPTIMIZER_H_
+
+#include <unordered_set>
+
+#include "tensorflow/core/grappler/costs/graph_properties.h"
+#include "tensorflow/core/grappler/optimizers/graph_optimizer.h"
+#include "tensorflow/core/grappler/utils.h"
+#include "tensorflow/core/lib/gtl/flatset.h"
+#include "tensorflow/core/protobuf/rewriter_config.pb.h"
+
+namespace tensorflow {
+namespace grappler {
+
+constexpr char kArithmeticOptimizer[] = "ArithmeticOptimizer";
+
+// Optimize TF computations by reducing the arithmetic complexity required to
+// run a model.
+class ArithmeticOptimizer : public GraphOptimizer {
+ public:
+  ArithmeticOptimizer()
+      : opt_level_(RewriterConfig::ON),
+        options_(ArithmeticOptimizerOptions::Default(RewriterConfig::ON)) {}
+
+  explicit ArithmeticOptimizer(RewriterConfig::Toggle opt_level)
+      : opt_level_(opt_level),
+        options_(ArithmeticOptimizerOptions::Default(opt_level)) {}
+
+  ~ArithmeticOptimizer() override {}
+
+  string name() const override { return "arithmetic_optimizer"; };
+
+  bool UsesFunctionLibrary() const override { return false; }
+
+  Status Optimize(Cluster* cluster, const GrapplerItem& item,
+                  GraphDef* optimized_graph) override;
+
+ private:
+  friend class ArithmeticOptimizerTest;
+
+  // Granular control for arithmetic optimizer stages
+  struct ArithmeticOptimizerOptions {
+    bool combine_add_to_addn = true;
+    bool convert_sqrt_div_to_rsqrt_mul = true;
+    bool dedup_computations = true;
+    bool fold_conjugate_into_transpose = true;
+    bool fold_multiply_into_conv = true;
+    bool fold_transpose_into_matmul = true;
+    bool fuse_squared_diff = true;
+    bool hoist_common_factor_out_of_aggregation = true;
+    bool hoist_cwise_unary_chains = true;
+    bool minimize_broadcasts = true;
+    bool optimize_max_or_min_of_monotonic = true;
+    bool remove_idempotent = true;
+    bool remove_identity_transpose = true;
+    bool remove_involution = true;
+    bool remove_logical_not = true;
+    bool remove_negation = true;
+    bool remove_redundant_bitcast = true;
+    bool remove_redundant_cast = true;
+    bool remove_redundant_reshape = true;
+    bool reduce_upsampling_dims = true;
+    bool reorder_cast_like_and_value_preserving = true;
+    bool replace_mul_with_tile = true;
+    bool replace_mul_with_square = true;
+    bool replace_pack_with_tile_reshape = true;
+    bool convert_pow = true;
+    bool convert_log1p = true;
+    bool convert_log_softmax = true;
+    bool convert_expm1 = true;
+    bool unary_ops_composition = true;
+    bool remove_stack_slice_same_axis = true;
+    bool simplify_aggregation = true;
+    bool simplify_embedding_lookup = true;
+    bool remove_cast_into_segment_reduction = true;
+
+    // Choose which arithmetic optimizer stages will be enabled for a given
+    // optimization level by default.
+    static ArithmeticOptimizerOptions Default(
+        RewriterConfig::Toggle opt_level) {
+      ArithmeticOptimizerOptions options;
+      return options;
+    }
+  };
+
+  // Returns true if it is safe to dedup node from the graph.
+  bool CanDedup(const NodeDef& node) const;
+
+  // Dedup redundant nodes in the graph.
+  void DedupComputations();
+
+  // Forward the control dependencies anchored on src_nodes to the target_nodes.
+  void ForwardControlDependencies(NodeDef* target_node,
+                                  const std::vector<const NodeDef*>& src_nodes);
+
+  // Runs peep-hole optimizations on `optimized_graph`, e.g., removing inverse
+  // transposes.
+  Status SimplifyArithmeticOps(bool can_use_shapes);
+  // Tries to simplify the expression that roots at `node` and replaces the uses
+  // of `node` to the simplified expression. Returns the name of the simplified
+  // tensor (e.g. "split:1") or an empty string if no simplification is
+  // performed.
+  //
+  // `node_map` stores the mapping from node names to NodeDef*, and will be
+  // updated according to the rewrite.
+  //
+  // `new_nodes` will be populated with the new nodes this function creates and
+  // updates. The caller can push these nodes into the simplification queue to
+  // optimize them further.
+  //
+  // TODO(jingyue): This interface is not suitable for optimizing nodes with
+  // multiple output tensors. We should pass in a tensor name instead of a
+  // NodeDef.
+  string TrySimplifyAndReplaceUses(const NodeDef* node,
+                                   SetVector<NodeDef*>* nodes_to_simplify);
+
+  RewriterConfig::Toggle opt_level_;
+  ArithmeticOptimizerOptions options_;
+
+  bool fetch_nodes_known_ = false;
+  std::unordered_set<string> nodes_to_preserve_;
+  std::unique_ptr<NodeMap> node_map_;
+  std::unique_ptr<GraphProperties> graph_properties_;
+  GraphDef* optimized_graph_ = nullptr;  // Not owned.
+  gtl::FlatSet<string> feed_nodes_;
+};
+
+}  // end namespace grappler
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_ARITHMETIC_OPTIMIZER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/auto_mixed_precision.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/auto_mixed_precision.h
new file mode 100644
index 0000000000000000000000000000000000000000..0807d740f1448c6085f70f03ef36fc66a9026056
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/auto_mixed_precision.h
@@ -0,0 +1,70 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_AUTO_MIXED_PRECISION_H_
+#define TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_AUTO_MIXED_PRECISION_H_
+
+#include "tensorflow/core/grappler/optimizers/graph_optimizer.h"
+#include "tensorflow/core/platform/cpu_info.h"
+#include "tensorflow/core/protobuf/rewriter_config.pb.h"
+
+namespace tensorflow {
+namespace grappler {
+
+// CUDA: convert to float16 on GPU
+// BF16: convert to bfloat16 on CPU
+// CPU: emulate float16 on CPU without changing operator kernel
+enum class AutoMixedPrecisionMode { CUDA, BF16, CPU };
+
+// Convert data types to float16 or bfloat16 where appropriate to improve
+// performance on GPUs or CPUs.
+class AutoMixedPrecision : public GraphOptimizer {
+ public:
+  // If 'mode' is CUDA, converts nodes to float16 on Nvidia GPUs. If BF16,
+  // converts nodes to bfloat16 on CPUs in order to take advantage of oneDNN
+  // performance improvements with bfloat16.
+  explicit AutoMixedPrecision(
+      AutoMixedPrecisionMode mode = AutoMixedPrecisionMode::CUDA)
+      : mode_(mode) {}
+
+  ~AutoMixedPrecision() override {}
+
+  string name() const override {
+    switch (mode_) {
+      case AutoMixedPrecisionMode::CUDA:
+        return "auto_mixed_precision";
+      case AutoMixedPrecisionMode::BF16:
+        return "auto_mixed_precision_onednn_bfloat16";
+      case AutoMixedPrecisionMode::CPU:
+        return "auto_mixed_precision_cpu";
+      default:
+        LOG(FATAL) << "Invalid value for AutoMixedPrecisionMode: "  // Crash Ok
+                   << static_cast<int>(mode_);
+    }
+  };
+
+  bool UsesFunctionLibrary() const override { return false; }
+
+  Status Optimize(Cluster* cluster, const GrapplerItem& item,
+                  GraphDef* output) override;
+
+ private:
+  const AutoMixedPrecisionMode mode_;
+};
+
+}  // end namespace grappler
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_AUTO_MIXED_PRECISION_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/auto_mixed_precision_lists.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/auto_mixed_precision_lists.h
new file mode 100644
index 0000000000000000000000000000000000000000..a0ad5a692d6b06263d4ff7f73de6fec4cd9b7a9b
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/auto_mixed_precision_lists.h
@@ -0,0 +1,570 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_AUTO_MIXED_PRECISION_LISTS_H_
+#define TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_AUTO_MIXED_PRECISION_LISTS_H_
+
+#include <string>
+
+#include "tensorflow/core/lib/gtl/flatset.h"
+#include "tensorflow/core/lib/strings/str_util.h"
+#include "tensorflow/core/util/env_var.h"
+
+namespace tensorflow {
+namespace grappler {
+
+// Represents the four lists of ops: the allow list, infer list, deny list, and
+// clear list. These lists determine which ops are converted to fp16/bf16
+// (referred to as 'f16' for short) and which ops stay as fp32.
+class AutoMixedPrecisionLists {
+ public:
+  virtual ~AutoMixedPrecisionLists() {}
+
+  // Returns the set of ops that are considered numerically-safe (for execution
+  // in f16), performance-critical, and can run in f16. These ops are always
+  // converted to f16.
+  virtual gtl::FlatSet<string> AllowList() = 0;
+  // Returns the set of ops that can run in f16 and are considered numerically-
+  // safe (for execution in f16), but which may be made unsafe by an upstream
+  // denylist op.
+  virtual gtl::FlatSet<string> InferList() = 0;
+  // Returns the set of ops that are considered numerically-dangerous (i.e.,
+  // unsafe for execution in f16) and whose effects may also be observed in
+  // downstream nodes (e.g. for f16, in Exp -> Add, the Add is unsafe due to
+  // the Exp).
+  virtual gtl::FlatSet<string> DenyList() = 0;
+  // Returns the set of ops that do not have numerically-significant effects
+  // (i.e., they are always considered safe for execution in f16 precision), and
+  // can run in f16.
+  virtual gtl::FlatSet<string> ClearList() = 0;
+
+ protected:
+  // Adds or removes ops from list if certain environmental variables are set.
+  static void UpdateList(const string& list_name, gtl::FlatSet<string>* list) {
+    CHECK(list_name == "ALLOWLIST" || list_name == "INFERLIST" ||  // Crash OK.
+          list_name == "DENYLIST" || list_name == "CLEARLIST" ||
+          // TODO(reedwm): for bkwds compat; remove when no longer necessary:
+          list_name == "WHITELIST" || list_name == "GRAYLIST" ||
+          list_name == "BLACKLIST");
+    string add_env_var =
+        "TF_AUTO_MIXED_PRECISION_GRAPH_REWRITE_" + list_name + "_ADD";
+    string remove_env_var =
+        "TF_AUTO_MIXED_PRECISION_GRAPH_REWRITE_" + list_name + "_REMOVE";
+    string to_add, to_remove;
+    TF_CHECK_OK(ReadStringFromEnvVar(add_env_var, "", &to_add));
+    TF_CHECK_OK(ReadStringFromEnvVar(remove_env_var, "", &to_remove));
+    for (const auto& x : str_util::Split(to_add, ",")) {
+      list->insert(x);
+    }
+    for (const auto& x : str_util::Split(to_remove, ",")) {
+      list->erase(x);
+    }
+  }
+
+  // Subclasses should include these on the ClearList.
+  static void AddTensorListOps(gtl::FlatSet<string>* list) {
+    // Note: if a data structure op (such as TensorListPopBack) is added here,
+    // IsTensorListReaderOp or IsTensorListWriterOp may need to be modified
+    // LINT.IfChange
+    constexpr const char* tensor_list_ops[] = {
+        "TensorListConcat",     "TensorListConcatLists",
+        "TensorListConcatV2",   "TensorListGather",
+        "TensorListGetItem",    "TensorListPopBack",
+        "TensorListPushBack",   "TensorListPushBackBatch",
+        "TensorListFromTensor", "TensorListScatter",
+        "TensorListScatterV2",  "TensorListScatterIntoExistingList",
+        "TensorListSetItem",    "TensorListSplit",
+        "TensorListStack"};
+    // LINT.ThenChange(//tensorflow/core/grappler/optimizers/auto_mixed_precision.cc)
+    for (auto op : tensor_list_ops) {
+      list->insert(op);
+    }
+  }
+};
+
+class AutoMixedPrecisionListsCuda : public AutoMixedPrecisionLists {
+ private:
+  static bool IsPseudoFastMath() {
+    string optimization_level;
+    TF_CHECK_OK(
+        ReadStringFromEnvVar("TF_AUTO_MIXED_PRECISION_GRAPH_REWRITE_LEVEL", "",
+                             &optimization_level));
+    optimization_level = str_util::Uppercase(optimization_level);
+    return optimization_level == "TENSOR_CORES_ONLY";
+  }
+
+ public:
+  AutoMixedPrecisionListsCuda(int cuda_version, int cudnn_version)
+      : cuda_version_(cuda_version), cudnn_version_(cudnn_version) {}
+
+  gtl::FlatSet<string> AllowList() override {
+    auto list = gtl::FlatSet<string>{
+        "BlockLSTM",
+        "BlockLSTMV2",
+        "BlockLSTMGrad",
+        "BlockLSTMGradV2",
+        "Conv2D",
+        "Conv2DBackpropFilter",
+        "Conv2DBackpropInput",
+        "CudnnRNN",
+        "CudnnRNNBackprop",
+        "CudnnRNNBackpropV2",
+        "CudnnRNNBackpropV3",
+        "CudnnRNNV2",
+        "CudnnRNNV3",
+        "Einsum",
+        "FusedConv2DBiasActivation",
+        "FusedSparseConvGpuV2",
+        "GRUBlockCell",
+        "GRUBlockCellGrad",
+        "LSTMBlockCell",
+        "LSTMBlockCellGrad",
+        "MatMul",
+        "Mha",
+        "MhaV2",
+        "Tmlp",
+        "TmlpV2",
+        "TmlpV3",
+        "Pmlp",
+        "FastUnsortedSegmentMax",
+    };
+#if TENSORFLOW_USE_ROCM
+    if (true) {
+#else
+    if (cuda_version_ >= 9010) {
+      // Fp16 BatchMatMul is slow before CUDA 9.1.
+#endif
+      list.insert("BatchMatMul");
+      list.insert("BatchMatMulV2");
+    }
+    if (cudnn_version_ >= 7602) {
+      // Fp16 3D conv is slow before CUDNN 7.6.2.
+      list.insert("Conv3D");
+      list.insert("Conv3DBackpropFilter");
+      list.insert("Conv3DBackpropFilterV2");
+      list.insert("Conv3DBackpropInput");
+      list.insert("Conv3DBackpropInputV2");
+    }
+    if (cudnn_version_ >= 8000) {
+      list.insert("DepthwiseConv2dNative");
+      list.insert("DepthwiseConv2dNativeBackpropFilter");
+      list.insert("DepthwiseConv2dNativeBackpropInput");
+    }
+    UpdateList("ALLOWLIST", &list);
+    // For backwards compatibility, keeping the original env variable here.
+    // TODO(reedwm): This should be removed if we don't have active users.
+    UpdateList("WHITELIST", &list);
+
+    return list;
+  }
+
+  gtl::FlatSet<string> InferList() override {
+    if (IsPseudoFastMath()) {
+      return gtl::FlatSet<string>{};
+    }
+
+    auto list = gtl::FlatSet<string>{
+        "Add",
+        "AddN",
+        "AddV2",
+        "AvgPool",
+        "AvgPool3D",
+        "AvgPool3DGrad",
+        "AvgPoolGrad",
+        "BiasAdd",
+        "BiasAddGrad",
+        "BiasAddV1",
+        "Elu",
+        "EluGrad",
+        "Erf",
+        "Erfc",
+        "FloorDiv",
+        "FusedBatchNormV2",
+        "FusedBatchNormGradV2",
+        "FusedBatchNormV3",
+        "FusedBatchNormGradV3",
+        "_FusedBatchNormEx",
+        "Inv",
+        "LeakyRelu",
+        "LeakyReluGrad",
+        "Log",
+        "Log1p",
+        "LogSoftmax",
+        "Mul",
+        "Prod",
+        "RealDiv",
+        "Reciprocal",
+        "Selu",
+        "SeluGrad",
+        "Sigmoid",
+        "SigmoidGrad",
+        "Softmax",
+        "Softplus",
+        "SoftplusGrad",
+        "Softsign",
+        "SoftsignGrad",
+        "Sqrt",
+        "Sub",
+        "Tanh",
+        "TanhGrad",
+    };
+    UpdateList("INFERLIST", &list);
+    // For backwards compatibility, keeping the original env variable here.
+    // TODO(reedwm): This should be removed if we don't have active users.
+    UpdateList("GRAYLIST", &list);
+    return list;
+  }
+
+  gtl::FlatSet<string> DenyList() override {
+    if (IsPseudoFastMath()) {
+      return gtl::FlatSet<string>{};
+    }
+
+    auto list = gtl::FlatSet<string>{
+        "Exp",
+        "Expm1",
+        "L2Loss",
+        "Mean",
+        "Pow",
+        "SaveV2",
+        "SoftmaxCrossEntropyWithLogits",
+        "SparseSoftmaxCrossEntropyWithLogits",
+        "Sum",
+    };
+    UpdateList("DENYLIST", &list);
+    // For backwards compatibility, keeping the original env variable here.
+    // TODO(reedwm): This should be removed if we don't have active users.
+    UpdateList("BLACKLIST", &list);
+    return list;
+  }
+
+  gtl::FlatSet<string> ClearList() override {
+    if (IsPseudoFastMath()) {
+      return gtl::FlatSet<string>{};
+    }
+
+    auto list = gtl::FlatSet<string>{
+        "Abs",
+        "ArgMax",
+        "ArgMin",
+        "BatchToSpace",
+        "BatchToSpaceND",
+        "BroadcastTo",
+        "Ceil",
+        "CheckNumerics",
+        "ClipByValue",
+        "Concat",
+        "ConcatV2",
+        "DepthToSpace",
+        "DynamicPartition",
+        "DynamicStitch",
+        "Enter",
+        "EnsureShape",
+        "Equal",
+        "Exit",
+        "ExpandDims",
+        "Fill",
+        "Floor",
+        "Gather",
+        "GatherNd",
+        "GatherV2",
+        "Greater",
+        "GreaterEqual",
+        "Identity",
+        "IdentityN",
+        "IsFinite",
+        "IsInf",
+        "IsNan",
+        "Less",
+        "LessEqual",
+        "Max",
+        "MaxPool",
+        "MaxPool3D",
+        "MaxPool3DGrad",
+        "MaxPool3DGradGrad",
+        "MaxPoolGrad",
+        "MaxPoolGradGrad",
+        "MaxPoolGradGradV2",
+        "MaxPoolGradV2",
+        "MaxPoolV2",
+        "Maximum",
+        "Merge",
+        "Min",
+        "Minimum",
+        "MirrorPad",
+        "MirrorPadGrad",
+        "Neg",
+        "NextIteration",
+        "NotEqual",
+        "OneHot",
+        "OnesLike",
+        "Pack",
+        "Pad",
+        "PadV2",
+        "PreventGradient",
+        "Rank",
+        "Relu",
+        "Relu6",
+        "Relu6Grad",
+        "ReluGrad",
+        "Reshape",
+        "ResizeNearestNeighbor",
+        "ResizeNearestNeighborGrad",
+        "Reverse",
+        "ReverseSequence",
+        "ReverseV2",
+        "Round",
+        "Select",
+        "SelectV2",
+        "Shape",
+        "ShapeN",
+        "Sign",
+        "Size",
+        "Slice",
+        "Snapshot",
+        "SpaceToBatch",
+        "SpaceToBatchND",
+        "SpaceToDepth",
+        "Split",
+        "SplitV",
+        "Squeeze",
+        "StopGradient",
+        "StridedSlice",
+        "StridedSliceGrad",
+        "Switch",
+        "Tile",
+        "TopK",
+        "TopKV2",
+        "Transpose",
+        "Unpack",
+        "Where",
+        "ZerosLike",
+    };
+    AddTensorListOps(&list);
+    UpdateList("CLEARLIST", &list);
+    return list;
+  }
+
+ private:
+  int cuda_version_;
+  int cudnn_version_;
+};
+
+class AutoMixedPrecisionListsMkl : public AutoMixedPrecisionLists {
+ public:
+  AutoMixedPrecisionListsMkl() {}
+
+  // Only ops which are supported by MKL in bfloat16 should be added to the
+  // allow list, infer list, or clear list.
+  gtl::FlatSet<string> AllowList() override {
+    auto list = gtl::FlatSet<string>{"Conv2D",
+                                     "Conv2DBackpropFilter",
+                                     "Conv2DBackpropInput",
+                                     "Conv3D",
+                                     "Conv3DBackpropFilterV2",
+                                     "Conv3DBackpropInputV2",
+                                     "DepthwiseConv2dNative",
+                                     "DepthwiseConv2dNativeBackpropFilter",
+                                     "DepthwiseConv2dNativeBackpropInput",
+                                     "MatMul",
+                                     "FusedPadConv2D",
+                                     "BatchMatMul",
+                                     "BatchMatMulV2",
+                                     "Einsum"};
+
+    UpdateList("ALLOWLIST", &list);
+    // For backwards compatibility, keeping the original env variable here.
+    // TODO(reedwm): This should be removed if we don't have active users.
+    UpdateList("WHITELIST", &list);
+    return list;
+  }
+
+  gtl::FlatSet<string> InferList() override {
+    auto list = gtl::FlatSet<string>{"Add",
+                                     "AddN",
+                                     "AddV2",
+                                     "AvgPool",
+                                     "AvgPool3D",
+                                     "AvgPool3DGrad",
+                                     "AvgPoolGrad",
+                                     "BiasAdd",
+                                     "BiasAddGrad",
+                                     "BiasAddV1",
+                                     "Erf",
+                                     "FusedBatchNormV2",
+                                     "FusedBatchNormGradV2",
+                                     "FusedBatchNormV3",
+                                     "FusedBatchNormGradV3",
+                                     "LeakyRelu",
+                                     "LeakyReluGrad",
+                                     "Mul",
+                                     "Sub",
+                                     "Elu",
+                                     "EluGrad",
+                                     "FloorDiv",
+                                     "_FusedBatchNormEx",
+                                     "Log",
+                                     "Log1p",
+                                     "LogSoftmax",
+                                     "Prod",
+                                     "RealDiv",
+                                     "Reciprocal",
+                                     "Rsqrt",
+                                     "Selu",
+                                     "SeluGrad",
+                                     "Sigmoid",
+                                     "SigmoidGrad",
+                                     "Softmax",
+                                     "Softplus",
+                                     "SoftplusGrad",
+                                     "Softsign",
+                                     "SoftsignGrad",
+                                     "Sqrt",
+                                     "Square",
+                                     "SquaredDifference",
+                                     "Sum"
+                                     "Tanh",
+                                     "TanhGrad"};
+    UpdateList("INFERLIST", &list);
+    // For backwards compatibility, keeping the original env variable here.
+    // TODO(reedwm): This should be removed if we don't have active users.
+    UpdateList("GRAYLIST", &list);
+    return list;
+  }
+
+  gtl::FlatSet<string> DenyList() override {
+    auto list = gtl::FlatSet<string>{
+        "Exp",
+        "Expm1",
+        "L2Loss",
+        "Mean",
+        "Pow",
+        "SaveV2",
+        "SoftmaxCrossEntropyWithLogits",
+        "SparseSoftmaxCrossEntropyWithLogits",
+    };
+    UpdateList("DENYLIST", &list);
+    // For backwards compatibility, keeping the original env variable here.
+    // TODO(reedwm): This should be removed if we don't have active users.
+    UpdateList("BLACKLIST", &list);
+    return list;
+  }
+
+  gtl::FlatSet<string> ClearList() override {
+    auto list = gtl::FlatSet<string>{
+        "Abs",
+        "ArgMax",
+        "ArgMin",
+        "BatchToSpace",
+        "BatchToSpaceND",
+        "BroadcastTo",
+        "Ceil",
+        "CheckNumerics",
+        "ClipByValue",
+        "Concat",
+        "ConcatV2",
+        "DepthToSpace",
+        "DynamicPartition",
+        "DynamicStitch",
+        "EnsureShape",
+        "Enter",
+        "Equal",
+        "Exit",
+        "ExpandDims",
+        "Fill",
+        "Floor",
+        "Gather",
+        "GatherNd",
+        "GatherV2",
+        "Greater",
+        "GreaterEqual",
+        "Identity",
+        "IsFinite",
+        "IsInf",
+        "IsNan",
+        "Less",
+        "LessEqual",
+        "Max",
+        "Maximum",
+        "MaxPool",
+        "MaxPool3D",
+        "MaxPool3DGrad",
+        "MaxPoolGrad",
+        "MaxPoolGradGrad",
+        "MaxPoolGradGradV2",
+        "MaxPoolGradV2",
+        "MaxPoolV2",
+        "Merge",
+        "Min",
+        "Minimum",
+        "MirrorPad",
+        "MirrorPadGrad",
+        "Neg",
+        "NextIteration",
+        "NotEqual",
+        "OnesLike",
+        "Pack",
+        "Pad",
+        "PadV2",
+        "PreventGradient",
+        "Rank",
+        "Relu",
+        "Relu6",
+        "Relu6Grad",
+        "ReluGrad",
+        "Reshape",
+        "ResizeNearestNeighbor",
+        "ResizeNearestNeighborGrad",
+        "ResizeBilinear",
+        "Reverse",
+        "ReverseSequence",
+        "ReverseV2",
+        "Round",
+        "ScatterNd",
+        "Select",
+        "SelectV2",
+        "Shape",
+        "ShapeN",
+        "Sign",
+        "Slice",
+        "Snapshot",
+        "SpaceToBatch",
+        "SpaceToBatchND",
+        "SpaceToDepth",
+        "Split",
+        "SplitV",
+        "Squeeze",
+        "StopGradient",
+        "StridedSlice",
+        "StridedSliceGrad",
+        "Switch",
+        "Tile",
+        "TopK",
+        "TopKV2",
+        "Transpose",
+        "Where",
+        "Unpack",
+        "ZerosLike",
+    };
+    AddTensorListOps(&list);
+    UpdateList("CLEARLIST", &list);
+    return list;
+  }
+};
+
+}  // end namespace grappler
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_AUTO_MIXED_PRECISION_LISTS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/auto_parallel.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/auto_parallel.h
new file mode 100644
index 0000000000000000000000000000000000000000..00d0cb0a610f76ee9604d341ebb5dd3065ae6b3e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/auto_parallel.h
@@ -0,0 +1,65 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_AUTO_PARALLEL_H_
+#define TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_AUTO_PARALLEL_H_
+
+#include "tensorflow/core/framework/variable.pb.h"
+#include "tensorflow/core/grappler/optimizers/graph_optimizer.h"
+#include "tensorflow/core/lib/core/status.h"
+
+namespace tensorflow {
+namespace grappler {
+
+// Automatically parallelize a graph by splitting in the batch dimension.
+class AutoParallel : public GraphOptimizer {
+ public:
+  AutoParallel(int num_replicas) : num_replicas_(num_replicas) {
+    CHECK(num_replicas_ >= 2);
+  }
+  ~AutoParallel() override {}
+
+  string name() const override { return "autoparallel"; };
+
+  bool UsesFunctionLibrary() const override { return false; }
+
+  Status Optimize(Cluster* cluster, const GrapplerItem& item,
+                  GraphDef* output) override;
+
+ private:
+  GraphDef graph_;
+  std::map<string, NodeDef*> all_nodes_;
+  std::set<string> apply_gradients_nodes_;
+  std::set<string> replica_nodes_;
+  std::set<string> shared_nodes_;
+  const GrapplerItem* item_;
+  int num_replicas_;
+  int num_gpus_;
+  Status Initialize(const GrapplerItem& item);
+  NodeDef* AddNodeDivConst();
+  NodeDef* AddNodeDiv(const string& name, const string& input_a,
+                      const string& input_b);
+  NodeDef* AddNodeControl(const string& name, const std::set<string>& deps,
+                          GraphDef* graph);
+  bool NotSharedNode(const string& name);
+  void AddSharedNodes(GraphDef* graph);
+  void AddOneReplica(GraphDef* graph, int number);
+  void BuildGraph(GraphDef* graph);
+};
+
+}  // end namespace grappler
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_AUTO_PARALLEL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/common_subgraph_elimination.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/common_subgraph_elimination.h
new file mode 100644
index 0000000000000000000000000000000000000000..866764d38c0d72bce440fe0d0463162f75870517
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/common_subgraph_elimination.h
@@ -0,0 +1,70 @@
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_COMMON_SUBGRAPH_ELIMINATION_H_
+#define TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_COMMON_SUBGRAPH_ELIMINATION_H_
+
+#include <unordered_set>
+
+#include "tensorflow/core/framework/graph.pb.h"
+#include "tensorflow/core/framework/node_def.pb.h"
+#include "tensorflow/core/grappler/optimizers/graph_optimizer.h"
+#include "tensorflow/core/lib/gtl/flatset.h"
+#include "tensorflow/core/platform/hash.h"
+#include "tensorflow/core/platform/status.h"
+#include "tensorflow/core/protobuf/rewriter_config.pb.h"
+
+namespace tensorflow {
+namespace grappler {
+
+// Optimize TF computations by deduping equivalent subgraphs.
+class Cluster;
+struct GrapplerItem;
+
+class CommonSubgraphElimination : public GraphOptimizer {
+ public:
+  CommonSubgraphElimination() {}
+
+  explicit CommonSubgraphElimination(RewriterConfig::Toggle opt_level)
+      : opt_level_(opt_level) {}
+
+  ~CommonSubgraphElimination() override {}
+
+  string name() const override { return "common_subgraph_elimination"; };
+
+  bool UsesFunctionLibrary() const override { return false; }
+
+  Status Optimize(Cluster* cluster, const GrapplerItem& item,
+                  GraphDef* optimized_graph) override;
+
+ private:
+  friend class CommonSubgraphEliminationTest;
+
+  // Returns true if it is safe to dedup node from the graph.
+  bool CanDedup(const NodeDef& node) const;
+
+  // Dedup redundant nodes in the graph.
+  Status DedupComputations(GraphDef* optimized_graph);
+
+  RewriterConfig::Toggle opt_level_;
+
+  bool fetch_nodes_known_ = false;
+  std::unordered_set<string> nodes_to_preserve_;
+};
+
+}  // end namespace grappler
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_COMMON_SUBGRAPH_ELIMINATION_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/constant_folding.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/constant_folding.h
new file mode 100644
index 0000000000000000000000000000000000000000..9305aa09764f3d22be311f11c834cca2fba35d39
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/constant_folding.h
@@ -0,0 +1,348 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_CONSTANT_FOLDING_H_
+#define TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_CONSTANT_FOLDING_H_
+
+#include "absl/container/flat_hash_map.h"
+#include "absl/container/flat_hash_set.h"
+#include "absl/types/span.h"
+#include "tensorflow/core/framework/device_base.h"
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/resource_mgr.h"
+#include "tensorflow/core/framework/tensor_shape.pb.h"
+#include "tensorflow/core/grappler/costs/graph_properties.h"
+#include "tensorflow/core/grappler/optimizers/graph_optimizer.h"
+#include "tensorflow/core/grappler/utils.h"
+#include "tensorflow/core/protobuf/rewriter_config.pb.h"
+
+namespace tensorflow {
+namespace grappler {
+
+const char kConstantFoldingConst[] = "ConstantFolding";
+const char kConstantFoldingCtrl[] = "ConstantFoldingCtrl";
+extern const int64_t kMaxConstantSize;
+
+// Constant folding optimization for a graph.
+class ConstantFolding : public GraphOptimizer {
+ public:
+  // The size limit will only be considered if the newly created node is greater
+  // than original_size (optional).
+  static Status CreateNodeDef(const string& name, const TensorValue& tensor,
+                              NodeDef* node, size_t original_size = 0);
+  static string AddControlDependency(const string& input_name, GraphDef* graph,
+                                     NodeMap* node_map);
+
+  explicit ConstantFolding(DeviceBase* cpu_device,
+                           bool disable_compressed_tensor_optimization = false,
+                           bool fold_quantization_emulation = true);
+  ConstantFolding(RewriterConfig::Toggle opt_level, DeviceBase* cpu_device,
+                  bool disable_compressed_tensor_optimization = false,
+                  bool fold_quantization_emulation = true);
+
+  ~ConstantFolding() override {}
+
+  string name() const override { return "constant_folding"; };
+
+  bool UsesFunctionLibrary() const override { return false; }
+
+  Status Optimize(Cluster* cluster, const GrapplerItem& item,
+                  GraphDef* output) override;
+
+ private:
+  bool ForwardInputs(NodeDef* node, absl::Span<const int> inputs_to_forward);
+  string OptimizedNodeName(const NodeDef& node, StringPiece suffix) const;
+  bool OptimizedNodeExists(const NodeDef& node, StringPiece suffix) const;
+
+  bool IsReallyConstant(const NodeDef& node) const;
+
+  bool GetTensorFromConstNode(const string& node_name_or_input, Tensor* tensor);
+
+  Status MaterializeShapes(const GraphProperties& properties);
+
+  Status MaterializeBroadcastGradientArgs(const NodeDef& node,
+                                          const GraphProperties& properties);
+  Status MaterializeReductionIndices(NodeDef* node,
+                                     const GraphProperties& properties);
+  Status MaterializeConstantValuedNode(NodeDef* node,
+                                       const GraphProperties& properties);
+  Status MaterializeOutputValues(NodeDef* node,
+                                 const GraphProperties& properties);
+  Status MaterializeConstants(const GraphProperties& properties);
+
+  bool IsFoldable(const NodeDef& node, const GraphProperties* properties);
+  bool IsFoldableUncached(const NodeDef& node,
+                          const GraphProperties* properties) const;
+  bool MaybeFoldable(const NodeDef& node,
+                     const GraphProperties* properties) const;
+
+  Status EvaluateNode(const NodeDef& node,
+                      const gtl::InlinedVector<TensorValue, 4>& inputs,
+                      gtl::InlinedVector<TensorValue, 4>* output) const;
+
+  Status EvaluateOneFoldable(const NodeDef& node, std::vector<NodeDef>* outputs,
+                             bool* result_too_large);
+
+  Status FoldMergeNode(NodeDef* node, GraphDef* output_graph);
+  Status FoldNode(NodeDef* node, GraphDef* output_graph,
+                  bool* result_too_large);
+
+  bool IsOnes(const NodeDef& node) const;
+  bool IsZeros(const NodeDef& node) const;
+  bool ReplaceOperationWithBroadcastTo(int input_to_broadcast,
+                                       const GraphProperties& properties,
+                                       NodeDef* node, GraphDef* graph);
+  void ReplaceOperationWithIdentity(int input_to_forward,
+                                    const GraphProperties& properties,
+                                    NodeDef* node, GraphDef* graph);
+  void ReplaceOperationWithSnapshot(int input_to_forward,
+                                    const GraphProperties& properties,
+                                    NodeDef* node, GraphDef* graph);
+  void ReplaceOperationWithNoOp(NodeDef* node, GraphProperties* properties,
+                                GraphDef* graph);
+  void ReplaceBinaryOperationWithBroadcastTo(int input_to_broadcast,
+                                             const GraphProperties& properties,
+                                             NodeDef* node, GraphDef* graph);
+  void ReplaceSubtractionFromZeroByNegation(NodeDef* node, GraphDef* graph);
+  Status ReplaceOperationWithConstant(double value,
+                                      const GraphProperties& properties,
+                                      const TensorShapeProto& shape,
+                                      NodeDef* node, GraphDef* graph);
+
+  // Notice: Destroys *value.
+  Status ReplaceOperationWithConstantTensor(DataType dtype, TensorProto* value,
+                                            NodeDef* node, GraphDef* graph);
+
+  void ReplaceDivisionOfOnesByReciprocal(NodeDef* node, GraphDef* graph);
+  Status FoldGraph(const GraphProperties& properties, GraphDef* output,
+                   absl::flat_hash_set<string>* nodes_to_not_simplify);
+
+  Status IsSimplifiableReshape(const NodeDef& node,
+                               const GraphProperties& properties) const;
+  Status SimplifyGraph(GraphDef* optimized_graph, GraphProperties* properties,
+                       absl::flat_hash_set<string>* nodes_to_not_simplify);
+  Status SimplifyNode(NodeDef* node, GraphDef* optimized_graph,
+                      GraphProperties* properties);
+
+  Status RunOptimizationPass(Cluster* cluster, GrapplerItem* item,
+                             GraphProperties* properties,
+                             GraphDef* optimized_graph);
+
+  // Applies partial constant folding for Concat which is not commutative.
+  // Returns true if the transformation applied successfully.
+  bool PartialConcatConstFolding(GraphDef* optimized_graph,
+                                 GraphProperties* properties, NodeDef* node);
+
+  // Applies partial constant folding for associative operators AddN and
+  // AccumulateNV2. Returns true if the transformation applied successfully.
+  bool PartialAssocOpConstFolding(GraphDef* optimized_graph,
+                                  GraphProperties* properties, NodeDef* node);
+
+  // Applies partial constant propagation through IdentityN operator.
+  // Returns true if the transformation applied successfully.
+  bool PartialConstPropThroughIdentityN(NodeDef* node);
+
+  struct ConstantPushDownContext {
+    NodeDef* op_child;
+    NodeDef* const_child;
+    bool left_child_is_const;
+    bool right_child_is_const;
+    NodeDef* left_leaf;
+    NodeDef* right_leaf;
+    bool left_leaf_is_const;
+    bool right_leaf_is_const;
+
+    // Shape & type information.
+    const std::vector<OpInfo::TensorProperties>* parent_input_props;
+    const std::vector<OpInfo::TensorProperties>* op_child_input_props;
+  };
+
+  // Populates ctx with pointers to the nodes in expression tree for which
+  // constant pushdown optimization is being considered, corresponding to one of
+  // the following configurations:
+  //
+  //               parent                            parent
+  //               /    \                            /    \
+  //        op_child   const_child            const_child op_child
+  //         /     \                                       /     \
+  //    left_leaf  right_leaf                        left_leaf  right_leaf
+  //
+  // Returns true if the expression is possible amenable for optimization.
+  // Returns false if must_have_properties is true and input properties for
+  // parent and op_child are not known.
+  bool PrepareConstantPushDown(const NodeDef& parent,
+                               const GraphProperties& properties,
+                               bool must_have_properties,
+                               ConstantPushDownContext* ctx) const;
+
+  // Pushes down constants on '+', '-', '*', and '/' operators if applicable.
+  // Returns true if the transformation applied successfully.
+  bool ConstantPushDown(GraphProperties* properties, GraphDef* optimized_graph,
+                        NodeDef* node);
+
+  // Pushes down constants on '+' and 'BiasAdd' operators if applicable.
+  // Returns true if the graph was modified.
+  bool ConstantPushDownBiasAdd(GraphProperties* properties,
+                               GraphDef* optimized_graph, NodeDef* node);
+
+  // Aggregate constants present around a conv operator. Returns true if the
+  // transformation was applied successfully.
+  bool MulConvPushDown(GraphDef* optimized_graph, NodeDef* node,
+                       const GraphProperties& properties);
+
+  // Strength reduces floating point division by a constant Div(x, const) to
+  // multiplication by the reciprocal Mul(x, Reciprocal(const)).
+  bool ReduceDivToReciprocalMul(GraphDef* optimized_graph, NodeDef* node);
+
+  // Simplifies arithmetic operations with ones or zeros. Returns the status,
+  // and updates the success input argument that denotes if any simplification
+  // was applied.
+  Status SimplifyArithmeticOperations(const GraphProperties& properties,
+                                      bool use_shape_info,
+                                      GraphDef* optimized_graph, NodeDef* node);
+
+  // Simplifies a Reshape operation to an Identity operation if applicable.
+  bool SimplifyReshape(const GraphProperties& properties, bool use_shape_info,
+                       NodeDef* node);
+
+  // Returns true iff the node is a reduction and its reduction indices are
+  // constant. Sets *indices_is_empty to true if the set of dimensions to reduce
+  // along is empty (this happens often in the gradient graphs).
+  bool IsReductionWithConstantIndices(const NodeDef& node,
+                                      bool* indices_is_empty) const;
+  // Returns true if theres a possibility that a Reduce node could be simplified
+  // to an Identity/Reshape.
+  bool IsReductionCandidateForSimplification(
+      const NodeDef& node, const GraphProperties& properties,
+      TensorShapeProto* input_tensor_shape,
+      TensorShapeProto* output_tensor_shape, bool* is_single_element_op) const;
+  // Returns true iff this reduction can be reduced to an identity (i.e if the
+  // input dimensions to reduce along are all of size 1 and keep_dims is true).
+  bool IsReductionSimplifiableToIdentity(
+      const NodeDef& node, const TensorShapeProto& input_shape, bool keep_dims,
+      const gtl::InlinedVector<TensorValue, 4>& reduction_indices_vector) const;
+  // Changes a reduction into an Identity op, returning true on success.
+  bool ReplaceReductionWithIdentity(NodeDef* node) const;
+
+  // Simplifies a Reduction operation to an Identity/Reshape operation if
+  // applicable.
+  bool SimplifyReduction(GraphDef* optimized_graph,
+                         const GraphProperties& properties, NodeDef* node);
+
+  // Switch(x, x) will always feed false to its false branch and true to
+  // its true branch. By rewriting the graph a bit, we can propagate these
+  // constants down the two output branches, and just use control dependencies
+  // to trigger the selected one at runtime. For example,
+  //
+  //     +------+
+  // x-->|Switch|-->a  (in practice there may be multiple consumers of each
+  // x-->|      |-->b   output branch.)
+  //     +------+
+  //
+  // Is rewritten as
+  //
+  //     +------+
+  // x-->|Switch|-->Identity--^>Const(false)-->a
+  // x-->|      |-->Identity--^>Const(true)-->b
+  //     +------+
+  bool SimplifySwitch(GraphDef* optimized_graph, NodeDef* node);
+
+  // Moves constants past Enter node if applicable.
+  bool MoveConstantsPastEnter(GraphDef* optimized_graph, NodeDef* node);
+
+  // Simplifies Pack operation if applicable.
+  bool SimplifyPack(GraphDef* optimized_graph, NodeDef* node);
+
+  // Simplifies a Squeeze operation to an Identity operation if applicable.
+  void SimplifySqueeze(const GraphProperties& properties, bool use_shape_info,
+                       GraphDef* optimized_graph, NodeDef* node);
+
+  // Simplifies a Pad operation to an Identity operation if applicable.
+  Status SimplifyPad(const GraphProperties& properties, bool use_shape_info,
+                     GraphDef* optimized_graph, NodeDef* node);
+
+  // Simplifies a Tile operation to an Identity operation if applicable.
+  Status SimplifyTile(const GraphProperties& properties, bool use_shape_info,
+                      GraphDef* optimized_graph, NodeDef* node);
+
+  // Simplifies a StridedSlice operation to an Identity operation if applicable.
+  Status SimplifyStridedSlice(const GraphProperties& properties,
+                              bool use_shape_info, GraphDef* optimized_graph,
+                              NodeDef* node);
+
+  // Simplifies a Slice operation to an Identity operation if applicable.
+  Status SimplifySlice(const GraphProperties& properties, bool use_shape_info,
+                       GraphDef* optimized_graph, NodeDef* node);
+
+  // Simplify a Case operation where the output_idx is known.
+  bool SimplifyCase(GraphDef* optimized_graph, NodeDef* node);
+
+  // Simplify a Select operation where the predicates are all true or all false.
+  bool SimplifySelect(const GraphProperties& properties,
+                      GraphDef* optimized_graph, NodeDef* node);
+
+  // Replaces variable updates that are effectively no-ops with NoOp nodes.
+  void RemoveRedundantVariableUpdates(GraphProperties* properties,
+                                      GraphDef* optimized_graph, NodeDef* node);
+
+  // Removes Reverse op over dimensions with size 1.
+  Status RemoveReverse(const GraphProperties& properties, bool use_shape_info,
+                       GraphDef* optimized_graph, NodeDef* node);
+
+  // Removes RandomShuffle op if it is scalar or first dimension is of size 1.
+  void RemoveRandomShuffle(const GraphProperties& properties,
+                           bool use_shape_info, GraphDef* optimized_graph,
+                           NodeDef* node);
+
+  // Removes Shuffle or Transpose op over dimensions of size 1.
+  Status RemoveShuffleOrTranspose(const GraphProperties& properties,
+                                  bool use_shape_info,
+                                  GraphDef* optimized_graph, NodeDef* node);
+
+  // Removes Split or SplitV node if possible.
+  void RemoveSplitOrSplitV(const GraphProperties& properties,
+                           GraphDef* optimized_graph, NodeDef* node);
+
+  bool GetConcatAxis(const NodeDef& node, int* axis);
+  bool MergeConcat(bool use_shape_info, GraphProperties* properties,
+                   GraphDef* optimized_graph, NodeDef* node);
+
+  Status AddQuantizedMatMulMinMaxOutConstNodes(NodeDef* node,
+                                               GraphDef* optimized_graph);
+
+  // Points to an externally provided device or to owned_device_;
+  RewriterConfig::Toggle opt_level_;
+  DeviceBase* cpu_device_;
+  std::unique_ptr<DeviceBase> owned_device_;
+
+  std::unique_ptr<ResourceMgr> resource_mgr_;
+  GraphDef* graph_;
+  std::unique_ptr<NodeMap> node_map_;
+  std::unordered_set<string> nodes_to_preserve_;
+  // TODO(rmlarsen): Could these be keyed on absl::string_view?
+  absl::flat_hash_set<string> nodes_allowlist_;
+  absl::flat_hash_set<string> feed_nodes_;
+  absl::flat_hash_map<string, bool> maybe_foldable_nodes_;
+  bool has_fetch_;
+  bool graph_modified_;
+  bool graph_contains_assign_or_inplace_op_;
+  bool disable_compressed_tensor_optimization_;
+  bool fold_quantization_emulation_;
+};
+
+}  // end namespace grappler
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_CONSTANT_FOLDING_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/custom_graph_optimizer.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/custom_graph_optimizer.h
new file mode 100644
index 0000000000000000000000000000000000000000..b7a6029846d6ef7817d9fe20118cc84a79d1490c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/custom_graph_optimizer.h
@@ -0,0 +1,47 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_CUSTOM_GRAPH_OPTIMIZER_H_
+#define TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_CUSTOM_GRAPH_OPTIMIZER_H_
+
+#include "tensorflow/core/grappler/optimizers/graph_optimizer.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/protobuf/config.pb.h"
+#include "tensorflow/core/protobuf/rewriter_config.pb.h"
+
+namespace tensorflow {
+namespace grappler {
+
+// A custom optimizer that can be registered.
+class CustomGraphOptimizer : public GraphOptimizer {
+ public:
+  virtual ~CustomGraphOptimizer() {}
+  virtual Status Init(const tensorflow::RewriterConfig_CustomGraphOptimizer*
+                          config = nullptr) = 0;
+  // Populates ConfigProto on which the Session is run prior to running Init.
+  Status InitWithConfig(
+      const ConfigProto& config_proto,
+      const tensorflow::RewriterConfig_CustomGraphOptimizer* config = nullptr) {
+    config_proto_ = config_proto;
+    return this->Init(config);
+  }
+
+  ConfigProto config_proto_;
+};
+
+}  // end namespace grappler
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_CUSTOM_GRAPH_OPTIMIZER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.h
new file mode 100644
index 0000000000000000000000000000000000000000..67dff162c98dfab985b8f3036bf30032ff304bb8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.h
@@ -0,0 +1,116 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_CUSTOM_GRAPH_OPTIMIZER_REGISTRY_H_
+#define TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_CUSTOM_GRAPH_OPTIMIZER_REGISTRY_H_
+
+#include <functional>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "tensorflow/core/grappler/optimizers/custom_graph_optimizer.h"
+
+namespace tensorflow {
+namespace grappler {
+
+// Contains plugin's configurations for each Grappler optimizer (on/off).
+// See tensorflow/core/protobuf/rewriter_config.proto for optimizer description.
+struct ConfigList {
+  ConfigList() {}
+  ConfigList(bool disable_model_pruning,
+             std::unordered_map<string, RewriterConfig_Toggle> config)
+      : disable_model_pruning(disable_model_pruning),
+        toggle_config(std::move(config)) {}
+
+  bool operator==(const ConfigList& other) const {
+    return (disable_model_pruning == other.disable_model_pruning) &&
+           (toggle_config == other.toggle_config);
+  }
+  bool disable_model_pruning;  // Don't remove unnecessary ops from the graph.
+  std::unordered_map<string, RewriterConfig_Toggle> toggle_config;
+};
+
+class CustomGraphOptimizerRegistry {
+ public:
+  static std::unique_ptr<CustomGraphOptimizer> CreateByNameOrNull(
+      const string& name);
+
+  static std::vector<string> GetRegisteredOptimizers();
+
+  typedef std::function<CustomGraphOptimizer*()> Creator;
+  // Register graph optimizer which can be called during program initialization.
+  // This class is not thread-safe.
+  static void RegisterOptimizerOrDie(const Creator& optimizer_creator,
+                                     const string& name);
+};
+
+class CustomGraphOptimizerRegistrar {
+ public:
+  explicit CustomGraphOptimizerRegistrar(
+      const CustomGraphOptimizerRegistry::Creator& creator,
+      const string& name) {
+    CustomGraphOptimizerRegistry::RegisterOptimizerOrDie(creator, name);
+  }
+};
+
+#define REGISTER_GRAPH_OPTIMIZER_AS(MyCustomGraphOptimizerClass, name) \
+  namespace {                                                          \
+  static ::tensorflow::grappler::CustomGraphOptimizerRegistrar         \
+      MyCustomGraphOptimizerClass##_registrar(                         \
+          []() { return new MyCustomGraphOptimizerClass; }, (name));   \
+  }  // namespace
+
+#define REGISTER_GRAPH_OPTIMIZER(MyCustomGraphOptimizerClass) \
+  REGISTER_GRAPH_OPTIMIZER_AS(MyCustomGraphOptimizerClass,    \
+                              #MyCustomGraphOptimizerClass)
+
+// A separate registry to register all plug-in CustomGraphOptimizers.
+class PluginGraphOptimizerRegistry {
+ public:
+  // Constructs a list of plug-in CustomGraphOptimizers from the global map
+  // `registered_plugin_optimizers`.
+  static std::vector<std::unique_ptr<CustomGraphOptimizer>> CreateOptimizers(
+      const std::set<string>& device_types);
+
+  typedef std::function<CustomGraphOptimizer*()> Creator;
+
+  // Returns plugin's config. If any of the config is turned off, the returned
+  // config will be turned off.
+  static ConfigList GetPluginConfigs(bool use_plugin_optimizers,
+                                     const std::set<string>& device_types);
+
+  // Registers plugin graph optimizer which can be called during program
+  // initialization. Dies if multiple plugins with the same `device_type` are
+  // registered. This class is not thread-safe.
+  static void RegisterPluginOptimizerOrDie(const Creator& optimizer_creator,
+                                           const std::string& device_type,
+                                           ConfigList& configs);
+
+  // Prints plugin's configs if there are some conflicts.
+  static void PrintPluginConfigsIfConflict(
+      const std::set<string>& device_types);
+
+  // Returns true when `plugin_config` conflicts with `user_config`:
+  // - Plugin's `disable_model_pruning` is not equal to `user_config`'s, or
+  // - At least one of plugin's `toggle_config`s is on when it is set to off in
+  //   `user_config`'s.
+  static bool IsConfigsConflict(ConfigList& user_config,
+                                ConfigList& plugin_config);
+};
+
+}  // end namespace grappler
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_CUSTOM_GRAPH_OPTIMIZER_REGISTRY_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/auto_shard.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/auto_shard.h
new file mode 100644
index 0000000000000000000000000000000000000000..3c84fbd8f0e1bcf1b8e1067de676134a78d3e9f0
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/auto_shard.h
@@ -0,0 +1,63 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_AUTO_SHARD_H_
+#define TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_AUTO_SHARD_H_
+
+#include <string>
+#include <vector>
+
+#include "tensorflow/core/framework/dataset_options.pb.h"
+#include "tensorflow/core/framework/node_def.pb.h"
+#include "tensorflow/core/grappler/mutable_graph_view.h"
+#include "tensorflow/core/grappler/optimizers/data/optimizer_base.h"
+
+namespace tensorflow {
+namespace grappler {
+
+class AutoShard : public TFDataOptimizerBase {
+ public:
+  AutoShard() = default;
+  ~AutoShard() override = default;
+
+  string name() const override { return "tf_auto_shard"; }
+
+  bool UsesFunctionLibrary() const override { return true; }
+
+  Status Init(
+      const tensorflow::RewriterConfig_CustomGraphOptimizer* config) override;
+
+  Status OptimizeAndCollectStats(Cluster* cluster, const GrapplerItem& item,
+                                 GraphDef* output,
+                                 OptimizationStats* stats) override;
+
+ private:
+  int64_t num_workers_;
+  int64_t num_replicas_;
+  int64_t index_;
+  tensorflow::data::AutoShardPolicy auto_shard_policy_;
+};
+
+// For testing only
+namespace internal {
+bool IsEligibleRewriteBatchSize(const NodeDef& sink_node,
+                                const MutableGraphView& graph,
+                                std::vector<std::string>* ineligible_reason);
+}
+
+}  // namespace grappler
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_AUTO_SHARD_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/autotune_buffer_sizes.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/autotune_buffer_sizes.h
new file mode 100644
index 0000000000000000000000000000000000000000..5594e77dc85f69b3a884560367bcea69c26a14e2
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/autotune_buffer_sizes.h
@@ -0,0 +1,74 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_AUTOTUNE_BUFFER_SIZES_H_
+#define TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_AUTOTUNE_BUFFER_SIZES_H_
+
+#include "absl/status/status.h"
+#include "tensorflow/core/framework/attr_value.pb.h"
+#include "tensorflow/core/grappler/optimizers/data/optimizer_base.h"
+
+namespace tensorflow {
+namespace grappler {
+
+constexpr char kAutotune[] = "autotune";
+
+// This optimization does the following:
+//
+// 1. Adds `prefetch(AUTOTUNE)` after all asynchronous tf.data transformations
+// (e.g. parallel batch, parallel map, parallel interleave, and map + batch) if
+// they are not followed by a `prefetch` yet.
+//
+// 2. If there exists any `prefetch(buffer_size=N)` for `N>=0`,  it will replace
+// the transformation with autotunable version of `prefetch` which uses N as
+// the minimum size of the buffer.
+class AutotuneBufferSizes : public TFDataOptimizerBase {
+ public:
+  AutotuneBufferSizes() = default;
+  ~AutotuneBufferSizes() override = default;
+
+  string name() const override { return "autotune_buffer_sizes"; };
+
+  bool UsesFunctionLibrary() const override { return false; }
+
+  Status Init(
+      const tensorflow::RewriterConfig_CustomGraphOptimizer* config) override {
+    if (!config) return OkStatus();
+
+    const string& autotune = config->parameter_map().at(kAutotune).s();
+    if (autotune == "true") {
+      autotune_ = true;
+    } else if (autotune == "false") {
+      autotune_ = false;
+    } else {
+      return absl::InvalidArgumentError(
+          absl::StrCat("Received an invalid value for parameter ", kAutotune,
+                       ": ", autotune));
+    }
+    return OkStatus();
+  }
+
+  Status OptimizeAndCollectStats(Cluster* cluster, const GrapplerItem& item,
+                                 GraphDef* output,
+                                 OptimizationStats* stats) override;
+
+ private:
+  bool autotune_ = true;
+};
+
+}  // namespace grappler
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_AUTOTUNE_BUFFER_SIZES_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/batch_parallelization.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/batch_parallelization.h
new file mode 100644
index 0000000000000000000000000000000000000000..430b57a4cbd0bd408c8e50ea0431b6ff4a3cc153
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/batch_parallelization.h
@@ -0,0 +1,64 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_BATCH_PARALLELIZATION_H_
+#define TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_BATCH_PARALLELIZATION_H_
+
+#include "tensorflow/core/framework/attr_value.pb.h"
+#include "tensorflow/core/grappler/optimizers/data/optimizer_base.h"
+
+namespace tensorflow {
+namespace grappler {
+
+constexpr char kAutotune[] = "autotune";
+
+// This optimization parallelizes BatchDataset.
+class BatchParallelization : public TFDataOptimizerBase {
+ public:
+  BatchParallelization() = default;
+  ~BatchParallelization() override = default;
+
+  string name() const override { return "batch_parallelization"; };
+
+  bool UsesFunctionLibrary() const override { return false; }
+
+  Status Init(
+      const tensorflow::RewriterConfig_CustomGraphOptimizer* config) override {
+    if (!config) return OkStatus();
+
+    const string& autotune = config->parameter_map().at(kAutotune).s();
+    if (autotune == "true") {
+      autotune_ = true;
+    } else if (autotune == "false") {
+      autotune_ = false;
+    } else {
+      return errors::InvalidArgument("Received an invalid value for parameter ",
+                                     kAutotune, ": ", autotune);
+    }
+    return OkStatus();
+  }
+
+  Status OptimizeAndCollectStats(Cluster* cluster, const GrapplerItem& item,
+                                 GraphDef* output,
+                                 OptimizationStats* stats) override;
+
+ private:
+  bool autotune_ = true;
+};
+
+}  // namespace grappler
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_BATCH_PARALLELIZATION_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/disable_intra_op_parallelism.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/disable_intra_op_parallelism.h
new file mode 100644
index 0000000000000000000000000000000000000000..c8f5df89c322634025732b3bd4342ed9dd62cf14
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/disable_intra_op_parallelism.h
@@ -0,0 +1,47 @@
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_DISABLE_INTRA_OP_PARALLELISM_H_
+#define TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_DISABLE_INTRA_OP_PARALLELISM_H_
+
+#include "tensorflow/core/grappler/optimizers/data/optimizer_base.h"
+
+namespace tensorflow {
+namespace grappler {
+
+// This optimization sets intra-op parallelism to be 1.
+class DisableIntraOpParallelism : public TFDataOptimizerBase {
+ public:
+  DisableIntraOpParallelism() = default;
+  ~DisableIntraOpParallelism() override = default;
+
+  string name() const override { return "disable_intra_op_parallelism"; };
+
+  bool UsesFunctionLibrary() const override { return false; }
+
+  Status Init(
+      const tensorflow::RewriterConfig_CustomGraphOptimizer* config) override {
+    return OkStatus();
+  }
+
+  Status OptimizeAndCollectStats(Cluster* cluster, const GrapplerItem& item,
+                                 GraphDef* output,
+                                 OptimizationStats* stats) override;
+};
+
+}  // namespace grappler
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_DISABLE_INTRA_OP_PARALLELISM_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/disable_prefetch_legacy_autotune.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/disable_prefetch_legacy_autotune.h
new file mode 100644
index 0000000000000000000000000000000000000000..e3de9bf8ca15cccd9574c63fdb01d31ac2d4b717
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/disable_prefetch_legacy_autotune.h
@@ -0,0 +1,64 @@
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_DISABLE_PREFETCH_LEGACY_AUTOTUNE_H_
+#define TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_DISABLE_PREFETCH_LEGACY_AUTOTUNE_H_
+
+#include "tensorflow/core/framework/attr_value.pb.h"
+#include "tensorflow/core/grappler/optimizers/data/optimizer_base.h"
+
+namespace tensorflow {
+namespace grappler {
+
+constexpr char kAutotune[] = "autotune";
+
+// This optimization disables the lagacy autotune option for PrefetchDataset.
+class DisablePrefetchLegacyAutotune : public TFDataOptimizerBase {
+ public:
+  DisablePrefetchLegacyAutotune() = default;
+  ~DisablePrefetchLegacyAutotune() override = default;
+
+  string name() const override { return "disable_prefetch_legacy_autotune"; };
+
+  bool UsesFunctionLibrary() const override { return false; }
+
+  Status Init(
+      const tensorflow::RewriterConfig_CustomGraphOptimizer* config) override {
+    if (!config) return OkStatus();
+
+    const string& autotune = config->parameter_map().at(kAutotune).s();
+    if (autotune == "true") {
+      autotune_ = true;
+    } else if (autotune == "false") {
+      autotune_ = false;
+    } else {
+      return errors::InvalidArgument("Received an invalid value for parameter ",
+                                     kAutotune, ": ", autotune);
+    }
+    return OkStatus();
+  }
+
+  Status OptimizeAndCollectStats(Cluster* cluster, const GrapplerItem& item,
+                                 GraphDef* output,
+                                 OptimizationStats* stats) override;
+
+ private:
+  bool autotune_ = true;
+};
+
+}  // namespace grappler
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_DISABLE_PREFETCH_LEGACY_AUTOTUNE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/enable_gradient_descent.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/enable_gradient_descent.h
new file mode 100644
index 0000000000000000000000000000000000000000..21f742a957de882b3aada35c8aafdad745504264
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/enable_gradient_descent.h
@@ -0,0 +1,64 @@
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_ENABLE_GRADIENT_DESCENT_H_
+#define TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_ENABLE_GRADIENT_DESCENT_H_
+
+#include "tensorflow/core/framework/attr_value.pb.h"
+#include "tensorflow/core/grappler/optimizers/data/optimizer_base.h"
+
+namespace tensorflow {
+namespace grappler {
+
+constexpr char kAutotune[] = "autotune";
+
+// This optimization enables Gradient Descent Optimization in `ModelDataset`.
+class EnableGradientDescent : public TFDataOptimizerBase {
+ public:
+  EnableGradientDescent() = default;
+  ~EnableGradientDescent() override = default;
+
+  string name() const override { return "enable_gradient_descent"; };
+
+  bool UsesFunctionLibrary() const override { return false; }
+
+  Status Init(
+      const tensorflow::RewriterConfig_CustomGraphOptimizer* config) override {
+    if (!config) return OkStatus();
+
+    const string& autotune = config->parameter_map().at(kAutotune).s();
+    if (autotune == "true") {
+      autotune_ = true;
+    } else if (autotune == "false") {
+      autotune_ = false;
+    } else {
+      return errors::InvalidArgument("Received an invalid value for parameter ",
+                                     kAutotune, ": ", autotune);
+    }
+    return OkStatus();
+  }
+
+  Status OptimizeAndCollectStats(Cluster* cluster, const GrapplerItem& item,
+                                 GraphDef* output,
+                                 OptimizationStats* stats) override;
+
+ private:
+  bool autotune_ = true;
+};
+
+}  // namespace grappler
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_ENABLE_GRADIENT_DESCENT_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/filter_fusion.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/filter_fusion.h
new file mode 100644
index 0000000000000000000000000000000000000000..30058b4975aa9202e506a93931e7d238667ec185
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/filter_fusion.h
@@ -0,0 +1,47 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_FILTER_FUSION_H_
+#define TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_FILTER_FUSION_H_
+
+#include "tensorflow/core/grappler/optimizers/data/optimizer_base.h"
+
+namespace tensorflow {
+namespace grappler {
+
+// This optimization fuses filter transformations.
+class FilterFusion : public TFDataOptimizerBase {
+ public:
+  FilterFusion() = default;
+  ~FilterFusion() override = default;
+
+  string name() const override { return "filter_fusion"; };
+
+  bool UsesFunctionLibrary() const override { return false; }
+
+  Status Init(
+      const tensorflow::RewriterConfig_CustomGraphOptimizer* config) override {
+    return OkStatus();
+  }
+
+  Status OptimizeAndCollectStats(Cluster* cluster, const GrapplerItem& item,
+                                 GraphDef* output,
+                                 OptimizationStats* stats) override;
+};
+
+}  // namespace grappler
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_FILTER_FUSION_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/filter_parallelization.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/filter_parallelization.h
new file mode 100644
index 0000000000000000000000000000000000000000..fd9f7827b52e995a4880133ea3c705feca6db147
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/filter_parallelization.h
@@ -0,0 +1,64 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_FILTER_PARALLELIZATION_H_
+#define TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_FILTER_PARALLELIZATION_H_
+
+#include "tensorflow/core/framework/attr_value.pb.h"
+#include "tensorflow/core/grappler/optimizers/data/optimizer_base.h"
+
+namespace tensorflow {
+namespace grappler {
+
+constexpr char kAutotune[] = "autotune";
+
+// This optimization parallelizes FilterDataset when function is stateless.
+class FilterParallelization : public TFDataOptimizerBase {
+ public:
+  FilterParallelization() = default;
+  ~FilterParallelization() override = default;
+
+  string name() const override { return "filter_parallelization"; };
+
+  bool UsesFunctionLibrary() const override { return false; }
+
+  Status Init(
+      const tensorflow::RewriterConfig_CustomGraphOptimizer* config) override {
+    if (!config) return OkStatus();
+
+    const string& autotune = config->parameter_map().at(kAutotune).s();
+    if (autotune == "true") {
+      autotune_ = true;
+    } else if (autotune == "false") {
+      autotune_ = false;
+    } else {
+      return errors::InvalidArgument("Received an invalid value for parameter ",
+                                     kAutotune, ": ", autotune);
+    }
+    return OkStatus();
+  }
+
+  Status OptimizeAndCollectStats(Cluster* cluster, const GrapplerItem& item,
+                                 GraphDef* output,
+                                 OptimizationStats* stats) override;
+
+ private:
+  bool autotune_ = true;
+};
+
+}  // namespace grappler
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_FILTER_PARALLELIZATION_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/function_utils.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/function_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..8941e58c55875b840574664fc2cfaae3d2e9c6f7
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/function_utils.h
@@ -0,0 +1,128 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_FUNCTION_UTILS_H_
+#define TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_FUNCTION_UTILS_H_
+
+#include "tensorflow/core/framework/attr_value.pb.h"
+#include "tensorflow/core/framework/function.pb.h"
+#include "tensorflow/core/framework/graph.pb.h"
+#include "tensorflow/core/framework/node_def.pb.h"
+#include "tensorflow/core/framework/tensor.pb.h"
+#include "tensorflow/core/framework/tensor_shape.pb.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/grappler/mutable_graph_view.h"
+#include "tensorflow/core/grappler/utils.h"
+#include "tensorflow/core/lib/core/errors.h"
+
+namespace tensorflow {
+namespace grappler {
+namespace function_utils {
+// This namespace contains utility functions for querying and modifying
+// FunctionDefs.
+
+// Describes a FunctionDef input tensor. In FunctionDefs, input tensor strings
+// have the format node_name:node_output:position (if they derive from nodes),
+// or input_name (if they derive from an argument).
+struct FunctionDefTensorDesc {
+  FunctionDefTensorDesc() = default;
+
+  FunctionDefTensorDesc(const string& node_name, const string& output,
+                        int position);
+
+  // Parses node_name:node_output:position string into its components.
+  explicit FunctionDefTensorDesc(const string& input);
+
+  // TODO(rachelim): Add provisions to deal with special formats, like how
+  // GrapplerFunctionItem expands node output range if position is not defined
+  string full_str;
+  string node_name;
+  string node_output;
+  int position = -1;
+};
+
+// Replaces all references to `from` tensor in func's nodes' inputs and retvals
+// to `to` tensor. This is similar to `MutableGraphView::ReplaceInputs`.
+void ReplaceReferences(const string& from, const string& to, FunctionDef* func);
+
+// Adds a function output to the function def, ensuring that the output key
+// is unique, and maps to output_tensor_name in the ret dict.
+void AddFunctionOutputWithUniqueName(StringPiece prefix,
+                                     StringPiece output_tensor_name,
+                                     FunctionDef* fdef, DataType dtype);
+
+// Adds an input to a FunctionDef.
+OpDef_ArgDef* AddFunctionInput(const string& name, FunctionDef* fdef,
+                               DataType dtype);
+
+// Adds a node to a FunctionDef.
+NodeDef* AddNode(StringPiece name, StringPiece op,
+                 const std::vector<string>& inputs,
+                 const std::vector<std::pair<string, AttrValue>>& attributes,
+                 FunctionDef* fd);
+
+// Checks whether the function contains a node with the given name.
+bool ContainsFunctionNodeWithName(StringPiece name,
+                                  const FunctionDef& function);
+
+// Checks whether the function contains a node with the given op.
+bool ContainsFunctionNodeWithOp(StringPiece op, const FunctionDef& function);
+
+// Checks whether the function contains an output with the given name.
+bool ContainsFunctionOutputWithName(StringPiece name,
+                                    const FunctionDef& function);
+
+// Returns the index of the function input with the given name or -1 if the
+// function node does not exist.
+int FindFunctionInputWithName(StringPiece name, const FunctionDef& function);
+
+// Returns the index of the function output with the given name or -1 if the
+// function node does not exist.
+int FindFunctionOutputWithName(StringPiece name, const FunctionDef& function);
+
+// Returns the index of the function node with the given name or -1 if the
+// function node does not exist.
+int FindFunctionNodeWithName(StringPiece name, const FunctionDef& function);
+
+// Returns the index of the function node with the given op or -1 if the
+// function node does not exist.
+int FindFunctionNodeWithOp(StringPiece op, const FunctionDef& function);
+
+// Sets the function node name using the `prefix` as a prefix while guaranteeing
+// the name is unique across the functions nodes.
+void SetUniqueFunctionNodeName(StringPiece prefix, FunctionDef* function,
+                               NodeDef* node);
+
+// Checks if the function is stateful by checking the function graph for
+// stateful ops. Because the "If" and "While" ops are conservatively marked as
+// stateful, the check recurses into their graph to determine whether they are
+// actually stateful. The `skip_assert` argument determines whether the "Assert"
+// op should be treated as stateful or not.
+bool IsFunctionStateful(const FunctionLibraryDefinition& library,
+                        const FunctionDef& function_def,
+                        bool skip_assert = false);
+
+// Checks if the node is stateful. Because the "If" or "While" ops are
+// conservatively marked as stateful, the check recurses into their graph to
+// determine whether they are actually stateful. The `skip_assert` argument
+// determines whether the "Assert" op  should be treated as stateful or not.
+bool IsNodeStateful(const FunctionLibraryDefinition& library,
+                    const NodeDef& node, bool skip_assert = false);
+
+}  // end namespace function_utils
+}  // end namespace grappler
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_FUNCTION_UTILS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/fusion_utils.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/fusion_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..19b7002dcd8562cc2eaea4a09bac0ab5f5f01707
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/fusion_utils.h
@@ -0,0 +1,135 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_FUSION_UTILS_H_
+#define TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_FUSION_UTILS_H_
+
+#include <functional>
+#include "tensorflow/core/framework/attr_value.pb.h"
+#include "tensorflow/core/framework/node_def.pb.h"
+#include "tensorflow/core/grappler/op_types.h"
+#include "tensorflow/core/grappler/optimizers/data/graph_utils.h"
+#include "tensorflow/core/lib/gtl/inlined_vector.h"
+#include "tensorflow/core/platform/protobuf.h"
+
+namespace tensorflow {
+namespace grappler {
+namespace fusion_utils {
+
+// These functions are invoked with first and second function signature,
+// should set a signature of fused second_function.
+using SetFunctionSignatureFn = std::function<void(
+    const OpDef& first_function_signature,
+    const OpDef& second_function_signature, OpDef* fused_function_signature)>;
+
+using StringCollection = gtl::InlinedVector<string, 2>;
+
+// These functions are invoked with nodes from second function that were
+// previously taking arguments as input. The `arg_num` tells which
+// function argument node was using as an input, e.g:
+// node(arg_1, other_node, arg_4)
+// would be called on the first and third input with arg_num equal 1 and 4.
+// It should set up inputs based on first function inputs or outputs or
+// second function inputs.
+using SetInputFn =
+    std::function<string(const StringCollection& first_function_inputs,
+                         const StringCollection& second_function_inputs,
+                         const StringCollection& parent_outputs, int arg_num)>;
+
+// This function is invoked with first and second function ret. It is used to
+// set up returns of fused function.
+using SetOutputFn =
+    std::function<void(const protobuf::Map<string, string>& parent_ret,
+                       const protobuf::Map<string, string>& second_function_ret,
+                       protobuf::Map<string, string>* fused_ret)>;
+
+using SetNodesFn = std::function<void(
+    const FunctionDef& first_function, const FunctionDef& second_function,
+    FunctionDef* fused_function, FunctionDefLibrary* library)>;
+
+void MergeNodes(const FunctionDef& first_function,
+                const FunctionDef& second_function, FunctionDef* fused_function,
+                FunctionDefLibrary* library);
+
+// Returns true if functions can be composed.
+bool CanCompose(const OpDef& first_signature, const OpDef& second_signature);
+
+void ComposeSignature(const OpDef& first_signature,
+                      const OpDef& second_signature, OpDef* fused_signature);
+
+string ComposeInput(const StringCollection& first_inputs,
+                    const StringCollection& second_inputs,
+                    const StringCollection& first_outputs, int arg_num);
+
+// Sets output to the composition of first and second function:
+// second_function(first_function(args...)).
+void ComposeOutput(const protobuf::Map<string, string>& first_ret,
+                   const protobuf::Map<string, string>& second_ret,
+                   protobuf::Map<string, string>* fused_ret);
+
+// Set input signature to `first_function_signature` and output signature
+// to `first_function_signature` + `second_function_signature`
+void CombineSignature(const OpDef& first_signature,
+                      const OpDef& second_signature, OpDef* fused_signature);
+
+// Apart from first function returns, return values from second function as
+// extra returns like:
+// return *first_function(...), *second_function(...)
+void CombineOutput(const protobuf::Map<string, string>& first_ret,
+                   const protobuf::Map<string, string>& second_ret,
+                   protobuf::Map<string, string>* fused_ret);
+
+// Returns true if both signatures have the same number of input and output
+// args.
+bool HasSameSignature(const OpDef& first_signature,
+                      const OpDef& second_signature);
+
+// Check if both signatures are same and copy it from `first_signature`.
+void SameSignature(const OpDef& first_signature, const OpDef& second_signature,
+                   OpDef* fused_signature);
+
+// Take the same input as first function.
+string SameInput(const StringCollection& first_inputs,
+                 const StringCollection& second_inputs,
+                 const StringCollection& first_outputs, int arg_num);
+
+// Create a fused function that computes the short-circuit logical AND of the
+// result of the first function and the result of the second function.
+void LazyConjunctionOutput(const protobuf::Map<string, string>& first_ret,
+                           const protobuf::Map<string, string>& second_ret,
+                           protobuf::Map<string, string>* fused_ret);
+
+void LazyConjunctionNodes(const FunctionDef& first_function,
+                          const FunctionDef& second_function,
+                          FunctionDef* fused_function,
+                          FunctionDefLibrary* library);
+
+// Fuse `first_function` with `second_function`, setting `fused_name_prefix` as
+// a name prefix.  The nodes from `first_function` are copied unmodified.  All
+// of the setup functions are called with a copy of second function having names
+// that are not conflicting with first function.  This means that copied nodes
+// from  second function can end up having different names.  For explanation of
+// set up functions see the documentation of the functions types.
+FunctionDef* FuseFunctions(
+    const FunctionDef& first_function, const FunctionDef& second_function,
+    StringPiece fused_name_prefix, const SetFunctionSignatureFn& set_signature,
+    const SetInputFn& set_input, const SetOutputFn& set_output,
+    const SetNodesFn& set_nodes, FunctionDefLibrary* library);
+
+}  // namespace fusion_utils
+}  // namespace grappler
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_FUSION_UTILS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/graph_utils.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/graph_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..8e7e486adfefbee5c2f02ae8b390dbb85f522666
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/graph_utils.h
@@ -0,0 +1,213 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_GRAPH_UTILS_H_
+#define TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_GRAPH_UTILS_H_
+
+#include "tensorflow/core/framework/attr_value.pb.h"
+#include "tensorflow/core/framework/function.pb.h"
+#include "tensorflow/core/framework/graph.pb.h"
+#include "tensorflow/core/framework/node_def.pb.h"
+#include "tensorflow/core/framework/tensor.pb.h"
+#include "tensorflow/core/framework/tensor_shape.pb.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/graph/graph.h"
+#include "tensorflow/core/grappler/grappler_item.h"
+#include "tensorflow/core/grappler/mutable_graph_view.h"
+#include "tensorflow/core/grappler/utils.h"
+#include "tensorflow/core/lib/core/errors.h"
+
+namespace tensorflow {
+namespace grappler {
+namespace graph_utils {
+
+// Returns the index of the first element in collection that fulfills predicate.
+// If no such element exists, returns -1.
+template <typename Predicate, typename Collection>
+int GetFirstElementIndexWithPredicate(const Predicate& predicate,
+                                      const Collection& collection) {
+  unsigned idx = 0;
+  for (auto&& element : collection) {
+    if (predicate(element)) {
+      return idx;
+    }
+    idx++;
+  }
+  return -1;
+}
+
+// Adds a node to the graph.
+NodeDef* AddNode(StringPiece name, StringPiece op,
+                 const std::vector<string>& inputs,
+                 const std::vector<std::pair<string, AttrValue>>& attributes,
+                 MutableGraphView* graph);
+
+// Adds Placeholder node for given type.
+NodeDef* AddScalarPlaceholder(DataType dtype, MutableGraphView* graph);
+
+// Adds a Const node with the given value to the graph.
+template <typename T>
+NodeDef* AddScalarConstNode(T v, MutableGraphView* graph) {
+  // is_same is an idiomatic hack for making it compile if not instantiated.
+  // Replacing with false will result in a compile-time error.
+  static_assert(!std::is_same<T, T>::value,
+                "Invalid specialization of this method for type T.");
+  return {};
+}
+
+template <>
+NodeDef* AddScalarConstNode(bool v, MutableGraphView* graph);
+template <>
+NodeDef* AddScalarConstNode(double v, MutableGraphView* graph);
+template <>
+NodeDef* AddScalarConstNode(float v, MutableGraphView* graph);
+template <>
+NodeDef* AddScalarConstNode(int v, MutableGraphView* graph);
+template <>
+NodeDef* AddScalarConstNode(int64_t v, MutableGraphView* graph);
+template <>
+NodeDef* AddScalarConstNode(StringPiece v, MutableGraphView* graph);
+
+// Retrieves the value of a const node. Returns an error
+// if the node is not const, or its value is of a different type.
+template <typename T>
+Status GetScalarConstNodeValue(const NodeDef& node, T* value) {
+  // is_same is an idiomatic hack for making it compile if not instantiated.
+  // Replacing with false will result in a compile-time error.
+  static_assert(!std::is_same<T, T>::value,
+                "Invalid specialization of this method fo rtype T.");
+}
+
+template <>
+Status GetScalarConstNodeValue(const NodeDef& node, int64_t* value);
+template <>
+Status GetScalarConstNodeValue(const NodeDef& node, bool* value);
+
+// Checks whether the two graphs are the same.
+bool Compare(const GraphDef& g1, const GraphDef& g2);
+
+// Checks whether the graph contains a node with the given name.
+bool ContainsGraphNodeWithName(StringPiece name, const GraphDef& graph);
+
+// Checks whether the library contains a function with the given name.
+bool ContainsGraphFunctionWithName(StringPiece name,
+                                   const FunctionDefLibrary& library);
+
+// Checks whether the graph contains a node with the given op.
+bool ContainsNodeWithOp(StringPiece op, const GraphDef& graph);
+
+// Returns the index of the node with the given name or -1 if the node does
+// not exist.
+int FindGraphNodeWithName(StringPiece name, const GraphDef& graph);
+
+// Returns the index of the function with the given name or -1 if the function
+// does not exist.
+int FindGraphFunctionWithName(StringPiece name,
+                              const FunctionDefLibrary& library);
+
+// Returns the index of the first node with the given op or -1 if no such  node
+// exists.
+int FindGraphNodeWithOp(StringPiece op, const GraphDef& graph);
+
+// Gets the 0th input to a node in the graph.
+NodeDef* GetInputNode(const NodeDef& node, const MutableGraphView& graph);
+
+// Gets the ith input to a node in the graph.
+NodeDef* GetInputNode(const NodeDef& node, const MutableGraphView& graph,
+                      int64_t i);
+
+// Gets the attr corresponding to a dataset node's output types, if it exists.
+Status GetDatasetOutputTypesAttr(const NodeDef& node,
+                                 DataTypeVector* output_types);
+
+// Returns the list of indices of all nodes with the given op or empty list if
+// no such node exists.
+std::vector<int> FindAllGraphNodesWithOp(const string& op,
+                                         const GraphDef& graph);
+
+// Sets the node name using `prefix` as a prefix while guaranteeing the name
+// is unique across the graph.
+void SetUniqueGraphNodeName(StringPiece prefix, GraphDef* graph, NodeDef* node);
+
+// Sets the function name using the `prefix` name as a prefix while guaranteeing
+// the name is unique across the function library.
+void SetUniqueGraphFunctionName(StringPiece prefix,
+                                const FunctionDefLibrary* library,
+                                FunctionDef* function);
+
+// Copies attribute having name `attribute_name` from node `from` to node
+// `to_node`.
+void CopyAttribute(const string& attribute_name, const NodeDef& from,
+                   NodeDef* to_node);
+
+// Concatenates list attribute having name `attribute_name` from `first` and
+// `second` node, setting it to `to_node`.
+void ConcatAttributeList(const string& attribute_name, const NodeDef& first,
+                         const NodeDef& second, NodeDef* to_node);
+
+// Checks that all nodes in the graphs have unique names, and sets their names
+// to be unique if they are not already.  This is necessary as Graph does not
+// have the provisions to deduplicate names, and name deduplication elsewhere
+// in tensorflow happens in other layers (for example, in the Scope class of the
+// C++ API). Note that the nodes in the graph are identified by their id,
+// and renaming nodes does not mutate any edges.
+Status EnsureNodeNamesUnique(Graph* g);
+
+// Returns the item's fetch node, if there is exactly one. Otherwise, returns an
+// error.
+Status GetFetchNode(const MutableGraphView& graph, const GrapplerItem& item,
+                    NodeDef** fetch_node);
+
+// Returns true if `item` is derived from a `FunctionDef`, false otherwise.
+// Currently, we determine this heuristically: If we don't have any fetch nodes
+// or all fetch nodes are `Retval` ops, then we consider this item as derived
+// from a `FunctionDef`.
+bool IsItemDerivedFromFunctionDef(const GrapplerItem& item,
+                                  const MutableGraphView& graph_view);
+
+// If both input nodes have the "metadata" attribute set, it populates the
+// "metadata" attribute for the fused node.
+void MaybeSetFusedMetadata(const NodeDef& node1, const NodeDef& node2,
+                           NodeDef* fused_node);
+
+// Copies the attributes `output_shapes`, `output_types` from node `from` to
+// node `to_node` if they exist. The method will return `true` if attributes
+// copied successfully, otherwise it will return `false`.
+//
+// Some tf.data transformations set `Toutput_types` instead of `output_types`
+// when the attribute describes type of tensor inputs (e.g. TensorDataset,
+// TensorSliceDataset, and PaddedBatchDataset). In this case the method copies
+// the attribute `Toutput_types` of node `from` to the attribute `output_types`
+// of node `to_node`.
+bool CopyShapesAndTypesAttrs(const NodeDef& from, NodeDef* to_node);
+
+// Checks whether the op has a "sloppy" attribute.
+bool HasSloppyAttr(const string& op);
+
+// Checks whether the op has a "replicate_on_split" attribute.
+bool HasReplicateOnSplitAttr(const string& op);
+
+// Checks whether the op has a "deterministic" attribute.
+bool HasDeterministicAttr(const string& op);
+
+// Sets the `name` as the metadata name of the `node`. It returns an error if
+// the `node` already has a metadata name.
+Status SetMetadataName(const std::string& name, NodeDef* node);
+
+}  // namespace graph_utils
+}  // namespace grappler
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_GRAPH_UTILS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/inject_io_prefetch.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/inject_io_prefetch.h
new file mode 100644
index 0000000000000000000000000000000000000000..444d49e77ac847a7badf6bfc38d37991447d1314
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/inject_io_prefetch.h
@@ -0,0 +1,64 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_INJECT_IO_PREFETCH_H_
+#define TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_INJECT_IO_PREFETCH_H_
+
+#include <string>
+
+#include "absl/status/status.h"
+#include "tensorflow/core/framework/graph.pb.h"
+#include "tensorflow/core/grappler/optimizers/data/optimizer_base.h"
+#include "tensorflow/core/grappler/optimizers/graph_optimizer.h"
+#include "tensorflow/core/protobuf/rewriter_config.pb.h"
+
+namespace tensorflow {
+namespace grappler {
+
+class InjectIoPrefetch : public TFDataOptimizerBase {
+ public:
+  InjectIoPrefetch() = default;
+  ~InjectIoPrefetch() override = default;
+
+  std::string name() const override { return "inject_io_prefetch"; };
+
+  bool UsesFunctionLibrary() const override { return false; }
+
+  absl::Status Init(
+      const tensorflow::RewriterConfig_CustomGraphOptimizer* config) override;
+
+  absl::Status OptimizeAndCollectStats(Cluster* cluster,
+                                       const GrapplerItem& item,
+                                       GraphDef* output,
+                                       OptimizationStats* stats) override;
+
+ protected:
+  bool autotune_ = true;
+};
+
+class InjectIoPrefetchEligible : public InjectIoPrefetch {
+ public:
+  std::string name() const override { return "inject_io_prefetch_eligible"; };
+
+  absl::Status OptimizeAndCollectStats(Cluster* cluster,
+                                       const GrapplerItem& item,
+                                       GraphDef* output,
+                                       OptimizationStats* stats) override;
+};
+
+}  // namespace grappler
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_INJECT_IO_PREFETCH_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/inject_prefetch.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/inject_prefetch.h
new file mode 100644
index 0000000000000000000000000000000000000000..5ce6b3dadec0852b063efdf45a3c6c1d4b1cbd7f
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/inject_prefetch.h
@@ -0,0 +1,65 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_INJECT_PREFETCH_H_
+#define TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_INJECT_PREFETCH_H_
+
+#include "tensorflow/core/framework/attr_value.pb.h"
+#include "tensorflow/core/grappler/optimizers/data/optimizer_base.h"
+
+namespace tensorflow {
+namespace grappler {
+
+constexpr char kAutotune[] = "autotune";
+
+// If autotune is ON and the last transformation in the input pipeline is not
+// `prefetch()`, this optimization adds `prefetch(AUTOTUNE)` after it.
+class InjectPrefetch : public TFDataOptimizerBase {
+ public:
+  InjectPrefetch() = default;
+  ~InjectPrefetch() override = default;
+
+  std::string name() const override { return "inject_prefetch"; };
+
+  bool UsesFunctionLibrary() const override { return false; }
+
+  Status Init(
+      const tensorflow::RewriterConfig_CustomGraphOptimizer* config) override {
+    if (!config) return OkStatus();
+
+    const std::string& autotune = config->parameter_map().at(kAutotune).s();
+    if (autotune == "true") {
+      autotune_ = true;
+    } else if (autotune == "false") {
+      autotune_ = false;
+    } else {
+      return errors::InvalidArgument("Received an invalid value for parameter ",
+                                     kAutotune, ": ", autotune);
+    }
+    return OkStatus();
+  }
+
+  Status OptimizeAndCollectStats(Cluster* cluster, const GrapplerItem& item,
+                                 GraphDef* output,
+                                 OptimizationStats* stats) override;
+
+ protected:
+  bool autotune_ = true;
+};
+
+}  // namespace grappler
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_INJECT_PREFETCH_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/make_deterministic.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/make_deterministic.h
new file mode 100644
index 0000000000000000000000000000000000000000..1df6e10def699edd08419417a31a5574cfb94b9a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/make_deterministic.h
@@ -0,0 +1,76 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_MAKE_DETERMINISTIC_H_
+#define TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_MAKE_DETERMINISTIC_H_
+
+#include "tensorflow/core/grappler/optimizers/data/optimizer_base.h"
+
+namespace tensorflow {
+namespace grappler {
+
+// Removes sources on nondeterminism from dataset ops. Nondeterminism can occur
+// in the follow ways, each which this pass addresses:
+//
+// 1. The datasets ParallelInterleave, ParallelMap, and MapAndBatch can
+//    introduce nondeterminism by running a function multiple times in parallel.
+//    Specifically, if the function can mutate state, it is potentially
+//    nondeterministic. In such cases, this pass converts such dataset ops to a
+//    non-parallel version. As a performance optimization, in certain cases this
+//    pass will instead move nondeterministic ops to a separate non-parallel Map
+//    op, so that most of the ops can still run in parallel.
+//
+// 2. Certain datasets, such as Prefetch, can introduce asynchrony by running a
+//    dataset iterator in a background thread while ops outside the dataset are
+//    also running. This can introduce nondeterminism if the input pipeline has
+//    certain stateful ops. Other than Prefetch, datasets with a
+//    `num_parallel_calls` argument also introduce asynchrony, which includes
+//    the parallel datasets mentioned in (1) above.
+//
+//    This pass modifies nodes to remove asynchrony when there are any datasets
+//    in the graph with problematic stateful ops. This is done by converting
+//    parallel ops into non-parallel versions, as in (1), and by removing
+//    Prefetch nodes. Unlike (1), legacy random ops such as RandomUniform are
+//    not problematic despite being stateful, as if the op is within a dataset's
+//    function, ops outside the dataset cannot access the state. Also unlike
+//    (1), nondeterministic ops are never moved to a separate Map op, since
+//    doing so would not remove asynchrony.
+//
+// 3. Nondeterminism occurs if an op has a "deterministic" attribute that is
+//    false or a "sloppy" attribute that is true. This pass changes such
+//    attributes to be deterministic.
+class MakeDeterministic : public TFDataOptimizerBase {
+ public:
+  MakeDeterministic() = default;
+  ~MakeDeterministic() override = default;
+
+  string name() const override { return "make_deterministic"; };
+
+  bool UsesFunctionLibrary() const override { return false; }
+
+  Status Init(
+      const tensorflow::RewriterConfig_CustomGraphOptimizer* config) override {
+    return OkStatus();
+  }
+
+  Status OptimizeAndCollectStats(Cluster* cluster, const GrapplerItem& item,
+                                 GraphDef* output,
+                                 OptimizationStats* stats) override;
+};
+
+}  // namespace grappler
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_MAKE_DETERMINISTIC_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/make_sloppy.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/make_sloppy.h
new file mode 100644
index 0000000000000000000000000000000000000000..72caf5138eb7bbd07891cc895122839a3b39e0d3
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/make_sloppy.h
@@ -0,0 +1,46 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_MAKE_SLOPPY_H_
+#define TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_MAKE_SLOPPY_H_
+
+#include "tensorflow/core/grappler/optimizers/data/optimizer_base.h"
+
+namespace tensorflow {
+namespace grappler {
+
+class MakeSloppy : public TFDataOptimizerBase {
+ public:
+  MakeSloppy() = default;
+  ~MakeSloppy() override = default;
+
+  string name() const override { return "make_sloppy"; }
+
+  bool UsesFunctionLibrary() const override { return false; }
+
+  Status Init(
+      const tensorflow::RewriterConfig_CustomGraphOptimizer* config) override {
+    return OkStatus();
+  }
+
+  Status OptimizeAndCollectStats(Cluster* cluster, const GrapplerItem& item,
+                                 GraphDef* output,
+                                 OptimizationStats* stats) override;
+};
+
+}  // namespace grappler
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_MAKE_SLOPPY_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/map_and_batch_fusion.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/map_and_batch_fusion.h
new file mode 100644
index 0000000000000000000000000000000000000000..dfc809a343e6ac1405a2040a2d0b44b316cd76fc
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/map_and_batch_fusion.h
@@ -0,0 +1,46 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_MAP_AND_BATCH_FUSION_H_
+#define TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_MAP_AND_BATCH_FUSION_H_
+
+#include "tensorflow/core/grappler/optimizers/data/optimizer_base.h"
+
+namespace tensorflow {
+namespace grappler {
+
+class MapAndBatchFusion : public TFDataOptimizerBase {
+ public:
+  MapAndBatchFusion() = default;
+  ~MapAndBatchFusion() override = default;
+
+  string name() const override { return "map_and_batch_fusion"; };
+
+  bool UsesFunctionLibrary() const override { return false; }
+
+  Status Init(
+      const tensorflow::RewriterConfig_CustomGraphOptimizer* config) override {
+    return OkStatus();
+  }
+
+  Status OptimizeAndCollectStats(Cluster* cluster, const GrapplerItem& item,
+                                 GraphDef* output,
+                                 OptimizationStats* stats) override;
+};
+
+}  // namespace grappler
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_MAP_AND_BATCH_FUSION_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/map_and_filter_fusion.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/map_and_filter_fusion.h
new file mode 100644
index 0000000000000000000000000000000000000000..11eca17cfe8ba83a08a3b75a95deacb3407b2944
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/map_and_filter_fusion.h
@@ -0,0 +1,55 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_MAP_AND_FILTER_FUSION_H_
+#define TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_MAP_AND_FILTER_FUSION_H_
+
+#include "tensorflow/core/grappler/optimizers/data/optimizer_base.h"
+
+namespace tensorflow {
+namespace grappler {
+
+// This transformation fuses map and filter operations by moving computation of
+// filter predicate to MapDataset, which as a result produces an extra boolean
+// component. We filter by the boolean component, then project it away.
+//
+// In symbols, we transform map(x -> f(x)).filter(f(x) -> p(f(x))) into
+// map(x -> f(x), p(f(x))).filter(f(x), p(f(x)) -> p(f(x))).map(f(x), p(f(x))
+// -> f(x)). This is more efficient because the latter filter and map operations
+// can be performed short-circuit, so only the first map requires an executor
+// invocation.
+class MapAndFilterFusion : public TFDataOptimizerBase {
+ public:
+  MapAndFilterFusion() = default;
+  ~MapAndFilterFusion() override = default;
+
+  string name() const override { return "map_and_filter_fusion"; };
+
+  bool UsesFunctionLibrary() const override { return false; }
+
+  Status Init(
+      const tensorflow::RewriterConfig_CustomGraphOptimizer* config) override {
+    return OkStatus();
+  }
+
+  Status OptimizeAndCollectStats(Cluster* cluster, const GrapplerItem& item,
+                                 GraphDef* output,
+                                 OptimizationStats* stats) override;
+};
+
+}  // namespace grappler
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_MAP_AND_FILTER_FUSION_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/map_fusion.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/map_fusion.h
new file mode 100644
index 0000000000000000000000000000000000000000..74549d0c3031e40dfc8d46b5eb4a74b4bf510dc7
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/map_fusion.h
@@ -0,0 +1,47 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_MAP_FUSION_H_
+#define TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_MAP_FUSION_H_
+
+#include "tensorflow/core/grappler/optimizers/data/optimizer_base.h"
+
+namespace tensorflow {
+namespace grappler {
+
+// This optimization fuses map transformations by merging their map functions.
+class MapFusion : public TFDataOptimizerBase {
+ public:
+  MapFusion() = default;
+  ~MapFusion() override = default;
+
+  string name() const override { return "map_fusion"; };
+
+  bool UsesFunctionLibrary() const override { return false; }
+
+  Status Init(
+      const tensorflow::RewriterConfig_CustomGraphOptimizer* config) override {
+    return OkStatus();
+  }
+
+  Status OptimizeAndCollectStats(Cluster* cluster, const GrapplerItem& item,
+                                 GraphDef* output,
+                                 OptimizationStats* stats) override;
+};
+
+}  // namespace grappler
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_MAP_FUSION_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/map_parallelization.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/map_parallelization.h
new file mode 100644
index 0000000000000000000000000000000000000000..3b6de4da545c9b204dcba6166246e031ee583581
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/map_parallelization.h
@@ -0,0 +1,64 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_MAP_PARALLELIZATION_H_
+#define TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_MAP_PARALLELIZATION_H_
+
+#include "tensorflow/core/framework/attr_value.pb.h"
+#include "tensorflow/core/grappler/optimizers/data/optimizer_base.h"
+
+namespace tensorflow {
+namespace grappler {
+
+constexpr char kAutotune[] = "autotune";
+
+// This optimization parallelizes MapDataset when function is stateless.
+class MapParallelization : public TFDataOptimizerBase {
+ public:
+  MapParallelization() = default;
+  ~MapParallelization() override = default;
+
+  string name() const override { return "map_parallelization"; };
+
+  bool UsesFunctionLibrary() const override { return false; }
+
+  Status Init(
+      const tensorflow::RewriterConfig_CustomGraphOptimizer* config) override {
+    if (!config) return OkStatus();
+
+    const string& autotune = config->parameter_map().at(kAutotune).s();
+    if (autotune == "true") {
+      autotune_ = true;
+    } else if (autotune == "false") {
+      autotune_ = false;
+    } else {
+      return errors::InvalidArgument("Received an invalid value for parameter ",
+                                     kAutotune, ": ", autotune);
+    }
+    return OkStatus();
+  }
+
+  Status OptimizeAndCollectStats(Cluster* cluster, const GrapplerItem& item,
+                                 GraphDef* output,
+                                 OptimizationStats* stats) override;
+
+ private:
+  bool autotune_ = true;
+};
+
+}  // namespace grappler
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_MAP_PARALLELIZATION_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/meta_optimizer.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/meta_optimizer.h
new file mode 100644
index 0000000000000000000000000000000000000000..7832e76cc71f3afa30bc2fdd677311ca6b7f9d3d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/meta_optimizer.h
@@ -0,0 +1,55 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_META_OPTIMIZER_H_
+#define TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_META_OPTIMIZER_H_
+
+#include "absl/container/flat_hash_map.h"
+#include "tensorflow/core/grappler/optimizers/custom_graph_optimizer.h"
+
+namespace tensorflow {
+namespace grappler {
+
+// This optimizer performs tf.data-specific optimizations by invoking
+// other optimizers.
+class TFDataMetaOptimizer : public CustomGraphOptimizer {
+ public:
+  TFDataMetaOptimizer() = default;
+  ~TFDataMetaOptimizer() override = default;
+
+  string name() const override { return "tf_data_meta_optimizer"; };
+
+  bool UsesFunctionLibrary() const override { return true; }
+
+  Status Init(
+      const tensorflow::RewriterConfig_CustomGraphOptimizer* config) override;
+
+  Status Optimize(Cluster* cluster, const GrapplerItem& item,
+                  GraphDef* output) override;
+
+ private:
+  absl::flat_hash_map<string, std::unique_ptr<GraphOptimizer>>
+      enabled_optimizers_;
+
+  // Applies an optimization with the specified name on `item`, and stores
+  // the result in `item.graph`
+  Status ApplyOptimization(const string& name, Cluster* cluster,
+                           GrapplerItem* item) const;
+};
+
+}  // namespace grappler
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_META_OPTIMIZER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/noop_elimination.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/noop_elimination.h
new file mode 100644
index 0000000000000000000000000000000000000000..45fd59326c289a8371b247fac75c121557f39048
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/noop_elimination.h
@@ -0,0 +1,48 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_NOOP_ELIMINATION_H_
+#define TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_NOOP_ELIMINATION_H_
+
+#include "tensorflow/core/grappler/optimizers/data/optimizer_base.h"
+
+namespace tensorflow {
+namespace grappler {
+
+// This class eliminates tf.data transformations such as `take(n)` (for n < 0),
+// `skip(0)`, `repeat(1)`, or `prefetch(0)`.
+class NoOpElimination : public TFDataOptimizerBase {
+ public:
+  NoOpElimination() = default;
+  ~NoOpElimination() override = default;
+
+  string name() const override { return "noop_elimination"; };
+
+  bool UsesFunctionLibrary() const override { return false; }
+
+  Status Init(
+      const tensorflow::RewriterConfig_CustomGraphOptimizer* config) override {
+    return OkStatus();
+  }
+
+  Status OptimizeAndCollectStats(Cluster* cluster, const GrapplerItem& item,
+                                 GraphDef* output,
+                                 OptimizationStats* stats) override;
+};
+
+}  // namespace grappler
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_NOOP_ELIMINATION_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/optimizer_base.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/optimizer_base.h
new file mode 100644
index 0000000000000000000000000000000000000000..967945489864876574c96f00f9b1320df495de56
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/optimizer_base.h
@@ -0,0 +1,47 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_OPTIMIZER_BASE_H_
+#define TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_OPTIMIZER_BASE_H_
+
+#include "tensorflow/core/grappler/optimizers/custom_graph_optimizer.h"
+
+namespace tensorflow {
+namespace grappler {
+
+// A base class for tf.data optimizers.
+class TFDataOptimizerBase : public CustomGraphOptimizer {
+ public:
+  struct OptimizationStats {
+    // Identifies the number of independent graph changes for an optimization.
+    int64_t num_changes = 0;
+  };
+
+  TFDataOptimizerBase() = default;
+  ~TFDataOptimizerBase() override = default;
+
+  Status Optimize(Cluster* cluster, const GrapplerItem& item,
+                  GraphDef* output) final;
+
+  virtual Status OptimizeAndCollectStats(Cluster* cluster,
+                                         const GrapplerItem& item,
+                                         GraphDef* output,
+                                         OptimizationStats* stats) = 0;
+};
+
+}  // namespace grappler
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_OPTIMIZER_BASE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/parallel_batch.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/parallel_batch.h
new file mode 100644
index 0000000000000000000000000000000000000000..b4ac857a9eaa6c54b25f064258858f92843a86b2
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/parallel_batch.h
@@ -0,0 +1,46 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_PARALLEL_BATCH_H_
+#define TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_PARALLEL_BATCH_H_
+
+#include "tensorflow/core/grappler/optimizers/data/optimizer_base.h"
+
+namespace tensorflow {
+namespace grappler {
+
+class ParallelBatch : public TFDataOptimizerBase {
+ public:
+  ParallelBatch() = default;
+  ~ParallelBatch() override = default;
+
+  string name() const override { return "parallel_batch"; }
+
+  bool UsesFunctionLibrary() const override { return false; }
+
+  Status Init(
+      const tensorflow::RewriterConfig_CustomGraphOptimizer* config) override {
+    return OkStatus();
+  }
+
+  Status OptimizeAndCollectStats(Cluster* cluster, const GrapplerItem& item,
+                                 GraphDef* output,
+                                 OptimizationStats* stats) override;
+};
+
+}  // namespace grappler
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_PARALLEL_BATCH_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/remove_compression_map.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/remove_compression_map.h
new file mode 100644
index 0000000000000000000000000000000000000000..d3dc881d119a424282517e64ad1d2565379a49c9
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/remove_compression_map.h
@@ -0,0 +1,46 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_REMOVE_COMPRESSION_MAP_H_
+#define TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_REMOVE_COMPRESSION_MAP_H_
+
+#include "tensorflow/core/grappler/optimizers/data/optimizer_base.h"
+
+namespace tensorflow {
+namespace grappler {
+
+class RemoveCompressionMap : public TFDataOptimizerBase {
+ public:
+  RemoveCompressionMap() = default;
+  ~RemoveCompressionMap() override = default;
+
+  string name() const override { return "remove_compression_map"; }
+
+  bool UsesFunctionLibrary() const override { return false; }
+
+  Status Init(
+      const tensorflow::RewriterConfig_CustomGraphOptimizer* config) override {
+    return OkStatus();
+  }
+
+  Status OptimizeAndCollectStats(Cluster* cluster, const GrapplerItem& item,
+                                 GraphDef* output,
+                                 OptimizationStats* stats) override;
+};
+
+}  // namespace grappler
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_REMOVE_COMPRESSION_MAP_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/replicate_on_split.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/replicate_on_split.h
new file mode 100644
index 0000000000000000000000000000000000000000..42732fbb1a1beaeaf8e4a13c52e7802ca39833e5
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/replicate_on_split.h
@@ -0,0 +1,46 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_REPLICATE_ON_SPLIT_H_
+#define TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_REPLICATE_ON_SPLIT_H_
+
+#include "tensorflow/core/grappler/optimizers/data/optimizer_base.h"
+
+namespace tensorflow {
+namespace grappler {
+
+class ReplicateOnSplit : public TFDataOptimizerBase {
+ public:
+  ReplicateOnSplit() = default;
+  ~ReplicateOnSplit() override = default;
+
+  string name() const override { return "replicate_on_split"; }
+
+  bool UsesFunctionLibrary() const override { return false; }
+
+  Status Init(
+      const tensorflow::RewriterConfig_CustomGraphOptimizer* config) override {
+    return OkStatus();
+  }
+
+  Status OptimizeAndCollectStats(Cluster* cluster, const GrapplerItem& item,
+                                 GraphDef* output,
+                                 OptimizationStats* stats) override;
+};
+
+}  // namespace grappler
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_REPLICATE_ON_SPLIT_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/shuffle_and_repeat_fusion.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/shuffle_and_repeat_fusion.h
new file mode 100644
index 0000000000000000000000000000000000000000..d21619b92b34aab7250a465c750374db77f6b9e8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/shuffle_and_repeat_fusion.h
@@ -0,0 +1,46 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_SHUFFLE_AND_REPEAT_FUSION_H_
+#define TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_SHUFFLE_AND_REPEAT_FUSION_H_
+
+#include "tensorflow/core/grappler/optimizers/data/optimizer_base.h"
+
+namespace tensorflow {
+namespace grappler {
+
+class ShuffleAndRepeatFusion : public TFDataOptimizerBase {
+ public:
+  ShuffleAndRepeatFusion() = default;
+  ~ShuffleAndRepeatFusion() override = default;
+
+  string name() const override { return "shuffle_and_repeat_fusion"; };
+
+  bool UsesFunctionLibrary() const override { return false; }
+
+  Status Init(
+      const tensorflow::RewriterConfig_CustomGraphOptimizer* config) override {
+    return OkStatus();
+  }
+
+  Status OptimizeAndCollectStats(Cluster* cluster, const GrapplerItem& item,
+                                 GraphDef* output,
+                                 OptimizationStats* stats) override;
+};
+
+}  // namespace grappler
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_SHUFFLE_AND_REPEAT_FUSION_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/slack.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/slack.h
new file mode 100644
index 0000000000000000000000000000000000000000..8ce90841ebf49c9a0f4b14e397cbd34c9bdc4eb1
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/slack.h
@@ -0,0 +1,65 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_SLACK_H_
+#define TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_SLACK_H_
+
+#include "absl/strings/numbers.h"
+#include "tensorflow/core/framework/attr_value.pb.h"
+#include "tensorflow/core/grappler/mutable_graph_view.h"
+#include "tensorflow/core/grappler/optimizers/data/optimizer_base.h"
+
+namespace tensorflow {
+namespace grappler {
+
+// This optimization sets the slack attr of the terminal PrefetchDataset node in
+// an input pipeline.
+class Slack : public TFDataOptimizerBase {
+ public:
+  Slack() = default;
+  ~Slack() override = default;
+
+  string name() const override { return "slack"; };
+
+  bool UsesFunctionLibrary() const override { return false; }
+
+  Status Init(
+      const tensorflow::RewriterConfig_CustomGraphOptimizer* config) override {
+    if (!config) return errors::InvalidArgument("Config parameter required.");
+
+    const string& slack_period_param =
+        config->parameter_map().at("slack_period").s();
+    if (!absl::SimpleAtoi(slack_period_param, &slack_period_)) {
+      return errors::InvalidArgument("Invalid `slack_period` parameter: ",
+                                     slack_period_param);
+    }
+    return OkStatus();
+  }
+
+  Status OptimizeAndCollectStats(Cluster* cluster, const GrapplerItem& item,
+                                 GraphDef* output,
+                                 OptimizationStats* stats) override;
+
+ private:
+  int64_t slack_period_ = -1;
+
+  Status RecursivelyHandleOp(const MutableGraphView& graph,
+                             NodeDef* dataset_node);
+};
+
+}  // namespace grappler
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_SLACK_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/split_utils.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/split_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..ac9951952fccac3a20b4e7645b9b9db45eb17de2
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/split_utils.h
@@ -0,0 +1,76 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_SPLIT_UTILS_H_
+#define TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_SPLIT_UTILS_H_
+
+#include <vector>
+
+#include "absl/container/flat_hash_set.h"
+#include "tensorflow/core/framework/function.h"
+#include "tensorflow/core/platform/statusor.h"
+
+namespace tensorflow {
+namespace grappler {
+namespace split_utils {
+
+// Return value of `SplitFunction`, which is described below.
+struct SplitResults {
+  FunctionDef first_function;
+  FunctionDef second_function;
+  std::vector<DataType> first_function_output_types;
+};
+
+// Splits a FunctionDef into two FunctionDefs, called `first` and `second`, such
+// that calling `function(*args)` is equivalent to calling
+// `second(first(*args))`. The set `nodes_in_first_function` specifies nodes
+// that are copied to `first`, and the other nodes are copied to `second`. Any
+// edges from `first` to `second` will be represented by an output of `first`
+// and a corresponding input of `second`. The caller must pass
+// `nodes_in_first_function` such that there will not be any edges from `second`
+// to `first`.
+//
+// For example, if you have the following function (using Python syntax):
+//
+//     def f(x):
+//       y = tf.math.add(x, 1., name='add')
+//       return tf.multiply(y, 2, name='mul')
+//
+// Calling SplitFunction(f, {'add'}) results in:
+//
+//     def first_function(x):
+//       return tf.math.add(x, 1., name='add')
+//     def second_function(y):
+//       return tf.multiply(y, 2, name='mul')
+//
+// The `num_captured_inputs` argument controls which arguments of `function`
+// will be arguments of `second`. If it is zero, the only arguments of `second`
+// are the outputs of `first`. If it is above zero, the last
+// `num_caputured_inputs` arguments of `function` will also be arguments of
+// `second`.
+//
+// Splitting functions in certain cases is unimplemented, in which case an
+// Unimplemented status will be returned. Grappler passes must gracefully handle
+// Unimplemented statuses without returning the error to its caller.
+StatusOr<SplitResults> SplitFunction(
+    const FunctionDef& function,
+    const absl::flat_hash_set<absl::string_view>& nodes_in_first_function,
+    int64_t num_captured_inputs, const FunctionLibraryDefinition& library);
+
+}  // namespace split_utils
+}  // namespace grappler
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_SPLIT_UTILS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/use_private_thread_pool.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/use_private_thread_pool.h
new file mode 100644
index 0000000000000000000000000000000000000000..8f2868af3852afb4c9bc854ba3af1e3d44166e14
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/data/use_private_thread_pool.h
@@ -0,0 +1,47 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_USE_PRIVATE_THREAD_POOL_H_
+#define TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_USE_PRIVATE_THREAD_POOL_H_
+
+#include "tensorflow/core/grappler/optimizers/data/optimizer_base.h"
+
+namespace tensorflow {
+namespace grappler {
+
+// This optimization creates private thread pool for the input pipeline.
+class UsePrivateThreadPool : public TFDataOptimizerBase {
+ public:
+  UsePrivateThreadPool() = default;
+  ~UsePrivateThreadPool() override = default;
+
+  string name() const override { return "use_private_thread_pool"; };
+
+  bool UsesFunctionLibrary() const override { return false; }
+
+  Status Init(
+      const tensorflow::RewriterConfig_CustomGraphOptimizer* config) override {
+    return OkStatus();
+  }
+
+  Status OptimizeAndCollectStats(Cluster* cluster, const GrapplerItem& item,
+                                 GraphDef* output,
+                                 OptimizationStats* stats) override;
+};
+
+}  // namespace grappler
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DATA_USE_PRIVATE_THREAD_POOL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/debug_stripper.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/debug_stripper.h
new file mode 100644
index 0000000000000000000000000000000000000000..ab081f85a7b87f7b37ccf9272be6472872c6d6d5
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/debug_stripper.h
@@ -0,0 +1,42 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DEBUG_STRIPPER_H_
+#define TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DEBUG_STRIPPER_H_
+
+#include "tensorflow/core/grappler/optimizers/graph_optimizer.h"
+
+namespace tensorflow {
+namespace grappler {
+
+// DebugStripper strips off debug-related nodes (e.g.
+// Assert, CheckNumerics, Print) from the graph.
+class DebugStripper : public GraphOptimizer {
+ public:
+  DebugStripper() {}
+  ~DebugStripper() override {}
+
+  string name() const override { return "debug_stripper"; };
+
+  bool UsesFunctionLibrary() const override { return false; }
+
+  Status Optimize(Cluster* cluster, const GrapplerItem& item,
+                  GraphDef* output) override;
+};
+
+}  // end namespace grappler
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DEBUG_STRIPPER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/dependency_optimizer.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/dependency_optimizer.h
new file mode 100644
index 0000000000000000000000000000000000000000..4251a4a559efdd671488e202b2c89aea2e9991cd
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/dependency_optimizer.h
@@ -0,0 +1,85 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DEPENDENCY_OPTIMIZER_H_
+#define TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DEPENDENCY_OPTIMIZER_H_
+
+#include <unordered_set>
+#include "tensorflow/core/grappler/optimizers/graph_optimizer.h"
+#include "tensorflow/core/grappler/utils.h"
+#include "tensorflow/core/protobuf/rewriter_config.pb.h"
+
+namespace tensorflow {
+namespace grappler {
+
+// Optimize TF computations by removing control dependencies or re-arranging
+// them to shorten the critical path for a model step or enable other
+// optimizations, such as removing nodes that are effectively noops.
+class DependencyOptimizer : public GraphOptimizer {
+ public:
+  DependencyOptimizer() {}
+  explicit DependencyOptimizer(RewriterConfig::Toggle opt_level) {}
+  ~DependencyOptimizer() override {}
+
+  string name() const override { return "dependency_optimizer"; };
+
+  bool UsesFunctionLibrary() const override { return false; }
+
+  Status Optimize(Cluster* cluster, const GrapplerItem& item,
+                  GraphDef* optimized_graph) override;
+
+ private:
+  // Returns true if bypassing node does not increase the number of edges or
+  // number of edges crossing a device boundary.
+  bool BypassingNodeIsBeneficial(
+      const NodeDef& node, const std::vector<NodeDef*>& input_nodes,
+      const std::vector<NodeDef*>& output_nodes) const;
+  int NumEdgesIfBypassed(const NodeDef& node,
+                         const std::vector<NodeDef*>& output_nodes) const;
+  // Returns true if node is not an Identity node or if it is an Identity
+  // that is safe to remove.
+  bool SafeToRemoveIdentity(const NodeDef& node) const;
+  // Returns true if it is safe to convert node to NoOp.
+  bool SafeToConvertToNoOp(const NodeDef& node) const;
+  // Removes all duplicate control dependencies.
+  void CleanControlInputs();
+  // Builds a map from the &optimized_graph_->node(i) to i.
+  void BuildNodeToIdx();
+  // Tries to optimize the node with the given index, possibly additional
+  // optimizations by inserting nodes in nodes_to_simplify, and pruning nodes by
+  // inserting them in nodes_to_delete.
+  void OptimizeNode(int node_idx, SetVector<int>* nodes_to_simplify,
+                    std::set<int>* nodes_to_delete);
+  // Eliminates redundant control dependencies by computing the transitive
+  // reduction of the graph.
+  Status TransitiveReduction();
+  // Main driver of dependency optimizations.
+  Status OptimizeDependencies();
+  // Replaces multiple cross-device control edges from the same device with a
+  // single control edge.  If `host_granularity` is true then group control
+  // edges from all devices on the same host.
+  void GroupCrossDeviceControlEdges(bool host_granularity);
+
+  bool fetch_nodes_known_;
+  std::unordered_set<string> nodes_to_preserve_;
+  std::unique_ptr<NodeMap> node_map_;
+  std::unordered_map<const NodeDef*, int> node_to_idx_;
+  GraphDef* optimized_graph_;  // Not owned.
+};
+
+}  // end namespace grappler
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_DEPENDENCY_OPTIMIZER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/evaluation_utils.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/evaluation_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..dd7b87777fd324eb5eaaca82013181bde21fe0d7
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/evaluation_utils.h
@@ -0,0 +1,61 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_EVALUATION_UTILS_H_
+#define TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_EVALUATION_UTILS_H_
+
+#define EIGEN_USE_THREADS
+
+#include "tensorflow/core/framework/device_base.h"
+#include "tensorflow/core/framework/node_def.pb.h"
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/tensor.pb.h"
+#include "tensorflow/core/lib/gtl/inlined_vector.h"
+
+namespace Eigen {
+class ThreadPoolInterface;
+class ThreadPoolWrapper;
+}  // namespace Eigen
+
+namespace tensorflow {
+namespace grappler {
+
+class DeviceSimple : public DeviceBase {
+ public:
+  DeviceSimple();
+  ~DeviceSimple();
+
+  Status MakeTensorFromProto(const TensorProto& tensor_proto,
+                             const AllocatorAttributes alloc_attrs,
+                             Tensor* tensor) override;
+
+  Allocator* GetAllocator(AllocatorAttributes attr) override {
+    return cpu_allocator();
+  }
+
+ private:
+  DeviceBase::CpuWorkerThreads eigen_worker_threads_;
+  std::unique_ptr<Eigen::ThreadPoolDevice> eigen_device_;
+};
+
+Status EvaluateNode(const NodeDef& node,
+                    const gtl::InlinedVector<TensorValue, 4>& inputs,
+                    DeviceBase* cpu_device, ResourceMgr* resource_mgr,
+                    gtl::InlinedVector<TensorValue, 4>* output);
+
+}  // end namespace grappler
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_EVALUATION_UTILS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/function_api_info.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/function_api_info.h
new file mode 100644
index 0000000000000000000000000000000000000000..c32cd5c9ca4c04c10acec9fb93e9d556ee995ce4
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/function_api_info.h
@@ -0,0 +1,106 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_FUNCTION_API_INFO_H_
+#define TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_FUNCTION_API_INFO_H_
+
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include "absl/container/flat_hash_map.h"
+#include "tensorflow/core/framework/function.pb.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/framework/types.pb.h"
+#include "tensorflow/core/lib/core/status.h"
+
+namespace tensorflow {
+namespace grappler {
+class FunctionApiInfo {
+ public:
+  FunctionApiInfo();
+  virtual ~FunctionApiInfo();
+
+  enum FunctionType {
+    INFERENCE,  // Default type.
+    FORWARD,
+    BACKWARD,
+  };
+
+  Status Init(const FunctionDef& function_def);
+
+  const string& interface_name() const;
+  const string& preferred_device() const;
+  const FunctionType function_type() const;
+  const string& pairing_function_name() const;
+  const DataTypeVector& input_arg_dtypes() const;
+  const DataTypeVector& output_arg_dtypes() const;
+
+ private:
+  string interface_name_;
+  string preferred_device_;
+  FunctionType function_type_;
+  // The pairing function is used to pair between forward and backward function,
+  // which will be useful during function swapping. Inference function won't
+  // have pairing function.
+  string pairing_function_name_;
+  // The following two attributes are useful for forward and backward functions.
+  DataTypeVector input_arg_dtypes_;
+  DataTypeVector output_arg_dtypes_;
+
+  FunctionApiInfo(const FunctionApiInfo&) = delete;
+  void operator=(const FunctionApiInfo&) = delete;
+};
+
+// A collection of information for function and the interface it implements.
+// A interface is a well defined math operation, eg I1 = 2 * x + y. Multiple
+// functions could implement the same interface with different behavior based on
+// different hardware condition and limits,
+// eg F1 = math_ops.add(math_ops.add(x, x), y), or
+//    F2 = math_ops.add(math_ops.matmul(x, 2), y).
+class FunctionLibraryApiInfo {
+ public:
+  FunctionLibraryApiInfo();
+  virtual ~FunctionLibraryApiInfo();
+  // Populate the internal field for the functions within the function_library.
+  Status Init(const FunctionDefLibrary& function_library);
+
+  Status GetEquivalentImplementations(
+      const string& function_name, std::vector<string>* other_functions) const;
+
+  const FunctionApiInfo* GetApiInfo(const string& function_name) const;
+  bool empty() const { return func_info_.empty(); }
+  std::size_t size() const { return func_info_.size(); }
+
+ private:
+  // Map between function name to function details.
+  std::unordered_map<string, std::unique_ptr<FunctionApiInfo>> func_info_;
+
+  // Map between interface name to function names.
+  // Forward/backward function pair usually have different signatures between
+  // each other since forward function could produce extra internal state as
+  // output, and backward will take those extra state as inputs.
+  absl::flat_hash_map<string, std::vector<string>> intf_to_inference_funcs_;
+  absl::flat_hash_map<string, std::vector<string>> intf_to_forward_funcs_;
+  absl::flat_hash_map<string, std::vector<string>> intf_to_backward_funcs_;
+
+  FunctionLibraryApiInfo(const FunctionLibraryApiInfo&) = delete;
+  void operator=(const FunctionLibraryApiInfo&) = delete;
+};
+
+}  // end namespace grappler
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_FUNCTION_API_INFO_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/function_optimizer.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/function_optimizer.h
new file mode 100644
index 0000000000000000000000000000000000000000..7b2712c9a7b2818a65ae558630b8779053055591
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/function_optimizer.h
@@ -0,0 +1,59 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_FUNCTION_OPTIMIZER_H_
+#define TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_FUNCTION_OPTIMIZER_H_
+
+#include "tensorflow/core/grappler/optimizers/graph_optimizer.h"
+#include "tensorflow/core/protobuf/rewriter_config.pb.h"
+
+namespace tensorflow {
+namespace grappler {
+
+// Remap TensorFlow subgraphs onto alternative operations or collection of
+// operations to make the overall graph more efficient.
+class FunctionOptimizer : public GraphOptimizer {
+ public:
+  explicit FunctionOptimizer(RewriterConfig::Toggle opt_level,
+                             bool lower_control_flow)
+      : opt_level_(opt_level), lower_control_flow_(lower_control_flow) {}
+  ~FunctionOptimizer() override = default;
+
+  string name() const override { return "function_optimizer"; };
+
+  bool UsesFunctionLibrary() const override { return true; }
+
+  Status Optimize(Cluster* cluster, const GrapplerItem& item,
+                  GraphDef* optimized_graph) override;
+
+ private:
+  friend class FunctionOptimizerTest;
+
+  // Runs a single function optimizer pass over the `graph`. All nodes that are
+  // not function calls will be copied from the `graph` to the
+  // `optimized_graph`. Function call nodes inlined or specialized, and
+  // instantiated function body or specialized function call nodes will be added
+  // to the `optimized_graph`.
+  Status RunFunctionOptimizerPass(const GrapplerItem& item,
+                                  GraphDef* optimized_graph) const;
+
+  RewriterConfig::Toggle opt_level_;
+  bool lower_control_flow_;
+};
+
+}  // end namespace grappler
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_FUNCTION_OPTIMIZER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/generic_layout_optimizer.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/generic_layout_optimizer.h
new file mode 100644
index 0000000000000000000000000000000000000000..a97cf4abe676d601f7c85b66a84ae32ace5204cb
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/generic_layout_optimizer.h
@@ -0,0 +1,62 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_GENERIC_LAYOUT_OPTIMIZER_H_
+#define TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_GENERIC_LAYOUT_OPTIMIZER_H_
+
+#include <string>
+
+#include "tensorflow/core/grappler/optimizers/graph_optimizer.h"
+#include "tensorflow/core/protobuf/rewriter_config.pb.h"
+
+namespace tensorflow {
+namespace grappler {
+
+// Optimize the data layout for convolutional models.
+class GenericLayoutOptimizer : public GraphOptimizer {
+ public:
+  explicit GenericLayoutOptimizer(string enforced_layout = "")
+      : GenericLayoutOptimizer(RewriterConfig::DEFAULT,
+                               RewriterConfig::NO_CONVERSION_ON_CPU,
+                               enforced_layout) {}
+  explicit GenericLayoutOptimizer(RewriterConfig::Toggle opt_level,
+                                  string enforced_layout = "")
+      : GenericLayoutOptimizer(opt_level, RewriterConfig::NO_CONVERSION_ON_CPU,
+                               enforced_layout) {}
+  explicit GenericLayoutOptimizer(RewriterConfig::Toggle opt_level,
+                                  RewriterConfig::CpuLayout layout_conversion,
+                                  string enforced_layout = "")
+      : opt_level_(opt_level),
+        cpu_layout_conversion_(layout_conversion),
+        enforced_layout_(enforced_layout) {}
+  ~GenericLayoutOptimizer() override = default;
+
+  string name() const override { return "layout"; };
+
+  bool UsesFunctionLibrary() const override { return false; }
+
+  Status Optimize(Cluster* cluster, const GrapplerItem& item,
+                  GraphDef* output) override;
+
+ private:
+  RewriterConfig::Toggle opt_level_;
+  RewriterConfig::CpuLayout cpu_layout_conversion_;
+  const string enforced_layout_;
+};
+
+}  // namespace grappler
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_GENERIC_LAYOUT_OPTIMIZER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/generic_layout_optimizer_transposer.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/generic_layout_optimizer_transposer.h
new file mode 100644
index 0000000000000000000000000000000000000000..acbac139dd919d9a84239900f20fa76ec0346089
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/generic_layout_optimizer_transposer.h
@@ -0,0 +1,673 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_GENERIC_LAYOUT_OPTIMIZER_TRANSPOSER_H_
+#define TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_GENERIC_LAYOUT_OPTIMIZER_TRANSPOSER_H_
+
+#include <memory>
+#include <vector>
+
+#include "absl/container/flat_hash_map.h"
+#include "absl/container/flat_hash_set.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/span.h"
+#include "tensorflow/core/framework/graph.pb.h"
+#include "tensorflow/core/framework/node_def.pb.h"
+#include "tensorflow/core/grappler/costs/graph_properties.h"
+#include "tensorflow/core/grappler/utils.h"
+#include "tensorflow/core/grappler/utils/frame.h"
+#include "tensorflow/core/grappler/utils/graph_view.h"
+#include "tensorflow/core/lib/core/errors.h"
+#include "tensorflow/core/lib/core/status.h"
+
+namespace tensorflow {
+namespace grappler {
+
+constexpr char kAttrSrcFormat[] = "src_format";
+constexpr char kAttrDstFormat[] = "dst_format";
+constexpr char kAttrOutputShape[] = "_output_shapes";
+constexpr char kGPU[] = "GPU";
+constexpr char kCPU[] = "CPU";
+
+// TransposeContext owns all data members. Must initialize GraphProperties,
+// FrameView, GraphDef and MutableGraphView with the same graph. NodeDef
+// pointers in FrameView, GraphDef and MutableGraphView must point to nodes in
+// the same GraphDef instance.
+struct TransposeContext {
+  // Initializes TransposeContext with given GrapplerItem. Because initializing
+  // FrameMap and GraphProperties may return error, we initialize
+  // TransposeContext outside constructor.
+  static Status InitializeTransposeContext(bool assume_valid_feeds,
+                                           const GrapplerItem& item,
+                                           const Cluster* cluster,
+                                           TransposeContext* context);
+
+  static Status InitializeTransposeContext(const GrapplerItem& item,
+                                           const Cluster* cluster,
+                                           TransposeContext* context) {
+    return InitializeTransposeContext(false, item, cluster, context);
+  }
+
+  // Sets data formats to convert from and to for specified device type.
+  void AssignDeviceAndDataFormats(absl::string_view target_device,
+                                  absl::string_view src_format,
+                                  absl::string_view dst_format);
+
+  FrameView frames;
+  GraphDef graph;
+  // Number of nodes in the original graph. As new nodes are appended to the end
+  // of the graph, all new nodes should have a node index greater than or equal
+  // to this.
+  int num_nodes;
+  absl::flat_hash_set<string> nodes_to_preserve;
+  std::unique_ptr<GraphProperties> graph_properties;
+  std::unique_ptr<utils::MutableGraphView> graph_view;
+
+  string target_device;
+  string src_format;
+  string dst_format;
+  absl::flat_hash_map<char, int> src_dim_indices;
+  absl::flat_hash_map<char, int> dst_dim_indices;
+  std::vector<int> src_to_dst;
+  std::vector<int> dst_to_src;
+
+  string enforced_layout;
+};
+
+class Transposer {
+ public:
+  explicit Transposer() {}
+
+  Transposer(const Transposer&) = delete;
+  Transposer& operator=(const Transposer&) = delete;
+
+  virtual ~Transposer() {}
+
+  // Returns true iff the node should be processed by this transposer.
+  // NodeProcessors may perform additional oprand specific checks before
+  // processing if necessary.
+  // Following common conditions are checked:
+  // * node's device matches target device
+  // * node's source format matches config's source format
+  // * node has output
+  bool ShouldProcess(const TransposeContext& context,
+                     const utils::MutableNodeView& node) const;
+
+  // Transposes given node from src format to dst format. Also perform other
+  // necessary operations to guarantee the graph produce the same result.
+  // Eg. Add Transpose node sets before fanin ports and after fanout ports.
+  virtual Status TransposeNode(TransposeContext* context,
+                               utils::MutableNodeView* node) = 0;
+
+  // Creates a Const node for permutation. If node with node_name already exits,
+  // return and reuse it.
+  Status CreateConstPermNode(TransposeContext* context,
+                             absl::string_view node_name,
+                             absl::string_view device,
+                             absl::Span<const int> permutation,
+                             absl::string_view control_node_name,
+                             utils::MutationNewNode* added_node);
+
+  // Creates a TransposeNode with given properties. If node with node_name
+  // already exits, return and reuse it.
+  // A const perm node is also created and connected to the 2nd fanin.
+  // control_node_name is ignored if it is empty.
+  Status CreateTransposeNode(
+      TransposeContext* context, absl::string_view name_format,
+      const DataType& data_type, absl::string_view device,
+      TensorShapeProto fanin_shape, absl::Span<const int> permutation,
+      absl::string_view control_node_name, utils::MutationNewNode* added_node,
+      string* transpose_node_name);
+
+  // Update all edges between dst_node->fanin[dst_ports] and dst_node by
+  // inserting an op node.
+  Status UpdateFaninEdgesWithOp(TransposeContext* context,
+                                absl::Span<const int> dst_ports,
+                                utils::MutableNodeView* dst_node,
+                                absl::string_view op);
+
+  // Update all edges between src_node:src_ports and nodes take
+  // src_node:src_ports as fanin. Also update attr _output_shape of src_node.
+  Status UpdateFanoutEdgesWithOp(TransposeContext* context,
+                                 absl::Span<const int> src_ports,
+                                 utils::MutableNodeView* src_node,
+                                 absl::string_view op);
+
+  // Creates a DataFromat node with given properties.
+  // DataFromat op is either DataFormatVecPermute or DataFormatDimMap.
+  Status CreateDataFormatNode(TransposeContext* context,
+                              absl::string_view node_name, absl::string_view op,
+                              absl::string_view device,
+                              const DataType& data_type, bool is_fanin_on_host,
+                              bool is_src_format_to_dst_format,
+                              utils::MutationNewNode* added_node);
+
+ protected:
+  int GetFanoutPortRank(const utils::MutableNodeView& node, int port) const;
+  bool IsFanoutPortRankN(const utils::MutableNodeView& node, int port,
+                         int n) const;
+  bool IsFanoutPortsRankN(const utils::MutableNodeView& node,
+                          absl::Span<const int> ports, int n) const;
+  int GetFaninPortRank(const utils::MutableNodeView& node, int port) const;
+  bool IsFaninPortRankN(const utils::MutableNodeView& node, int port,
+                        int n) const;
+
+  // Checks if fanin at specified port(s) has dimensions `dims` iff fanin is a
+  // Const. If fanin is not a Const, no dimensions will be checked and this will
+  // return true.
+  bool IsFaninPortDimsNIfConst(const utils::MutableNodeView& node, int port,
+                               absl::Span<const int> dims) const;
+  bool IsFaninPortsDimsNIfConst(const utils::MutableNodeView& node,
+                                absl::Span<const int> ports,
+                                absl::Span<const int> dims) const;
+  bool CanProcessNode(const TransposeContext& context,
+                      const utils::MutableNodeView& node) const;
+  // Update all edges between dst_node->fanin[dst_ports] and dst_node.
+  // A node with op is created and inserted between all edges.
+  // op is one of Transpose, DataFormatVecPermute or DataFormatDimMap.
+  Status UpdateEdge(TransposeContext* context, absl::string_view name_format,
+                    absl::string_view op, const AttrValue* input_shape,
+                    bool is_in_frame, bool is_src_format_to_dst_format,
+                    const int src_port, const int dst_port,
+                    utils::MutableNodeView* src_node,
+                    utils::MutableNodeView* dst_node);
+  string GetFaninNameFormat(absl::string_view node_name, int port,
+                            absl::string_view src_format,
+                            absl::string_view dst_format);
+  string GetFanoutNameFormat(absl::string_view node_name, int port, int index,
+                             absl::string_view src_format,
+                             absl::string_view dst_format);
+  string LayoutOptimizerNode(absl::string_view node_name);
+  string GetReshapeNodeNameFormat(absl::string_view node_name, int index,
+                                  absl::string_view src_format,
+                                  absl::string_view dst_format);
+  string GetShapeConstNodeNameFormat(absl::string_view node_name, int index);
+};
+
+class LayoutSensitiveOpTransposer : public Transposer {
+ public:
+  explicit LayoutSensitiveOpTransposer() : Transposer() {}
+
+  // Updates attrs data_format, ksize, strides of the given node to dst_format.
+  // _output_shape is updated during UpdateOutputEdges.
+  Status UpdateNode(TransposeContext* context, utils::MutableNodeView* node);
+};
+
+// Layout sensitive op transposers.
+
+class DefaultLayoutSensitiveOpTransposer : public LayoutSensitiveOpTransposer {
+ public:
+  explicit DefaultLayoutSensitiveOpTransposer()
+      : LayoutSensitiveOpTransposer() {}
+
+  Status TransposeNode(TransposeContext* context,
+                       utils::MutableNodeView* node) override;
+};
+
+class BiasAddTransposer : public LayoutSensitiveOpTransposer {
+ public:
+  explicit BiasAddTransposer() : LayoutSensitiveOpTransposer() {}
+
+  Status TransposeNode(TransposeContext* context,
+                       utils::MutableNodeView* node) override;
+};
+
+class AvgPoolGradTransposer : public LayoutSensitiveOpTransposer {
+ public:
+  explicit AvgPoolGradTransposer() : LayoutSensitiveOpTransposer() {}
+
+  Status TransposeNode(TransposeContext* context,
+                       utils::MutableNodeView* node) override;
+};
+
+class BiasAddGradTransposer : public LayoutSensitiveOpTransposer {
+ public:
+  explicit BiasAddGradTransposer() : LayoutSensitiveOpTransposer() {}
+
+  Status TransposeNode(TransposeContext* context,
+                       utils::MutableNodeView* node) override;
+};
+
+class Conv2DBackpropFilterTransposer : public LayoutSensitiveOpTransposer {
+ public:
+  explicit Conv2DBackpropFilterTransposer() : LayoutSensitiveOpTransposer() {}
+
+  Status TransposeNode(TransposeContext* context,
+                       utils::MutableNodeView* node) override;
+};
+
+class Conv2DBackpropInputTransposer : public LayoutSensitiveOpTransposer {
+ public:
+  explicit Conv2DBackpropInputTransposer() : LayoutSensitiveOpTransposer() {}
+
+  Status TransposeNode(TransposeContext* context,
+                       utils::MutableNodeView* node) override;
+};
+
+class Conv3DTransposer : public LayoutSensitiveOpTransposer {
+ public:
+  explicit Conv3DTransposer() : LayoutSensitiveOpTransposer() {}
+
+  Status TransposeNode(TransposeContext* context,
+                       utils::MutableNodeView* node) override;
+};
+
+class Conv3DBackpropFilterTransposer : public LayoutSensitiveOpTransposer {
+ public:
+  explicit Conv3DBackpropFilterTransposer() : LayoutSensitiveOpTransposer() {}
+
+  Status TransposeNode(TransposeContext* context,
+                       utils::MutableNodeView* node) override;
+};
+
+class Conv3DBackpropInputTransposer : public LayoutSensitiveOpTransposer {
+ public:
+  explicit Conv3DBackpropInputTransposer() : LayoutSensitiveOpTransposer() {}
+
+  Status TransposeNode(TransposeContext* context,
+                       utils::MutableNodeView* node) override;
+};
+
+class FusedBatchNormExTransposer : public LayoutSensitiveOpTransposer {
+ public:
+  explicit FusedBatchNormExTransposer() : LayoutSensitiveOpTransposer() {}
+
+  Status TransposeNode(TransposeContext* context,
+                       utils::MutableNodeView* node) override;
+};
+
+class FusedBatchNormGradTransposer : public LayoutSensitiveOpTransposer {
+ public:
+  explicit FusedBatchNormGradTransposer() : LayoutSensitiveOpTransposer() {}
+
+  Status TransposeNode(TransposeContext* context,
+                       utils::MutableNodeView* node) override;
+
+ private:
+  bool IsTraining(const utils::MutableNodeView& node) const;
+};
+
+class MaxPoolV2Transposer : public LayoutSensitiveOpTransposer {
+ public:
+  explicit MaxPoolV2Transposer() : LayoutSensitiveOpTransposer() {}
+
+  Status TransposeNode(TransposeContext* context,
+                       utils::MutableNodeView* node) override;
+};
+
+class MaxPool3DTransposer : public LayoutSensitiveOpTransposer {
+ public:
+  explicit MaxPool3DTransposer() : LayoutSensitiveOpTransposer() {}
+
+  Status TransposeNode(TransposeContext* context,
+                       utils::MutableNodeView* node) override;
+};
+
+class MaxPoolGradTransposer : public LayoutSensitiveOpTransposer {
+ public:
+  explicit MaxPoolGradTransposer() : LayoutSensitiveOpTransposer() {}
+
+  Status TransposeNode(TransposeContext* context,
+                       utils::MutableNodeView* node) override;
+};
+
+class MaxPoolGradV2Transposer : public LayoutSensitiveOpTransposer {
+ public:
+  explicit MaxPoolGradV2Transposer() : LayoutSensitiveOpTransposer() {}
+
+  Status TransposeNode(TransposeContext* context,
+                       utils::MutableNodeView* node) override;
+};
+
+// Layout agnostic op transposers.
+
+class LayoutAgnosticOpTransposer : public Transposer {
+ public:
+  explicit LayoutAgnosticOpTransposer() : Transposer() {}
+
+ protected:
+  bool IsAfterDstToSrcTransform(const TransposeContext& context,
+                                const utils::MutableNodeView& node) const;
+
+  std::vector<int> GetVariadicNDFaninPorts(const TransposeContext& context,
+                                           const utils::MutableNodeView& node,
+                                           int rank) const;
+};
+
+class DefaultLayoutAgnosticOpTransposer : public LayoutAgnosticOpTransposer {
+ public:
+  explicit DefaultLayoutAgnosticOpTransposer() : LayoutAgnosticOpTransposer() {}
+
+  Status TransposeNode(TransposeContext* context,
+                       utils::MutableNodeView* node) override;
+};
+
+class AddNTransposer : public LayoutAgnosticOpTransposer {
+ public:
+  explicit AddNTransposer() : LayoutAgnosticOpTransposer() {}
+
+  Status TransposeNode(TransposeContext* context,
+                       utils::MutableNodeView* node) override;
+};
+
+class BinaryOpTransposer : public LayoutAgnosticOpTransposer {
+ public:
+  explicit BinaryOpTransposer() : LayoutAgnosticOpTransposer() {}
+
+  Status TransposeNode(TransposeContext* context,
+                       utils::MutableNodeView* node) override;
+
+ private:
+  bool IsNDOperateWithMD(const utils::MutableNodeView& node, int n, int m);
+  bool IsFaninShapeSupported(const utils::MutableNodeView& node, int rank);
+  std::vector<int> GetNDDataFaninPorts(const utils::MutableNodeView& node,
+                                       int rank);
+  Status AddNodeShapeConst(utils::Mutation* mutation,
+                           absl::string_view node_name,
+                           absl::string_view node_device, bool node_in_frame,
+                           int num_channels, absl::string_view depended_node,
+                           int rank);
+  Status AddNodeReshape(utils::Mutation* mutation, absl::string_view node_name,
+                        absl::string_view node_device,
+                        absl::string_view input_name,
+                        absl::string_view shape_const_node_name,
+                        const DataType& data_type);
+  Status MaybeReshapeVectorFanin(TransposeContext* context,
+                                 utils::MutableNodeView* node, int rank);
+};
+
+class ConcatOpTransposer : public LayoutAgnosticOpTransposer {
+ public:
+  explicit ConcatOpTransposer() : LayoutAgnosticOpTransposer() {}
+
+  Status TransposeNode(TransposeContext* context,
+                       utils::MutableNodeView* node) override;
+};
+
+class FillOpTransposer : public LayoutAgnosticOpTransposer {
+ public:
+  explicit FillOpTransposer() : LayoutAgnosticOpTransposer() {}
+
+  Status TransposeNode(TransposeContext* context,
+                       utils::MutableNodeView* node) override;
+};
+
+class IdentityNTransposer : public LayoutAgnosticOpTransposer {
+ public:
+  explicit IdentityNTransposer() : LayoutAgnosticOpTransposer() {}
+
+  Status TransposeNode(TransposeContext* context,
+                       utils::MutableNodeView* node) override;
+};
+
+class MergeTransposer : public LayoutAgnosticOpTransposer {
+ public:
+  explicit MergeTransposer() : LayoutAgnosticOpTransposer() {}
+
+  Status TransposeNode(TransposeContext* context,
+                       utils::MutableNodeView* node) override;
+
+ private:
+  bool IsEveryFaninAfterDstToSrcTransform(
+      const TransposeContext& context,
+      const utils::MutableNodeView& node) const;
+};
+
+class PadTransposer : public LayoutAgnosticOpTransposer {
+ public:
+  explicit PadTransposer() : LayoutAgnosticOpTransposer() {}
+
+  Status TransposeNode(TransposeContext* context,
+                       utils::MutableNodeView* node) override;
+};
+
+class ReduceTransposer : public LayoutAgnosticOpTransposer {
+ public:
+  explicit ReduceTransposer() : LayoutAgnosticOpTransposer() {}
+
+  Status TransposeNode(TransposeContext* context,
+                       utils::MutableNodeView* node) override;
+
+ private:
+  bool KeepDims(const utils::MutableNodeView& node);
+  bool IsAlongAxis(const Tensor& tensor, absl::Span<const int> axis, int rank);
+  bool IsReduceAxisSupported(const TransposeContext& context,
+                             const utils::MutableNodeView& node, int rank);
+};
+
+class ReverseV2Transposer : public LayoutAgnosticOpTransposer {
+ public:
+  explicit ReverseV2Transposer() : LayoutAgnosticOpTransposer() {}
+
+  Status TransposeNode(TransposeContext* context,
+                       utils::MutableNodeView* node) override;
+};
+
+class SelectTransposer : public LayoutAgnosticOpTransposer {
+ public:
+  explicit SelectTransposer() : LayoutAgnosticOpTransposer() {}
+
+  Status TransposeNode(TransposeContext* context,
+                       utils::MutableNodeView* node) override;
+
+ protected:
+  bool IsFaninScalarVector4D(const utils::MutableNodeView& fanin, int port);
+  std::vector<int> GetFaninPorts(const utils::MutableNodeView& fanin, int port);
+};
+
+class ShapeTransposer : public LayoutAgnosticOpTransposer {
+ public:
+  explicit ShapeTransposer() : LayoutAgnosticOpTransposer() {}
+
+  Status TransposeNode(TransposeContext* context,
+                       utils::MutableNodeView* node) override;
+};
+
+class ShapeNTransposer : public LayoutAgnosticOpTransposer {
+ public:
+  explicit ShapeNTransposer() : LayoutAgnosticOpTransposer() {}
+
+  Status TransposeNode(TransposeContext* context,
+                       utils::MutableNodeView* node) override;
+};
+
+class SliceTransposer : public LayoutAgnosticOpTransposer {
+ public:
+  explicit SliceTransposer() : LayoutAgnosticOpTransposer() {}
+
+  Status TransposeNode(TransposeContext* context,
+                       utils::MutableNodeView* node) override;
+};
+
+class SplitTransposer : public LayoutAgnosticOpTransposer {
+ public:
+  explicit SplitTransposer() : LayoutAgnosticOpTransposer() {}
+
+  Status TransposeNode(TransposeContext* context,
+                       utils::MutableNodeView* node) override;
+};
+
+class SplitVTransposer : public LayoutAgnosticOpTransposer {
+ public:
+  explicit SplitVTransposer() : LayoutAgnosticOpTransposer() {}
+
+  Status TransposeNode(TransposeContext* context,
+                       utils::MutableNodeView* node) override;
+};
+
+class SqueezeTransposer : public LayoutAgnosticOpTransposer {
+ public:
+  explicit SqueezeTransposer() : LayoutAgnosticOpTransposer() {}
+
+  Status TransposeNode(TransposeContext* context,
+                       utils::MutableNodeView* node) override;
+
+ private:
+  bool IsInputConvertible(const TransposeContext& context,
+                          const utils::MutableNodeView& node) const;
+  bool IsAlongAxis(const AttrValue& attr, absl::Span<const int> axis,
+                   int rank) const;
+  bool IsDimsSupported(const TransposeContext& context,
+                       const utils::MutableNodeView& node) const;
+  Status UpdateSqueezeDims(TransposeContext* context,
+                           utils::MutableNodeView* node);
+};
+
+class StridedSliceTransposer : public LayoutAgnosticOpTransposer {
+ public:
+  explicit StridedSliceTransposer() : LayoutAgnosticOpTransposer() {}
+
+  Status TransposeNode(TransposeContext* context,
+                       utils::MutableNodeView* node) override;
+
+ private:
+  bool IsMaskZero(const utils::MutableNodeView& node, absl::string_view mask);
+  bool HasOnlyBeginEndMask(const utils::MutableNodeView& node);
+  Status PermuteMask(TransposeContext* context, utils::MutableNodeView* node,
+                     absl::string_view mask);
+};
+
+class SwitchTransposer : public LayoutAgnosticOpTransposer {
+ public:
+  explicit SwitchTransposer() : LayoutAgnosticOpTransposer() {}
+
+  Status TransposeNode(TransposeContext* context,
+                       utils::MutableNodeView* node) override;
+};
+
+class TernaryOpTransposer : public LayoutAgnosticOpTransposer {
+ public:
+  explicit TernaryOpTransposer() : LayoutAgnosticOpTransposer() {}
+
+  Status TransposeNode(TransposeContext* context,
+                       utils::MutableNodeView* node) override;
+};
+
+class TileTransposer : public LayoutAgnosticOpTransposer {
+ public:
+  explicit TileTransposer() : LayoutAgnosticOpTransposer() {}
+
+  Status TransposeNode(TransposeContext* context,
+                       utils::MutableNodeView* node) override;
+};
+
+class UnaryGradTransposer : public LayoutAgnosticOpTransposer {
+ public:
+  explicit UnaryGradTransposer() : LayoutAgnosticOpTransposer() {}
+
+  Status TransposeNode(TransposeContext* context,
+                       utils::MutableNodeView* node) override;
+};
+
+// Utils.
+
+// Permutes elements according to permutation and replaces the original values.
+// Permutation and values must have same size.
+template <typename T>
+Status PermuteSingle(absl::string_view location,
+                     absl::Span<const int> permutation, T* values) {
+  DCHECK(values != nullptr);
+  int permutation_size = permutation.size();
+  if (values->size() != permutation_size) {
+    return Status(absl::StatusCode::kInvalidArgument,
+                  absl::StrCat("Size of values ", values->size(),
+                               " does not match size of permutation ",
+                               permutation_size, " @ ", location));
+  }
+  typedef typename T::value_type V;
+  std::vector<V> elements(values->begin(), values->end());
+  int index = 0;
+  for (V& element : *values) {
+    element = elements[permutation[index++]];
+  }
+  return OkStatus();
+}
+
+// Permutes two elements at a time according to permutation and replaces the
+// original values. Values must be twice the size of permutation.
+template <typename T>
+Status PermuteDouble(absl::string_view location,
+                     absl::Span<const int> permutation, T* values) {
+  DCHECK(values != nullptr);
+  int permutation_size = permutation.size();
+  if (values->size() != permutation_size * 2) {
+    return Status(absl::StatusCode::kInvalidArgument,
+                  absl::StrCat("Size of values ", values->size(),
+                               " does not match twice the size of permutation ",
+                               permutation_size, " @ ", location));
+  }
+  typedef typename T::value_type V;
+  std::vector<V> elements(values->begin(), values->end());
+  for (int i = 0; i < values->size(); i = i + 2) {
+    const int permutation_index = permutation[i / 2];
+    (*values)[i] = elements[permutation_index * 2];
+    (*values)[i + 1] = elements[permutation_index * 2 + 1];
+  }
+  return OkStatus();
+}
+
+string GetDeviceName(const NodeDef& node);
+
+bool IsDefaultLayoutSensitiveOp(const NodeDef& node);
+
+bool IsLayoutSensitiveOp(const NodeDef& node);
+
+bool IsDefaultLayoutAgnosticOp(const NodeDef& node);
+
+bool IsLayoutAgnosticOp(const NodeDef& node);
+
+bool IsTernaryOp(const NodeDef& node);
+
+bool IsUnaryGrad(const NodeDef& node);
+
+bool IsMaxPoolV2(const NodeDef& node);
+
+bool IsMaxPool3D(const NodeDef& node);
+
+bool IsMaxPoolGradV2(const NodeDef& node);
+
+bool IsMaxPoolGradGradV1(const NodeDef& node);
+
+bool IsMaxPoolGradGradV2(const NodeDef& node);
+
+bool IsBinaryOp(const NodeDef& node);
+
+bool IsReduceOp(const NodeDef& node);
+
+std::vector<int> GetDataFaninPorts(const utils::MutableNodeView& node);
+
+std::vector<int> GetDataFanoutPorts(const utils::MutableNodeView& node);
+
+// Returns a value of constant input to the `node` at `index`, iff `predicate`
+// evaluated to true. Returns true if `tensor` was populated with data.
+bool GetValueAttrFromConstInputNode(
+    const utils::MutableNodeView& node,
+    const std::function<bool(const NodeDef&)>& predicate, int index,
+    Tensor* tensor);
+
+bool IsDataFormatOp(const utils::MutableNodeView& node);
+
+absl::flat_hash_map<char, int> GetDimensionIndices(
+    absl::string_view data_format);
+
+std::vector<int> GetPermutation(
+    const absl::flat_hash_map<char, int>& src_dim_indices,
+    absl::string_view dst_format);
+
+}  // namespace grappler
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_GENERIC_LAYOUT_OPTIMIZER_TRANSPOSER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/generic_layout_optimizer_transposer_factory.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/generic_layout_optimizer_transposer_factory.h
new file mode 100644
index 0000000000000000000000000000000000000000..a31b1ca67797bd6267c85e190af42be36c6ae21a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/generic_layout_optimizer_transposer_factory.h
@@ -0,0 +1,49 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_GENERIC_LAYOUT_OPTIMIZER_TRANSPOSER_FACTORY_H_
+#define TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_GENERIC_LAYOUT_OPTIMIZER_TRANSPOSER_FACTORY_H_
+
+#include <memory>
+
+#include "absl/container/flat_hash_map.h"
+#include "tensorflow/core/grappler/optimizers/generic_layout_optimizer_transposer.h"
+
+namespace tensorflow {
+namespace grappler {
+
+class TransposerFactory {
+ public:
+  explicit TransposerFactory() {}
+
+  std::shared_ptr<Transposer> GetTransposer(const NodeDef& node);
+
+ protected:
+  template <typename T>
+  std::shared_ptr<Transposer> GetOrCreateIfNotFound(const string& key) {
+    auto& transposer = transposer_map_[key];
+    if (transposer == nullptr) {
+      transposer = std::make_shared<T>();
+    }
+    return transposer;
+  }
+
+  absl::flat_hash_map<string, std::shared_ptr<Transposer>> transposer_map_;
+};
+
+}  // end namespace grappler
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_GENERIC_LAYOUT_OPTIMIZER_TRANSPOSER_FACTORY_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/graph_optimizer.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/graph_optimizer.h
new file mode 100644
index 0000000000000000000000000000000000000000..cf38fd2c4475f4adebd0ae1049050801b3bfb569
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/graph_optimizer.h
@@ -0,0 +1,93 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_GRAPH_OPTIMIZER_H_
+#define TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_GRAPH_OPTIMIZER_H_
+
+#include <string>
+
+#include "absl/status/status.h"
+#include "tensorflow/core/framework/graph.pb.h"
+#include "tensorflow/core/platform/env.h"
+#include "tensorflow/core/platform/errors.h"
+#include "tensorflow/core/platform/status.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+namespace grappler {
+
+class Cluster;
+struct GrapplerItem;
+
+// An abstract interface for an algorithm for generating a candidate
+// optimization of a GrapplerItem for running on a cluster.
+class GraphOptimizer {
+ public:
+  GraphOptimizer() : deadline_usec_(0) {}
+  virtual ~GraphOptimizer() {}
+
+  virtual string name() const = 0;
+
+  // Returns true if the optimizer requires a valid function library to perform
+  // graph optimization. If false, optimized GrapplerItem will have a stub
+  // instead of real function library (all function signatures and attributes
+  // will be valid, but function body will be empty). Most of the optimizers
+  // that do not instantiate functions should return true.
+  virtual bool UsesFunctionLibrary() const = 0;
+
+  // Routine called to allow an algorithm to propose a rewritten graph
+  // for the graph, feeds and fetches in "item" to run more efficiently
+  // on "cluster". If the returned status is OkStatus() then
+  // *optimized_graph contains the rewritten graph.
+  // Returns an error status if it failed to generate a solution.
+  //
+  // A return value of error::Aborted() can be used signal early termination of
+  // the optimizer, e.g. if the optimization turned out to be a no-op. In this
+  // case the content of *optimized_graph is undefined.
+  virtual Status Optimize(Cluster* cluster, const GrapplerItem& item,
+                          GraphDef* optimized_graph) = 0;
+
+  // Subclasses may define a version of Optimize that consumes item.
+  virtual Status Optimize(Cluster* cluster, GrapplerItem&& item,
+                          GraphDef* optimized_graph) {
+    return Optimize(cluster, item, optimized_graph);
+  }
+
+  // Set deadline in microseconds since epoch. A value of zero means no
+  // deadline.
+  void set_deadline_usec(uint64 deadline_usec) {
+    deadline_usec_ = deadline_usec;
+  }
+  uint64 deadline_usec() const { return deadline_usec_; }
+  bool DeadlineExceeded() const {
+    return deadline_usec_ > 0 && Env::Default()->NowMicros() > deadline_usec_;
+  }
+
+ private:
+  uint64 deadline_usec_;
+};
+
+#define GRAPPLER_RETURN_IF_DEADLINE_EXCEEDED()                \
+  do {                                                        \
+    if (this->DeadlineExceeded()) {                           \
+      return absl::DeadlineExceededError(                     \
+          absl::StrCat(this->name(), " exceeded deadline.")); \
+    }                                                         \
+  } while (0)
+
+}  // end namespace grappler
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_GRAPH_OPTIMIZER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/graph_optimizer_stage.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/graph_optimizer_stage.h
new file mode 100644
index 0000000000000000000000000000000000000000..00d4a2109a69e5b404f32671559880aeffd031e0
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/graph_optimizer_stage.h
@@ -0,0 +1,315 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_GRAPH_OPTIMIZER_STAGE_H_
+#define TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_GRAPH_OPTIMIZER_STAGE_H_
+
+#include <unordered_map>
+#include <unordered_set>
+
+#include "absl/strings/str_cat.h"
+#include "tensorflow/core/grappler/costs/graph_properties.h"
+#include "tensorflow/core/grappler/grappler_item.h"
+#include "tensorflow/core/grappler/utils.h"
+#include "tensorflow/core/lib/gtl/flatset.h"
+#include "tensorflow/core/protobuf/rewriter_config.pb.h"
+
+namespace tensorflow {
+namespace grappler {
+
+struct NodeScopeAndName {
+  string scope;
+  string name;
+};
+
+// Parse scope and name: "a/b/c/Add_1" -> {"a/b/c", "Add_1"}
+const NodeScopeAndName ParseNodeScopeAndName(const string& node_name);
+
+// Context owned by GraphOptimizer, and passed to every stage at construction
+// time. Each optimizer stage is responsible for updating it according to the
+// changes it made to the graph.
+//
+// If an optimizer needs access to some helper class that is not present in this
+// context, consider creating an extension context, specific to that
+// optimizer (see example of ArithmeticOptimizerContext). GraphOptimizerContext
+// should only have members that are useful to almost all optimizers.
+struct GraphOptimizerContext {
+  GraphOptimizerContext(const std::unordered_set<string>* nodes_to_preserve,
+                        GraphDef* optimized_graph,
+                        GraphProperties* graph_properties, NodeMap* node_map,
+                        gtl::FlatSet<string>* feed_nodes,
+                        RewriterConfig::Toggle opt_level)
+      : nodes_to_preserve(nodes_to_preserve),
+        optimized_graph(optimized_graph),
+        graph_properties(graph_properties),
+        node_map(node_map),
+        feed_nodes(feed_nodes),
+        opt_level(opt_level) {}
+
+  const std::unordered_set<string>* nodes_to_preserve;
+  GraphDef* optimized_graph;
+  GraphProperties* graph_properties;
+  NodeMap* node_map;
+  gtl::FlatSet<string>* feed_nodes;
+  RewriterConfig::Toggle opt_level;
+};
+
+Status GetInputNode(const GraphOptimizerContext& ctx, const string& input,
+                    NodeDef** node);
+Status GetTensorProperties(const GraphOptimizerContext& ctx,
+                           const string& tensor,
+                           const OpInfo::TensorProperties** properties);
+
+NodeDef* AddCopyNode(const GraphOptimizerContext& ctx, const string& name,
+                     const NodeDef* node_to_copy);
+NodeDef* AddEmptyNode(const GraphOptimizerContext& ctx, const string& name);
+
+// WARNING:
+// Optimizer stage must try to re-use original nodes of a graph and
+// make all updates in place. This helps to make robust node placement
+// decisions. Create new nodes only if there is a reason for that.
+
+// Make a name for a new node obtained by optimizing a single node of the
+// original graph. The optimized node is placed under the original node scope.
+//
+// Node name uniqueness is guaranteed by unique name of an original node in
+// a same scope.
+//
+// Empty sub_scope or prefix ignored. At least one of them must be non-empty.
+//
+// Example: a/b/c/Add -> a/b/c/${sub_scope}/${prefix}_Add.
+const string MakeOptimizedNodeName(const NodeScopeAndName& node,
+                                   const string& sub_scope,
+                                   const string& prefix);
+// Make a name for a new node obtained by optimizing multiple nodes of the
+// original graph, starting from "root". The optimized node is placed under
+// the original scope of a "root" node.
+//
+// Example: [a/b/c/Add, x/y/z/Mul] -> a/b/c/${sub_scope}/${prefix}_Add_Mul
+const string MakeOptimizedNodeName(const NodeScopeAndName& root,
+                                   const std::vector<string> node_names,
+                                   const string& sub_scope,
+                                   const string& prefix);
+
+// Base class for multi-stage GraphOptimizers (ArithmeticOptimizer, etc...).
+//
+// If a graph optimizer consists of large number of small independent
+// rewrites, each of them should be implemented as a separate stage.
+//
+// * Result:
+// Each graph optimizer choose what result is reported by each stage
+// (e.g. each stage can fill in the name of optimized nodes, or have more
+// complex result).
+template <typename Result>
+class GraphOptimizerStage {
+ public:
+  explicit GraphOptimizerStage(const string& optimizer_name,
+                               const string& stage_name,
+                               const GraphOptimizerContext& ctx)
+      : optimizer_name_(optimizer_name), stage_name_(stage_name), ctx_(ctx) {}
+  virtual ~GraphOptimizerStage() = default;
+
+  const string& stage_name() const { return stage_name_; }
+  const string& optimizer_name() const { return optimizer_name_; }
+
+  // Check if we should try to simplify node. Returning true doesn't
+  // guarantee that node will be simplified.
+  //
+  // Should implement just a basic sanity check, without any expensive graph
+  // traversals.
+  virtual bool IsSupported(const NodeDef* node) const = 0;
+
+  // Try to simplify the given node.
+  //
+  // Return error status only if some precondition is failed, or got an
+  // incorrect graph. In every other case return Status:OK(), even if didn't
+  // simplify anything.
+  //
+  // Report result using output argument. Each GraphOptimizer can choose it's
+  // own Result type.
+  // TODO(ezhulenev): if it will appear that Result output parameter is not
+  // sufficiently useful (used with a reason by most optimizers), get rid of it,
+  // and remove template parameter.
+  virtual Status TrySimplify(NodeDef* node, Result* result) = 0;
+
+  // Return InvalidArgumentError if node is not supported by the optimizer
+  // stage.
+  // TODO(ezhulenev): make this check part of non-virtual public API
+  // (TrySimplify), and make virtual implementation protected.
+  Status EnsureNodeIsSupported(const NodeDef* node) const {
+    return IsSupported(node)
+               ? OkStatus()
+               : errors::InvalidArgument(
+                     "Node ", node->name(), " is not supported by optimizer ",
+                     optimizer_name_, " and stage ", stage_name_);
+  }
+
+  // Get a name for a new node, created by this stage, based on one or multiple
+  // nodes of an original graph.
+  const string OptimizedNodeName(const NodeScopeAndName& node) const {
+    return MakeOptimizedNodeName(node, optimizer_name_, stage_name_);
+  }
+  const string OptimizedNodeName(const NodeScopeAndName& root,
+                                 const std::vector<string>& nodes) const {
+    return MakeOptimizedNodeName(root, nodes, optimizer_name_, stage_name_);
+  }
+  const string OptimizedNodeName(const NodeScopeAndName& node,
+                                 const string& rewrite_rule) const {
+    const string prefix = strings::StrCat(stage_name_, "_", rewrite_rule);
+    return MakeOptimizedNodeName(node, optimizer_name_, prefix);
+  }
+
+  const string UniqueOptimizedNodeName(const NodeScopeAndName& node) {
+    const string node_name = OptimizedNodeName(node);
+    return UniqueNodeName(node_name);
+  }
+  const string UniqueOptimizedNodeName(const NodeScopeAndName& node,
+                                       const string& rewrite_rule) {
+    const string node_name = OptimizedNodeName(node, rewrite_rule);
+    return UniqueNodeName(node_name);
+  }
+
+  // Get a node by input name from a node map. Return an error if node was not
+  // found.
+  Status GetInputNode(const string& input, NodeDef** node) const {
+    return ::tensorflow::grappler::GetInputNode(ctx_, input, node);
+  }
+  // Lookup tensor properties by name. Tensor name might have non-zero port
+  // number. Return an error if tensor node doesn't exists in a graph, or it
+  // doesn't have properties defined for requested port.
+  Status GetTensorProperties(
+      const string& tensor, const OpInfo::TensorProperties** properties) const {
+    return ::tensorflow::grappler::GetTensorProperties(ctx_, tensor,
+                                                       properties);
+  }
+
+  NodeDef* AddCopyNode(const string& name, const NodeDef* node_to_copy) {
+    return ::tensorflow::grappler::AddCopyNode(ctx_, name, node_to_copy);
+  }
+  NodeDef* AddEmptyNode(const string& name) {
+    return ::tensorflow::grappler::AddEmptyNode(ctx_, name);
+  }
+
+ protected:
+  const GraphOptimizerContext& ctx() const { return ctx_; }
+
+ private:
+  const string UniqueNodeName(absl::string_view name) {
+    string node_name = string(name);
+    while (ctx_.node_map->NodeExists(node_name)) {
+      node_name = absl::StrCat(name, "_unique",
+                               optimized_node_name_counter_.fetch_add(1));
+    }
+
+    return node_name;
+  }
+
+  const string optimizer_name_;
+  const string stage_name_;
+  const GraphOptimizerContext ctx_;
+  std::atomic<int64_t> optimized_node_name_counter_ = {0};
+};
+
+template <typename Result>
+class GraphOptimizerStagePipeline {
+ public:
+  // Break predicate specifies if a pipeline should stop early, and not pass
+  // a node to the next registered optimizer stage, typically that should be the
+  // case when a stage successfully optimized a node, and it wants to yield
+  // control to the optimizer.
+  explicit GraphOptimizerStagePipeline(
+      const std::function<bool(const Result&)> break_predicate)
+      : break_predicate_(break_predicate) {}
+
+  // Add a stage to the pipeline. It should be called with the arguments for the
+  // stage constructor:
+  //
+  //   pipeline.AddStage<FooStage>(constructor_arg1, constructor_arg2);
+  //
+  // Returns a reference to the added stage.
+  template <typename T, typename... Args>
+  T& AddStage(Args&&... args) {
+    auto stage = new T(std::forward<Args>(args)...);
+    stages_.push_back(std::unique_ptr<T>(stage));
+    return *stage;
+  }
+
+  // Pass a node through all registered optimizer stages, until break predicate
+  // is true.
+  //
+  // Return true, if pipeline exited after a break predicate was evaluated as
+  // 'true', which typically means that a node was optimized by one of the
+  // registered stages.
+  //
+  // Return false, if node was not optimized by any of registered stages.
+  bool PassThroughAllStages(NodeDef* node, Result* result) {
+    for (auto& stage : stages_) {
+      if (stage->IsSupported(node)) {
+        const Status stage_status = stage->TrySimplify(node, result);
+        // Each stage must be "error safe" (just like exception safe). In
+        // case of any error it must leave optimized graph unmodified.
+        if (!stage_status.ok()) {
+          VLOG(2) << "Failed to run optimizer " << stage->optimizer_name()
+                  << ", stage " << stage->stage_name() << " node "
+                  << node->name() << ". Error: " << stage_status.message();
+        }
+        if (break_predicate_(*result)) return true;
+      }
+    }
+    return false;
+  }
+
+  // Pass a node through all registered optimizer stages, until break predicate
+  // is true or a stage fails.
+  //
+  // Returns any stage failure status, or else OkStatus().
+  Status PassThroughAllStagesWithStatus(NodeDef* node, Result* result) {
+    for (auto& stage : stages_) {
+      if (!stage->IsSupported(node)) {
+        continue;
+      }
+      const Status stage_status = stage->TrySimplify(node, result);
+      if (!stage_status.ok()) {
+        return stage_status;
+      } else if (break_predicate_(*result)) {
+        break;
+      }
+    }
+    return OkStatus();
+  }
+
+  std::size_t NumStages() { return stages_.size(); }
+
+  std::vector<string> StageNames() {
+    std::vector<string> names;
+    names.reserve(stages_.size());
+    for (const auto& stage : stages_) {
+      names.push_back(stage->stage_name());
+    }
+    return names;
+  }
+
+ private:
+  std::vector<std::unique_ptr<GraphOptimizerStage<Result>>> stages_;
+  std::function<bool(const Result&)> break_predicate_;
+
+  GraphOptimizerStagePipeline(const GraphOptimizerStagePipeline&) = delete;
+  void operator=(const GraphOptimizerStagePipeline&) = delete;
+};
+
+}  // end namespace grappler
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_GRAPH_OPTIMIZER_STAGE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/implementation_selector.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/implementation_selector.h
new file mode 100644
index 0000000000000000000000000000000000000000..029248ee0c695c8e7cce06777062cad8e7d88a59
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/implementation_selector.h
@@ -0,0 +1,199 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_IMPLEMENTATION_SELECTOR_H_
+#define TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_IMPLEMENTATION_SELECTOR_H_
+
+#include <string>
+
+#include "tensorflow/core/framework/op.h"
+#include "tensorflow/core/grappler/costs/graph_properties.h"
+#include "tensorflow/core/grappler/grappler_item.h"
+#include "tensorflow/core/grappler/op_types.h"
+#include "tensorflow/core/grappler/optimizers/custom_graph_optimizer.h"
+#include "tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.h"
+#include "tensorflow/core/grappler/optimizers/function_api_info.h"
+#include "tensorflow/core/grappler/utils/graph_view.h"
+#include "tensorflow/core/lib/core/errors.h"
+#include "tensorflow/core/lib/core/stringpiece.h"
+#include "tensorflow/core/lib/strings/strcat.h"
+#include "tensorflow/core/util/device_name_utils.h"
+
+namespace tensorflow {
+namespace grappler {
+
+// Motivation: To achieve the same high level functionality, the underlying
+// implementations sometimes are different for various devices where the
+// function runs. In order to achieve the correct result and best performance,
+// the proper implementation needs to be picked dynamically.
+//
+// Currently there are two approaches to do this.
+// (1) Utilize case op and dynamacically change the branch index.
+// (2) Swap function implementation, it will be deprecated.
+//
+// Idea for approach 1.
+// This transformation rewrites the DeviceIndex op with a Const op with value
+// of the index of the device the associcated Case op runs.
+// Example:
+// def plus_one_gpu(x): return x + 1.0
+// def plus_one_reference_implementation(x): return x + 1.0
+// input = tf.constant(2.0, dtype=tf.float32)
+// cpu_fn = lambda:plus_one_reference_implementation(input)
+// gpu_fn = lambda:plus_one_gpu(input)
+// control_flow_switch_case.execute_fn_for_device(
+//  {"CPU": cpu_fn, "GPU":gpu_fn)}, default_fn=cpu_fn)
+//
+// Idea for approach 2.
+// This transformation replaces function calls by the appropriate function
+// definition based on properties of the runtime system. For instance,
+// we may choose one implementation over another if we have a GPU with
+// enough memory available.
+//
+// It is a way for the programmer to specify alternative implementations
+// of the same functionality in the graph, and let TensorFlow pick the
+// most appropriate one at runtime.
+//
+// For instance, the python code might specify:
+// @Defun(tf.float32,
+//        api_implements='plus_one',
+//        api_preferred_device='GPU')
+// def plus_one_gpu(x): return x + 1.0
+//
+// @Defun(tf.float32,
+//        api_implements='plus_one')
+// def plus_one_reference_implementation(x): return x + 1.0
+// input = tf.constant(2.0, dtype=tf.float32)
+//
+// z = plus_one_reference_implementation(input)
+// z = plus_one_gpu(input)
+// print(sess.run(z))
+//
+
+// At runtime, we will select either `plus_one_gpu` or
+// `plus_one_reference_implementation` based on the availability of the GPU.
+//
+// Available annotations:
+//  - api_implements(string): all functions mapping to the same
+//    string can be interchanged. For now, all functions must have the same
+//    signature and overloads are not allowed. Defuns within defuns are
+//    allowed.
+//  - api_preferred_device(string): sets which device is preferred.
+class ImplementationSelector : public CustomGraphOptimizer {
+ public:
+  ImplementationSelector() = default;
+  ~ImplementationSelector() override = default;
+  Status Init(
+      const tensorflow::RewriterConfig_CustomGraphOptimizer* config) override {
+    return OkStatus();
+  }
+  string name() const override {
+    return "implementation_selector";
+  }
+
+  bool UsesFunctionLibrary() const override { return false; }
+
+  // This call is not thread-safe.
+  Status Optimize(Cluster* cluster, const GrapplerItem& item,
+                  GraphDef* optimized_graph) override;
+
+ private:
+  Status LoadFunctions(const GraphDef& graph);
+  Status MaybeOptimizeFunctionCall(utils::MutableNodeView* node_view) const;
+
+  // Finds all call sites for functions, then replace with the appropriate
+  // implementation.
+  // There are two ways of calling functions:
+  //  1. By specifying an op name as a function name, and
+  //  2. Via the functional interface, where the function name appears as an
+  //  Attr.
+  //
+  // There may be multiple call sites for a given function. The function body
+  // may call into another function, so a function might have to be duplicated.
+  // For simplicity, we do not change function bodies. Also, we do not change
+  // gradients.
+  Status SelectImplementation(GraphDef* graph) const;
+
+  // Rewrites the DeviceIndex op with a Const op with value of the index of the
+  // device the associcated Case op runs.
+
+  // This function first looks up all the DeviceIndex ops.
+  // Then for each of these ops, it finds the device of the
+  // associated Case op that takes the DeviceIndex op as the input, and
+  // caculates the index of the device in the device list of DeviceIndex op.
+  // Lastly, it rewrites the DeviceIndex op with a Const op and sets the value
+  // to be the index.
+  //
+  // Example input nodes:
+  // node {
+  //   name: "x"
+  //   op: "DeviceIndex"
+  //   device: "/device:CPU:0"
+  //   attr {
+  //     key: "device_names"
+  //     value {
+  //       list {
+  //         s: "CPU"
+  //         s: "TPU_REPLICATED_CORE"
+  //         s: "GPU"
+  //       }
+  //     }
+  //   }
+  // }
+  // node {
+  //   name: "case"
+  //   op: "Case"
+  //   input: "x"
+  //   device: "/device:GPU:0"
+  //   ...
+  // }
+  // Example output nodes:
+  //
+  //  name: "x"
+  //  op: "Const"
+  //  device: "/device:CPU:0"
+  //  attr {
+  //    key: "dtype"
+  //    value {
+  //      type: DT_INT32
+  //    }
+  //  }
+  //  attr {
+  //    key: "value"
+  //    value {
+  //      tensor {
+  //        dtype: DT_INT32
+  //        int_val: 2
+  //      }
+  //    }
+  //  }
+  // node {
+  //   name: "case"
+  //   op: "Case"
+  //   input: "x"
+  //   device: "/device:GPU:0"
+  //   ...
+  // }
+  Status SelectDeviceIndex(GraphDef* graph) const;
+
+  std::unique_ptr<FunctionLibraryApiInfo> lib_info_;
+
+  ImplementationSelector(const ImplementationSelector&) = delete;
+  void operator=(const ImplementationSelector&) = delete;
+};
+
+}  // namespace grappler
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_IMPLEMENTATION_SELECTOR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/loop_optimizer.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/loop_optimizer.h
new file mode 100644
index 0000000000000000000000000000000000000000..007a33e64dcf0198a3716ddf67a9e212852ed116
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/loop_optimizer.h
@@ -0,0 +1,77 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_LOOP_OPTIMIZER_H_
+#define TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_LOOP_OPTIMIZER_H_
+
+#include <unordered_set>
+
+#include "tensorflow/core/grappler/costs/graph_properties.h"
+#include "tensorflow/core/grappler/optimizers/graph_optimizer.h"
+#include "tensorflow/core/grappler/utils.h"
+#include "tensorflow/core/grappler/utils/frame.h"
+#include "tensorflow/core/protobuf/rewriter_config.pb.h"
+
+namespace tensorflow {
+namespace grappler {
+
+constexpr char kLoopOptimizer[] = "LoopOptimizer";
+
+class LoopOptimizer : public GraphOptimizer {
+ public:
+  LoopOptimizer();
+
+  explicit LoopOptimizer(RewriterConfig::Toggle opt_level,
+                         DeviceBase* cpu_device);
+
+  ~LoopOptimizer() override {}
+
+  string name() const override { return "loop_optimizer"; };
+
+  bool UsesFunctionLibrary() const override { return false; }
+
+  Status Optimize(Cluster* cluster, const GrapplerItem& item,
+                  GraphDef* optimized_graph) override;
+
+ private:
+  friend class LoopOptimizerTest;
+
+  // Granular control for loop optimizer stages.
+  struct LoopOptimizerOptions {
+    bool enable_loop_invariant_node_motion = false;
+    bool enable_stack_push_removal = true;
+    bool enable_dead_branch_removal = true;
+
+    static LoopOptimizerOptions Default(RewriterConfig::Toggle opt_level) {
+      LoopOptimizerOptions options;
+      return options;
+    }
+  };
+
+  Status RemoveDeadBranches(const std::unordered_set<string>& nodes_to_preserve,
+                            NodeMap& node_map,
+                            const absl::flat_hash_set<string>& feed_nodes,
+                            GraphDef* optimized_graph);
+
+  RewriterConfig::Toggle opt_level_;
+  DeviceBase* cpu_device_;
+  LoopOptimizerOptions options_;
+  std::unique_ptr<ResourceMgr> resource_mgr_;
+};
+
+}  // end namespace grappler
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_LOOP_OPTIMIZER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/memory_optimizer.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/memory_optimizer.h
new file mode 100644
index 0000000000000000000000000000000000000000..397c059d2c2931f82534e424662d70ec7f25f025
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/memory_optimizer.h
@@ -0,0 +1,58 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_MEMORY_OPTIMIZER_H_
+#define TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_MEMORY_OPTIMIZER_H_
+
+#include <string>
+#include "tensorflow/core/grappler/clusters/cluster.h"
+#include "tensorflow/core/grappler/grappler_item.h"
+#include "tensorflow/core/grappler/optimizers/graph_optimizer.h"
+#include "tensorflow/core/protobuf/rewriter_config.pb.h"
+
+namespace tensorflow {
+namespace grappler {
+
+// Swap tensors in and out of device memory.
+class MemoryOptimizer : public GraphOptimizer {
+ public:
+  // optimization_level: Controls the level of autonomy for the memory
+  //   optimizer. See RewriterConfig::memory_optimization.
+  // recomputation_targets_name_scope: Name scope for potential outputs of
+  //   recomputations. See
+  //   RewriterConfig::memory_optimizer_target_node_name_scope.
+  explicit MemoryOptimizer(
+      RewriterConfig::MemOptType optimization_level,
+      const string& recomputation_targets_name_scope = "gradients/")
+      : optimization_level_(optimization_level),
+        recomputation_targets_name_scope_(recomputation_targets_name_scope) {}
+  ~MemoryOptimizer() override {}
+
+  string name() const override { return "memory_optimizer"; };
+
+  bool UsesFunctionLibrary() const override { return false; }
+
+  Status Optimize(Cluster* cluster, const GrapplerItem& item,
+                  GraphDef* pruned_graph) override;
+
+ private:
+  RewriterConfig::MemOptType optimization_level_;
+  string recomputation_targets_name_scope_;
+};
+
+}  // end namespace grappler
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_MEMORY_OPTIMIZER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/meta_optimizer.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/meta_optimizer.h
new file mode 100644
index 0000000000000000000000000000000000000000..3d1004071385c131baa155ad3ce0335ccc9311ea
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/meta_optimizer.h
@@ -0,0 +1,165 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_META_OPTIMIZER_H_
+#define TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_META_OPTIMIZER_H_
+
+#include "tensorflow/core/common_runtime/device_set.h"
+#include "tensorflow/core/framework/device_base.h"
+#include "tensorflow/core/framework/function.h"
+#include "tensorflow/core/graph/graph.h"
+#include "tensorflow/core/grappler/grappler_item.h"
+#include "tensorflow/core/grappler/optimizers/graph_optimizer.h"
+#include "tensorflow/core/grappler/verifiers/graph_verifier.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/protobuf/config.pb.h"
+#include "tensorflow/core/protobuf/rewriter_config.pb.h"
+#include "tensorflow/core/protobuf/verifier_config.pb.h"
+
+namespace tensorflow {
+namespace grappler {
+
+// Run the other grappler optimizers based on the specified rewriter config.
+class MetaOptimizer : public GraphOptimizer {
+ public:
+  MetaOptimizer(DeviceBase* cpu_device, const ConfigProto& cfg);
+  ~MetaOptimizer() override = default;
+
+  string name() const override { return "meta_optimizer"; };
+
+  bool UsesFunctionLibrary() const override { return true; }
+
+  Status Optimize(Cluster* cluster, const GrapplerItem& item,
+                  GraphDef* optimized_graph) override {
+    GrapplerItem copy(item);
+    return OptimizeConsumeItem(cluster, std::move(copy), optimized_graph);
+  }
+
+  Status OptimizeConsumeItem(Cluster* cluster, GrapplerItem&& item,
+                             GraphDef* optimized_graph);
+
+  string GetResultString() const;
+
+  void PrintResult();
+
+ private:
+  std::unique_ptr<GraphOptimizer> MakeNewOptimizer(
+      const string& optimizer, const std::set<string>& device_types) const;
+
+  // When grappler should lower control flow to V1 switch/merge style nodes.
+  bool LowerControlFlow() const;
+
+  // Initialize active optimizers from RewriterConfig toggles.
+  Status InitializeOptimizers(
+      const std::set<string>& device_types,
+      std::vector<std::unique_ptr<GraphOptimizer>>* optimizers) const;
+  // Initialize active optimizers from RewriterConfig optimizer names.
+  Status InitializeOptimizersByName(
+      const std::set<string>& device_types,
+      std::vector<std::unique_ptr<GraphOptimizer>>* optimizers) const;
+  // Initialize active optimizers from RewriterConfig.custom_optimizers.
+  Status InitializeCustomGraphOptimizers(
+      const std::set<string>& device_types,
+      const std::set<string>& pre_initialized_optimizers,
+      std::vector<std::unique_ptr<GraphOptimizer>>* optimizers) const;
+  Status InitializePluginGraphOptimizers(
+      const std::set<string>& device_types,
+      std::vector<std::unique_ptr<GraphOptimizer>>* optimizers) const;
+  // Returns the config for a custom graph optimizer. Null if none was found.
+  const RewriterConfig::CustomGraphOptimizer* GetCustomGraphOptimizerConfig(
+      const string& name) const;
+
+  // Initialize active verifiers from the RewriterConfig toggles.
+  void InitializeVerifiers(
+      std::vector<std::unique_ptr<GraphVerifier>>* inter_optimizer_verifiers,
+      std::vector<std::unique_ptr<GraphVerifier>>* post_optimization_verifiers)
+      const;
+
+  void PrintUserAndPluginConfigs(const std::set<string>& device_types) const;
+
+  // Run optimization pass over a single GrapplerItem. Meta optimizer might run
+  // multiple such passes: 1) for the main graph 2) for the function library
+  Status OptimizeGraph(
+      const std::vector<std::unique_ptr<GraphOptimizer>>& optimizers,
+      Cluster* cluster, GrapplerItem&& item, GraphDef* optimized_graph);
+  Status OptimizeGraph(Cluster* cluster, GrapplerItem&& item,
+                       GraphDef* optimized_graph);
+
+  DeviceBase* const cpu_device_;  // may be NULL
+  ConfigProto config_proto_;
+  RewriterConfig& cfg_;
+  bool xla_auto_clustering_on_;
+
+  struct OptimizerResult {
+    string optimizer_name;
+    string message;
+    Status status;
+  };
+
+  struct GraphOptimizationResult {
+    explicit GraphOptimizationResult(const string& id) : id(id) {}
+    string id;
+    std::vector<OptimizerResult> results;
+  };
+
+  Status RunOptimizer(GraphOptimizer* optimizer, Cluster* cluster,
+                      GrapplerItem* optimized_item, GraphDef* optimized_graph,
+                      GraphOptimizationResult* optimization_result);
+
+  std::vector<GraphOptimizationResult> optimization_results_;
+};
+
+bool MetaOptimizerEnabled(const ConfigProto& cfg);
+
+// Run the meta optimizer.
+//
+// If <cpu_device> is non-null, it is the device to be used for executing ops
+// during constant folding; if NULL, a new device is created for doing constant
+// folding. For performance, it is recommended to pass in an existing cpu_device
+// when possible.
+Status RunMetaOptimizer(GrapplerItem&& item, const ConfigProto& cfg,
+                        DeviceBase* cpu_device, Cluster* cluster,
+                        GraphDef* optimized_graph);
+
+// Wrapper around RunMetaOptimizer convenient for optimizing
+// function graphs.
+//
+// Runs grappler optimizations on `g` based on `config_proto`.
+// `ret_node_names`: a vector of node names whose outputs are returned,
+//    aka fetches. when `g` represent a function, these are _Retval nodes.
+// `lib`: function library to use with `g`.
+// `device_set`: the set of devices that graph can refer to.
+// `cpu_device`: the CPU device.
+// `config_proto`: Grapper configuration.
+// `grappler_item_id': Grappler item id (e.g. optimized function name).
+// `optimization_options`: Grappler optimization constraints that are known only
+//    at runtime.
+//
+// **g is a graph constructed based on the runtime library 'lib'.
+// OptimizeGraph mutates **g extensively and replaces '*g' with a
+// complete copy. Therefore, the caller should not keep any references
+// to nodes *g.
+Status OptimizeGraph(
+    std::vector<string> ret_node_names, std::vector<string> keep_node_names,
+    FunctionLibraryDefinition* lib, const DeviceSet& device_set,
+    Device* cpu_device, const ConfigProto& config_proto,
+    const string& grappler_item_id,
+    const GrapplerItem::OptimizationOptions& optimization_options,
+    std::unique_ptr<tensorflow::Graph>* g);
+
+}  // namespace grappler
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_META_OPTIMIZER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/model_pruner.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/model_pruner.h
new file mode 100644
index 0000000000000000000000000000000000000000..235d08e8268b263b44066aa5b6417bc3f65edd92
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/model_pruner.h
@@ -0,0 +1,43 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_MODEL_PRUNER_H_
+#define TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_MODEL_PRUNER_H_
+
+#include "tensorflow/core/grappler/optimizers/graph_optimizer.h"
+
+namespace tensorflow {
+namespace grappler {
+
+// Prune a model to make it more efficient:
+// * Remove unnecessary operations.
+// * Optimize gradient computations.
+class ModelPruner : public GraphOptimizer {
+ public:
+  ModelPruner() {}
+  ~ModelPruner() override {}
+
+  string name() const override { return "model_pruner"; };
+
+  bool UsesFunctionLibrary() const override { return false; }
+
+  Status Optimize(Cluster* cluster, const GrapplerItem& item,
+                  GraphDef* optimized_graph) override;
+};
+
+}  // end namespace grappler
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_MODEL_PRUNER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/pin_to_host_optimizer.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/pin_to_host_optimizer.h
new file mode 100644
index 0000000000000000000000000000000000000000..f56c823c495590d2779085efe4b5a2a677f838b3
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/pin_to_host_optimizer.h
@@ -0,0 +1,57 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_PIN_TO_HOST_OPTIMIZER_H_
+#define TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_PIN_TO_HOST_OPTIMIZER_H_
+
+#include <unordered_set>
+#include "tensorflow/core/grappler/costs/graph_properties.h"
+#include "tensorflow/core/grappler/optimizers/graph_optimizer.h"
+#include "tensorflow/core/lib/gtl/flatset.h"
+#include "tensorflow/core/protobuf/rewriter_config.pb.h"
+
+namespace tensorflow {
+namespace grappler {
+namespace internal {
+// Try and find an appropriate Host device in `devices` given `device`.
+string TryFindHostDevice(const gtl::FlatSet<string>& devices,
+                         bool has_device_cpu, const string& device);
+}  // end namespace internal
+
+// Optimize TensorFlow ops that should be swapped into the CPU to avoid
+// excessive cpu<->gpu memcpy/sync.
+//
+// TODO(williamchan): The current heuristic will swap any small integer Const to
+// CPU. This may cause a problem cpu->cpu->gpu wherein the original behaviour of
+// gpu->gpu->gpu may have been better/faster. We should probably fix this.
+class PinToHostOptimizer : public GraphOptimizer {
+ public:
+  PinToHostOptimizer() {}
+  explicit PinToHostOptimizer(RewriterConfig::Toggle opt_level) {}
+
+  ~PinToHostOptimizer() override {}
+
+  string name() const override { return "pin_to_host_optimizer"; };
+
+  bool UsesFunctionLibrary() const override { return false; }
+
+  Status Optimize(Cluster* cluster, const GrapplerItem& item,
+                  GraphDef* optimized_graph) override;
+};
+
+}  // end namespace grappler
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_PIN_TO_HOST_OPTIMIZER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/remapper.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/remapper.h
new file mode 100644
index 0000000000000000000000000000000000000000..92dc2a55fb4908e4c39c5c1cd346bea8103e5fe8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/remapper.h
@@ -0,0 +1,55 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_REMAPPER_H_
+#define TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_REMAPPER_H_
+
+#include "tensorflow/core/grappler/optimizers/graph_optimizer.h"
+#include "tensorflow/core/protobuf/rewriter_config.pb.h"
+
+namespace tensorflow {
+namespace grappler {
+
+// Optimize TF computations by remapping subgraphs/nodes onto other subgraphs or
+// nodes to decrease the amount of operations needed to perform a computation.
+class Remapper : public GraphOptimizer {
+ public:
+  explicit Remapper(RewriterConfig::Toggle opt_level,
+                    RewriterConfig::CpuLayout cpu_layout_conversion =
+                        RewriterConfig::NO_CONVERSION_ON_CPU,
+                    bool xla_auto_clustering_on = false)
+      : opt_level_(opt_level),
+        cpu_layout_conversion_(cpu_layout_conversion),
+        xla_auto_clustering_on_(xla_auto_clustering_on) {}
+
+  ~Remapper() override {}
+
+  string name() const override { return "remapper"; };
+
+  bool UsesFunctionLibrary() const override { return false; }
+
+  Status Optimize(Cluster* cluster, const GrapplerItem& item,
+                  GraphDef* optimized_graph) override;
+
+ private:
+  RewriterConfig::Toggle opt_level_;
+  RewriterConfig::CpuLayout cpu_layout_conversion_;
+  bool xla_auto_clustering_on_;
+};
+
+}  // end namespace grappler
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_REMAPPER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/scoped_allocator_optimizer.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/scoped_allocator_optimizer.h
new file mode 100644
index 0000000000000000000000000000000000000000..ac1ed3b5aedda51e07067e932f175eafb8ca19a7
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/scoped_allocator_optimizer.h
@@ -0,0 +1,126 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_SCOPED_ALLOCATOR_OPTIMIZER_H_
+#define TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_SCOPED_ALLOCATOR_OPTIMIZER_H_
+
+#include <atomic>
+#include <unordered_set>
+#include <vector>
+
+#include "absl/container/flat_hash_map.h"
+#include "absl/container/flat_hash_set.h"
+#include "tensorflow/core/grappler/optimizers/graph_optimizer.h"
+#include "tensorflow/core/grappler/utils.h"
+#include "tensorflow/core/protobuf/rewriter_config.pb.h"
+
+namespace tensorflow {
+class Graph;
+
+namespace grappler {
+class GraphProperties;
+class NodeMap;
+class ScopedAllocatorOptimizer;
+
+// An Optimizer that introduces ScopedAllocators in order to reduce data
+// movement and consolidate some kinds of Ops.
+class ScopedAllocatorOptimizer : public GraphOptimizer {
+ public:
+  ScopedAllocatorOptimizer(RewriterConfig::Toggle opt_level,
+                           const ScopedAllocatorOptions& opts);
+  ~ScopedAllocatorOptimizer() override;
+
+  string name() const override { return "scoped_allocator_optimizer"; }
+
+  bool UsesFunctionLibrary() const override { return true; }
+
+  Status Optimize(Cluster* cluster, const GrapplerItem& item,
+                  GraphDef* optimized_graph) override;
+
+  // Map from an Op name to a vector of Nodes with that Op.
+  typedef absl::flat_hash_map<string, std::vector<NodeDef*>> DevOpOccurrences;
+  // Map from a device name to a DevOpOccurrences map.
+  typedef absl::flat_hash_map<string, DevOpOccurrences> GraphOpOccurrences;
+  typedef absl::flat_hash_set<string> OpNameSet;
+
+  Status ProcessGraphDef(GraphDef* graph,
+                         const GraphProperties& graph_properties);
+
+  // Populates *occs by grouping Nodes with common Ops, according to
+  // their assigned devices.
+  void FindOpOccurrences(GraphDef* graph, const OpNameSet& op_names,
+                         GraphOpOccurrences* occs);
+
+  // Returns a new, unused scope_id to be assigned to a ScopedAllocator that
+  // will allocate num_fields (> 0) separate tensors.
+  int NewScopedAllocatorId(int num_fields);
+
+  // Returns a new, unused id to be assigned to an IdentityOp used in this graph
+  // rewrite.
+  Status NewIdentityId(int* id);
+
+  NodeMap* node_map() { return node_map_.get(); }
+
+  const absl::flat_hash_set<string>& repeated_outputs() {
+    return repeated_outputs_;
+  }
+
+  // Appends values to the attr value under name in node_def, if present.
+  // If not present does an assignment.
+  static void ExtendNodeAttr(StringPiece name, const std::vector<int32>& values,
+                             NodeDef* node_def);
+
+  // Class that knows how to do graph rewriting for a particular kind of Op in
+  // order to take advantage of a ScopedAllocator.
+  class Rewriter {
+   public:
+    virtual ~Rewriter() {}
+
+    virtual Status Rewrite(ScopedAllocatorOptimizer* paopti,
+                           int64_t invocation_count, GraphDef* graph,
+                           const string& op_name,
+                           const std::vector<NodeDef*>& nodes,
+                           bool* applied) = 0;
+
+    void SetGraphProperties(const GraphProperties& graph_properties) {
+      graph_properties_ = &graph_properties;
+      CHECK(graph_properties_);
+    }
+
+   protected:
+    const GraphProperties* graph_properties_;
+  };
+
+ private:
+  Rewriter* GetRewriter(const string& op_name);
+
+  Status OrderNodeSet(std::vector<NodeDef*>* nodes) const;
+
+  RewriterConfig::Toggle opt_level_;
+  std::unordered_set<string> nodes_to_preserve_;
+  OpNameSet op_name_set_;
+  absl::flat_hash_map<string, Rewriter*> rewriters_;
+  std::vector<Rewriter*> to_delete_;
+  int next_sa_id_ = 1;
+  int next_identity_id_ = 1;
+  std::unique_ptr<NodeMap> node_map_;
+  // Keeps track of outputs, i.e. a node and an output index, that are inputs to
+  // more than one op groups that are candidates for scoped allocator
+  // optimization.
+  absl::flat_hash_set<string> repeated_outputs_;
+};
+
+}  // namespace grappler
+}  // namespace tensorflow
+#endif  // TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_SCOPED_ALLOCATOR_OPTIMIZER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/shape_optimizer.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/shape_optimizer.h
new file mode 100644
index 0000000000000000000000000000000000000000..5710ec4970d68cb0ce938e8cafad969bc4e62f12
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/shape_optimizer.h
@@ -0,0 +1,49 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_SHAPE_OPTIMIZER_H_
+#define TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_SHAPE_OPTIMIZER_H_
+
+#include <unordered_set>
+#include "tensorflow/core/grappler/costs/graph_properties.h"
+#include "tensorflow/core/grappler/optimizers/graph_optimizer.h"
+#include "tensorflow/core/grappler/utils.h"
+#include "tensorflow/core/grappler/utils/frame.h"
+#include "tensorflow/core/protobuf/rewriter_config.pb.h"
+
+namespace tensorflow {
+namespace grappler {
+
+// Optimize TensorFlow subgraphs that operate on shape and shape related
+// information.
+class ShapeOptimizer : public GraphOptimizer {
+ public:
+  ShapeOptimizer() {}
+  explicit ShapeOptimizer(RewriterConfig::Toggle opt_level) {}
+
+  ~ShapeOptimizer() override {}
+
+  string name() const override { return "shape_optimizer"; };
+
+  bool UsesFunctionLibrary() const override { return false; }
+
+  Status Optimize(Cluster* cluster, const GrapplerItem& item,
+                  GraphDef* optimized_graph) override;
+};
+
+}  // end namespace grappler
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_SHAPE_OPTIMIZER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/static_schedule.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/static_schedule.h
new file mode 100644
index 0000000000000000000000000000000000000000..678b4d193fb30610820769d5e899322f924da4ad
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/static_schedule.h
@@ -0,0 +1,50 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_STATIC_SCHEDULE_H_
+#define TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_STATIC_SCHEDULE_H_
+
+#include <unordered_map>
+
+#include "tensorflow/core/framework/node_def.pb.h"
+#include "tensorflow/core/grappler/clusters/cluster.h"
+#include "tensorflow/core/grappler/costs/cost_estimator.h"
+#include "tensorflow/core/grappler/grappler_item.h"
+
+namespace tensorflow {
+namespace grappler {
+
+// Compute the earliest time at which the execution of each node in the graph
+// can complete.
+// In our estimation, we ensure that each node takes at least one nanosecond to
+// execute: therefore the execution times can be used to derive a topological
+// ordering of the graph (at least as long as there is no loop in the graph).
+Status EstimateEarliestExecutionTimes(
+    const GrapplerItem& item, const Cluster* cluster,
+    std::unordered_map<const NodeDef*, Costs::NanoSeconds>* execution_times);
+
+// Compute the time by which the execution of each node must complete to ensure
+// the subsequent nodes can still be executed by the times predicted by the
+// EstimateEarliestExecutionTimes function.
+Status EstimateRequiredTimes(
+    const GrapplerItem& item, const Cluster* cluster,
+    const std::unordered_map<const NodeDef*, Costs::NanoSeconds>&
+        execution_times,
+    std::unordered_map<const NodeDef*, Costs::NanoSeconds>* required_times);
+
+}  // namespace grappler
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_STATIC_SCHEDULE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/tfg_optimizer_hook.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/tfg_optimizer_hook.h
new file mode 100644
index 0000000000000000000000000000000000000000..5160862f60b70bb0578d66eb14a81240025ba192
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/tfg_optimizer_hook.h
@@ -0,0 +1,65 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_TFG_OPTIMIZER_HOOK_H_
+#define TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_TFG_OPTIMIZER_HOOK_H_
+
+#include <functional>
+#include <string>
+
+#include "tensorflow/core/grappler/optimizers/graph_optimizer.h"
+
+namespace mlir {
+class PassManager;
+
+namespace tfg {
+
+// A function that builds the TFG pass pipeline.
+using TFGPassPipelineBuilder = std::function<void(PassManager& pm)>;
+
+// This class implements a Grappler optimizer wrapping a pipeline of passes
+// implemented with TFG.
+class TFGGrapplerOptimizer : public tensorflow::grappler::GraphOptimizer {
+ public:
+  // Constructs a TFG optimizer using the provided pipeline builder. By default,
+  // the optimizer will not use multi-threading. If `num_tfg_threads` is
+  // non-zero, then TFG will use threading with the specified number of threads.
+  explicit TFGGrapplerOptimizer(TFGPassPipelineBuilder builder,
+                                unsigned num_tfg_threads = 0);
+  // Explicit destructor to defer instantiation of Impl.
+  ~TFGGrapplerOptimizer() override;
+
+  // Constructs a name for the optimizer using the registered passes.
+  std::string name() const override;
+  // The TFG optimizer requires access to the function library.
+  bool UsesFunctionLibrary() const override { return true; }
+
+  // Runs the optimizer on the GraphDef. The optimizer converts the GraphDef to
+  // TFG using the importer, runs the passes on the MLIR, and exports back to
+  // GraphDef. The result is stored in `optimized_graph`.
+  tensorflow::Status Optimize(tensorflow::grappler::Cluster* cluster,
+                              const tensorflow::grappler::GrapplerItem& item,
+                              tensorflow::GraphDef* optimized_graph) override;
+
+ private:
+  // Hide the implementation details.
+  class Impl;
+  std::unique_ptr<Impl> impl_;
+};
+
+}  // end namespace tfg
+}  // end namespace mlir
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_TFG_OPTIMIZER_HOOK_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/tfg_passes_builder.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/tfg_passes_builder.h
new file mode 100644
index 0000000000000000000000000000000000000000..4aee20b7a948049cc8677b670632a23c02c6cd5c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/optimizers/tfg_passes_builder.h
@@ -0,0 +1,38 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_TFG_PASSES_BUILDER_H_
+#define TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_TFG_PASSES_BUILDER_H_
+
+#include "mlir/Pass/PassManager.h"  // from @llvm-project
+#include "tensorflow/core/protobuf/rewriter_config.pb.h"
+
+namespace mlir {
+namespace tfg {
+
+// Constructs the default graph/function-level TFG pass pipeline.
+void DefaultGrapplerPipeline(PassManager& manager);
+
+// Constructs the default module-level TFG pass pipeline.
+void DefaultModuleGrapplerPipeline(PassManager& manager,
+                                   const tensorflow::RewriterConfig& config);
+
+// Constructs the Remapper pass pipeline.
+void RemapperPassBuilder(PassManager& manager);
+
+}  // namespace tfg
+}  // namespace mlir
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_OPTIMIZERS_TFG_PASSES_BUILDER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/utils.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..a15a83e1c0ca8a48519ec0a1c88f7721ee34f02b
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/utils.h
@@ -0,0 +1,432 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_UTILS_H_
+#define TENSORFLOW_CORE_GRAPPLER_UTILS_H_
+
+#include <functional>
+#include <iterator>
+#include <utility>
+#include <vector>
+
+#include "absl/container/flat_hash_set.h"
+#include "absl/container/node_hash_map.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/span.h"
+#include "tensorflow/core/framework/graph.pb.h"
+#include "tensorflow/core/framework/node_def.pb.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/graph/tensor_id.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/lib/core/stringpiece.h"
+#include "tensorflow/core/lib/core/threadpool.h"
+#include "tensorflow/core/lib/gtl/flatmap.h"
+#include "tensorflow/core/lib/gtl/flatset.h"
+#include "tensorflow/core/lib/gtl/inlined_vector.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+namespace grappler {
+
+// Utilities for manipulating node name and input strings.
+
+// Returns the trailing position number (or zero if no number is present) if
+// NodeName(input_name) is equal to node_name. Returns -1 for control inputs.
+// Returns -2 if input_name is empty or NodeName(input_name) is not equal to
+// node_name.
+inline int NodePositionIfSameNode(absl::string_view input_name,
+                                  absl::string_view node_name) {
+  bool is_control = absl::StartsWith(input_name, "^");
+  if (is_control) input_name.remove_prefix(1);
+  if (input_name.empty() || node_name.empty() ||
+      input_name.size() < node_name.size()) {
+    return -2;
+  }
+  TensorId id = ParseTensorName(input_name);
+  if (id.first != node_name) return -2;
+  if (is_control) return -1;
+  return id.second;
+}
+
+// Returns the node name and position in a single call.
+inline StringPiece ParseNodeNameAsStringPiece(absl::string_view name,
+                                              int* position) {
+  const bool is_control = absl::StartsWith(name, "^");
+  TensorId id = ParseTensorName(name);
+  if (position) {
+    *position = is_control ? -1 : id.second;
+  }
+  if (is_control && id.second >= 0) {
+    id.first.remove_prefix(1);
+  }
+  return id.first;
+}
+
+// Returns the node name and position in a single call.
+inline string ParseNodeName(const string& name, int* position) {
+  return string(ParseNodeNameAsStringPiece(name, position));
+}
+
+// Return the node name corresponding to 'name' if name is valid, or the empty
+// string otherwise.
+inline StringPiece NodeNameAsStringPiece(const string& name) {
+  return ParseNodeNameAsStringPiece(name, nullptr);
+}
+
+// Return the node name corresponding to 'name' if name is valid, or the empty
+// string otherwise.
+inline string NodeName(const string& name) {
+  return string(NodeNameAsStringPiece(name));
+}
+
+inline int NodePosition(const string& name) {
+  int position;
+  ParseNodeNameAsStringPiece(name, &position);
+  return position;
+}
+
+namespace internal {
+// Base template class for NodeMap and ImmutableNodeMap.
+template <typename GraphDefT, typename NodeDefT>
+class NodeMapInternal {
+ public:
+  // Note: The NodeMap will store pointers to nodes in graph, which may become
+  // invalid if graph is changed.
+  explicit NodeMapInternal(GraphDefT* graph) {
+    if (graph == nullptr) {
+      LOG(WARNING) << "NodeMapInternal constructor is called with a nullptr!";
+      return;
+    }
+    nodes_.reserve(graph->node_size());
+    outputs_.reserve(graph->node_size());
+    for (int i = 0; i < graph->node_size(); i++) {
+      NodeDefT* node = GetNodeDefFromGraph(graph, i);
+      const string& node_name = node->name();
+      auto rslt = nodes_.emplace(node_name, node);
+      // Check that the graph doesn't contain multiple nodes with the same name.
+      if (!rslt.second) {
+        // The first node found with a given name becomes the canonical.
+        LOG(WARNING) << "Duplicated node in the graph: " << node_name;
+      }
+      NodeDefT* canonical = rslt.second ? node : rslt.first->second;
+      for (const auto& input : node->input()) {
+        outputs_[NodeName(input)].insert(canonical);
+      }
+    }
+  }
+
+  // Get unordered list of fanouts from node. Notice, that the order is
+  // non-deterministic.
+  const absl::flat_hash_set<NodeDefT*>& GetOutputs(
+      const string& node_name) const {
+    auto it = outputs_.find(node_name);
+    if (it == outputs_.end()) {
+      return empty_set_;
+    }
+    return it->second;
+  }
+
+  // Get fanouts ordered by name.
+  std::vector<NodeDefT*> GetOutputsOrderedByNodeName(
+      const string& node_name) const {
+    std::vector<NodeDefT*> result;
+    auto it = outputs_.find(node_name);
+    if (it != outputs_.end()) {
+      const absl::flat_hash_set<NodeDefT*>& outputs = it->second;
+      result.reserve(outputs.size());
+      result.assign(outputs.begin(), outputs.end());
+      std::sort(result.begin(), result.end(),
+                [](const NodeDef* n1, const NodeDef* n2) {
+                  return n1->name() < n2->name();
+                });
+    }
+    return result;
+  }
+
+  // This method doesn't record the outputs of the added node; the outputs need
+  // to be explicitly added by the AddOutput method.
+  void AddNode(const string& node_name, NodeDefT* node) {
+    DCHECK(node != nullptr);
+    auto ret = nodes_.emplace(node_name, node);
+    DCHECK(ret.second)
+        << "Pair (" << node_name << "," << node
+        << ") is not inserted because the same key already exists.";
+  }
+
+  void RemoveNode(const string& name) {
+    nodes_.erase(NodeName(name));
+    outputs_.erase(NodeName(name));
+  }
+
+  NodeDefT* GetNode(const string& name) const {
+    const string node_name = NodeName(name);
+    auto it = nodes_.find(node_name);
+    if (it == nodes_.end()) {
+      VLOG(1) << "Node could not be found: " << name;
+      return nullptr;
+    }
+    return it->second;
+  }
+
+  bool NodeExists(const string& name) const {
+    const string node_name = NodeName(name);
+    return nodes_.find(node_name) != nodes_.end();
+  }
+
+  void AddOutput(const string& node_name, const string& output_name) {
+    auto output_node = nodes_[NodeName(output_name)];
+    DCHECK(output_node) << "Output node " << output_name
+                        << " is missing in NodeMap.";
+    outputs_[node_name].insert(output_node);
+  }
+
+  void RemoveOutput(const string& node_name, const string& output_name) {
+    outputs_[node_name].erase(nodes_[NodeName(output_name)]);
+  }
+
+  void UpdateInput(const string& node_name, const string& old_input_name,
+                   const string& new_input_name) {
+    RemoveOutput(NodeName(old_input_name), node_name);
+    AddOutput(NodeName(new_input_name), node_name);
+  }
+
+  void RemoveInputs(const string& node_name) {
+    auto node = nodes_[node_name];
+    for (const auto& input : node->input()) {
+      RemoveOutput(NodeName(input), node->name());
+    }
+  }
+
+  void RemoveOutputs(const string& node_name) { outputs_.erase(node_name); }
+
+  void UpdateOutput(const string& node_name, const string& old_output_name,
+                    const string& new_output_name) {
+    absl::flat_hash_set<NodeDef*>& outputs = outputs_[node_name];
+    outputs.erase(nodes_[NodeName(old_output_name)]);
+    outputs.insert(nodes_[NodeName(new_output_name)]);
+  }
+
+ private:
+  // Helper method to get the NodeDef pointer of i-th node in a graph.
+  inline NodeDefT* GetNodeDefFromGraph(GraphDefT* graph, int64_t i) const;
+
+  const absl::flat_hash_set<NodeDefT*> empty_set_;
+  absl::node_hash_map<string, NodeDefT*> nodes_;
+  absl::node_hash_map<string, absl::flat_hash_set<NodeDefT*>> outputs_;
+};
+
+// Specialized template class method GetNodeDefFromGraph.
+template <>
+inline NodeDef* NodeMapInternal<GraphDef, NodeDef>::GetNodeDefFromGraph(
+    GraphDef* graph, int64_t i) const {
+  return graph->mutable_node(i);
+}
+
+template <>
+inline const NodeDef*
+NodeMapInternal<const GraphDef, const NodeDef>::GetNodeDefFromGraph(
+    const GraphDef* graph, int64_t i) const {
+  return &graph->node(i);
+}
+}  // namespace internal
+
+// A utility class to lookup a node and its outputs by node name.
+class NodeMap : public internal::NodeMapInternal<GraphDef, NodeDef> {
+ public:
+  explicit NodeMap(GraphDef* graph) : NodeMapInternal(graph) {}
+};
+
+// Same to NodeMap, but uses const GraphDef.
+class ImmutableNodeMap
+    : public internal::NodeMapInternal<const GraphDef, const NodeDef> {
+ public:
+  explicit ImmutableNodeMap(const GraphDef* graph) : NodeMapInternal(graph) {}
+};
+
+// A vector with a set. The set stores the same elements as the vector, and
+// quickly answers whether a value is in the vector. Duplicated elements are not
+// allowed for now.
+template <class T, class Hash = std::hash<T>>
+class SetVector {
+ public:
+  // Returns false if value already existed in the set, true otherwise.
+  bool PushBack(const T& value) {
+    if (!set_.insert(value).second) {
+      return false;
+    }
+    vector_.push_back(value);
+    return true;
+  }
+
+  T PopBack() {
+    T back = vector_.back();
+    set_.erase(back);
+    vector_.pop_back();
+    return back;
+  }
+
+  bool Exists(const T& value) const { return set_.find(value) != set_.end(); }
+
+  bool Empty() const { return vector_.empty(); }
+
+  void Reserve(int64_t size) { vector_.reserve(size); }
+
+ private:
+  gtl::FlatSet<T, Hash> set_;
+  std::vector<T> vector_;
+};
+
+// Returns formatted string from TensorId specific to grappler. Specifically,
+// for the 0 port (first output), only the node name is returned.
+string TensorIdToString(const TensorId& tensor_id);
+
+// Returns formatted string from SafeTensorId specific to grappler.
+// Specifically, for the 0 port (first output), only the node name is returned.
+string SafeTensorIdToString(const SafeTensorId& tensor_id);
+
+// True iff 'name' refers to a control inputs, i.e. a node name prefixed with
+// the ^ character.
+bool IsControlInput(absl::string_view name);
+
+// True iff tensor index refers to a control input.
+bool IsControlInput(const TensorId& tensor_id);
+
+// True iff 'name1' and 'name2' refer to the same input.
+bool IsSameInput(const string& name1, const string& name2);
+
+
+// Add a prefix to a node name with a custom delimiter.
+string AddPrefixToNodeName(const string& name, const string& prefix,
+                           const string& delimiter);
+
+// Add a prefix to a node name.
+string AddPrefixToNodeName(const string& name, const string& prefix);
+
+// Executes a 'fn' in the 'thread_pool'. The method waits for the configured
+// timeout (in milliseconds) for 'fn' to complete, before returning false.
+//
+// If returning false, the 'fn' may still continue to execute in the
+// thread-pool. It is the responsibility of the caller to reset the thread-pool
+// as appropriate.
+bool ExecuteWithTimeout(std::function<void()> fn, int64_t timeout_in_ms,
+                        thread::ThreadPool* thread_pool);
+
+// Returns the node name prefixed with conventional symbol '^'
+// for control dependency, given a NodeDef.
+string AsControlDependency(const NodeDef& node);
+
+// Returns the node name prefixed with conventional symbol '^'
+// for control dependency, given a node name
+string AsControlDependency(const string& node);
+
+// Returns true if the node is assigned to run on CPU device.
+bool NodeIsOnCpu(const NodeDef* node);
+
+// Returns true if the node is assigned to run on GPU device.
+bool NodeIsOnGpu(const NodeDef* node);
+
+// Returns the number of outputs of a node according to its OpDef. Note that
+// some of the outputs may be unconnected.
+int NumOutputs(const NodeDef& node, GraphDef* graph);
+
+// Returns true iff the node has at least one control input.
+bool HasControlInputs(const NodeDef& node);
+
+// Returns true iff the node has at least one regular input.
+bool HasRegularInputs(const NodeDef& node);
+
+// Returns true iff the node has at least one regular output.
+bool HasRegularOutputs(const NodeDef& node, const NodeMap& node_map);
+
+// Returns true iff the node has at least one control output.
+bool HasControlOutputs(const NodeDef& node, const NodeMap& node_map);
+
+// Number of connected control inputs.
+int NumControlInputs(const NodeDef& node);
+
+// Number of connected non-control inputs.
+int NumNonControlInputs(const NodeDef& node);
+
+// Number of connected control outputs.
+int NumControlOutputs(const NodeDef& node, const NodeMap& node_map);
+
+// Number of connected non-control outputs.
+int NumNonControlOutputs(const NodeDef& node, const NodeMap& node_map);
+
+// Number of connected non-control data outputs (Ops that consume output tensor
+// data, not just it's shape).
+int NumNonControlDataOutputs(const NodeDef& node, const NodeMap& node_map);
+
+// Removes redundant control inputs from node.
+void DedupControlInputs(NodeDef* node);
+
+// Returns an error if an attribute with the given key does not exist in node.
+Status CheckAttrExists(const NodeDef& node, const string& key);
+
+// Returns an error if attributes with the given keys do not exist in node.
+Status CheckAttrsExist(const NodeDef& node, absl::Span<const string> keys);
+
+// Returns the data type in attribute `attr_name` of `node`. If that attribute
+// doesn't exist, returns DT_INVALID.
+DataType GetDataTypeFromAttr(const NodeDef& node, const string& type_attr);
+
+// Returns the last node in the simple chain starting at source and traversing
+// through the input(0) edge from each node as long as the next node satisfies
+// the predicate given in pred_fn. If no nodes satisfy the predicate, &source
+// will be returned. Example: For the chain
+//    source <- a <- b <- ... <- y <- z
+// where
+//    pred_fn(a) = pred_fn(b) = ... = pred_fn(y) = true,
+//    pred_fn(z) = false,
+// the return value will be a pointer to y.
+NodeDef* GetTailOfChain(const NodeDef& source, const NodeMap& node_map,
+                        bool follow_control_input,
+                        const std::function<bool(const NodeDef&)>& pred_fn);
+
+// Permute the nodes of graph in place according to the permutation.
+void PermuteNodesInPlace(GraphDef* graph, std::vector<int>* permutation,
+                         bool invert_permutation);
+
+// Returns OkStatus() if a kernel is registered for node.op() on the device
+// type corresponding to node.device().
+Status IsKernelRegisteredForNode(
+    absl::string_view node_name, bool has_experimental_debug_info,
+    const NodeDef_ExperimentalDebugInfo& experimental_debug_info,
+    absl::string_view node_op, absl::string_view node_device,
+    AttrSlice node_attrs);
+Status IsKernelRegisteredForNode(const NodeDef& node);
+
+Status SetTensorValue(DataType dtype, int value, Tensor* tensor);
+
+void EraseNodesFromGraph(const std::set<int>& nodes_to_delete, GraphDef* graph);
+
+void EraseNodesFromGraph(std::vector<int>&& nodes_to_delete, GraphDef* graph);
+
+void EraseNodesFromGraph(const std::set<string>& nodes_to_delete,
+                         GraphDef* graph);
+
+// Erase all attributes without leading underscore. Returns the number of
+// attributes erased.
+int EraseRegularNodeAttributes(NodeDef* node);
+
+// Erase attribute "_xla_inferred_shapes" as well as all attributes starting in
+// "_output_".
+int EraseNodeOutputAttributes(NodeDef* node);
+
+}  // end namespace grappler
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_UTILS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/utils/canonicalizer.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/utils/canonicalizer.h
new file mode 100644
index 0000000000000000000000000000000000000000..a913fc252339372b13b1e2cb3dae43db4e65822a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/utils/canonicalizer.h
@@ -0,0 +1,45 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_UTILS_CANONICALIZER_H_
+#define TENSORFLOW_CORE_GRAPPLER_UTILS_CANONICALIZER_H_
+
+#include "tensorflow/core/framework/graph.pb.h"
+#include "tensorflow/core/framework/node_def.pb.h"
+#include "tensorflow/core/lib/core/status.h"
+
+namespace tensorflow {
+namespace grappler {
+
+// Canonicalizes node by performing the following steps
+//  - sorting control inputs,
+//  - sorting data inputs if the node represents a commutative op.
+void CanonicalizeNode(NodeDef* node);
+
+// Canonicalizes all nodes in graph.
+void CanonicalizeGraph(GraphDef* graph);
+
+// Compresses Const and HostConstant nodes in the graph to the smallest
+// representation possible, either
+//   a) truncated repeated field representation, or
+//   b) raw serialized byte format.
+// Each node is only modified if it is larger than 64 bytes and compression
+// reduces its size by more than 50%.
+void CompressConstants(GraphDef* graph);
+
+}  // namespace grappler
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_UTILS_CANONICALIZER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/utils/colocation.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/utils/colocation.h
new file mode 100644
index 0000000000000000000000000000000000000000..6062db6102c50853145b15dae08994e971cca83d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/utils/colocation.h
@@ -0,0 +1,39 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_UTILS_COLOCATION_H_
+#define TENSORFLOW_CORE_GRAPPLER_UTILS_COLOCATION_H_
+
+#include <unordered_map>
+#include "tensorflow/core/framework/graph.pb.h"
+
+namespace tensorflow {
+namespace grappler {
+
+// Evaluates the colocation relation in the graph and rewrites the new
+// colocation relation in the graph. We scan the graph nodes sequentially, and
+// builds a disjoint-sets of nodes (within each disjoint-set the nodes are
+// colocated with each other). We then select the root node of each set as a
+// representative node, and then colocate each node within the set (should also
+// exist in graph) with the representative node.
+// Note that there is current one situation this function can't handle:
+// Node A colocates with X, node B colocates with Y, X colocates with Y but
+// X, Y are removed from graph. In this case we can't know A colocates with B.
+void ReassignColocation(GraphDef* graph);
+
+}  // namespace grappler
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_UTILS_COLOCATION_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/utils/frame.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/utils/frame.h
new file mode 100644
index 0000000000000000000000000000000000000000..c95597a246de6e9b7112cd63681542eb053bb77f
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/utils/frame.h
@@ -0,0 +1,75 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_UTILS_FRAME_H_
+#define TENSORFLOW_CORE_GRAPPLER_UTILS_FRAME_H_
+
+#include "absl/container/flat_hash_map.h"
+#include "tensorflow/core/framework/graph.pb.h"
+#include "tensorflow/core/grappler/utils/graph_view.h"
+#include "tensorflow/core/lib/core/status.h"
+
+namespace tensorflow {
+namespace grappler {
+
+// FrameView is a helper class that allows to find in what execution frames (if
+// any) the given node can be running in. It's constructed from an immutable
+// GraphView, and any modification of the underlying graph might invalidate it.
+//
+// All execution frames assigned a unique integer id, but they do not have any
+// meaning whatsoever, it's just a sequence number.
+//
+// See the paper "Dynamic Control Flow in Large-Scale Machine Learning" for
+// detailed explanation of execution frames (https://arxiv.org/abs/1805.01772).
+class FrameView {
+ public:
+  FrameView() : is_inferred_(false), num_frames_(0) {}
+
+  // Infers nodes execution frames from the GraphView. Returns an error if
+  // called multiple times.
+  Status InferFromGraphView(const utils::GraphView& graph_view);
+  // Infers nodes execution frames from the MutableGraphView. Returns an error
+  // if called multiple times.
+  Status InferFromGraphView(const utils::MutableGraphView& graph_view);
+  // Infers nodes execution by constructing temporary GraphView and passing it
+  // to InferFromGraphView.
+  Status InferFromGraph(const GraphDef& graph);
+
+  // Returns all frames of the given node (denoted by their frame ids) in
+  // outermost-to-innermost order.
+  const std::vector<int>& Frames(const NodeDef& node) const;
+
+  // Returns true iff the node is at least in one execution frame.
+  bool IsInFrame(const NodeDef& node) const;
+
+  int num_frames() const { return num_frames_; }
+  bool is_inferred() const { return is_inferred_; }
+
+ private:
+  template <typename GraphViewT>
+  inline Status InferFromGraphViewT(const GraphViewT& graph_view);
+
+  bool is_inferred_;  // true if it was inferred from the graph
+  int num_frames_;    // number of frames present in a graph
+  absl::flat_hash_map<const NodeDef*, std::vector<int>> node_to_frames_;
+
+  // We return a reference to this vector if node has no frames.
+  const std::vector<int> node_has_no_frames_;
+};
+
+}  // namespace grappler
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_UTILS_FRAME_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/utils/functions.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/utils/functions.h
new file mode 100644
index 0000000000000000000000000000000000000000..696963dbfa2ca051f0cf0aec7bcbc515893b0eb8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/utils/functions.h
@@ -0,0 +1,189 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_UTILS_FUNCTIONS_H_
+#define TENSORFLOW_CORE_GRAPPLER_UTILS_FUNCTIONS_H_
+
+#include <memory>
+#include <string>
+
+#include "absl/container/flat_hash_map.h"
+#include "absl/container/flat_hash_set.h"
+#include "absl/container/inlined_vector.h"
+#include "tensorflow/core/framework/attr_value.pb.h"
+#include "tensorflow/core/framework/function.h"
+#include "tensorflow/core/framework/function.pb.h"
+#include "tensorflow/core/framework/node_def_util.h"
+#include "tensorflow/core/framework/op_def.pb.h"
+#include "tensorflow/core/grappler/grappler_item.h"
+#include "tensorflow/core/lib/gtl/flatset.h"
+
+namespace tensorflow {
+namespace grappler {
+
+// Function input argument instantiated into an '_Arg' node in the function body
+// graph, with an 'index' attribute corresponding to the input position.
+struct InputArgInstantiation {
+  InputArgInstantiation(string node_name, DataType data_type)
+      : node_name(std::move(node_name)), data_type(data_type) {}
+  string node_name;
+  DataType data_type;
+};
+
+// Function output instantiated into a '_Retval' node in the function body
+// graph, with an 'index' attribute corresponding to the output position.
+struct OutputArgInstantiation {
+  OutputArgInstantiation(string node_name, DataType data_type)
+      : node_name(std::move(node_name)), data_type(data_type) {}
+  string node_name;
+  DataType data_type;
+};
+
+// A mapping from control output name to node name in function body graph.
+struct ControlOutput {
+  string output_name;
+  string node_name;
+  bool operator<(const ControlOutput& a) const {
+    return output_name < a.output_name;
+  }
+};
+
+// A special case of GrapplerItem, constructed from a TensorFlow Function.
+class GrapplerFunctionItem : public GrapplerItem {
+ public:
+  GrapplerFunctionItem() = default;
+
+  const string& description() const;
+
+  const std::vector<InputArgInstantiation>& inputs() const;
+  const InputArgInstantiation& input(int i) const;
+  const std::size_t input_size() const;
+
+  const std::vector<OutputArgInstantiation>& outputs() const;
+  const OutputArgInstantiation& output(int i) const;
+  const std::size_t output_size() const;
+
+  const std::vector<ControlOutput>& control_outputs() const;
+  const std::size_t control_output_size() const;
+
+  const AttrSlice& func_attr() const;
+  const std::vector<const FunctionDef::ArgAttrs*>& arg_attr() const;
+  const GraphDef& function_body() const;
+  GraphDef& mutable_function_body();
+
+  bool is_stateful() const;
+
+  GrapplerFunctionItem& SwapFunctionBody(GraphDef&& other);
+
+ private:
+  friend Status MakeGrapplerFunctionItem(const FunctionDef&, const AttrSlice&,
+                                         const FunctionLibraryDefinition&, int,
+                                         GrapplerFunctionItem*);
+  friend Status ReplaceInputWithConst(const NodeDef&, int,
+                                      GrapplerFunctionItem*);
+  friend Status RemoveFunctionOutputs(const absl::flat_hash_set<int>&,
+                                      GrapplerFunctionItem*,
+                                      std::vector<std::pair<int, int>>*);
+
+  GrapplerFunctionItem(string func_name, string description,
+                       AttrSlice func_attr,
+                       std::vector<const FunctionDef::ArgAttrs*> arg_attr,
+                       std::vector<InputArgInstantiation> input_args,
+                       std::vector<OutputArgInstantiation> output_args,
+                       std::vector<ControlOutput> control_outputs,
+                       int graph_def_version, bool is_stateful,
+                       GraphDef&& function_body);
+
+  string description_;
+  AttrSlice func_attr_;  // Attributes specific to function definition that
+                         // produced this item (FuncDef.attr field).
+
+  // Attributes of function arguments
+  std::vector<const FunctionDef::ArgAttrs*> arg_attr_;
+
+  std::vector<InputArgInstantiation> input_args_;
+  std::vector<OutputArgInstantiation> output_args_;
+  std::vector<ControlOutput> control_outputs_;
+
+  bool is_stateful_ = false;
+};
+
+// Check if function input/output types are fully defined only at instantiation
+// time (parametrized by its instantiation node).
+bool HasParametrizedType(const FunctionDef& func);
+
+// Check if a function body is parametrized by its instantiation node. Function
+// body is parametrized, if it has at least one node with a 'placeholder'
+// attribute.
+bool HasParametrizedBody(const FunctionDef& func);
+
+// Check if function has parametrized type or body.
+bool IsParametrized(const FunctionDef& func);
+
+// Resolve function instantiation type parameters from the attributes of the
+// caller node. Return error if type can't be resolved.
+Status InstantiationTypeParameters(
+    const FunctionDef& func, const AttrSlice& func_instantiation_attr,
+    absl::flat_hash_map<string, DataType>* type_parameters);
+
+// Resolve function instantiation body parameters (values for the function body
+// attr placeholders) from the attributes of the caller node. Return error if
+// type can't be resolved.
+Status InstantiationBodyParameters(
+    const FunctionDef& func, const AttrSlice& func_instantiation_attr,
+    absl::flat_hash_map<string, AttrValue>* body_parameters);
+
+// Replace one of the function inputs with a constant.
+Status ReplaceInputWithConst(const NodeDef& input_const, int input_index,
+                             GrapplerFunctionItem* item);
+
+// Removes outputs from instantiated grappler function item. For all active
+// function outputs that changed its output index, this function adds an output
+// mapping (std::pair<old index, new index>).
+Status RemoveFunctionOutputs(const absl::flat_hash_set<int>& remove_outputs,
+                             GrapplerFunctionItem* item,
+                             std::vector<std::pair<int, int>>* output_mapping);
+
+// TODO(ezhulenev, b/120103818): Add RemoveFunctionInputs.
+
+// Make a GrapplerFunctionItem from the function definition and function
+// instantiation attributes (caller node attributes). Returns error if the given
+// function def cannot be converted (e.g. not all attributes are defined).
+Status MakeGrapplerFunctionItem(const FunctionDef& func,
+                                const AttrSlice& func_instantiation_attr,
+                                const FunctionLibraryDefinition& flib,
+                                int graph_def_version,
+                                GrapplerFunctionItem* item);
+
+// Make a GrapplerFunction item from the function definition. Function must be
+// fully defined (no type or body parametrization).
+// TODO(ezhulenev): Support parametrized functions without fully defined
+// instantiation attributes? Do we ever want to optimize parametrized function
+// without specializing it to its instantiation attributes (at least types)?
+Status MakeGrapplerFunctionItem(const FunctionDef& func,
+                                const FunctionLibraryDefinition& flib,
+                                int graph_def_version,
+                                GrapplerFunctionItem* item);
+
+// Make a FunctionDef from the GrapplerFunctionItem. Use function library
+// definition to lookup function body nodes output names and ranges.
+Status MakeFunctionDef(const GrapplerFunctionItem& item,
+                       const FunctionLibraryDefinition& flib,
+                       FunctionDef* func);
+
+}  // end namespace grappler
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_UTILS_FUNCTIONS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/utils/graph_view.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/utils/graph_view.h
new file mode 100644
index 0000000000000000000000000000000000000000..575df428d6d2c4112b13fa87edade9b532f0f1f3
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/utils/graph_view.h
@@ -0,0 +1,541 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_UTILS_GRAPH_VIEW_H_
+#define TENSORFLOW_CORE_GRAPPLER_UTILS_GRAPH_VIEW_H_
+
+#include <vector>
+
+#include "absl/container/flat_hash_map.h"
+#include "absl/container/flat_hash_set.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/span.h"
+#include "tensorflow/core/framework/attr_value.pb.h"
+#include "tensorflow/core/framework/graph.pb.h"
+#include "tensorflow/core/framework/node_def.pb.h"
+#include "tensorflow/core/framework/node_def_util.h"
+#include "tensorflow/core/graph/tensor_id.h"
+#include "tensorflow/core/grappler/utils/graph_view_internal.h"
+#include "tensorflow/core/lib/core/status.h"
+
+namespace tensorflow {
+namespace grappler {
+namespace utils {
+
+class NodeView;
+
+class GraphView;
+
+// FaninView is a helper class to represent fanouts of a node. This holds a
+// pointer to GraphView, the index of the node being represented from GraphView,
+// and the input index (hence is labeled as Fanin).
+class FaninView : public internal::NodeIndexAndPortIndex<NodeView, GraphView> {
+ public:
+  FaninView() : NodeIndexAndPortIndex() {}
+
+  FaninView(GraphView* graph_view, int node_index, int port_index)
+      : NodeIndexAndPortIndex(graph_view, node_index, port_index) {}
+
+  FaninView(NodeView* node_view, int index);
+
+ private:
+  friend class NodeView;
+  friend class GraphView;
+};
+
+// FanoutView is a helper class to represent fanins of a node. This holds a
+// pointer to GraphView, the index of the node being represented from GraphView,
+// and the output index (hence is labeled as Fanout).
+class FanoutView : public internal::NodeIndexAndPortIndex<NodeView, GraphView> {
+ public:
+  FanoutView() : NodeIndexAndPortIndex() {}
+
+  FanoutView(GraphView* graph_view, int node_index, int port_index)
+      : NodeIndexAndPortIndex(graph_view, node_index, port_index) {}
+
+  FanoutView(NodeView* node_view, int index);
+
+ private:
+  friend class NodeView;
+  friend class GraphView;
+};
+
+// Immutable NodeView that keeps the constness of the NodeDef. This allows for
+// lookups of fanins and fanouts, and traversals of the graph, but no mutations.
+// No dedupping of fanins will be performed on the node to preserve it's
+// constness.
+class NodeView : public internal::NodeViewInternal<FaninView, FanoutView,
+                                                   GraphView, true> {
+ public:
+  explicit NodeView(GraphView* graph_view, int node_index)
+      : NodeViewInternal(graph_view, node_index) {}
+
+  NodeView() : NodeViewInternal() {}
+
+  ~NodeView() override = default;
+
+  NodeView(NodeView&&) = default;
+  NodeView& operator=(NodeView&&) = default;
+
+  const NodeDef* node() const override;
+
+  // Checks if a fanin exists for the node.
+  bool HasFanin(const FanoutView& fanin) const override;
+
+  // Checks if a fanout exists for the node.
+  bool HasFanout(const FaninView& fanout) const override;
+
+ private:
+  inline const FanoutView& GetMissingFanin() const override;
+
+  inline const std::vector<FaninView>& GetMissingFanout() const override;
+
+  absl::flat_hash_set<internal::NodeDefAndPortIndex> fanins_set_;
+
+  friend class FaninView;
+  friend class FanoutView;
+  friend class GraphView;
+};
+
+// Immutable GraphView that keeps the constness of the GraphDef. This allows
+// for lookups and traversals of the graph, but no mutations.
+class GraphView : public internal::GraphViewInternal<NodeView, FaninView,
+                                                     FanoutView, true> {
+ public:
+  explicit GraphView(const GraphDef* graph, Status* status);
+  ~GraphView() override = default;
+
+ private:
+  bool AddUniqueNodeInternal(const NodeDef* node);
+
+  Status CheckAndAddFaninsInternal(NodeView* node_view);
+
+  friend class NodeView;
+};
+
+class MutableNodeView;
+
+class MutableGraphView;
+
+class Mutation;
+
+// MutableFaninView is a helper class to represent fanouts of a node. This holds
+// a pointer to MutableGraphView, the index of the node from MutableGraphView
+// being mutated, and the input index (hence is labeled as Fanin).
+class MutableFaninView
+    : public internal::NodeIndexAndPortIndex<MutableNodeView,
+                                             MutableGraphView> {
+ public:
+  MutableFaninView() : NodeIndexAndPortIndex() {}
+
+  MutableFaninView(MutableGraphView* graph_view, int node_index, int port_index)
+      : NodeIndexAndPortIndex(graph_view, node_index, port_index) {}
+
+  explicit MutableFaninView(MutableGraphView* graph_view, int node_index,
+                            int port_index, int fanin_index)
+      : NodeIndexAndPortIndex(graph_view, node_index, port_index),
+        fanin_index_(fanin_index) {
+    // TODO(lyandy): Remove once constructor is not public.
+    DCHECK(port_index < 0 || port_index == fanin_index);
+  }
+
+  MutableFaninView(MutableNodeView* node_view, int index);
+
+ private:
+  // Index of associated fanin in fanout's underlying MutableNodeView. For
+  // regular fanouts, this will be the same as port_index (index of the
+  // associated fanin in MutableNodeView::regular_fanins_). For controlled
+  // fanouts, this will be the index of the associated fanin in
+  // MutableNodeView::controlling_fanins_.
+  int fanin_index_ = internal::kMissingIndex;
+
+  friend class MutableNodeView;
+  friend class MutableGraphView;
+  friend class Mutation;
+};
+
+// MutableFanoutView is a helper class to represent fanins of a node. This holds
+// a pointer to MutableGraphView, the index of the node from MutableGraphView
+// being mutated, and the output index (hence is labeled as Fanout).
+class MutableFanoutView
+    : public internal::NodeIndexAndPortIndex<MutableNodeView,
+                                             MutableGraphView> {
+ public:
+  MutableFanoutView() : NodeIndexAndPortIndex() {}
+
+  MutableFanoutView(MutableGraphView* graph_view, int node_index,
+                    int port_index)
+      : NodeIndexAndPortIndex(graph_view, node_index, port_index) {}
+
+  explicit MutableFanoutView(MutableGraphView* graph_view, int node_index,
+                             int port_index, int fanout_index)
+      : NodeIndexAndPortIndex(graph_view, node_index, port_index),
+        fanout_index_(fanout_index) {}
+
+  MutableFanoutView(MutableNodeView* node_view, int index);
+
+ private:
+  // Index of associated fanout in fanin's underlying MutableNodeView. For
+  // regular fanins, this will be the index of the associated fanout in
+  // MutableNodeView::regular_fanouts_by_port_[port_index]. For controlled
+  // fanins, this will be the index of the associated fanout in
+  // MutableNodeView::controlled_fanouts_.
+  int fanout_index_ = internal::kMissingIndex;
+
+  friend class MutableNodeView;
+  friend class MutableGraphView;
+  friend class Mutation;
+};
+
+// Mutable NodeView that holds a mutable NodeDef. This allows for lookups of
+// fanins and fanouts, and traversals of the graph. Control dependencies will be
+// dedupped among other control dependencies on initialization via
+// MutableGraphView. Mutations should be handled via MutableGraphView and not
+// directly on the mutable NodeDef.
+class MutableNodeView
+    : public internal::NodeViewInternal<MutableFaninView, MutableFanoutView,
+                                        MutableGraphView, false> {
+ public:
+  explicit MutableNodeView(MutableGraphView* graph_view, int node_index)
+      : NodeViewInternal(graph_view, node_index) {}
+
+  MutableNodeView() : NodeViewInternal() {}
+
+  ~MutableNodeView() override = default;
+
+  MutableNodeView(MutableNodeView&&) = default;
+  MutableNodeView& operator=(MutableNodeView&&) = default;
+
+  NodeDef* node() const override;
+
+  // Checks if a fanin exists for the node.
+  bool HasFanin(const MutableFanoutView& fanin) const override;
+
+  // Checks if a fanout exists for the node.
+  bool HasFanout(const MutableFaninView& fanout) const override;
+
+ private:
+  inline const MutableFanoutView& GetMissingFanin() const override;
+
+  inline const std::vector<MutableFaninView>& GetMissingFanout() const override;
+
+  absl::flat_hash_map<internal::NodeDefAndPortIndex, int> fanins_count_;
+  absl::flat_hash_map<absl::string_view, int> controlling_fanins_index_;
+  // Index of associated MutableNodeViewDiff in Mutation::updated_nodes_.
+  // If this is -1, there exists no MutableNodeViewDiff for this node.
+  int update_index_ = internal::kMissingIndex;
+
+  friend class MutableFaninView;
+  friend class MutableFanoutView;
+  friend class MutableGraphView;
+  friend class Mutation;
+};
+
+class MutationNewNode {
+ public:
+  MutationNewNode() {}
+
+ private:
+  explicit MutationNewNode(Mutation* mutation, int mutation_counter, int index)
+      : mutation_(mutation),
+        mutation_counter_(mutation_counter),
+        index_(index) {}
+
+  Mutation* mutation_ = nullptr;
+  int mutation_counter_ = internal::kMissingSlot;
+  int index_ = internal::kMissingIndex;
+
+  friend class Mutation;
+};
+
+// Mutation is a helper class that allows rewrites of MutableGraphView. This
+// should not be initialized or be used directly.
+// Note, if a node is renamed to another node, or a new node is created with the
+// same name as an existing node, the node with the same name originally in the
+// graph will be overwritten.
+class Mutation {
+ public:
+  // Create a new node to be added to the graph. If the node's fanins are not
+  // well formed (self loops, control dependencies between regular fanins), the
+  // `status` will be set.
+  MutationNewNode AddNode(NodeDef&& node, Status* status);
+
+  // Remove an existing node in the graph.
+  void RemoveNode(MutableNodeView* node);
+
+  // Update the name of an existing node.
+  void UpdateNodeName(MutableNodeView* node, absl::string_view name);
+
+  // Update the name of a new node.
+  void UpdateNodeName(const MutationNewNode& node, absl::string_view name);
+
+  // Update the op of an existing node.
+  void UpdateNodeOp(MutableNodeView* node, absl::string_view op);
+
+  // Update the op of a new node.
+  void UpdateNodeOp(const MutationNewNode& node, absl::string_view op);
+
+  // Update the device of an existing node.
+  void UpdateNodeDevice(MutableNodeView* node, absl::string_view device);
+
+  // Update the device of a new node.
+  void UpdateNodeDevice(const MutationNewNode& node, absl::string_view device);
+
+  // Add or replace regular fanin `fanin` at `index` for an existing node.
+  void AddOrUpdateRegularFanin(MutableNodeView* node, int index,
+                               const TensorId& fanin);
+
+  // Add or replace regular fanin `fanin` at `index` for a new node.
+  void AddOrUpdateRegularFanin(const MutationNewNode& node, int index,
+                               const TensorId& fanin);
+
+  // Remove regular fanin at `index` for an existing node.
+  void RemoveRegularFanin(MutableNodeView* node, int index);
+
+  // Remove regular fanin at `index` for a new node.
+  void RemoveRegularFanin(const MutationNewNode& node, int index);
+
+  // Add controlling fanin `fanin_node_name` for an existing node.
+  void AddControllingFanin(MutableNodeView* node,
+                           absl::string_view fanin_node_name);
+
+  // Add controlling fanin `fanin_node_name` for a new node.
+  void AddControllingFanin(const MutationNewNode& node,
+                           absl::string_view fanin_node_name);
+
+  // Remove controlling fanin `fanin_node_name` for an existing node.
+  void RemoveControllingFanin(MutableNodeView* node,
+                              absl::string_view fanin_node_name);
+
+  // Remove controlling fanin `fanin_node_name` for a new node.
+  void RemoveControllingFanin(const MutationNewNode& node,
+                              absl::string_view fanin_node_name);
+
+  // Add or replace attribute `attr_name` with `attr_value` for an existing
+  // node.
+  void AddOrUpdateNodeAttr(MutableNodeView* node, absl::string_view attr_name,
+                           const AttrValue& attr_value);
+
+  // Add or replace attribute `attr_name` with `attr_value` for a new node.
+  void AddOrUpdateNodeAttr(const MutationNewNode& node,
+                           absl::string_view attr_name,
+                           const AttrValue& attr_value);
+
+  // Remove attribute `attr_name` for an existing node.
+  void RemoveNodeAttr(MutableNodeView* node, absl::string_view attr_name);
+
+  // Remove attribute `attr_name` for a new node.
+  void RemoveNodeAttr(const MutationNewNode& node, absl::string_view attr_name);
+
+  // Reset and clear mutation.
+  void Reset();
+
+  // Applies the Mutation to the graph. If the mutation is valid, the graph will
+  // be modified. Otherwise an error status will be returned and the graph will
+  // not be modified.
+  Status Apply();
+
+ private:
+  explicit Mutation(MutableGraphView* graph_view);
+
+  void ResetInternal();
+
+  using MutableNodeViewDiff = internal::NodeViewDiff<MutableGraphView>;
+
+  // Adds a mutation to the `node`. Mutation function `mutate_fn` must return
+  // `true` if it actually does any mutations. If it returns `false` mutation
+  // will be ignored.
+  void AddMutation(MutableNodeView* node,
+                   std::function<bool(MutableNodeViewDiff*)> mutate_fn);
+
+  MutableGraphView* graph_view_ = nullptr;
+  int mutation_counter_ = 0;
+  std::vector<MutableNodeViewDiff> updated_nodes_;
+  absl::flat_hash_set<int> removed_nodes_;
+
+  using MutationNewNodeHolder = internal::NewNode<MutableGraphView>;
+  std::vector<MutationNewNodeHolder> new_nodes_;
+
+  friend class MutableGraphView;
+};
+
+// Mutable GraphView that holds a mutable GraphDef. This allows for lookups and
+// traversals of the graph. Control dependencies will be dedupped among other
+// control dependencies on initialization. Mutations should be handled using
+// this API instead of directly on the GraphDef/NodeDef.
+// Note, after a mutation, pointers of MutableNodeView's from MutableGraphView
+// may be invalidated.
+class MutableGraphView
+    : public internal::GraphViewInternal<MutableNodeView, MutableFaninView,
+                                         MutableFanoutView, false> {
+ public:
+  explicit MutableGraphView(GraphDef* graph, Status* status);
+  ~MutableGraphView() override = default;
+
+  // Returns a Mutation (builder) that can be used to modify MutableGraphView.
+  Mutation* GetMutationBuilder();
+
+  // Helper class representing an extra dependency for topological sorting.
+  class TopologicalDependency {
+   public:
+    TopologicalDependency(const MutableNodeView* from_node,
+                          const MutableNodeView* to_node) {
+      if (from_node->graph_view_ == to_node->graph_view_) {
+        graph_view_ = from_node->graph_view_;
+        from_ = from_node->node_index_;
+        to_ = to_node->node_index_;
+      }
+    }
+
+   private:
+    MutableGraphView* graph_view_ = nullptr;
+    int from_ = internal::kMissingIndex;
+    int to_ = internal::kMissingIndex;
+
+    friend class MutableGraphView;
+  };
+
+  // Sorts graph topologically in-place. If `ignore_cycles` is set, a
+  // topological like sorting will be performed when there are cycles. Otherwise
+  // if a cycle is detected or if the graph cannot be sorted, an error will be
+  // returned.
+  Status SortTopologically(
+      bool ignore_cycles,
+      absl::Span<const TopologicalDependency> extra_dependencies);
+
+ private:
+  bool AddUniqueNodeInternal(NodeDef* node);
+
+  Status CheckFaninsInternal(std::vector<std::vector<TensorId>>* fanins);
+
+  void AddFaninsInternal(std::vector<std::vector<TensorId>>* fanins);
+
+  // RenamedOrOverwrittenNode holds a index to Mutation::updated_nodes_ for a
+  // renamed node, alongside a potential overwritten node index in the actual
+  // graph. If the renamed node is not overwriting any existing nodes,
+  // `overwritten_node_index_` will be set to `internal::kMissingIndex`.
+  class RenamedOrOverwrittenNode {
+   public:
+    RenamedOrOverwrittenNode(int renamed_update_index,
+                             int overwritten_node_index)
+        : renamed_update_index_(renamed_update_index),
+          overwritten_node_index_(overwritten_node_index) {}
+
+   private:
+    int renamed_update_index_;
+    int overwritten_node_index_;
+
+    friend class MutableGraphView;
+  };
+
+  Status GetNodeNamesAndPartitionUpdatedNodes(
+      absl::flat_hash_map<absl::string_view, int>* node_names,
+      std::vector<RenamedOrOverwrittenNode>* renamed_nodes,
+      std::vector<int>* inplace_nodes,
+      std::vector<int>* empty_diff_node_indices);
+
+  Status RemovedOrMissingNodeFanoutsWellFormed(
+      const absl::flat_hash_map<absl::string_view, int>& node_names,
+      const std::vector<RenamedOrOverwrittenNode>& renamed_nodes);
+
+  Status CheckNodeNamesAndFanins(
+      const absl::flat_hash_map<absl::string_view, int>& node_names,
+      const std::vector<RenamedOrOverwrittenNode>& renamed_nodes,
+      const std::vector<int>& inplace_nodes);
+
+  Status CheckKernelRegisteredForNodes();
+
+  // Helper class to move fanouts around.
+  class NodeViewFanouts {
+   public:
+    NodeViewFanouts(
+        std::vector<std::vector<MutableFaninView>>&& regular_fanouts_by_port,
+        int num_regular_fanouts,
+        std::vector<MutableFaninView> controlled_fanouts)
+        : regular_fanouts_by_port_(std::move(regular_fanouts_by_port)),
+          num_regular_fanouts_(num_regular_fanouts),
+          controlled_fanouts_(std::move(controlled_fanouts)) {}
+
+   private:
+    std::vector<std::vector<MutableFaninView>> regular_fanouts_by_port_;
+    int num_regular_fanouts_ = 0;
+    std::vector<MutableFaninView> controlled_fanouts_;
+
+    friend class MutableGraphView;
+  };
+
+  template <typename T>
+  void ReplaceNodeFanouts(MutableNodeView* node, T* fanouts);
+
+  void FixRenamedNodes(
+      std::vector<RenamedOrOverwrittenNode>* renamed_nodes,
+      absl::flat_hash_map<string, NodeViewFanouts>* renamed_fanouts,
+      std::vector<bool>* overwritten_name_removed_nodes);
+
+  void AddNewNodes(
+      absl::flat_hash_map<string, NodeViewFanouts>* renamed_fanouts,
+      std::vector<int>* new_node_indices);
+
+  void FixRenamedFanouts(
+      const absl::flat_hash_map<string, NodeViewFanouts>& renamed_fanouts);
+
+  inline void RemoveRegularFaninFanoutInternal(MutableNodeView* node_view,
+                                               int i);
+
+  inline void AddRegularFaninInternal(MutableNodeView* node_view,
+                                      const SafeTensorId& fanin_id);
+
+  inline void UpdateRegularFaninInternal(MutableNodeView* node_view,
+                                         const int i,
+                                         const SafeTensorId& fanin_id);
+
+  inline void RemoveControllingFaninFanoutInternal(MutableNodeView* node_view,
+                                                   int i);
+
+  inline void RemoveControllingFaninInternal(
+      MutableNodeView* node_view, const std::set<int>& indices_to_remove);
+
+  inline void AddControllingFaninInternal(MutableNodeView* node_view,
+                                          absl::string_view fanin_node_name);
+
+  void ApplyNodeUpdates();
+
+  void SetNewNodesFanins(const std::vector<int>& new_node_indices);
+
+  inline void RemoveAllFaninFanoutInternal(MutableNodeView* node_view);
+
+  void RemoveNodesInternal(
+      const std::vector<RenamedOrOverwrittenNode>& renamed_nodes,
+      const std::vector<bool>& overwritten_name_removed_nodes);
+
+  inline Status ValidateInternal(
+      absl::flat_hash_map<absl::string_view, int>* node_names,
+      std::vector<RenamedOrOverwrittenNode>* renamed_nodes,
+      std::vector<int>* inplace_nodes,
+      std::vector<int>* empty_diff_node_indices);
+
+  Status ApplyMutationInternal();
+
+  Mutation mutation_;
+
+  friend class MutableNodeView;
+  friend class Mutation;
+};
+
+}  // namespace utils
+}  // namespace grappler
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_UTILS_GRAPH_VIEW_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/utils/graph_view_internal.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/utils/graph_view_internal.h
new file mode 100644
index 0000000000000000000000000000000000000000..d66b1ca04528e1c7843b4b7cdb70b2bc7a7ee399
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/utils/graph_view_internal.h
@@ -0,0 +1,920 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_UTILS_GRAPH_VIEW_INTERNAL_H_
+#define TENSORFLOW_CORE_GRAPPLER_UTILS_GRAPH_VIEW_INTERNAL_H_
+
+#include "absl/container/flat_hash_map.h"
+#include "absl/container/flat_hash_set.h"
+#include "absl/hash/hash.h"
+#include "absl/strings/string_view.h"
+#include "tensorflow/core/framework/attr_value.pb.h"
+#include "tensorflow/core/framework/graph.pb.h"
+#include "tensorflow/core/framework/node_def.pb.h"
+#include "tensorflow/core/framework/node_def_util.h"
+#include "tensorflow/core/graph/tensor_id.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/lib/gtl/map_util.h"
+
+namespace tensorflow {
+namespace grappler {
+namespace utils {
+namespace internal {
+
+constexpr int kMissingSlot = -2;
+constexpr int kMissingIndex = -1;
+constexpr int kNodeNamePresent = -1;
+
+// NodeIndexAndPortIndex is a helper class that represents fanins and fanouts
+// of a node.
+template <typename NodeViewT, typename GraphViewT>
+class NodeIndexAndPortIndex {
+ public:
+  NodeIndexAndPortIndex()
+      : graph_view_(nullptr),
+        node_index_(kMissingIndex),
+        port_index_(kMissingSlot) {}
+  NodeIndexAndPortIndex(GraphViewT* graph_view, int node_index, int port_index)
+      : graph_view_(graph_view),
+        node_index_(node_index),
+        port_index_(port_index) {}
+
+  bool operator==(const NodeIndexAndPortIndex& other) const {
+    return port_index_ == other.port_index_ &&
+           node_index_ == other.node_index_ && graph_view_ == other.graph_view_;
+  }
+
+  template <typename Hash>
+  friend Hash AbslHashValue(Hash h, const NodeIndexAndPortIndex& n) {
+    return Hash::combine(std::move(h), n.node_index_, n.port_index_);
+  }
+
+  // Returns NodeView from `graph_view_` at `node_index_`.
+  NodeViewT* node_view() const {
+    if (graph_view_ == nullptr) {
+      return nullptr;
+    }
+    return graph_view_->GetNode(node_index_);
+  }
+
+  // Returns node index in graph.
+  int node_index() const { return node_index_; }
+
+  // Returns input/output port index.
+  int index() const { return port_index_; }
+
+ protected:
+  GraphViewT* graph_view_;
+  int node_index_;
+  int port_index_;
+};
+
+// NodeDefAndPortIndex is a helper class that represents fanins hashed with
+// pointer stability using the fanin's NodeDef.
+class NodeDefAndPortIndex {
+ public:
+  NodeDefAndPortIndex(const NodeDef* node_def, int port_index)
+      : node_def_(node_def), port_index_(port_index) {}
+
+  bool operator==(const NodeDefAndPortIndex& other) const {
+    return node_def_ == other.node_def_ && port_index_ == other.port_index_;
+  }
+
+  template <typename Hash>
+  friend Hash AbslHashValue(Hash h, const NodeDefAndPortIndex& n) {
+    return Hash::combine(std::move(h), n.node_def_, n.port_index_);
+  }
+
+ private:
+  const NodeDef* node_def_;
+  int port_index_;
+};
+
+// NodeViewInternal is a helper class to simplify graph traversal. It creates
+// a view of a node and associated fanins and fanouts from the NodeDef
+// protocol buffer.
+//
+// There are two public classes implementing NodeViewInternal:
+//
+// - NodeView: constructed from `const NodeDef` and doesn't allow mutating the
+//   underlying node.
+// - MutableNodeView: constructed from `NodeDef` and allows mutating the
+//   underlying node.
+//
+// --------------------------- !!! WARNING !!! ---------------------------------
+//     Modifying the node outside of implementations of NodeViewInternal
+//     (i.e. modifying inputs of the NodeDef directly) may leave the NodeView
+//     in an inconsistent/invalid state.
+// -----------------------------------------------------------------------------
+//
+template <typename FaninViewT, typename FanoutViewT, typename GraphViewT,
+          bool IsConst>
+class NodeViewInternal {
+ private:
+  using NodeDefT =
+      typename std::conditional<IsConst, const NodeDef, NodeDef>::type;
+
+ public:
+  explicit NodeViewInternal(GraphViewT* graph_view, int node_index)
+      : graph_view_(graph_view),
+        node_index_(node_index),
+        attrs_(AttrSlice(graph_view->graph()->node(node_index))) {}
+
+  NodeViewInternal()
+      : graph_view_(nullptr), node_index_(kMissingIndex), attrs_(AttrSlice()) {}
+
+  virtual ~NodeViewInternal() {}
+
+  NodeViewInternal(NodeViewInternal&&) = default;
+  NodeViewInternal& operator=(NodeViewInternal&&) = default;
+
+  bool operator==(const NodeViewInternal& other) const {
+    return node_index_ == other.node_index_ && graph_view_ == other.graph_view_;
+  }
+
+  template <typename Hash>
+  friend Hash AbslHashValue(Hash h, const NodeViewInternal& n) {
+    return Hash::combine(std::move(h), n.node_index_);
+  }
+
+  // Returns NodeDef of view.
+  virtual NodeDefT* node() const = 0;
+
+  // Returns index of node in GraphDef/GraphView.
+  int node_index() const { return node_index_; }
+
+  // Returns the name of the node.
+  const string& GetName() const { return node()->name(); }
+
+  // Returns the op of the node.
+  const string& GetOp() const { return node()->op(); }
+
+  // Returns the device set for the node.
+  const string& GetDevice() const { return node()->device(); }
+
+  // Returns all regular fanins, based on ordering in the node.
+  const std::vector<FanoutViewT>& GetRegularFanins() const {
+    return regular_fanins_;
+  }
+
+  // Returns a regular fanin based on input index. If no such fanin exist, a
+  // missing fanin is returned, with no NodeView set and an index of -2.
+  const FanoutViewT& GetRegularFanin(int i) const {
+    int regular_fanins_size = regular_fanins_.size();
+    if (i < 0 || i >= regular_fanins_size) {
+      return GetMissingFanin();
+    }
+    return regular_fanins_[i];
+  }
+
+  // Returns all controlling fanins, based on ordering in the node.
+  const std::vector<FanoutViewT>& GetControllingFanins() const {
+    return controlling_fanins_;
+  }
+
+  // Returns all regular fanouts.
+  const std::vector<std::vector<FaninViewT>>& GetRegularFanouts() const {
+    return regular_fanouts_by_port_;
+  }
+
+  // Returns a regular fanout(s) based on output index. If no such output index
+  // exists, no fanouts will be returned.
+  const std::vector<FaninViewT>& GetRegularFanout(int i) const {
+    int regular_fanouts_by_port_size = regular_fanouts_by_port_.size();
+    if (i < 0 || i >= regular_fanouts_by_port_size) {
+      return GetMissingFanout();
+    }
+    return regular_fanouts_by_port_[i];
+  }
+
+  // Returns all controlled fanouts.
+  const std::vector<FaninViewT>& GetControlledFanouts() const {
+    return controlled_fanouts_;
+  }
+
+  // Returns the number of regular fanins.
+  int NumRegularFanins() const { return regular_fanins_.size(); }
+
+  // Returns the number of controlling fanins.
+  int NumControllingFanins() const { return controlling_fanins_.size(); }
+
+  // Returns the number of regular fanouts.
+  int NumRegularFanouts() const { return num_regular_fanouts_; }
+
+  // Returns the number of controlled fanouts.
+  int NumControlledFanouts() const { return controlled_fanouts_.size(); }
+
+  // Checks if a fanin exists for the node.
+  virtual bool HasFanin(const FanoutViewT& fanin) const = 0;
+
+  // Checks if a fanout exists for the node.
+  virtual bool HasFanout(const FaninViewT& fanout) const = 0;
+
+  // Returns an attribute of the node by key. If no attribute for such key
+  // exists, a `nullptr` is returned.
+  const AttrValue* GetAttr(absl::string_view attr_name) const {
+    return attrs_.Find(attr_name);
+  }
+
+  // Returns all attributes of the node.
+  const AttrSlice& GetAttrs() const { return attrs_; }
+
+  // Returns the number of attributes in the node.
+  int NumAttrs() const { return attrs_.size(); }
+
+  // Checks if an attribute exist in the node.
+  bool HasAttr(absl::string_view attr_name) const {
+    return attrs_.Find(attr_name) != nullptr;
+  }
+
+ protected:
+  virtual inline const FanoutViewT& GetMissingFanin() const = 0;
+  virtual inline const std::vector<FaninViewT>& GetMissingFanout() const = 0;
+
+  std::vector<FanoutViewT> regular_fanins_;
+  std::vector<FanoutViewT> controlling_fanins_;
+  std::vector<std::vector<FaninViewT>> regular_fanouts_by_port_;
+  int num_regular_fanouts_ = 0;
+  std::vector<FaninViewT> controlled_fanouts_;
+
+  GraphViewT* graph_view_;
+  int node_index_;
+  AttrSlice attrs_;
+};
+
+// GraphViewInternal is a helper class to simplify graph traversal. It creates
+// a view of the nodes and associated fanins and fanouts from the GraphDef
+// protocol buffer.
+//
+// There are two public classes implementing GraphViewInternal:
+//
+// - GraphView: constructed from `const GraphDef` and doesn't allow mutating
+//   the underlying graph and its nodes.
+// - MutableGraphView: constructed from `GraphDef` and allows mutating the
+//   underlying graph and its nodes.
+//
+// --------------------------- !!! WARNING !!! ---------------------------------
+//     Modifying the graph outside of implementations of GraphViewInternal
+//     (i.e. removing nodes from the GraphDef directly) may lead to
+//     segfaults! Guaranteed by absl::string_view!
+// -----------------------------------------------------------------------------
+//
+template <typename NodeViewT, typename FaninViewT, typename FanoutViewT,
+          bool IsConst>
+class GraphViewInternal {
+ private:
+  using GraphDefT =
+      typename std::conditional<IsConst, const GraphDef, GraphDef>::type;
+
+ public:
+  explicit GraphViewInternal(GraphDefT* graph) : graph_(graph) {}
+  virtual ~GraphViewInternal() {}
+
+  bool operator==(const GraphViewInternal& other) const {
+    return graph_ == other.graph_;
+  }
+
+  GraphDefT* graph() const { return graph_; }
+
+  // Finds node by index in the graph. If no such node exists in the graph, a
+  // `nullptr` is returned.
+  const NodeViewT* GetNode(int node_index) const {
+    int nodes_size = nodes_.size();
+    if (node_index < 0 || node_index >= nodes_size) {
+      return nullptr;
+    }
+    return &nodes_[node_index];
+  }
+
+  NodeViewT* GetNode(int node_index) {
+    int nodes_size = nodes_.size();
+    if (node_index < 0 || node_index >= nodes_size) {
+      return nullptr;
+    }
+    return &nodes_[node_index];
+  }
+
+  // Finds node by name. If no such node exists in the graph, a `nullptr` is
+  // returned.
+  const NodeViewT* GetNode(absl::string_view node_name) const {
+    auto it = node_index_by_name_.find(node_name);
+    if (it == node_index_by_name_.end()) {
+      return nullptr;
+    }
+    return &nodes_[it->second];
+  }
+
+  NodeViewT* GetNode(absl::string_view node_name) {
+    auto it = node_index_by_name_.find(node_name);
+    if (it == node_index_by_name_.end()) {
+      return nullptr;
+    }
+    return &nodes_[it->second];
+  }
+
+  // Returns all nodes (as NodeView) in the graph.
+  const std::vector<NodeViewT>& GetNodes() const { return nodes_; }
+
+  // Checks if a node by name exists in the graph.
+  bool HasNode(absl::string_view node_name) const {
+    return node_index_by_name_.contains(node_name);
+  }
+
+  // Returns the number of nodes in the graph.
+  int NumNodes() const { return nodes_.size(); }
+
+ protected:
+  // Reset allocated node vector and node map in case of failure.
+  void Reset() {
+    std::vector<NodeViewT>().swap(nodes_);
+    absl::flat_hash_map<absl::string_view, int>().swap(node_index_by_name_);
+  }
+
+  // nodes_[i] is a view of graph_.{mutable_}node(i).
+  std::vector<NodeViewT> nodes_;
+  absl::flat_hash_map<absl::string_view, int> node_index_by_name_;
+  GraphDefT* graph_;
+  const FanoutViewT missing_fanin_;
+  const std::vector<FaninViewT> missing_fanout_;
+};
+
+inline SafeTensorId EmptyTensorId() {
+  return SafeTensorId("", internal::kMissingSlot);
+}
+
+inline bool IsEmptyTensorId(const TensorId tensor_id) {
+  return tensor_id.node().empty() &&
+         tensor_id.index() == internal::kMissingSlot;
+}
+
+// NodeViewDiff is a helper struct holding changes to be made to an existing
+// node in GraphViewT. This should not be initialized or be used directly.
+template <typename GraphViewT>
+struct NodeViewDiff {
+  explicit NodeViewDiff(GraphViewT* graph_view, int node_index)
+      : graph_view(graph_view), node_index(node_index) {}
+
+  GraphViewT* graph_view;
+  int node_index;
+  string name;
+  bool update_name = false;
+  string op;
+  bool update_op = false;
+  string device;
+  bool update_device = false;
+  // Fanins to append after existing regular fanins.
+  std::vector<SafeTensorId> regular_inputs_to_add;
+  // Number of fanins to be appended. This is used for a quick comparison with
+  // `regular_inputs_to_add` for if there will be any missing inputs in the
+  // updated node.
+  int num_regular_inputs_to_add = 0;
+  // Fanins to update inplace.
+  std::map<int, SafeTensorId> regular_inputs_to_update;
+  // Fanins from end of regular fanins to remove. This keeps track of existing
+  // regular fanins in the original node to remove.
+  std::vector<bool> regular_inputs_to_remove;
+  // Number of fanins marked for removal. This is used for a quick comparison
+  // with `regular_inputs_to_remove` for if there will be any missing inputs
+  // in the updated node.
+  int num_regular_inputs_to_remove = 0;
+  absl::flat_hash_set<string> controlling_inputs_to_add;
+  std::set<int> controlling_inputs_to_remove;
+  absl::flat_hash_map<string, AttrValue> attrs_to_add;
+  absl::flat_hash_set<string> attrs_to_remove;
+  // AttrValueMap constructor and destructor are very expensive, we will
+  // initialize it lazily only if needed.
+  absl::optional<AttrValueMap> processed_attrs;
+};
+
+// Updates node name. If `name` is the same as the name in the original node,
+// the field will be cleared in the diff.
+template <typename GraphViewT>
+inline bool UpdateName(NodeViewDiff<GraphViewT>* diff, absl::string_view name) {
+  if (diff->graph_view->GetNode(diff->node_index)->GetName() == name) {
+    diff->name.clear();
+    diff->update_name = false;
+  } else {
+    diff->name = string(name);
+    diff->update_name = true;
+  }
+  return true;
+}
+
+// Updates node op. If `op` is the same as the op in the original node, the
+// field will be cleared in the diff.
+template <typename GraphViewT>
+inline bool UpdateOp(NodeViewDiff<GraphViewT>* diff, absl::string_view op) {
+  if (diff->graph_view->GetNode(diff->node_index)->GetOp() == op) {
+    diff->op.clear();
+    diff->update_op = false;
+  } else {
+    diff->op = string(op);
+    diff->update_op = true;
+  }
+  return true;
+}
+
+// Updates node device. If `device` is the same as the device in the original
+// node, the field will be cleared in the diff.
+template <typename GraphViewT>
+inline bool UpdateDevice(NodeViewDiff<GraphViewT>* diff,
+                         absl::string_view device) {
+  if (diff->graph_view->GetNode(diff->node_index)->GetDevice() == device) {
+    diff->device.clear();
+    diff->update_device = false;
+  } else {
+    diff->device = string(device);
+    diff->update_device = true;
+  }
+  return true;
+}
+
+// Adds or updates value in vector `v` at index `i`. This will also resize the
+// vector if index `i` is out of bounds, padding the vector with
+// `default_value`. Returns true if a new value was appended or if an update
+// occurred where an existing value was changed from `default_value`.
+template <typename T, typename U>
+inline bool AddOrUpdateAtIndex(std::vector<T>* v, int i, const U& value,
+                               const T& default_value) {
+  int v_size = v->size();
+  if (i > v_size) {
+    // Resize to include `value`, filling the newly introduced gap with
+    // `default_value` for later checks of validity (gaps in vector).
+    v->reserve(i + 1);
+    v->resize(i, default_value);
+    v->push_back({value});
+  } else if (i == v_size) {
+    // Vector is large enough, simply append `value` to the end.
+    v->push_back({value});
+  } else {
+    // Update existing value.
+    bool updated = (*v)[i] == default_value;
+    (*v)[i] = {value};
+    return updated;
+  }
+  return true;
+}
+
+// Checks if a node with name `node_name` will exist in the final mutated graph.
+template <typename GraphViewT>
+inline bool CheckNodeNameExists(
+    absl::string_view node_name,
+    const absl::flat_hash_map<absl::string_view, int>& updated_node_names,
+    const GraphViewT* graph_view) {
+  auto it = updated_node_names.find(node_name);
+  if (it != updated_node_names.end()) {
+    return it->second == kNodeNamePresent;
+  }
+  return graph_view->HasNode(node_name);
+}
+
+// Adds or updates regular fanin at `index` of regular fanins. If `index` is
+// less than the number of regular fanins in the original node, the fanin at
+// `index` in the original node will be updated with `fanin` if the fanin
+// differs. If `index` is greater than or equal to the number of regular fanins,
+// `fanin` will be added beyond the end of regular fanins at `index`.
+template <typename GraphViewT>
+inline bool AddOrUpdateRegularFanin(NodeViewDiff<GraphViewT>* diff, int index,
+                                    const TensorId& fanin) {
+  if (index < 0) {
+    // Not a valid index for regular fanins.
+    return false;
+  }
+  auto* node_view = diff->graph_view->GetNode(diff->node_index);
+  const int num_regular_fanins = node_view->NumRegularFanins();
+  if (index < num_regular_fanins) {  // Updating existing fanins.
+    // Calculate (relative) index from end of regular fanins, from absolute
+    // index from beginning of regular fanins.
+    const int relative_removal_index = num_regular_fanins - index - 1;
+    // Check if at relative index fanin was already marked for removal.
+    int diff_regular_inputs_to_remove_size =
+        diff->regular_inputs_to_remove.size();
+    if (relative_removal_index < diff_regular_inputs_to_remove_size &&
+        diff->regular_inputs_to_remove[relative_removal_index]) {
+      // Unmark fanin for removal.
+      diff->regular_inputs_to_remove[relative_removal_index] = false;
+      --diff->num_regular_inputs_to_remove;
+    }
+    const auto& existing_fanin = node_view->GetRegularFanin(index);
+    if (existing_fanin.index() != fanin.index() ||
+        existing_fanin.node_view()->GetName() != fanin.node()) {
+      // Update fanin if it is different from original fanin in node.
+      gtl::InsertOrUpdate(&diff->regular_inputs_to_update, index,
+                          SafeTensorId(fanin));
+    }
+  } else {
+    // Add fanin beyond current fanin range.
+    const int relative_add_index = index - num_regular_fanins;
+    if (AddOrUpdateAtIndex(&diff->regular_inputs_to_add, relative_add_index,
+                           fanin, EmptyTensorId())) {
+      // New fanin was added.
+      ++diff->num_regular_inputs_to_add;
+    }
+  }
+  return true;
+}
+
+// Remove regular fanin at `index` of regular fanins. This can remove existing
+// fanins and updated/added fanins via AddOrUpdateRegularFanins.
+template <typename GraphViewT>
+inline bool RemoveRegularFanin(NodeViewDiff<GraphViewT>* diff, int index) {
+  if (index < 0) {
+    // Not a valid index for regular fanins.
+    return false;
+  }
+  auto* node_view = diff->graph_view->GetNode(diff->node_index);
+  const int num_regular_fanins = node_view->NumRegularFanins();
+  if (index < num_regular_fanins) {  // Removing existing fanins.
+    // Remove updated fanin if it exists.
+    diff->regular_inputs_to_update.erase(index);
+    // Calculate (relative) index from end of regular fanins, from absolute
+    // index from beginning of regular fanins.
+    const int relative_removal_index = num_regular_fanins - index - 1;
+    if (AddOrUpdateAtIndex(&diff->regular_inputs_to_remove,
+                           relative_removal_index,
+                           /*value=*/true, /*default_value=*/false)) {
+      ++diff->num_regular_inputs_to_remove;
+    }
+  } else {
+    // Relative index from end of regular fanins.
+    const int relative_add_index = index - num_regular_fanins;
+    int diff_regular_inputs_to_add_size = diff->regular_inputs_to_add.size();
+    if (relative_add_index >= diff_regular_inputs_to_add_size ||
+        IsEmptyTensorId(diff->regular_inputs_to_add[relative_add_index])) {
+      // At relative index, appended regular fanin was already marked for
+      // removal.
+      return false;
+    }
+    // Remove added fanin.
+    diff->regular_inputs_to_add[relative_add_index] = EmptyTensorId();
+    --diff->num_regular_inputs_to_add;
+  }
+  return true;
+}
+
+// Adds controlling fanin. If the controlling fanin already exists in the
+// original node, it will be dedupped. If the controlling fanin is marked for
+// removal, this will reverse it.
+template <typename GraphViewT>
+inline bool AddControllingFanin(NodeViewDiff<GraphViewT>* diff,
+                                int control_index,
+                                absl::string_view fanin_node_name) {
+  if (control_index == kMissingIndex) {
+    diff->controlling_inputs_to_add.emplace(fanin_node_name);
+  } else {
+    diff->controlling_inputs_to_remove.erase(control_index);
+  }
+  return true;
+}
+
+// Remove controlling fanin. If the controlling fanin does not exist in the
+// original node and diff, nothing will happen. If the controlling fanin exists
+// in the diff, it will be removed. Otherwise the controlling fanin will be
+// marked for removal from the original node.
+template <typename GraphViewT>
+inline bool RemoveControllingFanin(NodeViewDiff<GraphViewT>* diff,
+                                   int control_index,
+                                   absl::string_view fanin_node_name) {
+  if (control_index == kMissingIndex) {
+    diff->controlling_inputs_to_add.erase(fanin_node_name);
+  } else {
+    diff->controlling_inputs_to_remove.emplace(control_index);
+  }
+  return true;
+}
+
+// Adds or updates an attribute by name. If an attribute exist in the original
+// node or diff (including those marked for removal), this will overwrite it.
+template <typename GraphViewT>
+inline bool AddOrUpdateAttribute(NodeViewDiff<GraphViewT>* diff,
+                                 absl::string_view attr_name,
+                                 const AttrValue& attr_value) {
+  diff->attrs_to_add.empty() ? 0 : diff->attrs_to_remove.erase(attr_name);
+  gtl::InsertOrUpdate(&diff->attrs_to_add, string(attr_name), attr_value);
+  return true;
+}
+
+// Removes an attribute by name. If an attribute exist in the original node or
+// diff, this will remove it.
+template <typename GraphViewT>
+inline bool RemoveAttribute(NodeViewDiff<GraphViewT>* diff,
+                            absl::string_view attr_name) {
+  const size_t num_erased =
+      diff->attrs_to_add.empty() ? 0 : diff->attrs_to_add.erase(attr_name);
+  auto* node_view = diff->graph_view->GetNode(diff->node_index);
+  if (node_view->HasAttr(attr_name)) {
+    diff->attrs_to_remove.emplace(attr_name);
+    return true;
+  }
+  return num_erased > 0;
+}
+
+// Removes trailing values in vector `v` for values equal to `value`.
+template <typename T>
+inline void ResizeByTrimmingEndForValue(std::vector<T>* v, const T& value) {
+  int curr_index = v->size();
+  const int last_index = v->size() - 1;
+  for (int i = last_index; i >= 0; --i) {
+    if ((*v)[i] == value) {
+      curr_index = i;
+    } else {
+      break;
+    }
+  }
+  if (curr_index <= last_index) {
+    v->resize(curr_index);
+  }
+}
+
+// Checks if any changes are set in the diff.
+template <typename GraphViewT>
+inline bool IsEmpty(NodeViewDiff<GraphViewT>* diff) {
+  ResizeByTrimmingEndForValue(&diff->regular_inputs_to_remove, false);
+  ResizeByTrimmingEndForValue(&diff->regular_inputs_to_add, EmptyTensorId());
+  return !diff->update_name && !diff->update_op && !diff->update_device &&
+         diff->regular_inputs_to_add.empty() &&
+         diff->regular_inputs_to_update.empty() &&
+         diff->regular_inputs_to_remove.empty() &&
+         diff->controlling_inputs_to_add.empty() &&
+         diff->controlling_inputs_to_remove.empty() &&
+         diff->attrs_to_add.empty() && diff->attrs_to_remove.empty();
+}
+
+// Resets and clears existing diff.
+template <typename GraphViewT>
+inline void Reset(NodeViewDiff<GraphViewT>* diff) {
+  diff->name.clear();
+  diff->update_name = false;
+  diff->op.clear();
+  diff->update_op = false;
+  diff->device.clear();
+  diff->update_device = false;
+  std::vector<SafeTensorId>().swap(diff->regular_inputs_to_add);
+  diff->num_regular_inputs_to_add = false;
+  std::map<int, SafeTensorId>().swap(diff->regular_inputs_to_update);
+  std::vector<bool>().swap(diff->regular_inputs_to_remove);
+  diff->num_regular_inputs_to_remove = 0;
+  absl::flat_hash_set<string>().swap(diff->controlling_inputs_to_add);
+  std::set<int>().swap(diff->controlling_inputs_to_remove);
+  absl::flat_hash_map<string, AttrValue>().swap(diff->attrs_to_add);
+  absl::flat_hash_set<string>().swap(diff->attrs_to_remove);
+}
+
+// Checks if changes to node will result in a valid node.
+template <typename GraphViewT>
+inline bool IsWellFormed(
+    NodeViewDiff<GraphViewT>* diff,
+    const absl::flat_hash_map<absl::string_view, int>& updated_node_names) {
+  ResizeByTrimmingEndForValue(&diff->regular_inputs_to_remove, false);
+  ResizeByTrimmingEndForValue(&diff->regular_inputs_to_add, EmptyTensorId());
+  int diff_regular_inputs_to_add_size = diff->regular_inputs_to_add.size();
+  if (diff_regular_inputs_to_add_size != diff->num_regular_inputs_to_add) {
+    // Missing regular fanins in between appended fanins.
+    return false;
+  } else if (diff->num_regular_inputs_to_add > 0 &&
+             !diff->regular_inputs_to_remove.empty()) {
+    // Appending new fanins while removing existing fanins, resulting in missing
+    // regular fanins in between.
+    return false;
+  } else if (static_cast<int>(diff->regular_inputs_to_remove.size()) !=
+             diff->num_regular_inputs_to_remove) {
+    // Regular fanins exist in between removed fanins.
+    return false;
+  }
+  auto* node_view = diff->graph_view->GetNode(diff->node_index);
+  const string& node_name =
+      diff->update_name ? diff->name : node_view->GetName();
+  auto invalid_node_name = [&](absl::string_view fanin_node_name) -> bool {
+    return fanin_node_name == node_name ||
+           !CheckNodeNameExists(fanin_node_name, updated_node_names,
+                                diff->graph_view);
+  };
+
+  // Check if nodes of all updated and new fanins exist (from name) and if such
+  // fanins do not introduce self loops. Note, this will not check for if
+  // unmodified fanins exist.
+  if (diff->update_name) {
+    // If name of node was changed in node, check all fanins. Updated fanins are
+    // checked for existence and self loops. Unmodified fanins are checked for
+    // self loops.
+    // `regular_inputs_to_update`, `controlling_inputs_to_remove` are sorted,
+    // so iterators from these maps/sets can be incremented alongside iteration
+    // and be used for comparisons.
+    const int last_index =
+        node_view->NumRegularFanins() - diff->num_regular_inputs_to_remove - 1;
+    auto regular_to_update_it = diff->regular_inputs_to_update.begin();
+    for (int i = 0; i <= last_index; ++i) {
+      if (regular_to_update_it != diff->regular_inputs_to_update.end() &&
+          regular_to_update_it->first < i) {
+        ++regular_to_update_it;
+      }
+      if (regular_to_update_it != diff->regular_inputs_to_update.end() &&
+          regular_to_update_it->first == i) {
+        if (invalid_node_name(regular_to_update_it->second.node())) {
+          return false;
+        }
+      } else {
+        const string& regular_name =
+            node_view->GetRegularFanin(i).node_view()->GetName();
+        if (regular_name == node_name) {
+          return false;
+        }
+      }
+    }
+
+    auto& controls = node_view->GetControllingFanins();
+    const int num_controls = controls.size();
+    auto control_to_remove_it = diff->controlling_inputs_to_remove.begin();
+    for (int i = 0; i < num_controls; ++i) {
+      if (control_to_remove_it != diff->controlling_inputs_to_remove.end() &&
+          *control_to_remove_it < i) {
+        ++control_to_remove_it;
+      }
+      if (control_to_remove_it != diff->controlling_inputs_to_remove.end() &&
+          *control_to_remove_it == i) {
+        // Control dependency marked for removal, can be ignored.
+        continue;
+      } else if (controls[i].node_view()->GetName() == node_name) {
+        return false;
+      }
+    }
+  } else {
+    // Name of node was not changed, check only updated fanins under the
+    // assumption prior fanins were valid.
+    for (const auto& updated : diff->regular_inputs_to_update) {
+      const string& fanin_name = updated.second.node();
+      if (invalid_node_name(fanin_name)) {
+        return false;
+      }
+    }
+  }
+  // Check appended regular fanins.
+  for (const auto& regular : diff->regular_inputs_to_add) {
+    if (invalid_node_name(regular.node())) {
+      return false;
+    }
+  }
+  // Check new controlling fanins.
+  for (const auto& control : diff->controlling_inputs_to_add) {
+    if (invalid_node_name(control)) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+// NewNode is a helper struct holding a new node to be added to a GraphViewT.
+// This should not be initialized or be used directly.
+template <typename GraphViewT>
+struct NewNode {
+  explicit NewNode(GraphViewT* graph_view, NodeDef&& node)
+      : graph_view(graph_view), node(std::move(node)) {}
+
+  GraphViewT* graph_view;
+  NodeDef node;
+  std::vector<SafeTensorId> regular_fanins;
+  int num_regular_fanins = 0;
+  absl::flat_hash_set<string> controlling_fanins;
+};
+
+// Updates new node name.
+template <typename GraphViewT>
+inline void UpdateName(NewNode<GraphViewT>* new_node, absl::string_view name) {
+  if (name.empty()) {
+    new_node->node.clear_name();
+  } else {
+    new_node->node.set_name(string(name));
+  }
+}
+
+// Updates new node op.
+template <typename GraphViewT>
+inline void UpdateOp(NewNode<GraphViewT>* new_node, absl::string_view op) {
+  if (op.empty()) {
+    new_node->node.clear_op();
+  } else {
+    new_node->node.set_op(string(op));
+  }
+}
+
+// Updates new node device.
+template <typename GraphViewT>
+inline void UpdateDevice(NewNode<GraphViewT>* new_node,
+                         absl::string_view device) {
+  if (device.empty()) {
+    new_node->node.clear_device();
+  } else {
+    new_node->node.set_device(string(device));
+  }
+}
+
+// Adds or updates regular fanin at `index` of regular fanins in the new node.
+// If another fanin already exists at `index`, it will be replaced with `fanin`.
+template <typename GraphViewT>
+inline void AddOrUpdateRegularFanin(NewNode<GraphViewT>* new_node, int index,
+                                    const TensorId& fanin) {
+  if (index < 0) {
+    // Not a valid index for regular fanins.
+    return;
+  } else if (AddOrUpdateAtIndex(&new_node->regular_fanins, index, fanin,
+                                EmptyTensorId())) {
+    ++new_node->num_regular_fanins;
+  }
+}
+
+// Remove regular fanin at `index` of regular fanins in the new node. This can
+// remove existing fanins and updated/added fanins via AddOrUpdateRegularFanins.
+template <typename GraphViewT>
+inline void RemoveRegularFanin(NewNode<GraphViewT>* new_node, int index) {
+  int new_node_regular_fanins_size = new_node->regular_fanins.size();
+  if (index < 0 || index >= new_node_regular_fanins_size ||
+      IsEmptyTensorId(new_node->regular_fanins[index])) {
+    return;
+  }
+  new_node->regular_fanins[index] = EmptyTensorId();
+  --new_node->num_regular_fanins;
+}
+
+// Adds controlling fanin to new node.
+template <typename GraphViewT>
+inline void AddControllingFanin(NewNode<GraphViewT>* new_node,
+                                absl::string_view fanin_node_name) {
+  new_node->controlling_fanins.emplace(fanin_node_name);
+}
+
+// Removes controlling fanin to new node.
+template <typename GraphViewT>
+inline void RemoveControllingFanin(NewNode<GraphViewT>* new_node,
+                                   absl::string_view fanin_node_name) {
+  new_node->controlling_fanins.erase(fanin_node_name);
+}
+
+// Adds or updates an attribute by name to a new node.
+template <typename GraphViewT>
+inline void AddOrUpdateAttribute(NewNode<GraphViewT>* new_node,
+                                 absl::string_view attr_name,
+                                 const AttrValue& attr_value) {
+  gtl::InsertOrUpdate(new_node->node.mutable_attr(), string(attr_name),
+                      attr_value);
+}
+
+// Removes an attribute by name to a new node.
+template <typename GraphViewT>
+inline void RemoveAttribute(NewNode<GraphViewT>* new_node,
+                            absl::string_view attr_name) {
+  new_node->node.mutable_attr()->erase(string(attr_name));
+}
+
+// Checks if current state of new node is a valid node.
+template <typename GraphViewT>
+inline bool IsWellFormed(
+    NewNode<GraphViewT>* new_node,
+    const absl::flat_hash_map<absl::string_view, int>& updated_node_names) {
+  ResizeByTrimmingEndForValue(&new_node->regular_fanins, EmptyTensorId());
+  int new_node_regular_fanins_size = new_node->regular_fanins.size();
+  if (new_node_regular_fanins_size != new_node->num_regular_fanins) {
+    return false;
+  }
+
+  const string& node_name = new_node->node.name();
+  auto invalid_node_name = [new_node, updated_node_names,
+                            node_name](absl::string_view fanin_node_name) {
+    return fanin_node_name == node_name ||
+           !CheckNodeNameExists(fanin_node_name, updated_node_names,
+                                new_node->graph_view);
+  };
+  // Check if nodes of all fanins exist (from name) and if fanins do not
+  // introduce self loops.
+  for (const auto& regular : new_node->regular_fanins) {
+    if (invalid_node_name(regular.node())) {
+      return false;
+    }
+  }
+  for (const auto& control : new_node->controlling_fanins) {
+    if (invalid_node_name(control)) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+}  // namespace internal
+}  // namespace utils
+}  // namespace grappler
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_UTILS_GRAPH_VIEW_INTERNAL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/utils/pattern_utils.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/utils/pattern_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..de4eecb8329db9c028584da32c39c3242448d647
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/utils/pattern_utils.h
@@ -0,0 +1,245 @@
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_UTILS_PATTERN_UTILS_H_
+#define TENSORFLOW_CORE_GRAPPLER_UTILS_PATTERN_UTILS_H_
+
+#include "tensorflow/core/grappler/utils/graph_view.h"
+
+namespace tensorflow {
+namespace grappler {
+namespace utils {
+
+//------------------------------------------------------------------------------
+// A pattern can be defined by the following grammar. Here, op_type is any valid
+// op name in the TensorFlow.
+//
+//    leaf_pattern ::= `{` op_type `}`
+//    pattern ::= leaf_pattern |
+//                `{` op_type `,` `{` pattern `,` ... `,` pattern `}` `}`
+//
+// (1) For example, the following pattern syntax describes a pattern for
+// _FusedConv2D (Conv2D + BiasAdd + Relu). Note that "*" means any type of op.
+//
+//  {"Relu",
+//    {
+//      "BiasAdd",
+//      {
+//        {"Conv2D"},
+//        {"*"}
+//      }
+//    }
+//  }
+//
+// The syntax above has a root ("Relu") and children (inputs), where each child
+// is a sub-pattern. Graph pattern matcher finds a match for the given pattern
+// syntax in a graph and returns a set of matched nodes.
+//
+// (2) In order to match a DAG with a given root, we extend pattern syntax with
+// labels. For example, a frequently found pattern in Deep Learning models is a
+// residual block like below.
+//
+//    Placeholder  Const
+//          |        |
+//    +-----+-----+  |
+//    |           |  |
+//    |           v  v
+//    |          Conv2D   Const
+//    |            |        |
+//    |            v  v-----+
+//    |          BiasAdd
+//    |            |
+//    v v----------+
+//   AddV2
+//
+// As shown above, it is the same input node (Placeholder) consumed by both
+// AddV2 and and Conv2D. This constrained can be put as labels in the following
+// augmented pattern syntax.
+//
+//  {"AddV2", "my_add",
+//    {
+//      {"*", "my_residual_input"},
+//      {"BiasAdd", "my_bias_add",
+//        {
+//          {"Conv2D", "my_conv",
+//            {
+//              {"*", "my_residual_input"},
+//              {"*", "my_filter"}
+//            }
+//          },
+//          {"*", my_bias"}
+//        }
+//      }
+//    }
+//  }
+//
+// Note that the same label "my_residual_input" is used to tell that it is a
+// child of both "AddV2" and "Conv2D". Labels are arbitrary strings to associate
+// with the nodes to be matched as well as to uniquely identify those nodes.
+//
+// (3) The motivatation for a grammar based pattern matching in grappler is to
+// make easy for finding fusion pattern in the remapper. A subgraph that
+// matches a given pattern, however, is not fusable if any of the matched node,
+// that will be removed as a part of fusion, has a consumer outside the matched
+// subgraph. In order to check for such type of external dependencies, we
+// further extend pattern syntax by prospective action (NodeStatus) on the
+// matched nodes as shown below. This helps cross checking the nodes to be
+// removed with the nodes matched intially.
+//
+//  {"AddV2", "my_add", NodeStatus::kReplace,
+//    {
+//      {"*", "my_residual_input", NodeStatus::kRemain},
+//      {"BiasAdd", "my_bias_add", NodeStatus::kRemove,
+//        {
+//          {"Conv2D", "my_conv", NodeStatus::kRemove,
+//            {
+//              {"*", "my_residual_input", NodeStatus::kRemain},
+//              {"*", "my_filter", NodeStatus::Remain}
+//            }
+//          },
+//          {"*", my_bias", NodeStatus::kRemain}
+//        }
+//      }
+//    }
+//  }
+//------------------------------------------------------------------------------
+
+// Pattern matcher recursively matches child subpatterns. The direction
+// for children could be toward node's input (fanins) or outputs (fanouts).
+enum class MatchingDirection { kFollowInputs, kFollowOutputs };
+
+// Action for each node in the set of matched nodes for a given pattern.
+enum class NodeStatus { kRemain, kRemove, kReplace };
+
+// TODO (intel-tf): Support multiple roots by making them children of a single
+// virtual root.
+struct OpTypePattern {
+  string op;
+  string label;
+  NodeStatus node_status;
+  std::vector<OpTypePattern> children;
+
+  string DebugString() const {
+    string result = "{(op: " + op + ", " + "label: " + label + "), {";
+    for (const OpTypePattern& child : children) {
+      result += child.DebugString() + ",";
+    }
+    result += "}}";
+    return result;
+  }
+};
+
+// This is a helpful recursive structure that keeps one-to-one mapping of
+// pattern syntax to the matched nodes. User can call DebugString to see what
+// has been matched so far and where is the failing point.
+struct NodeViewMatch {
+  MutableNodeView* node_view = nullptr;
+  std::vector<NodeViewMatch> children;
+
+  string DebugString() const {
+    string result = "{";
+    if (node_view == nullptr) {
+      result += "Non-Matched-Node}";
+      return result;
+    } else {
+      result += node_view->node()->DebugString();
+      result += ", {";
+      for (const NodeViewMatch& child : children) {
+        result += child.DebugString() + ",";
+      }
+      result += "}}";
+      return result;
+    }
+  }
+
+  void Clear() {
+    for (NodeViewMatch& child : children) {
+      child.Clear();  // child is an object.
+    }
+    children.clear();  // children is a vector.
+    if (node_view != nullptr) {
+      node_view = nullptr;
+    }
+  }
+};
+
+template <MatchingDirection DIRECTION = MatchingDirection::kFollowInputs>
+class SubGraphMatcher {
+ public:
+  SubGraphMatcher(MutableGraphView* graph_view) : graph_view_(graph_view){};
+
+  // If a given pattern is matched, this function returns true as well as the
+  // matched node and remove node info is populated.
+  bool GetMatchedNodes(const OpTypePattern& pattern,
+                       const std::unordered_set<string>& nodes_to_preserve,
+                       MutableNodeView* node_view,
+                       std::map<string, int>* matched_nodes_map,
+                       std::set<int>* remove_node_indices);
+
+ private:
+  MutableGraphView* graph_view_;
+  std::map<string, int> node_label_to_index_;
+  std::set<int> matched_node_indices_;
+  std::set<int> remove_node_indices_;
+  std::unique_ptr<NodeViewMatch> match_ = nullptr;
+
+  bool DoesOpTypePatternMatch(const OpTypePattern& pattern,
+                              MutableNodeView* node_view, NodeViewMatch* match);
+
+  // This function should be called after the pattern matcher has found
+  // potential matched nodes (i.e. when DoesOpTypePatternMatch returns "true").
+  // It performs a sanity check if the candidate nodes for removal in subgraph
+  // fusion is indeed safe to remove.
+  bool IsSafeNodesToRemove(
+      const std::unordered_set<string>& nodes_to_preserve) {
+    for (const auto& node_idx : remove_node_indices_) {
+      auto node_view = graph_view_->GetNode(node_idx);
+      // Check if the node to be removed is in the nodes to be preserved.
+      string node_name = node_view->GetName();
+      if (nodes_to_preserve.count(node_name) > 0) return false;
+      // Traverse all the Regular Fanouts. Fanouts are stored as vector of
+      // vector, std::vector<std::vector<MutableFaninView>>. Note that
+      // a MutableNodeView's fanouts are stored in a nested vector of
+      // MutableFaninView type.
+      auto fanouts_by_ports = node_view->GetRegularFanouts();
+      for (const auto& fanouts : fanouts_by_ports) {
+        for (const auto& fanout : fanouts) {
+          if (!matched_node_indices_.count(fanout.node_index())) {
+            return false;
+          }
+        }
+      }
+    }
+    return true;
+  }
+};
+
+template <>
+bool SubGraphMatcher<MatchingDirection::kFollowInputs>::DoesOpTypePatternMatch(
+    const OpTypePattern& pattern, MutableNodeView* node_view,
+    NodeViewMatch* match);
+
+template <>
+bool SubGraphMatcher<MatchingDirection::kFollowInputs>::GetMatchedNodes(
+    const OpTypePattern& pattern,
+    const std::unordered_set<string>& nodes_to_preserve,
+    MutableNodeView* node_view, std::map<string, int>* matched_nodes_map,
+    std::set<int>* remove_node_indices);
+
+}  // namespace utils
+}  // namespace grappler
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_UTILS_PATTERN_UTILS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/utils/symbolic_shapes.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/utils/symbolic_shapes.h
new file mode 100644
index 0000000000000000000000000000000000000000..9da374ed96876617e74838b4d321550b24f7403c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/utils/symbolic_shapes.h
@@ -0,0 +1,77 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_UTILS_SYMBOLIC_SHAPES_H_
+#define TENSORFLOW_CORE_GRAPPLER_UTILS_SYMBOLIC_SHAPES_H_
+
+#include "tensorflow/core/framework/tensor_shape.pb.h"
+#include "tensorflow/core/grappler/costs/op_performance_data.pb.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+namespace grappler {
+
+bool IsKnown(const TensorShapeProto::Dim& dim);
+bool IsKnownSymbolically(const TensorShapeProto::Dim& dim);
+bool IsUnknown(const TensorShapeProto::Dim& dim);
+
+// Shape is symbolically defined, if it has a known rank, and each dimension is
+// known (dim_size >= 0), or is a symbolic dimension size (dim_size <= -2).
+bool ShapeIsSymbolicallyDefined(const TensorShapeProto& shape);
+bool ShapeIsSymbolicallyDefined(const OpInfo::TensorProperties& properties);
+
+// Returns the rank of the shape ir -1 if unknown
+int Rank(const TensorShapeProto& shape);
+
+// Returns the number of coefficients in the shape or -1 if unknown.
+// TODO(bsteiner) Add a function that computes the minimum size of the tensor,
+// ie the size assuming all the symbolic dimensions take the value 1.
+int64_t NumCoefficients(const TensorShapeProto& shape);
+
+// Shapes are symbolically equal, if they have the same rank, they are known or
+// symbolically defined, and have matching dimensions.
+bool ShapesSymbolicallyEqual(const TensorShapeProto& left,
+                             const TensorShapeProto& right);
+bool ShapesSymbolicallyEqual(const OpInfo::TensorProperties& left,
+                             const OpInfo::TensorProperties& right);
+
+// Check if two shapes can be broadcasted to each other. Both shapes must be at
+// least symbolically defined, and the have valid BCast instance.
+bool ShapesBroadcastable(const TensorShapeProto& left,
+                         const TensorShapeProto& right);
+bool ShapesBroadcastable(const OpInfo::TensorProperties& left,
+                         const OpInfo::TensorProperties& right);
+bool ShapeAfterBroadcast(const TensorShapeProto& left,
+                         const TensorShapeProto& right,
+                         TensorShapeProto* output_shape);
+
+// Return true if can prove, that tensor of size 'left' is smaller than tensor
+// of size 'right'. Return false if it's larger or equal, or it's impossible to
+// compare because of unknown dimensions, or mismatch in symbolic dimensions.
+bool CompareSymbolicallyShapedTensorSizes(const TensorShapeProto& left,
+                                          const TensorShapeProto& right);
+bool CompareSymbolicallyShapedTensorSizes(
+    const OpInfo::TensorProperties& left,
+    const OpInfo::TensorProperties& right);
+
+// Returns the ratio of the sizes of the 2 shapes if known statically, or -1
+// otherwise.
+int64_t ComputeSizeRatio(const TensorShapeProto& numerator,
+                         const TensorShapeProto& denominator);
+
+}  // namespace grappler
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_UTILS_SYMBOLIC_SHAPES_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/utils/topological_sort.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/utils/topological_sort.h
new file mode 100644
index 0000000000000000000000000000000000000000..dd4208dfff3b28f2b55f71e0cf369b655d6f8c09
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/utils/topological_sort.h
@@ -0,0 +1,58 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_UTILS_TOPOLOGICAL_SORT_H_
+#define TENSORFLOW_CORE_GRAPPLER_UTILS_TOPOLOGICAL_SORT_H_
+
+#include "absl/types/span.h"
+#include "tensorflow/core/framework/graph.pb.h"
+#include "tensorflow/core/lib/core/status.h"
+
+namespace tensorflow {
+namespace grappler {
+
+// TODO(ezhulenev, b/121379902): We should be consistent with GraphTopologyView
+// and use `GraphView::Edge` to pass extra dependencies.
+struct TopologicalDependency {
+  TopologicalDependency(const NodeDef* from, const NodeDef* to)
+      : from(from), to(to) {}
+  const NodeDef* from;
+  const NodeDef* to;
+};
+
+// Computes a topological ordering for the graph nodes and outputs nodes in the
+// topological order to the `topo_order` output argument.
+//
+// It's possible to pass additional edges that do not exists in a graph, but
+// must be respected when computing graph topological order. Example: Tensorflow
+// runtime allows concurrent execution of dequeue/enqueue ops from the same
+// queue resource, but we might want to enforce ordering between them.
+Status ComputeTopologicalOrder(
+    const GraphDef& graph,
+    absl::Span<const TopologicalDependency> extra_dependencies,
+    std::vector<const NodeDef*>* topo_order);
+Status ComputeTopologicalOrder(const GraphDef& graph,
+                               std::vector<const NodeDef*>* topo_order);
+
+// Sorts a graph in topological order.
+Status TopologicalSort(GraphDef* graph);
+
+// Sorts a graph in topological order and reverse it.
+Status ReversedTopologicalSort(GraphDef* graph);
+
+}  // namespace grappler
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_UTILS_TOPOLOGICAL_SORT_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/utils/tpu.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/utils/tpu.h
new file mode 100644
index 0000000000000000000000000000000000000000..f81ab93f469bdb14769dc6dd75e86b35c373c318
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/utils/tpu.h
@@ -0,0 +1,31 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_UTILS_TPU_H_
+#define TENSORFLOW_CORE_GRAPPLER_UTILS_TPU_H_
+
+#include "tensorflow/core/framework/graph.pb.h"
+
+namespace tensorflow {
+namespace grappler {
+
+// Check if the graphdef contains nodes that indicate a graph processed by the
+// legacy TPU bridge.
+bool IsLegacyTPUBridgeGraphDef(const GraphDef& def);
+
+}  // end namespace grappler
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_UTILS_TPU_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/utils/transitive_fanin.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/utils/transitive_fanin.h
new file mode 100644
index 0000000000000000000000000000000000000000..11dccfc82e0fe86a2a76f0df7c948e3fcf54f17e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/utils/transitive_fanin.h
@@ -0,0 +1,50 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_GRAPPLER_UTILS_TRANSITIVE_FANIN_H_
+#define TENSORFLOW_CORE_GRAPPLER_UTILS_TRANSITIVE_FANIN_H_
+
+#include <unordered_map>
+#include <vector>
+
+#include "tensorflow/core/framework/graph.pb.h"
+#include "tensorflow/core/lib/core/status.h"
+
+namespace tensorflow {
+namespace grappler {
+
+// Computes the transitive fanin of the graph based on reachability from the
+// specified terminal nodes. Returns the set of nodes comprising the
+// transitive fanin into fanin_nodes. Optionally returns a map of name->node
+// for that graph into name_to_fanin_node if that is not set to nullptr.
+Status ComputeTransitiveFanin(
+    const GraphDef& graph, const std::vector<string>& terminal_nodes,
+    std::unordered_map<string, const NodeDef*>* name_to_fanin_node,
+    std::vector<const NodeDef*>* fanin_nodes);
+
+Status ComputeTransitiveFanin(const GraphDef& graph,
+                              const std::vector<string>& terminal_nodes,
+                              std::vector<const NodeDef*>* fanin_nodes);
+
+// Creates output_graph from input_graph using the transitive fanin from the
+// specified terminal nodes. Returns error if the input_graph is deemed
+// structurally invalid.
+Status SetTransitiveFaninGraph(const GraphDef& input_graph,
+                               GraphDef* output_graph,
+                               const std::vector<string>& terminal_nodes);
+
+}  // namespace grappler
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_UTILS_TRANSITIVE_FANIN_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/utils/traversal.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/utils/traversal.h
new file mode 100644
index 0000000000000000000000000000000000000000..5c9dada4933ff803c9f53fec44f74104daec11f6
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/utils/traversal.h
@@ -0,0 +1,103 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_UTILS_TRAVERSAL_H_
+#define TENSORFLOW_CORE_GRAPPLER_UTILS_TRAVERSAL_H_
+
+#include <functional>
+
+#include "tensorflow/core/grappler/graph_topology_view.h"
+
+namespace tensorflow {
+namespace grappler {
+
+enum class TraversalDirection { kFollowInputs, kFollowOutputs };
+
+// Encapsulate DFS callbacks that will be called during the graph traversal.
+//
+// If non-empty, the `pre_order` and `post_order` functors will be called on
+// each reachable node (including the `from` nodes) in pre and post order. If
+// loops are found, the `on_back_edge` functor will be called on the
+// corresponding back edges. Moreover, the pre and post order will assume that
+// these back edges will be cut.
+struct DfsCallbacks {
+  DfsCallbacks() = default;
+  DfsCallbacks(std::function<void(const NodeDef*)> pre,
+               std::function<void(const NodeDef*)> post,
+               std::function<void(const NodeDef*, const NodeDef*)> back_edge)
+      : pre_order(std::move(pre)),
+        post_order(std::move(post)),
+        on_back_edge(std::move(back_edge)) {}
+
+  static DfsCallbacks PreOrder(std::function<void(const NodeDef*)> pre) {
+    return DfsCallbacks(std::move(pre), nullptr, nullptr);
+  }
+
+  static DfsCallbacks PostOrder(std::function<void(const NodeDef*)> post) {
+    return DfsCallbacks(nullptr, std::move(post), nullptr);
+  }
+
+  std::function<void(const NodeDef*)> pre_order;
+  std::function<void(const NodeDef*)> post_order;
+  std::function<void(const NodeDef*, const NodeDef*)> on_back_edge;
+};
+
+// Encapsulate DFS predicates for traversing the graph.
+//
+// The `enter` predicate decides if traversal should enter the node, and the
+// `advance` predicate decides if the traversal should follow inputs/outputs
+// from the node.
+//
+// If predicates are empty (default initialized), it's assumed that we can enter
+// into any node and advance from any node respectively.
+struct DfsPredicates {
+  DfsPredicates() = default;
+  DfsPredicates(std::function<bool(const NodeDef*)> enter,
+                std::function<bool(const NodeDef*)> advance)
+      : enter(std::move(enter)), advance(std::move(advance)) {}
+
+  static DfsPredicates Enter(std::function<bool(const NodeDef*)> enter) {
+    return DfsPredicates(std::move(enter), nullptr);
+  }
+
+  static DfsPredicates Advance(std::function<bool(const NodeDef*)> advance) {
+    return DfsPredicates(nullptr, std::move(advance));
+  }
+
+  std::function<bool(const NodeDef*)> enter;
+  std::function<bool(const NodeDef*)> advance;
+};
+
+// Traverse the graph in DFS order in the given direction, starting from the
+// list of nodes specified in the `from` argument. Use `predicates` to decide if
+// traversal should enter/advance to/from the graph node. These predicates also
+// applied to the `from` nodes. Call corresponding callbacks for each visited
+// node.
+void DfsTraversal(const GraphTopologyView& graph_view,
+                  absl::Span<const NodeDef* const> from,
+                  TraversalDirection direction, const DfsPredicates& predicates,
+                  const DfsCallbacks& callbacks);
+
+// Traverse the graph in DFS order in the given direction, starting from the
+// list of nodes specified in the `from` argument. Call corresponding callbacks
+// for each visited node.
+void DfsTraversal(const GraphTopologyView& graph_view,
+                  absl::Span<const NodeDef* const> from,
+                  TraversalDirection direction, const DfsCallbacks& callbacks);
+
+}  // namespace grappler
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_UTILS_TRAVERSAL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/verifiers/graph_verifier.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/verifiers/graph_verifier.h
new file mode 100644
index 0000000000000000000000000000000000000000..10fd201eadcfd33709c0e7d2540528ad895b3358
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/verifiers/graph_verifier.h
@@ -0,0 +1,55 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_VERIFIERS_GRAPH_VERIFIER_H_
+#define TENSORFLOW_CORE_GRAPPLER_VERIFIERS_GRAPH_VERIFIER_H_
+
+#include <string>
+#include <vector>
+#include "tensorflow/core/framework/graph.pb.h"
+#include "tensorflow/core/lib/core/status.h"
+
+namespace tensorflow {
+namespace grappler {
+
+// An abstract interface for verifying a graph.
+// This will be used to implement specific verifiers to verify that a grappler
+// transformed graph is valid.
+// Some examples of specific verifiers are:
+// 1. A general structural verifier that verifies that the specified graph has
+//    a valid structure that meets the specification of what it means to be
+//      a valid TensorFlow graph.
+// 2. A backend specific verifier that verifies that the specified graph,
+//     generated after a grappler transformation to convert the input TensorFlow
+//     graph to a corresponding backend graph, is a valid graph in the
+//     specification of the backend.
+class GraphVerifier {
+ public:
+  GraphVerifier() {}
+  virtual ~GraphVerifier() {}
+
+  // A name for the verifier.
+  virtual string name() const = 0;
+
+  // Implement an algorithm to verify the specified graph.
+  // The return value is a Status that represents a concatenation of Status of
+  // each verification step.
+  virtual Status Verify(const GraphDef& graph) = 0;
+};
+
+}  // end namespace grappler
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_VERIFIERS_GRAPH_VERIFIER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/verifiers/structure_verifier.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/verifiers/structure_verifier.h
new file mode 100644
index 0000000000000000000000000000000000000000..ab719f1214eebb624d50a814ce437ffe3957304d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/grappler/verifiers/structure_verifier.h
@@ -0,0 +1,43 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_GRAPPLER_VERIFIERS_STRUCTURE_VERIFIER_H_
+#define TENSORFLOW_CORE_GRAPPLER_VERIFIERS_STRUCTURE_VERIFIER_H_
+
+#include <string>
+#include <vector>
+
+#include "tensorflow/core/framework/graph.pb.h"
+#include "tensorflow/core/grappler/verifiers/graph_verifier.h"
+#include "tensorflow/core/lib/core/status.h"
+
+namespace tensorflow {
+namespace grappler {
+
+// Verifies the structure of a graph to ensure it is valid.
+class StructureVerifier : public GraphVerifier {
+ public:
+  StructureVerifier() {}
+  ~StructureVerifier() override {}
+
+  string name() const override { return "structure_verifier"; };
+
+  Status Verify(const GraphDef& graph) override;
+};
+
+}  // end namespace grappler
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_GRAPPLER_VERIFIERS_STRUCTURE_VERIFIER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/ir/dialect.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/ir/dialect.h
new file mode 100644
index 0000000000000000000000000000000000000000..df6deb2ac171406807545f2818b483d041bdd52e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/ir/dialect.h
@@ -0,0 +1,82 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_IR_DIALECT_H_
+#define TENSORFLOW_CORE_IR_DIALECT_H_
+
+#include "mlir/IR/BuiltinTypes.h"  // from @llvm-project
+#include "mlir/IR/Diagnostics.h"  // from @llvm-project
+#include "mlir/IR/Dialect.h"  // from @llvm-project
+#include "mlir/IR/OpImplementation.h"  // from @llvm-project
+#include "mlir/IR/TypeUtilities.h"  // from @llvm-project
+#include "tensorflow/core/ir/types/dialect.h"
+
+namespace mlir {
+namespace tfg {
+// Include the relevant TensorFlow attrs/types directly in the TFG namespace.
+using mlir::tf_type::Bfloat16RefType;      // NOLINT
+using mlir::tf_type::BoolRefType;          // NOLINT
+using mlir::tf_type::Complex128RefType;    // NOLINT
+using mlir::tf_type::Complex64RefType;     // NOLINT
+using mlir::tf_type::ControlType;          // NOLINT
+using mlir::tf_type::DoubleRefType;        // NOLINT
+using mlir::tf_type::Float8E4M3FNRefType;  // NOLINT
+using mlir::tf_type::Float8E5M2RefType;    // NOLINT
+using mlir::tf_type::FloatRefType;         // NOLINT
+using mlir::tf_type::FuncAttr;             // NOLINT
+using mlir::tf_type::HalfRefType;          // NOLINT
+using mlir::tf_type::Int16RefType;         // NOLINT
+using mlir::tf_type::Int32RefType;         // NOLINT
+using mlir::tf_type::Int4RefType;          // NOLINT
+using mlir::tf_type::Int64RefType;         // NOLINT
+using mlir::tf_type::Int8RefType;          // NOLINT
+using mlir::tf_type::OpaqueTensorType;     // NOLINT
+using mlir::tf_type::PlaceholderAttr;      // NOLINT
+using mlir::tf_type::Qint16RefType;        // NOLINT
+using mlir::tf_type::Qint16Type;           // NOLINT
+using mlir::tf_type::Qint32RefType;        // NOLINT
+using mlir::tf_type::Qint32Type;           // NOLINT
+using mlir::tf_type::Qint8RefType;         // NOLINT
+using mlir::tf_type::Qint8Type;            // NOLINT
+using mlir::tf_type::Quint16RefType;       // NOLINT
+using mlir::tf_type::Quint16Type;          // NOLINT
+using mlir::tf_type::Quint8RefType;        // NOLINT
+using mlir::tf_type::Quint8Type;           // NOLINT
+using mlir::tf_type::ResourceRefType;      // NOLINT
+using mlir::tf_type::ResourceType;         // NOLINT
+using mlir::tf_type::ShapeAttr;            // NOLINT
+using mlir::tf_type::StringRefType;        // NOLINT
+using mlir::tf_type::StringType;           // NOLINT
+using mlir::tf_type::Uint16RefType;        // NOLINT
+using mlir::tf_type::Uint32RefType;        // NOLINT
+using mlir::tf_type::Uint4RefType;         // NOLINT
+using mlir::tf_type::Uint64RefType;        // NOLINT
+using mlir::tf_type::Uint8RefType;         // NOLINT
+using mlir::tf_type::VariantRefType;       // NOLINT
+using mlir::tf_type::VariantType;          // NOLINT
+using mlir::tf_type::VersionAttr;          // NOLINT
+
+class TFGraphOpAsmInterface;
+class TFOp;
+}  // namespace tfg
+}  // namespace mlir
+
+// Dialect main class is defined in ODS, we include it here.
+#include "tensorflow/core/ir/dialect.h.inc"
+// ODS-generated attribute classes.
+#define GET_ATTRDEF_CLASSES
+#include "tensorflow/core/ir/attributes.h.inc"
+
+#endif  // TENSORFLOW_CORE_IR_DIALECT_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/ir/importexport/convert_attributes.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/ir/importexport/convert_attributes.h
new file mode 100644
index 0000000000000000000000000000000000000000..f57aaf99a6d68344073e75ed55a3e9c3c67147d3
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/ir/importexport/convert_attributes.h
@@ -0,0 +1,87 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_IR_IMPORTEXPORT_CONVERT_ATTRIBUTES_H_
+#define TENSORFLOW_CORE_IR_IMPORTEXPORT_CONVERT_ATTRIBUTES_H_
+
+#include <string>
+
+#include "absl/strings/string_view.h"
+#include "mlir/IR/Attributes.h"  // from @llvm-project
+#include "mlir/IR/Builders.h"  // from @llvm-project
+#include "mlir/IR/BuiltinTypes.h"  // from @llvm-project
+#include "tensorflow/core/framework/node_def_util.h"
+#include "tensorflow/core/framework/op_def.pb.h"
+#include "tensorflow/core/framework/resource_handle.pb.h"
+#include "tensorflow/core/ir/dialect.h"
+#include "tensorflow/core/platform/statusor.h"
+
+namespace mlir {
+namespace tfg {
+
+// Convert the list of MLIR Attributes `attrs` to the `tensorflow::AttrValueMap`
+// `values`.
+tensorflow::Status ConvertAttributes(ArrayRef<NamedAttribute> attrs,
+                                     ArrayRef<StringRef> attrs_to_ignore,
+                                     bool remove_ref_type,
+                                     tensorflow::AttrValueMap* values);
+
+// Convert the MLIR attribute `attr` and return a `tensorflow::AttrValue`.
+tensorflow::StatusOr<tensorflow::AttrValue> ConvertAttribute(Attribute attr);
+
+tensorflow::Status SetShapeAttribute(absl::string_view name,
+                                     ShapedType shaped_type,
+                                     tensorflow::AttrValueMap* values);
+
+// Converts an MLIR shaped type to a TensorFlow shape attribute.
+ShapeAttr ConvertTypeToTensorShapeAttr(const Type& type);
+
+/// Import from TensorFlow to MLIR
+
+// Converts non func AttrValue proto into an MLIR attribute. Func attribute is
+// exclused in this function because the function might be renamed when the
+// function definition is imported.
+tensorflow::StatusOr<Attribute> ConvertNonFuncAttributeValue(
+    const tensorflow::AttrValue& value, Builder& builder);
+
+// Converts all kinds of AttrValue proto into an MLIR attribute.
+tensorflow::StatusOr<Attribute> ConvertAttributeValue(
+    const tensorflow::AttrValue& value, Builder& builder);
+
+// Convert the MLIR FullTyoe attribute `attr` and return a
+// `tensorflow::FullTypeDef`.
+tensorflow::StatusOr<tensorflow::FullTypeDef> ConvertAttribute(
+    tf_type::FullTypeAttr full_type);
+
+// Converts fulltype proto to attribute.
+tensorflow::StatusOr<::mlir::tf_type::FullTypeAttr> ConvertAttribute(
+    const tensorflow::FullTypeDef& full_type, Builder& builder);
+
+// Convert an array of handle data (pairs of data types and shapes) to an array
+// attribute of tensor types.
+tensorflow::StatusOr<ArrayAttr> ConvertHandleData(
+    Builder builder,
+    const tensorflow::protobuf::RepeatedPtrField<
+        tensorflow::ResourceHandleProto_DtypeAndShape>& handle_data);
+
+// Convert an array of handle data into the `handle_data` field of the provided
+// ArgDef. Each entry of the array is expected to be a TensorType.
+tensorflow::Status ConvertHandleData(ArrayAttr handle_data_arr,
+                                     tensorflow::OpDef::ArgDef* arg);
+
+}  // namespace tfg
+}  // namespace mlir
+
+#endif  // TENSORFLOW_CORE_IR_IMPORTEXPORT_CONVERT_ATTRIBUTES_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/ir/importexport/convert_tensor.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/ir/importexport/convert_tensor.h
new file mode 100644
index 0000000000000000000000000000000000000000..d20245e2f9fbcc33f7211c4d1cbcb67ed4ea5fa3
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/ir/importexport/convert_tensor.h
@@ -0,0 +1,93 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_IR_IMPORTEXPORT_CONVERT_TENSOR_H_
+#define TENSORFLOW_CORE_IR_IMPORTEXPORT_CONVERT_TENSOR_H_
+
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/SmallVector.h"
+#include "mlir/IR/Attributes.h"  // from @llvm-project
+#include "mlir/IR/Builders.h"  // from @llvm-project
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/tensor.pb.h"
+#include "tensorflow/core/framework/tensor_shape.pb.h"
+#include "tensorflow/core/ir/dialect.h"
+#include "tensorflow/core/ir/types/dialect.h"
+#include "tensorflow/core/platform/statusor.h"
+
+namespace mlir {
+namespace tfg {
+
+// Converts an TensorFlow tensor proto into an MLIR elements attribute.
+tensorflow::StatusOr<ElementsAttr> ConvertTensorProto(
+    const tensorflow::TensorProto& input_tensor, Builder builder);
+
+// Converts an TensorFlow tensor into an MLIR elements attribute.
+tensorflow::StatusOr<ElementsAttr> ConvertTensor(
+    const tensorflow::Tensor& input_tensor, Builder builder);
+
+// Converts a shape from MLIR to a TensorFlow tensor shape proto.
+void ConvertToTensorShapeProto(ArrayRef<int64_t> shape,
+                               tensorflow::TensorShapeProto* output_shape);
+
+// Converts an MLIR type to a TensorFlow tensor shape.
+tensorflow::PartialTensorShape ConvertTypeToTensorShape(const Type& type);
+
+// Converts a TensorFlow shape attribute to an MLIR shape attribute.
+tensorflow::StatusOr<ShapeAttr> ConvertTensorShapeProto(
+    const tensorflow::TensorShapeProto& shape, MLIRContext* context);
+
+// Fill in the contents of TensorShapeProto for the given shape.
+// ShapeContainerT is any type with the following methods:
+//   bool hasRank()
+//   ArrayRef<int64_t> getShape()
+// This includes TF::ShapeAttr and ShapedType.
+template <typename ShapeContainerT>
+void SetTensorShapeProto(ShapeContainerT shape,
+                         tensorflow::TensorShapeProto* proto) {
+  if (shape.hasRank()) {
+    for (int64_t dim : shape.getShape()) {
+      // TODO(hinsu): Use tensorflow::kTFDynamicSize instead of -1 without
+      // depending on tensorflow/compiler
+      proto->add_dim()->set_size(mlir::ShapedType::isDynamic(dim) ? -1 : dim);
+    }
+  } else {
+    proto->set_unknown_rank(true);
+  }
+}
+
+// Converts an MLIR elements attribute to a TensorFlow tensor proto.
+tensorflow::Status ConvertToTensorProto(ElementsAttr attr,
+                                        tensorflow::TensorProto* output_tensor);
+
+// Converts an MLIR elements attribute to a TensorFlow tensor.
+tensorflow::Status ConvertToTensor(ElementsAttr attr,
+                                   tensorflow::Tensor* output_tensor);
+
+// Converts a TF shape to MLIR shape, i.e. -1 becomes kDynamicSize.
+llvm::SmallVector<int64_t> ConvertTFShapeToMlir(llvm::ArrayRef<int64_t> shape);
+
+// Converts an MLIR shape to TF shape, i.e. kDynamicSize becomes -1.
+llvm::SmallVector<int64_t> ConvertMlirShapeToTF(llvm::ArrayRef<int64_t> shape);
+
+// Creates a TF TensorShape using MLIR shape, element type and encoding.
+mlir::RankedTensorType GetTypeFromTFTensorShape(llvm::ArrayRef<int64_t> shape,
+                                                mlir::Type elementType,
+                                                mlir::Attribute encoding = {});
+
+}  // namespace tfg
+}  // namespace mlir
+
+#endif  // TENSORFLOW_CORE_IR_IMPORTEXPORT_CONVERT_TENSOR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/ir/importexport/convert_types.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/ir/importexport/convert_types.h
new file mode 100644
index 0000000000000000000000000000000000000000..5dd230a614b8d6c5be54d58509ea5de7ad6da89d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/ir/importexport/convert_types.h
@@ -0,0 +1,57 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_IR_IMPORTEXPORT_CONVERT_TYPES_H_
+#define TENSORFLOW_CORE_IR_IMPORTEXPORT_CONVERT_TYPES_H_
+
+#include "mlir/IR/Builders.h"  // from @llvm-project
+#include "mlir/IR/Types.h"  // from @llvm-project
+#include "tensorflow/core/framework/tensor_shape.h"
+#include "tensorflow/core/framework/tensor_shape.pb.h"
+#include "tensorflow/core/framework/types.pb.h"
+#include "tensorflow/core/platform/statusor.h"
+
+namespace mlir {
+namespace tfg {
+// Converts the TensorFlow DataType 'dtype' into an MLIR (scalar) type.
+tensorflow::Status ConvertDataType(tensorflow::DataType dtype, Builder& builder,
+                                   Type* type);
+
+// Converts a scalar MLIR type to a TensorFlow Datatype.
+tensorflow::Status ConvertScalarTypeToDataType(Type type,
+                                               tensorflow::DataType* dtype);
+
+// Converts an MLIR type to TensorFlow DataType. If 'type' is a scalar type, it
+// is converted directly. If it is a shaped type, the element type is converted.
+tensorflow::Status ConvertToDataType(Type type, tensorflow::DataType* dtype);
+
+// Converts an TensorFlow shape to the one used in MLIR.
+void ConvertToMlirShape(const tensorflow::TensorShape& input_shape,
+                        SmallVectorImpl<int64_t>* shape);
+
+// Converts an TensorFlow shape proto to the one used in MLIR.
+tensorflow::Status ConvertToMlirShape(
+    const tensorflow::TensorShapeProto& input_shape,
+    SmallVectorImpl<int64_t>* shape);
+
+// Given a tensor shape and dtype, get the corresponding MLIR tensor type.
+tensorflow::StatusOr<Type> ConvertToMlirTensorType(
+    const tensorflow::TensorShapeProto& shape, tensorflow::DataType dtype,
+    Builder* builder);
+
+}  // namespace tfg
+}  // namespace mlir
+
+#endif  // TENSORFLOW_CORE_IR_IMPORTEXPORT_CONVERT_TYPES_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/ir/importexport/functiondef_export.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/ir/importexport/functiondef_export.h
new file mode 100644
index 0000000000000000000000000000000000000000..8959b552ee07470916eff5b55717ab62943fe15e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/ir/importexport/functiondef_export.h
@@ -0,0 +1,35 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_IR_IMPORTEXPORT_FUNCTIONDEF_EXPORT_H_
+#define TENSORFLOW_CORE_IR_IMPORTEXPORT_FUNCTIONDEF_EXPORT_H_
+
+#include "mlir/IR/Builders.h"  // from @llvm-project
+#include "tensorflow/core/framework/function.pb.h"
+#include "tensorflow/core/ir/ops.h"
+#include "tensorflow/core/platform/statusor.h"
+
+namespace mlir {
+namespace tfg {
+
+// Export a generic GraphFuncOp into a FunctionDef. This is intended to be a
+// straight serialization, an error is returned in case of failure.
+tensorflow::StatusOr<tensorflow::FunctionDef>
+ConvertGenericFunctionToFunctionDef(GraphFuncOp func);
+
+}  // namespace tfg
+}  // namespace mlir
+
+#endif  // TENSORFLOW_CORE_IR_IMPORTEXPORT_FUNCTIONDEF_EXPORT_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/ir/importexport/functiondef_import.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/ir/importexport/functiondef_import.h
new file mode 100644
index 0000000000000000000000000000000000000000..4bd76d1a50f5f4b1cdcdb1c206ca13387a9b90ad
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/ir/importexport/functiondef_import.h
@@ -0,0 +1,36 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_IR_IMPORTEXPORT_FUNCTIONDEF_IMPORT_H_
+#define TENSORFLOW_CORE_IR_IMPORTEXPORT_FUNCTIONDEF_IMPORT_H_
+
+#include "mlir/IR/Builders.h"  // from @llvm-project
+#include "tensorflow/core/framework/function.pb.h"
+#include "tensorflow/core/ir/ops.h"
+#include "tensorflow/core/platform/status.h"
+
+namespace mlir {
+namespace tfg {
+
+// Import the FunctionDef `func` as a TFG generic function (see GraphFuncOp
+// documentation). The function will be inserted using the provided `builder`.
+tensorflow::Status ConvertGenericFunction(GraphFuncOp func_op,
+                                          const tensorflow::FunctionDef& func,
+                                          OpBuilder& builder);
+
+}  // namespace tfg
+}  // namespace mlir
+
+#endif  // TENSORFLOW_CORE_IR_IMPORTEXPORT_FUNCTIONDEF_IMPORT_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/ir/importexport/graphdef_export.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/ir/importexport/graphdef_export.h
new file mode 100644
index 0000000000000000000000000000000000000000..8ae221e454563d930a2e954b272b0e45efc20ad5
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/ir/importexport/graphdef_export.h
@@ -0,0 +1,58 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_IR_IMPORTEXPORT_GRAPHDEF_EXPORT_H_
+#define TENSORFLOW_CORE_IR_IMPORTEXPORT_GRAPHDEF_EXPORT_H_
+
+#include <string>
+
+#include "mlir/IR/BuiltinOps.h"  // from @llvm-project
+#include "mlir/IR/Value.h"  // from @llvm-project
+#include "mlir/Support/LLVM.h"  // from @llvm-project
+#include "tensorflow/core/framework/function.h"
+#include "tensorflow/core/framework/graph.pb.h"
+#include "tensorflow/core/framework/node_def.pb.h"
+#include "tensorflow/core/ir/dialect.h"
+#include "tensorflow/core/ir/ops.h"
+#include "tensorflow/core/platform/status.h"
+#include "tensorflow/core/platform/statusor.h"
+
+namespace mlir {
+namespace tfg {
+
+// Get the name of a value as if it were an edge in a graph.
+tensorflow::StatusOr<std::string> GetValueName(Value value,
+                                               TFGraphDialect *dialect);
+
+// Convert a TFG graph directly to GraphDef. Graph functions in the module are
+// added to the GraphDef's function library.
+tensorflow::Status ConvertToGraphDef(ModuleOp module,
+                                     tensorflow::GraphDef *graph);
+
+// Convert a single TFG op to NodeDef. This utliity function requires a callback
+// `get_value_name` that returns the edge name of the given operand.
+tensorflow::Status ConvertToNodeDef(
+    Operation *op, tensorflow::NodeDef *node, TFGraphDialect *dialect,
+    function_ref<tensorflow::StatusOr<std::string>(Value)> get_value_name);
+
+// Convert a single TFG function to a FunctionDef and add it to the function
+// library. If a function with the same name already exists, replace it.
+tensorflow::Status ConvertToFunctionDef(
+    GraphFuncOp func, tensorflow::FunctionLibraryDefinition &library);
+
+}  // namespace tfg
+}  // namespace mlir
+
+#endif  // TENSORFLOW_CORE_IR_IMPORTEXPORT_GRAPHDEF_EXPORT_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/ir/importexport/graphdef_import.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/ir/importexport/graphdef_import.h
new file mode 100644
index 0000000000000000000000000000000000000000..f5489b698f4d77ff4720aed203c9b58a04d9a128
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/ir/importexport/graphdef_import.h
@@ -0,0 +1,45 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_IR_IMPORTEXPORT_GRAPHDEF_IMPORT_H_
+#define TENSORFLOW_CORE_IR_IMPORTEXPORT_GRAPHDEF_IMPORT_H_
+
+#include "mlir/IR/BuiltinOps.h"  // from @llvm-project
+#include "mlir/IR/MLIRContext.h"  // from @llvm-project
+#include "mlir/IR/OwningOpRef.h"  // from @llvm-project
+#include "tensorflow/core/framework/function.h"
+#include "tensorflow/core/framework/graph.pb.h"
+#include "tensorflow/core/framework/graph_debug_info.pb.h"
+#include "tensorflow/core/graph/graph.h"
+#include "tensorflow/core/platform/statusor.h"
+
+namespace mlir {
+namespace tfg {
+
+// Convert a GraphDef directly to TFG.
+tensorflow::StatusOr<OwningOpRef<ModuleOp>> ImportGraphDef(
+    MLIRContext *context, const tensorflow::GraphDebugInfo &debug_info,
+    const tensorflow::GraphDef &graph_def);
+
+// Converts a graph and function library to a TFG module.
+tensorflow::StatusOr<OwningOpRef<ModuleOp>> ImportGraphAndFunctionsToMlir(
+    MLIRContext *context, const tensorflow::GraphDebugInfo &debug_info,
+    const tensorflow::Graph &graph,
+    const tensorflow::FunctionLibraryDefinition &flib_def);
+
+}  // namespace tfg
+}  // namespace mlir
+
+#endif  // TENSORFLOW_CORE_IR_IMPORTEXPORT_GRAPHDEF_IMPORT_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/ir/importexport/mangling.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/ir/importexport/mangling.h
new file mode 100644
index 0000000000000000000000000000000000000000..98bcddccc9df6cc08d2280abe8de4078ec599823
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/ir/importexport/mangling.h
@@ -0,0 +1,76 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_IR_IMPORTEXPORT_MANGLING_H_
+#define TENSORFLOW_CORE_IR_IMPORTEXPORT_MANGLING_H_
+
+#include <string>
+
+#include "absl/strings/string_view.h"
+#include "tensorflow/core/framework/tensor.pb.h"
+#include "tensorflow/core/framework/tensor_shape.pb.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/lib/core/status.h"
+
+namespace mlir {
+namespace tfg {
+namespace mangling_util {
+// The type of a mangled string.
+enum class MangledKind { kUnknown, kDataType, kTensorShape, kTensor };
+
+// Print proto in TextFormat in the single-line mode.
+std::string PrintShortTextProto(const ::tensorflow::protobuf::Message& message);
+// The MessageLite interface does not support reflection so this API
+// will only print a summary of the proto. This API is needed for code
+// that may work with both Message and MessageLite.
+std::string PrintShortTextProto(
+    const ::tensorflow::protobuf::MessageLite& message);
+
+// Mangles an attribute name, marking the attribute as a TensorFlow attribute.
+std::string MangleAttributeName(absl::string_view str);
+
+// Returns true if 'str' was mangled with MangleAttributeName.
+bool IsMangledAttributeName(absl::string_view str);
+
+// Demangles an attribute name that was manged with MangleAttributeName.
+// REQUIRES: IsMangledAttributeName returns true.
+absl::string_view DemangleAttributeName(absl::string_view str);
+
+// Returns the type of a mangled string, or kUnknown.
+MangledKind GetMangledKind(absl::string_view str);
+
+// Return a TensorShapeProto mangled as a string.
+std::string MangleShape(const tensorflow::TensorShapeProto& shape);
+// Demangle a string mangled with MangleShape.
+tensorflow::Status DemangleShape(absl::string_view str,
+                                 tensorflow::TensorShapeProto* proto);
+
+// Return a TensorProto mangled as a string.
+std::string MangleTensor(const tensorflow::TensorProto& tensor);
+// Demangle a string mangled with MangleTensor.
+tensorflow::Status DemangleTensor(absl::string_view str,
+                                  tensorflow::TensorProto* proto);
+
+// Return a DataType mangled as a string.
+std::string MangleDataType(const tensorflow::DataType& dtype);
+// Demangle a string mangled with MangleDataType.
+tensorflow::Status DemangleDataType(absl::string_view str,
+                                    tensorflow::DataType* proto);
+
+}  // namespace mangling_util
+}  // namespace tfg
+}  // namespace mlir
+
+#endif  // TENSORFLOW_CORE_IR_IMPORTEXPORT_MANGLING_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/ir/importexport/parse_text_proto.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/ir/importexport/parse_text_proto.h
new file mode 100644
index 0000000000000000000000000000000000000000..913081de7eed44d67164ef602723540e2ccf46d1
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/ir/importexport/parse_text_proto.h
@@ -0,0 +1,47 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_IR_IMPORTEXPORT_PARSE_TEXT_PROTO_H_
+#define TENSORFLOW_CORE_IR_IMPORTEXPORT_PARSE_TEXT_PROTO_H_
+
+#include "absl/strings/string_view.h"
+#include "tensorflow/core/lib/core/errors.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/platform/protobuf.h"
+
+namespace mlir {
+namespace tfg {
+
+// Sets output to the given input with `prefix` stripped, or returns an error if
+// the prefix doesn't exist.
+tensorflow::Status ConsumePrefix(absl::string_view str,
+                                 absl::string_view prefix,
+                                 absl::string_view* output);
+
+// Strips `prefix_to_strip` from `text_proto`, parses, and returns the parsed
+// proto.
+tensorflow::Status ParseTextProto(absl::string_view text_proto,
+                                  absl::string_view prefix_to_strip,
+                                  tensorflow::protobuf::Message* parsed_proto);
+inline tensorflow::Status ParseTextProto(
+    absl::string_view /* text_proto */, absl::string_view /* prefix_to_strip */,
+    tensorflow::protobuf::MessageLite* /* parsed_proto */) {
+  return tensorflow::errors::Unavailable("Cannot parse text protos on mobile.");
+}
+
+}  // namespace tfg
+}  // namespace mlir
+
+#endif  // TENSORFLOW_CORE_IR_IMPORTEXPORT_PARSE_TEXT_PROTO_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/ir/interfaces.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/ir/interfaces.h
new file mode 100644
index 0000000000000000000000000000000000000000..c6b07034d2ec9c1aa9a8da88cd7f118f057f170d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/ir/interfaces.h
@@ -0,0 +1,75 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_IR_INTERFACES_H_
+#define TENSORFLOW_CORE_IR_INTERFACES_H_
+
+#include "mlir/IR/Dialect.h"  // from @llvm-project
+#include "mlir/IR/DialectInterface.h"  // from @llvm-project
+#include "mlir/IR/OpDefinition.h"  // from @llvm-project
+#include "mlir/Interfaces/ControlFlowInterfaces.h"  // from @llvm-project
+#include "mlir/Interfaces/SideEffectInterfaces.h"  // from @llvm-project
+#include "mlir/Support/LLVM.h"  // from @llvm-project
+#include "tensorflow/core/ir/dialect.h"
+
+// Include generated declarations.
+#include "tensorflow/core/ir/interfaces.h.inc"
+
+namespace mlir {
+namespace tfg {
+// The dialect fallback model for the TensorFlow registry interface.
+class TensorFlowRegistryInterfaceBase
+    : public TensorFlowRegistryInterface::FallbackModel<
+          TensorFlowRegistryInterfaceBase>,
+      public DialectInterface::Base<TensorFlowRegistryInterfaceBase> {
+ public:
+  explicit TensorFlowRegistryInterfaceBase(Dialect *dialect)
+      : DialectInterface::Base<TensorFlowRegistryInterfaceBase>(dialect) {}
+
+  // Returns whether the operation is stateful.
+  virtual bool isStateful(Operation *op) const = 0;
+};
+
+// This dialect fallback model implements memory effects for TensorFlow
+// operations.
+class StatefulMemoryEffectInterface
+    : public MemoryEffectOpInterface::FallbackModel<
+          StatefulMemoryEffectInterface>,
+      public DialectInterface::Base<StatefulMemoryEffectInterface> {
+ public:
+  explicit StatefulMemoryEffectInterface(Dialect *dialect)
+      : DialectInterface::Base<StatefulMemoryEffectInterface>(dialect) {}
+
+  // Get the memory effects of a TensorFlow operation. If the operation is known
+  // to be stateless, then it has no memory effects. Otherwise, statefulness is
+  // modelled as `MemoryWrite`.
+  void getEffects(
+      Operation *op,
+      SmallVectorImpl<SideEffects::EffectInstance<MemoryEffects::Effect>>
+          &effects) const;
+};
+}  // namespace tfg
+
+namespace OpTrait {
+// This trait marks intrinsic TFG operations, e.g. terminators, functions,
+// and region control-flow operations. Any TFG operation that has this trait
+// exists only in MLIR.
+template <typename ConcreteType>
+class IntrinsicOperation
+    : public mlir::OpTrait::TraitBase<ConcreteType, IntrinsicOperation> {};
+}  // namespace OpTrait
+}  // namespace mlir
+
+#endif  // TENSORFLOW_CORE_IR_INTERFACES_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/ir/ops.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/ir/ops.h
new file mode 100644
index 0000000000000000000000000000000000000000..08e20991969a35a6c9331187356fe35ad72f4c49
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/ir/ops.h
@@ -0,0 +1,67 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_IR_OPS_H_
+#define TENSORFLOW_CORE_IR_OPS_H_
+
+#include "mlir/IR/Attributes.h"  // from @llvm-project
+#include "mlir/IR/Builders.h"  // from @llvm-project
+#include "mlir/IR/BuiltinOps.h"  // from @llvm-project
+#include "mlir/IR/BuiltinTypes.h"  // from @llvm-project
+#include "mlir/IR/Dialect.h"  // from @llvm-project
+#include "mlir/IR/Matchers.h"  // from @llvm-project
+#include "mlir/IR/OpImplementation.h"  // from @llvm-project
+#include "mlir/IR/PatternMatch.h"  // from @llvm-project
+#include "mlir/IR/RegionKindInterface.h"  // from @llvm-project
+#include "mlir/IR/TypeUtilities.h"  // from @llvm-project
+#include "mlir/Interfaces/CallInterfaces.h"  // from @llvm-project
+#include "mlir/Interfaces/ControlFlowInterfaces.h"  // from @llvm-project
+#include "mlir/Interfaces/FunctionInterfaces.h"  // from @llvm-project
+#include "mlir/Interfaces/InferTypeOpInterface.h"  // from @llvm-project
+#include "tensorflow/core/ir/dialect.h"
+#include "tensorflow/core/ir/interfaces.h"
+#include "tensorflow/core/ir/tf_op_wrapper.h"
+
+// Get the C++ declaration for all the ops defined in ODS for the dialect.
+
+#define GET_OP_CLASSES
+#include "tensorflow/core/ir/ops.h.inc"
+
+namespace mlir {
+namespace tfg {
+
+// Analysis that keeps track of all function names in a module.
+struct FunctionTable {
+  explicit FunctionTable(ModuleOp module);
+
+  // Returns whether there are no functions.
+  bool empty() const { return functions.empty(); }
+
+  // Returns whether `op` may be a function call.
+  bool MayBeCall(Operation* op) const;
+
+  // Returns whether `op` is a legacy function call. A "legacy" function call
+  // is when the operation name is the name of a function in the library.
+  bool IsLegacyCall(Operation* op) const;
+
+ private:
+  // All the functions in the graph.
+  DenseSet<StringRef> functions;
+};
+
+}  // namespace tfg
+}  // namespace mlir
+
+#endif  // TENSORFLOW_CORE_IR_OPS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/ir/tf_op_registry.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/ir/tf_op_registry.h
new file mode 100644
index 0000000000000000000000000000000000000000..3e00af059f4a34068d4b3696c9a0dfc0db6eb928
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/ir/tf_op_registry.h
@@ -0,0 +1,50 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_IR_TF_OP_REGISTRY_H_
+#define TENSORFLOW_CORE_IR_TF_OP_REGISTRY_H_
+
+#include "tensorflow/core/ir/interfaces.h"
+
+// Forward declaration of TensorFlow types.
+namespace tensorflow {
+class OpRegistry;
+}  // namespace tensorflow
+
+namespace mlir {
+namespace tfg {
+class TensorFlowOpRegistryInterface : public TensorFlowRegistryInterfaceBase {
+ public:
+  // Create the interface model with a provided registry.
+  TensorFlowOpRegistryInterface(Dialect *dialect,
+                                const tensorflow::OpRegistry *registry)
+      : TensorFlowRegistryInterfaceBase(dialect), registry_(registry) {}
+  // Create the interface model with the global registry.
+  explicit TensorFlowOpRegistryInterface(Dialect *dialect);
+
+  // Returns true if the operation is stateful.
+  bool isStateful(Operation *op) const override;
+
+  // Returns the current TensorFlow op registry.
+  const tensorflow::OpRegistry *GetRegistry() const { return registry_; }
+
+ private:
+  // The TensorFlow op registry instance.
+  const tensorflow::OpRegistry *registry_;
+};
+}  // namespace tfg
+}  // namespace mlir
+
+#endif  // TENSORFLOW_CORE_IR_TF_OP_REGISTRY_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/ir/tf_op_wrapper.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/ir/tf_op_wrapper.h
new file mode 100644
index 0000000000000000000000000000000000000000..1bf02d90877c664541db18f36122d1125302c16c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/ir/tf_op_wrapper.h
@@ -0,0 +1,195 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_IR_TF_OP_WRAPPER_H_
+#define TENSORFLOW_CORE_IR_TF_OP_WRAPPER_H_
+
+#include <cstddef>
+
+#include "llvm/ADT/iterator_range.h"
+#include "mlir/IR/Operation.h"  // from @llvm-project
+#include "mlir/IR/OperationSupport.h"  // from @llvm-project
+#include "mlir/IR/TypeRange.h"  // from @llvm-project
+#include "tensorflow/core/ir/dialect.h"
+#include "tensorflow/core/ir/types/dialect.h"
+#include "tensorflow/core/ir/utility.h"
+
+namespace mlir {
+namespace detail {
+// This class iterates over the control dependencies of the values.
+template <typename ValueIteratorT>
+class ControlRetIterator final
+    : public llvm::mapped_iterator_base<ControlRetIterator<ValueIteratorT>,
+                                        ValueIteratorT, Value> {
+ public:
+  using llvm::mapped_iterator_base<ControlRetIterator<ValueIteratorT>,
+                                   ValueIteratorT, Value>::mapped_iterator_base;
+
+  Value mapElement(Value value) const {
+    return value.getType().isa<tf_type::ControlType>()
+               ? value
+               : tfg::LookupControlDependency(value);
+  }
+};
+}  // namespace detail
+
+namespace tfg {
+
+// Wrapper class exposing convenience methods to manipulate TensorFlow graph
+// nodes uniformly.
+class TFOp {
+ public:
+  // Wrap an operation. The operation can be null. The constructor must be
+  // marked as implicit to support `llvm::dyn_cast`.
+  TFOp(Operation *op = nullptr);  // NOLINT
+
+  explicit TFOp(Operation &op) : TFOp(&op) {}
+
+  // Support LLVM-style RTTI.
+  static bool classof(Operation *op) {
+    return isa<TFGraphDialect>(op->getDialect());
+  }
+
+  // Get the wrapped operation.
+  Operation *getOperation() { return op_; }
+
+  // Returns a pointer to the TensorFlow Graph Dialect. It nevers returns
+  // nullptr.
+  TFGraphDialect *getDialect() {
+    return cast<TFGraphDialect>(op_->getDialect());
+  }
+
+  // Split the operands into data and control operands.
+  std::pair<OperandRange, OperandRange> splitOperands() {
+    ControlType ctl_type = getDialect()->getControlType();
+    return SplitDataAndControlValues(op_->getOperands(), ctl_type);
+  }
+
+  // Returns the regular operands, the control operands will be excluded.
+  OperandRange getNonControlOperands() { return splitOperands().first; }
+
+  // The control operands are always after the regular inputs.
+  OperandRange getControlOperands() { return splitOperands().second; }
+
+  // Returns the control token produced by this operation.
+  Value controlRet() { return op_->getResult(op_->getNumResults() - 1); }
+
+  // Returns the non-control results produced by this operation.
+  ResultRange getNonControlResults() {
+    return op_->getResults().slice(0, op_->getNumResults() - 1);
+  }
+
+  // Returns the node name for this operation.
+  StringAttr nameAttr();
+  StringRef name();
+  // Set a new node name for this operation.
+  void setName(const Twine &name);
+  void setName(StringAttr name);
+
+  // Returns the requested device, which is also the "device" field in a
+  // GraphDef.
+  StringAttr requestedDeviceAttr();
+  StringRef requestedDevice();
+  // Set a new requested device for this operation.
+  void setRequestedDevice(const Twine &requested_device);
+  void setRequestedDevice(StringAttr requested_device);
+
+  // Returns the assigned device, this field is set by placer in general.
+  StringAttr assignedDeviceAttr();
+  StringRef assignedDevice();
+  // Set a new assigned device for this operation.
+  void setAssignedDevice(const Twine &assigned_device);
+  void setAssignedDevice(StringAttr assigned_device);
+
+  // Returns the assigned TPU cluster name.
+  StringAttr tpuReplicate();
+  // Set the assigned TPU cluster name.
+  void setTpuReplicate(StringAttr tpu_replicate);
+
+  // Returns the device, preferring the assigned device if set, and the
+  // requested device otherwise.
+  StringAttr deviceAttr() {
+    StringAttr device = assignedDeviceAttr();
+    if (device) {
+      assert(!device.getValue().empty());
+      return device;
+    }
+    return requestedDeviceAttr();
+  }
+  StringRef device() {
+    StringAttr device_attr = deviceAttr();
+    if (device_attr) return device_attr.getValue();
+    return "";
+  }
+
+  // Forward `->` to the underlying operation, exposing the `Operation` methods.
+  Operation *operator->() { return op_; }
+  Operation &operator*() { return *op_; }
+
+  // Converts to true if there is a wrapped operation.
+  explicit operator bool() const { return op_; }
+
+ private:
+  // The wrapped operation.
+  Operation *op_;
+};
+
+// A range iterator to get the control tokens associated with a value range.
+// This range allows to wrap a ValueRange (or an OperandRange) and iterates on
+// the control token associated to the producer of each value. For example, if
+// you wrap the operands of an operation:
+//     OperandControlRetRange range = op->getOperands();
+// iterating this range will yield the control edges from each of the operations
+// (or block arguments) producing these operands.
+template <typename ValueRangeT>
+class ControlRetRange final
+    : public llvm::iterator_range<
+          ::mlir::detail::ControlRetIterator<typename ValueRangeT::iterator>> {
+ public:
+  using Base = llvm::iterator_range<
+      ::mlir::detail::ControlRetIterator<typename ValueRangeT::iterator>>;
+  explicit ControlRetRange(ValueRangeT c) : Base(c.begin(), c.end()) {}
+
+  /// Return the value at the given index.
+  Value operator[](size_t index) const {
+    assert(index < size() && "invalid index into value range");
+    return *(this->begin() + index);
+  }
+
+  // Return the size of this range.
+  size_t size() const { return llvm::size(*this); }
+
+  // Return first value in the range.
+  Value front() { return (*this)[0]; }
+
+  // Compare this range with another.
+  template <typename OtherT>
+  bool operator==(const OtherT &other) const {
+    return llvm::size(*this) == llvm::size(other) &&
+           std::equal(this->begin(), this->end(), other.begin());
+  }
+  template <typename OtherT>
+  bool operator!=(const OtherT &other) const {
+    return !(*this == other);
+  }
+};
+
+using OperandControlRetRange = ControlRetRange<OperandRange>;
+using ValueControlRetRange = ControlRetRange<ValueRange>;
+
+}  // namespace tfg
+}  // namespace mlir
+
+#endif  // TENSORFLOW_CORE_IR_TF_OP_WRAPPER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/ir/types/dialect.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/ir/types/dialect.h
new file mode 100644
index 0000000000000000000000000000000000000000..419d396cb7aaf09a4b260622c8a868375f81bf03
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/ir/types/dialect.h
@@ -0,0 +1,355 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_IR_TYPES_DIALECT_H_
+#define TENSORFLOW_CORE_IR_TYPES_DIALECT_H_
+
+#include <optional>
+#include <string>
+
+#include "mlir/Dialect/Quant/QuantTypes.h"  // from @llvm-project
+#include "mlir/IR/BuiltinTypes.h"  // from @llvm-project
+#include "mlir/IR/Diagnostics.h"  // from @llvm-project
+#include "mlir/IR/Dialect.h"  // from @llvm-project
+#include "mlir/IR/TypeUtilities.h"  // from @llvm-project
+
+// Include the dialect class generated from dialect.td.
+// The constructor and the printing/parsing of dialect types are manually
+// implemented (see ops.cpp).
+#include "tensorflow/core/ir/types/dialect.h.inc"
+
+// Include the Type classes declaration generated from types.td
+#define GET_TYPEDEF_CLASSES
+#include "tensorflow/core/ir/types/types.h.inc"
+
+namespace mlir {
+namespace tf_type {
+
+//===----------------------------------------------------------------------===//
+// TensorFlow types
+//===----------------------------------------------------------------------===//
+
+// The base class in the TensorFlow type hierarchy.
+class TensorFlowType : public Type {
+ public:
+  using Type::Type;
+
+  // Support method to enable LLVM-style type casting.
+  static bool classof(Type type);
+};
+
+// Returns true if the specified type is a valid TensorFlow element type.
+inline bool IsValidTFElementType(Type type) {
+  return type.isa<ComplexType, FloatType, IntegerType, TensorFlowType,
+                  quant::QuantizedType>();
+}
+
+// Returns true if this is a valid TensorFlow tensor type.
+inline bool IsValidTFTensorType(Type type) {
+  // TensorFlow types should be tensors of one of the valid TensorFlow element
+  // types.
+  if (auto tensor_ty = type.dyn_cast<TensorType>())
+    return IsValidTFElementType(tensor_ty.getElementType());
+  return false;
+}
+
+namespace detail {
+// Common implementation of TensorFlow types. The template argument indicates
+// the concrete derived class per CRTP.
+template <typename Derived>
+class TensorFlowTypeImpl
+    : public Type::TypeBase<Derived, TensorFlowType, TypeStorage> {
+ public:
+  using Base = typename Type::TypeBase<Derived, TensorFlowType, TypeStorage>;
+  using TFBase = TensorFlowTypeImpl<Derived>;
+  using Base::Base;
+};
+}  // namespace detail
+
+// TensorFlowRefType class supports all the ref types in TensorFlow dialect.
+class TensorFlowRefType : public TensorFlowType {
+ public:
+  using TensorFlowType::TensorFlowType;
+
+  // Checks if a type is TensorFlow Ref type.
+  static bool classof(Type type);
+
+  // Converts a type to the corresponding TensorFlowRef type.
+  static TensorFlowType get(Type type);
+  static TensorFlowType getChecked(Type type, MLIRContext* context,
+                                   Location loc) {
+    if (failed(verify(loc, type))) {
+      return TensorFlowRefType();
+    }
+    return get(type);
+  }
+
+  static LogicalResult verify(Location loc, Type type) {
+    // type should be a valid TensorFlow type.
+    if (!IsValidTFTensorType(type)) {
+      return emitError(loc) << "invalid TensorFlow type: " << type;
+    }
+    return success();
+  }
+
+  // Converts a TensorFlowRef type to the corresponding TensorFlow or standard
+  // type.
+  Type RemoveRef();
+};
+
+// Define a class for each individual TensorFlow type (dtype), see types.def
+// for the list.
+#define HANDLE_TF_TYPE(tftype, enumerant, name)                          \
+  class tftype##Type : public detail::TensorFlowTypeImpl<tftype##Type> { \
+   public:                                                               \
+    using TFBase::TFBase;                                                \
+  };
+#define HANDLE_CUSTOM_TF_TYPE(tftype, enumerant, name)
+#include "tensorflow/core/ir/types/types.def"
+
+namespace detail {
+// Storage type contains inferred subtypes for TypeWithSubtype.
+class TypeWithSubtypeStorage : public TypeStorage {
+ public:
+  using KeyTy = ArrayRef<TensorType>;
+
+  // NOLINTNEXTLINE
+  static TypeWithSubtypeStorage* construct(TypeStorageAllocator& allocator,
+                                           const KeyTy& key) {
+    ArrayRef<TensorType> subtypes = allocator.copyInto(key);
+    return new (allocator.allocate<TypeWithSubtypeStorage>())
+        TypeWithSubtypeStorage(subtypes);
+  }
+
+  explicit TypeWithSubtypeStorage(const KeyTy& key) : subtypes_(key) {}
+
+  bool operator==(const KeyTy& key) const { return key == subtypes_; }
+
+  static llvm::hash_code hashKey(const KeyTy& key) {
+    return llvm::hash_combine_range(key.begin(), key.end());
+  }
+
+  KeyTy subtypes_;
+};
+
+// Common implementation of TensorFlow types with subtypes. These subtypes are
+// opaque and their interpretation depends on the actual underlying type.
+// The template argument indicates the concrete derived class per CRTP. Concrete
+// classes must implement the following:
+//   - `static std::string getTypeName()` that returns the name of the type for
+//     verification logging.
+template <typename Derived>
+class TypeWithSubtypeImpl
+    : public Type::TypeBase<Derived, TensorFlowType, TypeWithSubtypeStorage> {
+ public:
+  using Base = Type::TypeBase<Derived, TensorFlowType, TypeWithSubtypeStorage>;
+  using TFBase = TypeWithSubtypeImpl<Derived>;
+  using Base::Base;
+
+  static Derived get(ArrayRef<TensorType> subtypes, MLIRContext* context) {
+    return Base::get(context, subtypes);
+  }
+
+  static Derived getChecked(ArrayRef<TensorType> subtypes, MLIRContext* context,
+                            Location loc) {
+    return Base::getChecked(loc, subtypes);
+  }
+  static Derived getChecked(function_ref<InFlightDiagnostic()> emitError,
+                            MLIRContext* context,
+                            ArrayRef<TensorType> subtypes) {
+    return Base::getChecked(emitError, context, subtypes);
+  }
+
+  static Derived get(MLIRContext* context) { return get({}, context); }
+
+  static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
+                              ArrayRef<TensorType> subtypes) {
+    // Each of the subtypes should be a valid TensorFlow type.
+    for (TensorType subtype : subtypes) {
+      if (!IsValidTFTensorType(subtype)) {
+        return emitError() << "invalid " << Derived::getTypeName()
+                           << " subtype: " << subtype;
+      }
+    }
+    return success();
+  }
+
+  ArrayRef<TensorType> getSubtypes() { return Base::getImpl()->subtypes_; }
+};
+}  // namespace detail
+
+// TensorFlowTypeWithSubtype class supports all the types with subtypes in
+// TensorFlow dialect.
+class TensorFlowTypeWithSubtype : public TensorFlowType {
+ public:
+  using TensorFlowType::TensorFlowType;
+
+  // Checks if a type is TensorFlow type with subtypes.
+  static bool classof(Type type);
+
+  // Converts a TypeWithSubtype type to the same type but without its subtypes.
+  Type RemoveSubtypes();
+
+  // Clone the current Type with new subtypes.
+  TensorFlowTypeWithSubtype clone(ArrayRef<TensorType> new_subtypes);
+
+  // Returns the subtypes.
+  ArrayRef<TensorType> GetSubtypes();
+};
+
+// Returns the corresponding TensorFlow type with subtypes but without its
+// subtypes.
+inline Type GetDefaultTypeOf(TensorFlowTypeWithSubtype type) {
+  return type.RemoveSubtypes();
+}
+
+// TensorFlow resource type is used to support TensorFlow resource variables,
+// which represent shared, persistent state manipulated by a TensorFlow program.
+// ResourceType stores shape and datatype for subtypes unlike most other data
+// types that don't have any associated information.
+class ResourceType : public detail::TypeWithSubtypeImpl<ResourceType> {
+ public:
+  using TFBase::TFBase;
+  static std::string getTypeName() { return "ResourceType"; }
+};
+
+// TensorFlow variant type is used to support arbitrary custom C++ data types.
+// VariantType stores inferred shape and datatype for subtypes unlike most other
+// data types that don't have any associated information. For example, variants
+// encoding TensorList type stores the common shape and dtype of the list
+// elements as the only subtype.
+class VariantType : public detail::TypeWithSubtypeImpl<VariantType> {
+ public:
+  using TFBase::TFBase;
+  static std::string getTypeName() { return "VariantType"; }
+};
+
+// Given two types `a` and `b`, returns a refined type which is cast compatible
+// with both `a` and `b` and is equal to or more precise than both of them. It
+// returns empty Type if the input types are not cast compatible.
+// Provides option to ignore ref types on 'a'. This is useful for TF ops that
+// might allow operands to either be same as result type or be a ref type
+// corresponding to it.
+Type GetCastCompatibleType(Type a, Type b, bool may_ignore_ref_type_a = false);
+
+// Returns whether two arrays of Type are broadcast compatible.
+bool BroadcastCompatible(TypeRange lhs, TypeRange rhs);
+
+// Returns whether the two elemental types are compatible. Shapes are compatible
+// if:
+// - the types are statically equal
+// - could be dynamically equal
+//   - considering dynamic shapes equal unless contradictory info known;
+//   - element types are equivalent, modulo subtypes possible be less exact
+//     (e.g., a resource type without subtype is considered compatible with
+//      resource type with known subtype).
+// Provide option to ignore ref types on 'lhs'.
+bool HasCompatibleElementTypes(Type lhs, Type rhs,
+                               bool may_ignore_ref_type_lhs = false);
+
+// Returns true if all TensorFlow types can be cast to one
+// another. In other words, a single run-time value is legal for all the types.
+// For example, tensor<*xf32>, tensor<?xf32> and tensor<3xf32> are cast
+// compatible.
+bool AreCastCompatible(TypeRange types);
+
+// Returns true if corresponding elements of lhs and rhs AreCastCompatible and
+// lhs and rhs are the same length.
+bool ArraysAreCastCompatible(TypeRange lhs, TypeRange rhs);
+
+// If `ty` is a tensor type and its element type has subtypes, then returns a
+// new type of same shape but dropped subtypes for the element type.
+// Otherwise, if `ty` has subtypes, then returns corresponding type with dropped
+// subtypes.
+// Otherwise, returns the original type `ty`.
+Type DropSubTypes(Type ty);
+
+// If `ty` is a tensor type and has elements of a ref type, then returns a new
+// type of same shape but corresponding non-ref type as element type.
+// Otherwise, if `ty` is a ref type, then returns corresponding non-ref type.
+// Otherwise, returns the original type `ty`.
+Type DropRefType(Type ty);
+
+// Convenience call for executing both `DropRefType` and `DropSubTypes`.
+Type DropRefAndSubTypes(Type ty);
+
+//===----------------------------------------------------------------------===//
+// Utility iterators
+//===----------------------------------------------------------------------===//
+
+// An iterator for the tensor shapes of an op's operands of shaped types.
+// Returns std::nullopt if a operand is unranked; returns ArrayRef<int64_t> as
+// the shape otherwise.
+class OperandShapeIterator final
+    : public llvm::mapped_iterator<Operation::operand_iterator,
+                                   std::optional<ArrayRef<int64_t>> (*)(
+                                       Value)> {
+ public:
+  using reference = std::optional<ArrayRef<int64_t>>;
+
+  /// Initializes the operand shape iterator to the specified operand iterator.
+  explicit OperandShapeIterator(Operation::operand_iterator it);
+};
+
+using OperandShapeRange = iterator_range<OperandShapeIterator>;
+
+// An iterator for the tensor shapes of an op's results of shaped types.
+// Returns std::nullopt if a result is unranked; returns ArrayRef<int64_t> as
+// the shape otherwise.
+class ResultShapeIterator final
+    : public llvm::mapped_iterator<Operation::result_iterator,
+                                   std::optional<ArrayRef<int64_t>> (*)(
+                                       Value)> {
+ public:
+  using reference = std::optional<ArrayRef<int64_t>>;
+
+  /// Initializes the result shape iterator to the specified result iterator.
+  explicit ResultShapeIterator(Operation::result_iterator it);
+};
+
+using ResultShapeRange = iterator_range<ResultShapeIterator>;
+
+// Returns a range with just resource type values from the input range
+// preserved.
+template <typename RangeT>
+auto filter_resources(RangeT&& range) {
+  return llvm::make_filter_range(std::forward<RangeT>(range), [](Value val) {
+    return getElementTypeOrSelf(val.getType()).isa<ResourceType>();
+  });
+}
+
+// Returns the element type if `type` is a `ShapedType` and the type itself
+// otherwise, converting `TensorFlowRef` type to corresponding `TensorFlow` or
+// standard type if necessary.
+inline Type GetElementTypeOrSelfResolveRef(Type type) {
+  Type element_type = getElementTypeOrSelf(type);
+  if (auto ref_type = element_type.dyn_cast<TensorFlowRefType>()) {
+    element_type = ref_type.RemoveRef();
+  }
+  return element_type;
+}
+
+}  // namespace tf_type
+}  // namespace mlir
+
+//===----------------------------------------------------------------------===//
+// Tablegen Attribute Declarations
+//===----------------------------------------------------------------------===//
+
+#define GET_ATTRDEF_CLASSES
+#include "tensorflow/core/ir/types/attributes.h.inc"
+#include "tensorflow/core/ir/types/attributes_enum.h.inc"
+
+#endif  // TENSORFLOW_CORE_IR_TYPES_DIALECT_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/ir/utility.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/ir/utility.h
new file mode 100644
index 0000000000000000000000000000000000000000..e234751e59d276e6fa4a2bfe3a8ba7aa9adb053d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/ir/utility.h
@@ -0,0 +1,87 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_IR_UTILITY_H_
+#define TENSORFLOW_CORE_IR_UTILITY_H_
+
+#include <optional>
+
+#include "llvm/ADT/STLExtras.h"
+#include "mlir/IR/Block.h"  // from @llvm-project
+#include "mlir/IR/OperationSupport.h"  // from @llvm-project
+#include "mlir/IR/Value.h"  // from @llvm-project
+#include "mlir/Support/LLVM.h"  // from @llvm-project
+#include "tensorflow/core/ir/dialect.h"
+
+namespace mlir {
+namespace tfg {
+
+// Region-based loop ops store control tokens all after the data values, unlike
+// functions which store them as pairs. This is required by
+// RegionBranchOpInterface's API which requires MutableOperandRange, i.e. the
+// data operands need to be stored contiguously.
+
+// TODO(jeffniu): These functions aren't just for "loop regions" any more, but
+// any region-based ops (if/case have explicit capture forms).
+
+// Given a region belonging to a region-based loop operation (e.g. a while
+// loop), return the subrange of block arguments that are data values.
+Block::BlockArgListType GetLoopRegionDataArgs(Region &region);
+// Given a region belonging to a region-based loop operation (e.g. a while
+// loop), return the subrange of block arguments that are control tokens.
+Block::BlockArgListType GetLoopRegionControlTokens(Region &region);
+// Given a data value block argument of a region belonging to a region-based
+// loop operation (e.g. a while loop), return the block argument that
+// corresponds to the control token.
+BlockArgument GetLoopRegionControlOf(BlockArgument data);
+// Given a control token block argument of a region belonging to a region-based
+// loop operation (e.g. a while loop), return the block argument that
+// corresponds to the data value.
+BlockArgument GetLoopRegionDataOf(BlockArgument ctl);
+
+// Given a TFG value, lookup the associated control token. For op results, the
+// token will be the last result of the op. For block arguments, the token will
+// be the subsequent argument. A data value always has an associated control
+// token.
+Value LookupControlDependency(Value data);
+
+// Given a TFG control token, lookup the associated data value. Block arguments
+// will always have an associated data value: the previous argument. For ops,
+// if the only result is a control token, return None. Otherwise, returns the
+// first result.
+std::optional<Value> LookupDataValue(Value ctl);
+
+// Given a range of values, operands, or results, that contains data and control
+// values, where all control tokens come after the data values, split the range
+// between the two.
+template <typename RangeT>
+std::pair<RangeT, RangeT> SplitDataAndControlValues(RangeT values,
+                                                    ControlType ctl_type) {
+  unsigned num_ctl = 0;
+  for (Value value : llvm::reverse(values)) {
+    if (value.getType() == ctl_type)
+      ++num_ctl;
+    else
+      break;
+  }
+  unsigned split_idx = llvm::size(values) - num_ctl;
+  return std::make_pair(values.slice(0, split_idx),
+                        values.slice(split_idx, num_ctl));
+}
+
+}  // namespace tfg
+}  // namespace mlir
+
+#endif  // TENSORFLOW_CORE_IR_UTILITY_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/ir/utils/shape_inference_utils.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/ir/utils/shape_inference_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..fa66af32fd06cf7b1f189a4005ebd83683327b97
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/ir/utils/shape_inference_utils.h
@@ -0,0 +1,89 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_IR_UTILS_SHAPE_INFERENCE_UTILS_H_
+#define TENSORFLOW_CORE_IR_UTILS_SHAPE_INFERENCE_UTILS_H_
+
+#include <cstdint>
+
+#include "mlir/IR/Attributes.h"  // from @llvm-project
+#include "mlir/IR/Operation.h"  // from @llvm-project
+#include "mlir/IR/Types.h"  // from @llvm-project
+#include "mlir/Interfaces/InferTypeOpInterface.h"  // from @llvm-project
+#include "mlir/Support/LLVM.h"  // from @llvm-project
+#include "mlir/Support/LogicalResult.h"  // from @llvm-project
+#include "tensorflow/core/framework/shape_inference.h"
+
+namespace tensorflow {
+struct OpRegistrationData;
+}  // namespace tensorflow
+
+namespace mlir {
+namespace tfg {
+
+// Function that takes in a value and extracts a constant from it, if available.
+// If the value cannot be resolved as a constant, a nullptr will be returned.
+// Certain shape functions require constant values as arguments.
+using OperandAsConstantFn = llvm::function_ref<Attribute(Value)>;
+
+// Function that takes in an operation result and computes a shape (can be
+// partial) value. Certain shape functions require shape values as arguments.
+using OpResultAsShapeFn =
+    llvm::function_ref<tensorflow::shape_inference::ShapeHandle(
+        tensorflow::shape_inference::InferenceContext&, OpResult)>;
+
+// Function that takes a result index and returns the element type. Element
+// types are necessary for handle types (resource, variant).
+using ResultElementTypeFn = llvm::function_ref<Type(int)>;
+
+// Extracts the attributes of a MLIR operation and populates the converted
+// attributes in a proto map<string, AttrValue>. This is used by operation
+// defined in TF dialect which has different attributes format than TFG dialect.
+using GetAttrValuesFn = llvm::function_ref<tensorflow::Status(
+    Operation*, llvm::StringRef, const tensorflow::OpRegistrationData*, bool,
+    tensorflow::AttrValueMap*)>;
+
+// Runs TensorFlow shape inference associated to the op type registered in the
+// TensorFlow op registry based on the Graph version, operands, and attributes.
+// Invoking this shape function will create conversions of parameters to the
+// TensorFlow Graph equivalent data structures and back to MLIR equivalent data
+// structures. This does not use a natively implemented shape inference in MLIR,
+// and instead is temporary until shape functions are reimplemented/migrated to
+// being in MLIR instead of the TensorFlow op registry.
+// Note that the default way to get the attrs in the operation is using the API
+// in TFG importer. For operations that has different format of attributes, they
+// should give the `get_attr_values_fn` to read the attributes correctly.
+LogicalResult InferReturnTypeComponentsForTFOp(
+    std::optional<Location> location, Operation* op, ValueRange operands,
+    int64_t graph_version, OperandAsConstantFn operand_as_constant_fn,
+    OpResultAsShapeFn op_result_as_shape_fn,
+    ResultElementTypeFn result_element_type_fn,
+    GetAttrValuesFn get_attr_values_fn,
+    SmallVectorImpl<ShapedTypeComponents>& inferred_return_shapes);
+
+// This one is almost the same as the above one, the difference is that we use
+// ConvertOperationToNode to convert the operation to NodeDef to get the attr
+// values.
+LogicalResult InferReturnTypeComponentsForTFOp(
+    std::optional<Location> location, Operation* op, ValueRange operands,
+    int64_t graph_version, OperandAsConstantFn operand_as_constant_fn,
+    OpResultAsShapeFn op_result_as_shape_fn,
+    ResultElementTypeFn result_element_type_fn,
+    SmallVectorImpl<ShapedTypeComponents>& inferred_return_shapes);
+
+}  // namespace tfg
+}  // namespace mlir
+
+#endif  // TENSORFLOW_CORE_IR_UTILS_SHAPE_INFERENCE_UTILS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/aggregate_ops.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/aggregate_ops.h
new file mode 100644
index 0000000000000000000000000000000000000000..7f56e994a0bf574126daca959e861b26f84d5bcc
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/aggregate_ops.h
@@ -0,0 +1,226 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_AGGREGATE_OPS_H_
+#define TENSORFLOW_CORE_KERNELS_AGGREGATE_OPS_H_
+
+#include <numeric>
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/framework/tensor_types.h"
+
+namespace tensorflow {
+namespace functor {
+
+// Functor definitions for Aggregate ops, must be compilable by nvcc.
+template <typename Device, typename T>
+struct Add2Functor {
+  void operator()(const Device& d, typename TTypes<T>::Flat out,
+                  typename TTypes<T>::ConstFlat in1,
+                  typename TTypes<T>::ConstFlat in2);
+};
+
+template <typename Device, typename T>
+struct Add2EigenImpl {
+  static void Compute(const Device& d, typename TTypes<T>::Flat out,
+                      typename TTypes<T>::ConstFlat in1,
+                      typename TTypes<T>::ConstFlat in2) {
+    out.device(d) = in1 + in2;
+  }
+};
+
+template <typename Device, typename T>
+struct Add3Functor {
+  void operator()(const Device& d, typename TTypes<T>::Flat out,
+                  typename TTypes<T>::ConstFlat in1,
+                  typename TTypes<T>::ConstFlat in2,
+                  typename TTypes<T>::ConstFlat in3);
+};
+
+template <typename Device, typename T>
+struct Add3EigenImpl {
+  static void Compute(const Device& d, typename TTypes<T>::Flat out,
+                      typename TTypes<T>::ConstFlat in1,
+                      typename TTypes<T>::ConstFlat in2,
+                      typename TTypes<T>::ConstFlat in3) {
+    out.device(d) = in1 + in2 + in3;
+  }
+};
+
+template <typename Device, typename T>
+struct Add4Functor {
+  void operator()(const Device& d, typename TTypes<T>::Flat out,
+                  typename TTypes<T>::ConstFlat in1,
+                  typename TTypes<T>::ConstFlat in2,
+                  typename TTypes<T>::ConstFlat in3,
+                  typename TTypes<T>::ConstFlat in4);
+};
+
+template <typename Device, typename T>
+struct Add4EigenImpl {
+  static void Compute(const Device& d, typename TTypes<T>::Flat out,
+                      typename TTypes<T>::ConstFlat in1,
+                      typename TTypes<T>::ConstFlat in2,
+                      typename TTypes<T>::ConstFlat in3,
+                      typename TTypes<T>::ConstFlat in4) {
+    out.device(d) = in1 + in2 + in3 + in4;
+  }
+};
+
+template <typename Device, typename T>
+struct Add5Functor {
+  void operator()(const Device& d, typename TTypes<T>::Flat out,
+                  typename TTypes<T>::ConstFlat in1,
+                  typename TTypes<T>::ConstFlat in2,
+                  typename TTypes<T>::ConstFlat in3,
+                  typename TTypes<T>::ConstFlat in4,
+                  typename TTypes<T>::ConstFlat in5);
+};
+
+template <typename Device, typename T>
+struct Add5EigenImpl {
+  static void Compute(const Device& d, typename TTypes<T>::Flat out,
+                      typename TTypes<T>::ConstFlat in1,
+                      typename TTypes<T>::ConstFlat in2,
+                      typename TTypes<T>::ConstFlat in3,
+                      typename TTypes<T>::ConstFlat in4,
+                      typename TTypes<T>::ConstFlat in5) {
+    out.device(d) = in1 + in2 + in3 + in4 + in5;
+  }
+};
+
+template <typename Device, typename T>
+struct Add6Functor {
+  void operator()(const Device& d, typename TTypes<T>::Flat out,
+                  typename TTypes<T>::ConstFlat in1,
+                  typename TTypes<T>::ConstFlat in2,
+                  typename TTypes<T>::ConstFlat in3,
+                  typename TTypes<T>::ConstFlat in4,
+                  typename TTypes<T>::ConstFlat in5,
+                  typename TTypes<T>::ConstFlat in6);
+};
+
+template <typename Device, typename T>
+struct Add6EigenImpl {
+  static void Compute(const Device& d, typename TTypes<T>::Flat out,
+                      typename TTypes<T>::ConstFlat in1,
+                      typename TTypes<T>::ConstFlat in2,
+                      typename TTypes<T>::ConstFlat in3,
+                      typename TTypes<T>::ConstFlat in4,
+                      typename TTypes<T>::ConstFlat in5,
+                      typename TTypes<T>::ConstFlat in6) {
+    out.device(d) = in1 + in2 + in3 + in4 + in5 + in6;
+  }
+};
+
+template <typename Device, typename T>
+struct Add7Functor {
+  void operator()(const Device& d, typename TTypes<T>::Flat out,
+                  typename TTypes<T>::ConstFlat in1,
+                  typename TTypes<T>::ConstFlat in2,
+                  typename TTypes<T>::ConstFlat in3,
+                  typename TTypes<T>::ConstFlat in4,
+                  typename TTypes<T>::ConstFlat in5,
+                  typename TTypes<T>::ConstFlat in6,
+                  typename TTypes<T>::ConstFlat in7);
+};
+
+template <typename Device, typename T>
+struct Add7EigenImpl {
+  static void Compute(const Device& d, typename TTypes<T>::Flat out,
+                      typename TTypes<T>::ConstFlat in1,
+                      typename TTypes<T>::ConstFlat in2,
+                      typename TTypes<T>::ConstFlat in3,
+                      typename TTypes<T>::ConstFlat in4,
+                      typename TTypes<T>::ConstFlat in5,
+                      typename TTypes<T>::ConstFlat in6,
+                      typename TTypes<T>::ConstFlat in7) {
+    out.device(d) = in1 + in2 + in3 + in4 + in5 + in6 + in7;
+  }
+};
+
+template <typename Device, typename T>
+struct Add8Functor {
+  void operator()(
+      const Device& d, typename TTypes<T>::Flat out,
+      typename TTypes<T>::ConstFlat in1, typename TTypes<T>::ConstFlat in2,
+      typename TTypes<T>::ConstFlat in3, typename TTypes<T>::ConstFlat in4,
+      typename TTypes<T>::ConstFlat in5, typename TTypes<T>::ConstFlat in6,
+      typename TTypes<T>::ConstFlat in7, typename TTypes<T>::ConstFlat in8);
+};
+
+template <typename Device, typename T>
+struct Add8EigenImpl {
+  static void Compute(
+      const Device& d, typename TTypes<T>::Flat out,
+      typename TTypes<T>::ConstFlat in1, typename TTypes<T>::ConstFlat in2,
+      typename TTypes<T>::ConstFlat in3, typename TTypes<T>::ConstFlat in4,
+      typename TTypes<T>::ConstFlat in5, typename TTypes<T>::ConstFlat in6,
+      typename TTypes<T>::ConstFlat in7, typename TTypes<T>::ConstFlat in8) {
+    out.device(d) = in1 + in2 + in3 + in4 + in5 + in6 + in7 + in8;
+  }
+};
+
+// Add8p is like Add8 except the underlying implementation should +=
+// rather than assign to the output.
+template <typename Device, typename T>
+struct Add8pFunctor {
+  void operator()(
+      const Device& d, typename TTypes<T>::Flat out,
+      typename TTypes<T>::ConstFlat in1, typename TTypes<T>::ConstFlat in2,
+      typename TTypes<T>::ConstFlat in3, typename TTypes<T>::ConstFlat in4,
+      typename TTypes<T>::ConstFlat in5, typename TTypes<T>::ConstFlat in6,
+      typename TTypes<T>::ConstFlat in7, typename TTypes<T>::ConstFlat in8);
+};
+
+template <typename Device, typename T>
+struct Add8pEigenImpl {
+  static void Compute(
+      const Device& d, typename TTypes<T>::Flat out,
+      typename TTypes<T>::ConstFlat in1, typename TTypes<T>::ConstFlat in2,
+      typename TTypes<T>::ConstFlat in3, typename TTypes<T>::ConstFlat in4,
+      typename TTypes<T>::ConstFlat in5, typename TTypes<T>::ConstFlat in6,
+      typename TTypes<T>::ConstFlat in7, typename TTypes<T>::ConstFlat in8) {
+    out.device(d) += in1 + in2 + in3 + in4 + in5 + in6 + in7 + in8;
+  }
+};
+
+template <typename Device, typename T>
+struct Add9Functor {
+  void operator()(
+      const Device& d, typename TTypes<T>::Flat out,
+      typename TTypes<T>::ConstFlat in1, typename TTypes<T>::ConstFlat in2,
+      typename TTypes<T>::ConstFlat in3, typename TTypes<T>::ConstFlat in4,
+      typename TTypes<T>::ConstFlat in5, typename TTypes<T>::ConstFlat in6,
+      typename TTypes<T>::ConstFlat in7, typename TTypes<T>::ConstFlat in8,
+      typename TTypes<T>::ConstFlat in9);
+};
+
+template <typename Device, typename T>
+struct Add9EigenImpl {
+  static void Compute(
+      const Device& d, typename TTypes<T>::Flat out,
+      typename TTypes<T>::ConstFlat in1, typename TTypes<T>::ConstFlat in2,
+      typename TTypes<T>::ConstFlat in3, typename TTypes<T>::ConstFlat in4,
+      typename TTypes<T>::ConstFlat in5, typename TTypes<T>::ConstFlat in6,
+      typename TTypes<T>::ConstFlat in7, typename TTypes<T>::ConstFlat in8,
+      typename TTypes<T>::ConstFlat in9) {
+    out.device(d) = in1 + in2 + in3 + in4 + in5 + in6 + in7 + in8 + in9;
+  }
+};
+}  // namespace functor
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_AGGREGATE_OPS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/aggregate_ops_cpu.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/aggregate_ops_cpu.h
new file mode 100644
index 0000000000000000000000000000000000000000..f205d8d1ba637a60139e59812485a02b39db9f1c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/aggregate_ops_cpu.h
@@ -0,0 +1,142 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_AGGREGATE_OPS_CPU_H_
+#define TENSORFLOW_CORE_KERNELS_AGGREGATE_OPS_CPU_H_
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/framework/tensor_types.h"
+
+#include "tensorflow/core/kernels/aggregate_ops.h"
+
+typedef Eigen::ThreadPoolDevice CPUDevice;
+
+
+namespace tensorflow {
+
+// Partial specializations for a CPUDevice, that uses the Eigen implementation
+// from AddNEigenImpl.
+namespace functor {
+template <typename T>
+struct Add2Functor<CPUDevice, T> {
+  void operator()(const CPUDevice& d, typename TTypes<T>::Flat out,
+                  typename TTypes<T>::ConstFlat in1,
+                  typename TTypes<T>::ConstFlat in2) {
+    Add2EigenImpl<CPUDevice, T>::Compute(d, out, in1, in2);
+  }
+};
+template <typename T>
+struct Add3Functor<CPUDevice, T> {
+  void operator()(const CPUDevice& d, typename TTypes<T>::Flat out,
+                  typename TTypes<T>::ConstFlat in1,
+                  typename TTypes<T>::ConstFlat in2,
+                  typename TTypes<T>::ConstFlat in3) {
+    Add3EigenImpl<CPUDevice, T>::Compute(d, out, in1, in2, in3);
+  }
+};
+template <typename T>
+struct Add4Functor<CPUDevice, T> {
+  void operator()(const CPUDevice& d, typename TTypes<T>::Flat out,
+                  typename TTypes<T>::ConstFlat in1,
+                  typename TTypes<T>::ConstFlat in2,
+                  typename TTypes<T>::ConstFlat in3,
+                  typename TTypes<T>::ConstFlat in4) {
+    Add4EigenImpl<CPUDevice, T>::Compute(d, out, in1, in2, in3, in4);
+  }
+};
+template <typename T>
+struct Add5Functor<CPUDevice, T> {
+  void operator()(const CPUDevice& d, typename TTypes<T>::Flat out,
+                  typename TTypes<T>::ConstFlat in1,
+                  typename TTypes<T>::ConstFlat in2,
+                  typename TTypes<T>::ConstFlat in3,
+                  typename TTypes<T>::ConstFlat in4,
+                  typename TTypes<T>::ConstFlat in5) {
+    Add5EigenImpl<CPUDevice, T>::Compute(d, out, in1, in2, in3, in4, in5);
+  }
+};
+template <typename T>
+struct Add6Functor<CPUDevice, T> {
+  void operator()(const CPUDevice& d, typename TTypes<T>::Flat out,
+                  typename TTypes<T>::ConstFlat in1,
+                  typename TTypes<T>::ConstFlat in2,
+                  typename TTypes<T>::ConstFlat in3,
+                  typename TTypes<T>::ConstFlat in4,
+                  typename TTypes<T>::ConstFlat in5,
+                  typename TTypes<T>::ConstFlat in6) {
+    Add6EigenImpl<CPUDevice, T>::Compute(d, out, in1, in2, in3, in4, in5, in6);
+  }
+};
+template <typename T>
+struct Add7Functor<CPUDevice, T> {
+  void operator()(const CPUDevice& d, typename TTypes<T>::Flat out,
+                  typename TTypes<T>::ConstFlat in1,
+                  typename TTypes<T>::ConstFlat in2,
+                  typename TTypes<T>::ConstFlat in3,
+                  typename TTypes<T>::ConstFlat in4,
+                  typename TTypes<T>::ConstFlat in5,
+                  typename TTypes<T>::ConstFlat in6,
+                  typename TTypes<T>::ConstFlat in7) {
+    Add7EigenImpl<CPUDevice, T>::Compute(d, out, in1, in2, in3, in4, in5, in6,
+                                         in7);
+  }
+};
+
+template <typename T>
+struct Add8Functor<CPUDevice, T> {
+  void operator()(
+      const CPUDevice& d, typename TTypes<T>::Flat out,
+      typename TTypes<T>::ConstFlat in1, typename TTypes<T>::ConstFlat in2,
+      typename TTypes<T>::ConstFlat in3, typename TTypes<T>::ConstFlat in4,
+      typename TTypes<T>::ConstFlat in5, typename TTypes<T>::ConstFlat in6,
+      typename TTypes<T>::ConstFlat in7, typename TTypes<T>::ConstFlat in8) {
+    Add8EigenImpl<CPUDevice, T>::Compute(d, out, in1, in2, in3, in4, in5, in6,
+                                         in7, in8);
+  }
+};
+
+template <typename T>
+struct Add8pFunctor<CPUDevice, T> {
+  void operator()(
+      const CPUDevice& d, typename TTypes<T>::Flat out,
+      typename TTypes<T>::ConstFlat in1, typename TTypes<T>::ConstFlat in2,
+      typename TTypes<T>::ConstFlat in3, typename TTypes<T>::ConstFlat in4,
+      typename TTypes<T>::ConstFlat in5, typename TTypes<T>::ConstFlat in6,
+      typename TTypes<T>::ConstFlat in7, typename TTypes<T>::ConstFlat in8) {
+    Add8pEigenImpl<CPUDevice, T>::Compute(d, out, in1, in2, in3, in4, in5, in6,
+                                          in7, in8);
+  }
+};
+
+template <typename T>
+struct Add9Functor<CPUDevice, T> {
+  void operator()(
+      const CPUDevice& d, typename TTypes<T>::Flat out,
+      typename TTypes<T>::ConstFlat in1, typename TTypes<T>::ConstFlat in2,
+      typename TTypes<T>::ConstFlat in3, typename TTypes<T>::ConstFlat in4,
+      typename TTypes<T>::ConstFlat in5, typename TTypes<T>::ConstFlat in6,
+      typename TTypes<T>::ConstFlat in7, typename TTypes<T>::ConstFlat in8,
+      typename TTypes<T>::ConstFlat in9) {
+    Add9EigenImpl<CPUDevice, T>::Compute(d, out, in1, in2, in3, in4, in5, in6,
+                                         in7, in8, in9);
+  }
+};
+
+
+}  // namespace functor
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_AGGREGATE_OPS_CPU_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/argmax_op.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/argmax_op.h
new file mode 100644
index 0000000000000000000000000000000000000000..9b2325c36c421c7b1f5123b953093f9fff9f9498
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/argmax_op.h
@@ -0,0 +1,72 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_ARGMAX_OP_H_
+#define TENSORFLOW_CORE_KERNELS_ARGMAX_OP_H_
+// Generator definition for ArgMaxOp, must be compilable by nvcc.
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/framework/tensor_types.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+
+namespace functor {
+
+template <typename Device, typename T, typename Tout>
+struct ArgMax {
+#define DECLARE_COMPUTE_SPEC(Dims)                                             \
+  EIGEN_ALWAYS_INLINE static void Reduce##Dims(                                \
+      const Device& d, typename TTypes<T, Dims>::ConstTensor input,            \
+      const int32 dimension, typename TTypes<Tout, Dims - 1>::Tensor output) { \
+    output.device(d) = input.argmax(dimension).template cast<Tout>();          \
+  }
+
+  DECLARE_COMPUTE_SPEC(1);
+  DECLARE_COMPUTE_SPEC(2);
+  DECLARE_COMPUTE_SPEC(3);
+  DECLARE_COMPUTE_SPEC(4);
+  DECLARE_COMPUTE_SPEC(5);
+  DECLARE_COMPUTE_SPEC(6);
+  DECLARE_COMPUTE_SPEC(7);
+
+#undef DECLARE_COMPUTE_SPEC
+};
+
+template <typename Device, typename T, typename Tout>
+struct ArgMin {
+#define DECLARE_COMPUTE_SPEC(Dims)                                             \
+  EIGEN_ALWAYS_INLINE static void Reduce##Dims(                                \
+      const Device& d, typename TTypes<T, Dims>::ConstTensor input,            \
+      const int32 dimension, typename TTypes<Tout, Dims - 1>::Tensor output) { \
+    output.device(d) = input.argmin(dimension).template cast<Tout>();          \
+  }
+
+  DECLARE_COMPUTE_SPEC(1);
+  DECLARE_COMPUTE_SPEC(2);
+  DECLARE_COMPUTE_SPEC(3);
+  DECLARE_COMPUTE_SPEC(4);
+  DECLARE_COMPUTE_SPEC(5);
+  DECLARE_COMPUTE_SPEC(6);
+  DECLARE_COMPUTE_SPEC(7);
+
+#undef DECLARE_COMPUTE_SPEC
+};
+
+}  // namespace functor
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_ARGMAX_OP_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/assign_op.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/assign_op.h
new file mode 100644
index 0000000000000000000000000000000000000000..063be3e4711cb203d7526816ea48d8efe73f04b1
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/assign_op.h
@@ -0,0 +1,71 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_ASSIGN_OP_H_
+#define TENSORFLOW_CORE_KERNELS_ASSIGN_OP_H_
+
+#define EIGEN_USE_THREADS
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/ref_var.h"
+#include "tensorflow/core/framework/tensor_types.h"
+
+namespace tensorflow {
+
+// TODO(jeff): Get rid of use_exclusive_lock_ option
+
+// Computes *input[0] = input[1]
+class AssignOp : public OpKernel {
+ public:
+  explicit AssignOp(OpKernelConstruction* context) : OpKernel(context) {
+    OP_REQUIRES_OK(context,
+                   context->GetAttr("use_locking", &use_exclusive_lock_));
+    OP_REQUIRES_OK(context,
+                   context->GetAttr("validate_shape", &validate_shape_));
+    OP_REQUIRES(context, IsRefType(context->input_type(0)),
+                errors::InvalidArgument("lhs input needs to be a ref type"));
+    if (!context
+             ->GetAttr("_grappler_relax_allocator_constraints",
+                       &relax_constraints_)
+             .ok()) {
+      relax_constraints_ = false;
+    }
+  }
+
+  void Compute(OpKernelContext* context) override {
+    constexpr int input_ref_index = 0;
+    constexpr int output_ref_index = 0;
+    constexpr int value_index = 1;
+
+    auto copy = [this](OpKernelContext* cc_ctx, Tensor* lhs,
+                       const Tensor& rhs) { Copy(cc_ctx, lhs, rhs); };
+
+    AssignRefVariable(context, input_ref_index, output_ref_index, value_index,
+                      use_exclusive_lock_, validate_shape_, relax_constraints_,
+                      copy);
+  }
+
+  virtual void Copy(OpKernelContext* context, Tensor* lhs,
+                    const Tensor& rhs) = 0;
+
+  bool use_exclusive_lock_;
+  bool validate_shape_;
+  bool relax_constraints_;
+};
+
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_ASSIGN_OP_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/autotune_conv_impl.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/autotune_conv_impl.h
new file mode 100644
index 0000000000000000000000000000000000000000..7d9299f8c25a1a97149e887371eff4363adf09b2
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/autotune_conv_impl.h
@@ -0,0 +1,98 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+------------------------------------------------------------------------------*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_AUTOTUNE_CONV_IMPL_H_
+#define TENSORFLOW_CORE_KERNELS_AUTOTUNE_CONV_IMPL_H_
+
+#if GOOGLE_CUDA
+#define EIGEN_USE_THREADS
+
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/kernels/conv_ops_gpu.h"
+#include "tensorflow/core/util/proto/proto_utils.h"
+
+#include "xla/stream_executor/gpu/redzone_allocator.h"
+#include "xla/stream_executor/tf_allocator_adapter.h"
+
+namespace tensorflow::internal {
+
+template <typename LaunchFunc, typename Sig>
+StatusOr<std::vector<xla::AutotuneResult>> AutotuneConvImpl(
+    OpKernelContext* ctx,
+    std::vector<std::unique_ptr<const se::dnn::OpRunner<Sig>>>& runners,
+    bool actually_do_autotune, const LaunchFunc& launch_func,
+    size_t scratch_size_limit, const se::RedzoneAllocator& rz_allocator) {
+  auto* stream = ctx->op_device_context()->stream();
+
+  se::TfAllocatorAdapter tf_allocator_adapter(ctx->device()->GetAllocator({}),
+                                              stream);
+
+  std::vector<xla::AutotuneResult> results;
+  // TODO(reedwm): Warn if determinism is enabled after autotune is run
+  for (auto& runner : runners) {
+    // TODO(zhengxq): profile each algorithm multiple times to better
+    // accuracy.
+    se::RedzoneAllocator rz_scratch_allocator(
+        stream, &tf_allocator_adapter, se::GpuAsmOpts(),
+        /*memory_limit=*/scratch_size_limit);
+    DnnScratchAllocator scratch_allocator(scratch_size_limit, ctx);
+    se::ScratchAllocator* allocator_used =
+        !RedzoneCheckDisabled()
+            ? static_cast<se::ScratchAllocator*>(&rz_scratch_allocator)
+            : static_cast<se::ScratchAllocator*>(&scratch_allocator);
+
+    TF_ASSIGN_OR_RETURN(auto desc, runner->ToAlgorithmDesc());
+    se::dnn::ProfileResult profile_result;
+    Status cudnn_launch_status =
+        actually_do_autotune
+            ? launch_func(allocator_used, runner, &profile_result)
+            : OkStatus();
+    if (!actually_do_autotune) {
+      // Make the result valid according to `is_valid`.
+      profile_result.set_algorithm(desc);
+      profile_result.set_elapsed_time_in_ms(0);
+    }
+
+    // We need to make sure the profiling results are one-to-one with the
+    // "runners". So, we insert dummy results when the execution fails.
+    results.emplace_back();
+    auto& result = results.back();
+    *result.mutable_algorithm() = desc.ToProto();
+    if (cudnn_launch_status.ok() && profile_result.is_valid()) {
+      result.set_scratch_bytes(
+          !RedzoneCheckDisabled()
+              ? rz_scratch_allocator.TotalAllocatedBytesExcludingRedzones()
+              : scratch_allocator.TotalByteSize());
+      *result.mutable_run_time() = proto_utils::ToDurationProto(
+          absl::Milliseconds(profile_result.elapsed_time_in_ms()));
+
+      CheckRedzones(rz_scratch_allocator, &result);
+      CheckRedzones(rz_allocator, &result);
+    } else {
+      result.mutable_failure()->set_kind(xla::AutotuneResult::UNKNOWN);
+      result.mutable_failure()->set_msg(
+          absl::StrCat("Profiling failure on CUDNN engine ", desc.ToString(),
+                       ": ", cudnn_launch_status.ToString()));
+    }
+  }
+
+  return results;
+}
+
+}  // namespace tensorflow::internal
+
+#endif  // GOOGLE_CUDA
+
+#endif  // TENSORFLOW_CORE_KERNELS_AUTOTUNE_CONV_IMPL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/avgpooling_op.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/avgpooling_op.h
new file mode 100644
index 0000000000000000000000000000000000000000..8008c3c43bc0b16ada0f62edfd3d548681ea7223
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/avgpooling_op.h
@@ -0,0 +1,76 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_AVGPOOLING_OP_H_
+#define TENSORFLOW_CORE_KERNELS_AVGPOOLING_OP_H_
+// Functor definition for AvgPoolingOp, must be compilable by nvcc.
+
+#include "tensorflow/core/framework/tensor_types.h"
+#include "tensorflow/core/kernels/eigen_pooling.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+namespace functor {
+
+template <typename Device, typename T>
+struct SpatialAvgPooling {
+  void operator()(const Device& d, typename TTypes<T, 4>::Tensor output,
+                  typename TTypes<T, 4>::ConstTensor input, int window_rows,
+                  int window_cols, int row_stride, int col_stride,
+                  const Eigen::PaddingType& padding) {
+    MaybeWith32BitIndexing<Device>(
+        [&](auto output32, auto input32) {
+          // Because we swap the layout, we swap the row/cols as well.
+          output32.swap_layout().device(d) = Eigen::SpatialAvgPooling(
+              input32.swap_layout(), window_cols, window_rows, col_stride,
+              row_stride, padding);
+        },
+        output, input);
+  }
+};
+
+}  // namespace functor
+
+typedef Eigen::GpuDevice GPUDevice;
+
+// Launch a custom GPU kernels from Yanqing for the avgpooling backward
+// operation that works NHWC data formats. Arguments:
+//   top_diff: backprop to the output of the pooling layer
+//   num: number of input batches
+//   height: input height
+//   width: input width
+//   channels: number of input channels
+//   pooled_height: the height of the output to the pooling layer
+//   pooled_width: the width of the output to the pooling layer
+//   kernel_h: the height of the pooling kernel
+//   kernel_w: the width of the pooling kernel
+//   stride_h: the height of the vertical stride
+//   stride_w: the width of the horizontal stride
+//   pad_t: padding size to the top side
+//   pad_l: padding size to the left side
+//   bottom_diff: backprop to the input of the pooling layer.
+template <typename T>
+bool RunAvePoolBackwardNHWC(const T* const top_diff, const int num,
+                            const int height, const int width,
+                            const int channels, const int pooled_height,
+                            const int pooled_width, const int kernel_h,
+                            const int kernel_w, const int stride_h,
+                            const int stride_w, const int pad_t,
+                            const int pad_l, T* const bottom_diff,
+                            const GPUDevice& d);
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_AVGPOOLING_OP_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/batch_kernel_test_util.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/batch_kernel_test_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..e26f6c5d78914c0cab2ee93b6def02ae750f5d24
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/batch_kernel_test_util.h
@@ -0,0 +1,52 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_BATCH_KERNEL_TEST_UTIL_H_
+#define TENSORFLOW_CORE_KERNELS_BATCH_KERNEL_TEST_UTIL_H_
+
+#include "tensorflow/core/framework/node_def_builder.h"
+#include "tensorflow/core/kernels/batch_kernels.h"
+#include "tensorflow/core/kernels/ops_testutil.h"
+#include "tensorflow/core/kernels/ops_util.h"
+#include "tensorflow/core/lib/core/status_test_util.h"
+#include "tensorflow/core/platform/env.h"
+#include "tensorflow/core/platform/test.h"
+
+namespace tensorflow {
+namespace internal {
+class BatchFunctionKernelTestAccess {
+ public:
+  explicit BatchFunctionKernelTestAccess(BatchFunctionKernel* kernel);
+
+  bool enable_adaptive_batch_threads() const;
+
+ private:
+  BatchFunctionKernel* const kernel_;
+};
+
+}  // namespace internal
+
+class BatchFunctionKernelTestBase : public OpsTestBase,
+                                    public ::testing::WithParamInterface<bool> {
+ public:
+  bool enable_adaptive_scheduler() const;
+
+  // Init test fixture with a batch kernel instance.
+  Status Init();
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_BATCH_KERNEL_TEST_UTIL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/batch_kernels.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/batch_kernels.h
new file mode 100644
index 0000000000000000000000000000000000000000..9ea1b195a050f673534bc57a3d0c552420173d3e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/batch_kernels.h
@@ -0,0 +1,136 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_BATCH_KERNELS_H_
+#define TENSORFLOW_CORE_KERNELS_BATCH_KERNELS_H_
+
+#include <cstdint>
+
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+#include "tensorflow/core/framework/function.h"
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/platform/mutex.h"
+#include "tensorflow/core/platform/status.h"
+#include "tsl/platform/types.h"
+
+namespace tensorflow {
+
+// Per-model inflight batches parameters.
+ABSL_CONST_INIT extern const int64_t kMinInflightBatches;
+ABSL_CONST_INIT extern const int64_t kInitialInflightBatches;
+ABSL_CONST_INIT extern const int64_t kBatchesToAverageOver;
+ABSL_CONST_INIT extern const int64_t kMaxInflightBatches;
+
+namespace internal {
+class BatchFunctionKernelTestAccess;
+}
+
+// Records the usage of attribute `enable_large_batch_splitting`.
+void RecordBatchSplitUsage(
+    std::optional<bool> maybe_enable_large_batch_splitting,
+    absl::string_view model_name);
+
+// Records the number of batch threads of a model.
+void RecordBatchParamNumBatchThreads(int64_t num_batch_threads,
+                                     absl::string_view model_name);
+
+// Returns the model name from the context.
+absl::string_view GetModelName(OpKernelContext* ctx);
+
+// `BatchFunctionKernel` is the implementation of op `BatchFunction`.
+//
+// `BatchFunctionKernel` will batch (tensor) inputs by concatenating them
+// along the 0-th dimension, schedule a user-defined computation, and then
+// splits the returned tensors as batch output.
+//
+// In particular, an instance of `BatchFunctionKernel` creates or re-uses a
+// a batch scheduler instance based on op attributes, pre-processes and enqueues
+// concatenated inputs to the scheduler which invokes user-defined function,
+// and then splits function output as op output.
+//
+// User defined function is named by attribute `f` and defined in the graph.
+class BatchFunctionKernel : public AsyncOpKernel {
+ public:
+  explicit BatchFunctionKernel(OpKernelConstruction* c);
+
+  bool IsExpensive() override;
+
+  void ComputeAsync(OpKernelContext* c, DoneCallback done) final;
+
+ private:
+  friend class internal::BatchFunctionKernelTestAccess;
+
+  // Validates 'allowed_batch_sizes_'. The entries must increase monotonically.
+  // If large batch split is not enabled, the last one must equal
+  // `max_batch_size_`. otherwise the last element must be smaller than or equal
+  // to `max_batch_size_`.
+  Status ValidateAllowedBatchSizes() const;
+
+  // Creates the function handle if it isn't initialized yet; and re-use it
+  // afterwards.
+  Status GetOrCreateFunctionHandle(OpKernelContext* c,
+                                   FunctionLibraryRuntime::Handle* handle);
+
+  // Instantiate the user-defined function and emits `handle`.
+  Status InstantiateFunction(OpKernelContext* c,
+                             FunctionLibraryRuntime::Handle* handle) const;
+
+  // Initialize vars by reading from op-kernel-construction.
+  // Vars
+  // - enable_adaptive_batch_threads_
+  //   true if value of attribute `kEnableAdaptiveSchedulerAttr` is true, or
+  //   if `num_batch_threads` is not positive.
+  // - adaptive_batch_scheduler_options_
+  //   Read from corresponding attributes as long as they are set.
+  void SetAdaptiveBatchSchedulerOptions(OpKernelConstruction* c,
+                                        int32_t num_batch_threads);
+  string container_;
+  string shared_name_;
+  string batcher_queue_;
+  int32 num_batch_threads_;
+  int32 max_batch_size_;
+  int32 batch_timeout_micros_;
+  int32 max_enqueued_batches_;
+  std::vector<int32> allowed_batch_sizes_;
+  int32 low_priority_max_batch_size_;
+  int32 low_priority_batch_timeout_micros_;
+  int32 low_priority_max_enqueued_batches_;
+  std::vector<int32> low_priority_allowed_batch_sizes_;
+  NameAttrList func_;
+  absl::optional<FunctionLibraryRuntime::Handle> fhandle_ TF_GUARDED_BY(mu_);
+  bool enable_large_batch_splitting_;
+  bool has_attribute_enable_large_batch_splitting_;
+  bool enable_adaptive_batch_threads_ = false;
+
+  mutex mu_;
+
+  // Parameters for adaptive batch scheduler only.
+  // Note 'num_batch_threads_' above is shared by two implementations of batch
+  // scheduler.
+  struct AdaptiveBatchSchedulerOptions {
+    int32 min_in_flight_batches_limit = kMinInflightBatches;
+    int32 initial_in_flight_batches_limit = kInitialInflightBatches;
+    int32 max_in_flight_batches_limit = kMaxInflightBatches;
+    int32 batches_to_average_over = kBatchesToAverageOver;
+    int64 full_batch_scheduling_boost_micros = -1;
+  };
+  absl::optional<AdaptiveBatchSchedulerOptions>
+      adaptive_batch_scheduler_options_ = absl::nullopt;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_BATCH_KERNELS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/batch_norm_op.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/batch_norm_op.h
new file mode 100644
index 0000000000000000000000000000000000000000..7341833ed0c4134f60754434028f7b1ca5b85501
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/batch_norm_op.h
@@ -0,0 +1,143 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_BATCH_NORM_OP_H_
+#define TENSORFLOW_CORE_KERNELS_BATCH_NORM_OP_H_
+// Functor definition for BatchNormOp, must be compilable by nvcc.
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/framework/tensor_types.h"
+
+namespace tensorflow {
+namespace functor {
+
+// Functor used by BatchNormOp to do the computations.
+template <typename Device, typename T>
+struct BatchNorm {
+  void operator()(const Device& d, typename TTypes<T, 4>::ConstTensor input,
+                  typename TTypes<T>::ConstVec mean,
+                  typename TTypes<T>::ConstVec var,
+                  typename TTypes<T>::ConstVec beta,
+                  typename TTypes<T>::ConstVec gamma, T variance_epsilon,
+                  bool scale_after_normalization,
+                  typename TTypes<T, 4>::Tensor output) {
+    const int depth = mean.dimension(0);
+    const int rest_size = input.size() / depth;
+
+    Eigen::DSizes<int, 2> rest_by_depth(rest_size, depth);
+    Eigen::IndexList<int, Eigen::type2index<1> > rest_by_one;
+    rest_by_one.set(0, rest_size);
+    Eigen::IndexList<Eigen::type2index<1>, int> one_by_depth;
+    one_by_depth.set(1, depth);
+    Eigen::IndexList<int, Eigen::type2index<1> > depth_by_one;
+    depth_by_one.set(0, depth);
+    if (scale_after_normalization) {
+      output.reshape(rest_by_depth).device(d) =
+          (input.reshape(rest_by_depth) -
+           mean.reshape(one_by_depth).broadcast(rest_by_one)) *
+              ((var + var.constant(variance_epsilon)).rsqrt() * gamma)
+                  .eval()
+                  .reshape(one_by_depth)
+                  .broadcast(rest_by_one) +
+          beta.reshape(one_by_depth).broadcast(rest_by_one);
+    } else {
+      output.reshape(rest_by_depth).device(d) =
+          (input.reshape(rest_by_depth) -
+           mean.reshape(one_by_depth).broadcast(rest_by_one)) *
+              ((var + var.constant(variance_epsilon)).rsqrt())
+                  .eval()
+                  .reshape(one_by_depth)
+                  .broadcast(rest_by_one) +
+          beta.reshape(one_by_depth).broadcast(rest_by_one);
+    }
+  }
+};
+
+template <typename Device, typename T>
+struct BatchNormGrad {
+  void operator()(const Device& d, typename TTypes<T, 4>::ConstTensor input,
+                  typename TTypes<T>::ConstVec mean,
+                  typename TTypes<T>::ConstVec var,
+                  typename TTypes<T>::ConstVec gamma,
+                  typename TTypes<T, 4>::ConstTensor out_backprop,
+                  T variance_epsilon, bool scale_after_normalization,
+                  typename TTypes<T, 4>::Tensor dx, typename TTypes<T>::Vec dm,
+                  typename TTypes<T>::Vec dv, typename TTypes<T>::Vec db,
+                  typename TTypes<T>::Vec dg, typename TTypes<T>::Vec scratch1,
+                  typename TTypes<T>::Vec scratch2) {
+    const int depth = mean.dimension(0);
+    const int rest_size = input.size() / depth;
+
+    typedef typename TTypes<T>::ConstVec::Index Index;
+
+    Eigen::DSizes<Index, 2> rest_by_depth(rest_size, depth);
+    Eigen::IndexList<Index, Eigen::type2index<1> > rest_by_one;
+    rest_by_one.set(0, rest_size);
+    Eigen::IndexList<Eigen::type2index<1>, Index> one_by_depth;
+    one_by_depth.set(1, depth);
+    Eigen::IndexList<Eigen::type2index<0> > reduction_axis;
+
+    // db = out_backprop
+    //
+    // dg = out_backprop * ((x - m) * rsqrt(v + epsilon))
+    //
+    // dv = sum_over_rest(out_backprop * gamma * (x - m)) *
+    //      (-1/2) * (v + epsilon) ^ (-3/2)
+    //
+    // dm = sum_over_rest(out_backprop * gamma) * (-1 / rsqrt(v + epsilon))
+    //
+    // dx = out_backprop * (gamma * rsqrt(v + epsilon))
+    db.device(d) = out_backprop.reshape(rest_by_depth).sum(reduction_axis);
+
+    // scratch1 = rsqrt(v + epsilon)
+    scratch1.device(d) = (var + var.constant(variance_epsilon)).rsqrt();
+
+    // scratch2 = sum_over_rest(out_backprop * (x - m))
+    scratch2.device(d) = (out_backprop.reshape(rest_by_depth) *
+                          (input.reshape(rest_by_depth) -
+                           mean.reshape(one_by_depth).broadcast(rest_by_one)))
+                             .sum(reduction_axis);
+
+    if (scale_after_normalization) {
+      dx.reshape(rest_by_depth).device(d) =
+          out_backprop.reshape(rest_by_depth) * ((scratch1 * gamma)
+                                                     .eval()
+                                                     .reshape(one_by_depth)
+                                                     .broadcast(rest_by_one));
+      dm.device(d) = -db * (scratch1 * gamma).eval();
+      dg.device(d) = scratch2 * scratch1;
+    } else {
+      dx.reshape(rest_by_depth).device(d) =
+          out_backprop.reshape(rest_by_depth) *
+          scratch1.reshape(one_by_depth).broadcast(rest_by_one);
+      dm.device(d) = -db * scratch1;
+      dg.device(d) = dg.constant(static_cast<T>(0.0));  // Gamma is not learned.
+    }
+
+    // scratch1 = - 1/2 * (var + epsilon) ^ (-3/2)
+    scratch1.device(d) = scratch1 * scratch1.constant(static_cast<T>(-0.5f)) /
+                         (var + var.constant(variance_epsilon));
+
+    if (scale_after_normalization) {
+      dv.device(d) = scratch2 * (scratch1 * gamma).eval();
+    } else {
+      dv.device(d) = scratch2 * scratch1;
+    }
+  }
+};
+
+}  // namespace functor
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_BATCH_NORM_OP_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/batch_util.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/batch_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..dad2ec4e103e19c37cb3893c05d7c05e6e80ab4c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/batch_util.h
@@ -0,0 +1,23 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+// NOTE(lespeholt): This file is deprecated. Use
+// "tensorflow/core/util/batch_util.h" instead.
+
+#ifndef TENSORFLOW_CORE_KERNELS_BATCH_UTIL_H_
+#define TENSORFLOW_CORE_KERNELS_BATCH_UTIL_H_
+
+#include "tensorflow/core/util/batch_util.h"
+
+#endif  // TENSORFLOW_CORE_KERNELS_BATCH_UTIL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/betainc_op.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/betainc_op.h
new file mode 100644
index 0000000000000000000000000000000000000000..c808e688b2fdf86c53b323c8f1c476c7bd77f71e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/betainc_op.h
@@ -0,0 +1,51 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_BETAINC_OP_H_
+#define TENSORFLOW_CORE_KERNELS_BETAINC_OP_H_
+// Functor definition for BetaincOp, must be compilable by nvcc.
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/framework/tensor_types.h"
+
+namespace tensorflow {
+namespace functor {
+
+// Functor used by BetaincOp to do the computations.
+template <typename Device, typename T, int NDIM>
+struct Betainc {
+  void operator()(const Device& d, typename TTypes<T, NDIM>::ConstTensor a,
+                  typename TTypes<T, NDIM>::ConstTensor b,
+                  typename TTypes<T, NDIM>::ConstTensor x,
+                  typename TTypes<T, NDIM>::Tensor output) {
+    output.device(d) = Eigen::betainc(a, b, x);
+  }
+
+  void BCast(const Device& d, typename TTypes<T, NDIM>::ConstTensor a,
+             const typename Eigen::array<Eigen::DenseIndex, NDIM>& bcast_a,
+             typename TTypes<T, NDIM>::ConstTensor b,
+             const typename Eigen::array<Eigen::DenseIndex, NDIM>& bcast_b,
+             typename TTypes<T, NDIM>::ConstTensor x,
+             const typename Eigen::array<Eigen::DenseIndex, NDIM>& bcast_x,
+             typename TTypes<T, NDIM>::Tensor output) {
+    output.device(d) = Eigen::betainc(
+        a.broadcast(bcast_a), b.broadcast(bcast_b), x.broadcast(bcast_x));
+  }
+};
+
+}  // namespace functor
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_BETAINC_OP_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/bias_op.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/bias_op.h
new file mode 100644
index 0000000000000000000000000000000000000000..d4a78804576c5359f2f3036ee93a5a056ac84dec
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/bias_op.h
@@ -0,0 +1,60 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_BIAS_OP_H_
+#define TENSORFLOW_CORE_KERNELS_BIAS_OP_H_
+// Functor definition for BiasOp, must be compilable by nvcc.
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/framework/tensor_types.h"
+
+namespace tensorflow {
+namespace functor {
+
+// Functor used by BiasOp to do the computations.
+template <typename Device, typename T>
+struct Bias {
+  // Add "bias" to "input", repeating "bias".
+  void operator()(const Device& d, typename TTypes<T>::ConstFlat input,
+                  typename TTypes<T>::ConstVec bias,
+                  typename TTypes<T>::Flat output) {
+    const Eigen::Index rest_size = input.size() / bias.dimension(0);
+    Eigen::DSizes<Eigen::Index, 1> bcast(rest_size);
+    MaybeWith32BitIndexing<Device>(
+        [&](auto input32, auto bias32, auto output32, const auto& bcast32) {
+          output32.device(d) = input32 + bias32.broadcast(bcast32);
+        },
+        input, bias, output, bcast);
+  }
+
+  // NCHW layout, repeating on the first dimension, broadcasting on the last
+  // dimension.
+  void operator()(const Device& d, typename TTypes<T>::ConstMatrix input,
+                  typename TTypes<T>::ConstMatrix bias1,  // shape [C, 1].
+                  typename TTypes<T>::Matrix output) {
+    const Eigen::Index rest_size = input.dimension(0) / bias1.dimension(0);
+    Eigen::DSizes<Eigen::Index, 2> bcast(rest_size, input.dimension(1));
+    MaybeWith32BitIndexing<Device>(
+        [&](auto input32, auto bias32, auto output32, const auto& bcast32) {
+          output32.device(d) = input32 + bias32.broadcast(bcast32);
+        },
+        input, bias1, output, bcast);
+  }
+};
+
+}  // namespace functor
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_BIAS_OP_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/bias_op_gpu.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/bias_op_gpu.h
new file mode 100644
index 0000000000000000000000000000000000000000..0ece14a946cd1968c3730a54c47549588857f940
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/bias_op_gpu.h
@@ -0,0 +1,81 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_BIAS_OP_GPU_H_
+#define TENSORFLOW_CORE_KERNELS_BIAS_OP_GPU_H_
+
+#define EIGEN_USE_GPU
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/tensor_types.h"
+#include "tensorflow/core/kernels/gpu_utils.h"
+#include "tensorflow/core/util/tensor_format.h"
+
+namespace tensorflow {
+
+typedef Eigen::GpuDevice GPUDevice;
+
+template <typename T>
+struct BiasGPU {
+  static void compute(const GPUDevice& d, const T* input, const T* bias,
+                      T* output, int32_t batch, int32_t height, int32_t width,
+                      int32_t depth, int32_t channel, TensorFormat data_format);
+};
+
+template <typename T>
+struct BiasGradGPU {
+  static void compute(const GPUDevice& device, const T* output_backprop,
+                      T* bias_backprop, int32_t batch, int32_t height,
+                      int32_t width, int32_t depth, int32_t channel,
+                      TensorFormat data_format);
+
+  static void DoRowReduction(OpKernelContext* context, T* output,
+                             const T* input, int rows, int cols);
+
+  static void DoColReduction(OpKernelContext* context, T* output,
+                             const T* input, int rows, int cols);
+};
+
+enum class BiasAddGradGPUMode {
+  kInvalid = 0,
+  kNative = 1,
+  kReduction = 2,
+};
+
+// Describe the BiasGradGPU result from a perf experiment.
+//
+// Arguments:
+// algorithm: returns the method to use for bias add grad.
+// elapsed_time; returns the measured elapsed time in microseconds.
+class BiasGradGPUProfileResult {
+ public:
+  bool is_valid() const {
+    return (algorithm_ != BiasAddGradGPUMode::kInvalid &&
+            elapsed_time_ != std::numeric_limits<float>::max());
+  }
+  BiasAddGradGPUMode algorithm() const { return algorithm_; }
+  void set_algorithm(BiasAddGradGPUMode val) { algorithm_ = val; }
+  uint64 elapsed_time() const { return elapsed_time_; }
+  void set_elapsed_time(uint64 val) { elapsed_time_ = val; }
+
+ private:
+  BiasAddGradGPUMode algorithm_ = BiasAddGradGPUMode::kInvalid;
+  uint64 elapsed_time_ = std::numeric_limits<uint64>::max();
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_BIAS_OP_GPU_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/bincount_op.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/bincount_op.h
new file mode 100644
index 0000000000000000000000000000000000000000..56ad0dbb7ab242541b6e812dfa898a937f1372f3
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/bincount_op.h
@@ -0,0 +1,51 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_BINCOUNT_OP_H_
+#define TENSORFLOW_CORE_KERNELS_BINCOUNT_OP_H_
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/tensor_types.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/lib/core/errors.h"
+
+namespace tensorflow {
+
+namespace functor {
+
+template <typename Device, typename Tidx, typename T, bool binary_count>
+struct BincountFunctor {
+  static Status Compute(OpKernelContext* context,
+                        const typename TTypes<Tidx, 1>::ConstTensor& arr,
+                        const typename TTypes<T, 1>::ConstTensor& weights,
+                        typename TTypes<T, 1>::Tensor& output,
+                        const Tidx num_bins);
+};
+
+template <typename Device, typename Tidx, typename T, bool binary_count>
+struct BincountReduceFunctor {
+  static Status Compute(OpKernelContext* context,
+                        const typename TTypes<Tidx, 2>::ConstTensor& in,
+                        const typename TTypes<T, 2>::ConstTensor& weights,
+                        typename TTypes<T, 2>::Tensor& out,
+                        const Tidx num_bins);
+};
+
+}  // end namespace functor
+
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_BINCOUNT_OP_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/broadcast_to_op.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/broadcast_to_op.h
new file mode 100644
index 0000000000000000000000000000000000000000..083723e186a6b57ae52d30e30cea931da92181a6
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/broadcast_to_op.h
@@ -0,0 +1,91 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_BROADCAST_TO_OP_H_
+#define TENSORFLOW_CORE_KERNELS_BROADCAST_TO_OP_H_
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/tensor_shape.h"
+#include "tensorflow/core/framework/tensor_types.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/kernels/fill_functor.h"
+#include "tensorflow/core/util/bcast.h"
+
+namespace tensorflow {
+
+namespace functor {
+
+template <typename Device, typename T>
+struct BroadcastTo {
+  template <int NDIMS>
+  void DoBCast(
+      const Device &device, typename TTypes<T, NDIMS>::Tensor out,
+      typename TTypes<T, NDIMS>::ConstTensor in,
+      const typename Eigen::array<Eigen::DenseIndex, NDIMS> &bcast) const {
+    MaybeWith32BitIndexing<Device>(
+        [&](auto out32, auto in32, const auto &bcast32) {
+          out32.device(device) = in32.broadcast(bcast32);
+        },
+        out, in, bcast);
+  }
+
+  template <int NDIMS>
+  void ReshapeAndBCast(const Device &device, Tensor &output_tensor,
+                       const Tensor &input_tensor, const BCast &bcast) const {
+    DoBCast<NDIMS>(
+        device, output_tensor.template shaped<T, NDIMS>(bcast.result_shape()),
+        input_tensor.template shaped<T, NDIMS>(bcast.x_reshape()),
+        BCast::ToIndexArrayType<Eigen::DenseIndex, NDIMS>(bcast.x_bcast()));
+  }
+
+  // PRECONDITION: rank(input_shape) > 0 &&
+  //               rank(input_shape) <= rank(output_shape)  &&
+  //               output_shape.num_elements() > 0.
+  void operator()(const Device &device, OpKernelContext *ctx,
+                  Tensor &output_tensor, const TensorShape &output_shape,
+                  const Tensor &input_tensor, const TensorShape &input_shape,
+                  const BCast &bcast) const {
+    const int ndims = bcast.y_reshape().size();
+    switch (ndims) {
+      case 1:
+        ReshapeAndBCast<1>(device, output_tensor, input_tensor, bcast);
+        break;
+      case 2:
+        ReshapeAndBCast<2>(device, output_tensor, input_tensor, bcast);
+        break;
+      case 3:
+        ReshapeAndBCast<3>(device, output_tensor, input_tensor, bcast);
+        break;
+      case 4:
+        ReshapeAndBCast<4>(device, output_tensor, input_tensor, bcast);
+        break;
+      case 5:
+        ReshapeAndBCast<5>(device, output_tensor, input_tensor, bcast);
+        break;
+      default:
+        ctx->SetStatus(errors::Unimplemented(
+            "Broadcast between ", input_shape.DebugString(), " and ",
+            output_shape.DebugString(), " is not supported yet."));
+        break;
+    }
+  }
+};
+
+}  // namespace functor
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_BROADCAST_TO_OP_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/bucketize_op.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/bucketize_op.h
new file mode 100644
index 0000000000000000000000000000000000000000..d26525fdc88bcb7f10d79658aef1f3dda5ac2c8d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/bucketize_op.h
@@ -0,0 +1,41 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_BUCKETIZE_OP_H_
+#define TENSORFLOW_CORE_KERNELS_BUCKETIZE_OP_H_
+
+#include <vector>
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/tensor_types.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/lib/core/errors.h"
+
+namespace tensorflow {
+namespace functor {
+
+template <typename Device, typename T>
+struct BucketizeFunctor {
+  static Status Compute(OpKernelContext* context,
+                        const typename TTypes<T, 1>::ConstTensor& input,
+                        const std::vector<float>& boundaries_vector,
+                        typename TTypes<int32, 1>::Tensor& output);
+};
+
+}  // namespace functor
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_BUCKETIZE_OP_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/cast_op.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/cast_op.h
new file mode 100644
index 0000000000000000000000000000000000000000..c0b6eaf084089a318cf851a8adbb6ce92543bce4
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/cast_op.h
@@ -0,0 +1,351 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_CAST_OP_H_
+#define TENSORFLOW_CORE_KERNELS_CAST_OP_H_
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/framework/bfloat16.h"
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/tensor_types.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/platform/byte_order.h"
+#include "tensorflow/core/platform/types.h"
+
+// Note that the GPU cast functor templates need to be instantiated unlike the
+// CPU ones, and hence their specializations are different than that for CPUs.
+#ifdef SPECIALIZE_FOR_GPUS
+#define SPECIALIZE_CAST(DEVICE, OUT_TYPE, IN_TYPE)                  \
+  template <typename Device>                                        \
+  struct CastFunctor<Device, OUT_TYPE, IN_TYPE> {                   \
+    void operator()(const Device& d,                                \
+                    typename TTypes<OUT_TYPE>::Flat out_tensor,     \
+                    typename TTypes<IN_TYPE>::ConstFlat in_tensor,  \
+                    bool truncate = false) {                        \
+      if (truncate) {                                               \
+        out_tensor.device(d) =                                      \
+            in_tensor.unaryExpr(LSBZeroSetter<IN_TYPE, OUT_TYPE>()) \
+                .template cast<OUT_TYPE>();                         \
+      } else {                                                      \
+        out_tensor.device(d) = in_tensor.template cast<OUT_TYPE>(); \
+      }                                                             \
+    }                                                               \
+  };                                                                \
+  template struct CastFunctor<DEVICE, OUT_TYPE, IN_TYPE>;
+#else
+#define SPECIALIZE_CAST(DEVICE, OUT_TYPE, IN_TYPE)                  \
+  template <>                                                       \
+  struct CastFunctor<DEVICE, OUT_TYPE, IN_TYPE> {                   \
+    void operator()(const DEVICE& d,                                \
+                    typename TTypes<OUT_TYPE>::Flat out_tensor,     \
+                    typename TTypes<IN_TYPE>::ConstFlat in_tensor,  \
+                    bool truncate = false) {                        \
+      if (truncate) {                                               \
+        out_tensor.device(d) =                                      \
+            in_tensor.unaryExpr(LSBZeroSetter<IN_TYPE, OUT_TYPE>()) \
+                .template cast<OUT_TYPE>();                         \
+      } else {                                                      \
+        out_tensor.device(d) = in_tensor.template cast<OUT_TYPE>(); \
+      }                                                             \
+    }                                                               \
+  };
+#endif
+
+#define CAST_FUNCTORS(devname)                                        \
+  SPECIALIZE_CAST(devname, float, double)                             \
+  SPECIALIZE_CAST(devname, float, std::complex<double>)               \
+  SPECIALIZE_CAST(devname, std::complex<float>, std::complex<double>) \
+  SPECIALIZE_CAST(devname, std::complex<float>, double)               \
+  SPECIALIZE_CAST(devname, Eigen::half, double)                       \
+  SPECIALIZE_CAST(devname, Eigen::half, float)                        \
+  SPECIALIZE_CAST(devname, Eigen::half, std::complex<double>)         \
+  SPECIALIZE_CAST(devname, Eigen::half, std::complex<float>)          \
+  SPECIALIZE_CAST(devname, bfloat16, float)                           \
+  SPECIALIZE_CAST(devname, float8_e5m2, double)                       \
+  SPECIALIZE_CAST(devname, float8_e5m2, float)                        \
+  SPECIALIZE_CAST(devname, float8_e5m2, bfloat16)                     \
+  SPECIALIZE_CAST(devname, float8_e5m2, Eigen::half)                  \
+  SPECIALIZE_CAST(devname, float8_e5m2, float8_e4m3fn)                \
+  SPECIALIZE_CAST(devname, float8_e4m3fn, double)                     \
+  SPECIALIZE_CAST(devname, float8_e4m3fn, float)                      \
+  SPECIALIZE_CAST(devname, float8_e4m3fn, bfloat16)                   \
+  SPECIALIZE_CAST(devname, float8_e4m3fn, Eigen::half)                \
+  template <typename OUT_TYPE, typename IN_TYPE>                      \
+  struct CastFunctor<devname, OUT_TYPE, IN_TYPE> {                    \
+    void operator()(const devname& d,                                 \
+                    typename TTypes<OUT_TYPE>::Flat out_tensor,       \
+                    typename TTypes<IN_TYPE>::ConstFlat in_tensor,    \
+                    bool truncate = false) {                          \
+      out_tensor.device(d) = in_tensor.template cast<OUT_TYPE>();     \
+    }                                                                 \
+  };
+
+#if defined(MLIR_GENERATED_GPU_KERNELS_ENABLED)
+// If MLIR kernels are enabled, we don't need the specialized cast from float to
+// double or from Eigen::half to double. We still need the specialized cast from
+// Eigen::half to float, because it is used in depthwise_conv_grad_op.cc. We
+// still need the specialized cast from float to double because it is used in
+// resize_bilinear_op.cc.
+#define CAST_FUNCTORS_SUBSET(devname)                              \
+  SPECIALIZE_CAST(devname, float, double)                          \
+  SPECIALIZE_CAST(devname, Eigen::half, float)                     \
+  SPECIALIZE_CAST(devname, bfloat16, float)                        \
+  SPECIALIZE_CAST(devname, float8_e5m2, double)                    \
+  SPECIALIZE_CAST(devname, float8_e5m2, float)                     \
+  SPECIALIZE_CAST(devname, float8_e5m2, bfloat16)                  \
+  SPECIALIZE_CAST(devname, float8_e5m2, Eigen::half)               \
+  SPECIALIZE_CAST(devname, float8_e5m2, float8_e4m3fn)             \
+  SPECIALIZE_CAST(devname, float8_e4m3fn, double)                  \
+  SPECIALIZE_CAST(devname, float8_e4m3fn, float)                   \
+  SPECIALIZE_CAST(devname, float8_e4m3fn, bfloat16)                \
+  SPECIALIZE_CAST(devname, float8_e4m3fn, Eigen::half)             \
+  template <typename OUT_TYPE, typename IN_TYPE>                   \
+  struct CastFunctor<devname, OUT_TYPE, IN_TYPE> {                 \
+    void operator()(const devname& d,                              \
+                    typename TTypes<OUT_TYPE>::Flat out_tensor,    \
+                    typename TTypes<IN_TYPE>::ConstFlat in_tensor, \
+                    bool truncate = false) {                       \
+      out_tensor.device(d) = in_tensor.template cast<OUT_TYPE>();  \
+    }                                                              \
+  };
+#endif
+
+namespace tensorflow {
+
+typedef std::function<void(OpKernelContext*, const Tensor&, Tensor*,
+                           bool trunc)>
+    CastFunctorType;
+
+// Common base class of Cast kernels
+class CastOpBase : public OpKernel {
+ public:
+  explicit CastOpBase(OpKernelConstruction* ctx);
+
+  void Compute(OpKernelContext* ctx) override;
+
+ protected:
+  DataType src_dtype_;
+  DataType dst_dtype_;
+  DataType external_src_dtype_;
+  DataType external_dst_dtype_;
+  bool use_truncation_;
+  CastFunctorType work_ = nullptr;
+  Status Unimplemented();
+
+  CastOpBase(const CastOpBase&) = delete;
+  void operator=(const CastOpBase&) = delete;
+};
+
+// CPU implementation of Cast
+class CpuCastOp : public CastOpBase {
+ public:
+  explicit CpuCastOp(OpKernelConstruction* ctx);
+
+ private:
+  Status Prepare();
+};
+
+namespace functor {
+
+template <typename I>
+constexpr int MantissaWidth() {
+  return std::numeric_limits<I>::digits;
+}
+
+template <>
+constexpr int MantissaWidth<Eigen::half>() {
+  // Remember, there's 1 hidden bit
+  return 10 + 1;
+}
+
+template <>
+constexpr int MantissaWidth<bfloat16>() {
+  // Remember, there's 1 hidden bit
+  return 7 + 1;
+}
+
+template <typename Device, typename Tout, typename Tin>
+void Cast(const Device& d, typename TTypes<Tout>::Flat o,
+          typename TTypes<Tin>::ConstFlat i) {
+  o.device(d) = i.template cast<Tout>();
+}
+
+template <typename Device, typename Tout, typename Tin>
+struct CastFunctor {
+  void operator()(const Device& d, typename TTypes<Tout>::Flat o,
+                  typename TTypes<Tin>::ConstFlat i, bool truncate = false);
+};
+
+template <typename I>
+typename std::enable_if<sizeof(I) == 8, void>::type EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE static LSBZeroSetterHelper(I& t, int n) {
+  // Only zero the bits for non-NaNs.
+  // For NaNs, let the non-truncation version handle it.
+  if (!Eigen::numext::isnan(t)) {
+    uint64_t* p = reinterpret_cast<uint64_t*>(&t);
+    *p &= (0xFFFFFFFFFFFFFFFF << n);
+  }
+}
+
+template <typename I>
+typename std::enable_if<sizeof(I) == 4, void>::type EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE static LSBZeroSetterHelper(I& t, int n) {
+  // Only zero the bits for non-NaNs.
+  // For NaNs, let the non-truncation version handle it.
+  if (!Eigen::numext::isnan(t)) {
+    uint32_t* p = reinterpret_cast<uint32_t*>(&t);
+    *p &= (0xFFFFFFFF << n);
+  }
+}
+
+template <typename I>
+typename std::enable_if<sizeof(I) == 2, void>::type EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE static LSBZeroSetterHelper(I& t, int n) {
+  // Only zero the bits for non-NaNs.
+  // For NaNs, let the non-truncation version handle it.
+  if (!Eigen::numext::isnan(t)) {
+    uint16_t* p = reinterpret_cast<uint16_t*>(&t);
+    *p &= (0xFFFF << n);
+  }
+}
+
+template <typename I>
+typename std::enable_if<sizeof(I) == 1, void>::type EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE static LSBZeroSetterHelper(I& t, int n) {
+  // Only zero the bits for non-NaNs.
+  // For NaNs, let the non-truncation version handle it.
+  if (!Eigen::numext::isnan(t)) {
+    uint8_t* p = reinterpret_cast<uint8_t*>(&t);
+    *p &= (0xFF << n);
+  }
+}
+
+// Set n least significant bits to 0
+template <typename I, typename O>
+struct LSBZeroSetter {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE I operator()(const I& a) const {
+    constexpr int bits = MantissaWidth<I>() - MantissaWidth<O>();
+    static_assert(
+        bits > 0,
+        "The output type must have fewer mantissa bits than the input type\n");
+    I t = a;
+    LSBZeroSetterHelper(t, bits);
+    return t;
+  }
+};
+
+template <typename I, typename O>
+struct LSBZeroSetter<std::complex<I>, std::complex<O>> {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::complex<I> operator()(
+      const std::complex<I>& a) const {
+    constexpr int bits = MantissaWidth<I>() - MantissaWidth<O>();
+    static_assert(
+        bits > 0,
+        "The output type must have fewer mantissa bits than the input type\n");
+    I re = Eigen::numext::real(a);
+    I img = Eigen::numext::imag(a);
+    LSBZeroSetterHelper(re, bits);
+    LSBZeroSetterHelper(img, bits);
+    std::complex<I> toReturn(re, img);
+    return toReturn;
+  }
+};
+
+template <typename I, typename O>
+struct LSBZeroSetter<std::complex<I>, O> {
+  // Sets the 16 LSBits of the float to 0
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::complex<I> operator()(
+      const std::complex<I>& a) const {
+    constexpr int bits = MantissaWidth<I>() - MantissaWidth<O>();
+    static_assert(
+        bits > 0,
+        "The output type must have fewer mantissa bits than the input type\n");
+    I re = Eigen::numext::real(a);
+    I img = Eigen::numext::imag(a);
+    LSBZeroSetterHelper(re, bits);
+    LSBZeroSetterHelper(img, bits);
+    std::complex<I> toReturn(re, img);
+    return toReturn;
+  }
+};
+
+}  // end namespace functor
+}  // end namespace tensorflow
+
+namespace Eigen {
+namespace internal {
+
+// Eigen can't convert to/from complex numbers, because it is limited to cases
+// that can be static_casted. But numpy is able to cast to/from complex, which
+// we want to replicate. So we add specializations for complex here.
+template <typename From, typename To>
+struct scalar_cast_op<std::complex<From>, To> {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE To
+  operator()(const std::complex<From>& a) const {
+    // Replicate numpy behavior of returning just the real part
+    return static_cast<To>(a.real());
+  }
+};
+
+template <typename From>
+struct scalar_cast_op<std::complex<From>, bool> {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator()(
+      const std::complex<From>& a) const {
+    return static_cast<bool>(a.real());
+  }
+};
+
+template <typename From, typename To>
+struct scalar_cast_op<From, std::complex<To>> {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::complex<To> operator()(
+      const From& a) const {
+    // Replicate numpy behavior of setting the imaginary part to 0
+    return std::complex<To>(static_cast<To>(a), To(0));
+  }
+};
+
+template <typename From, typename To>
+struct scalar_cast_op<std::complex<From>, std::complex<To>> {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::complex<To> operator()(
+      const std::complex<From>& a) const {
+    return std::complex<To>(static_cast<To>(a.real()),
+                            static_cast<To>(a.imag()));
+  }
+};
+
+template <typename From, typename To>
+struct functor_traits_complex_impl {
+  enum { Cost = NumTraits<To>::AddCost, PacketAccess = false };
+};
+
+template <typename From>
+struct functor_traits<scalar_cast_op<std::complex<From>, bool>>
+    : functor_traits_complex_impl<std::complex<From>, bool> {};
+
+template <typename From, typename To>
+struct functor_traits<scalar_cast_op<std::complex<From>, To>>
+    : functor_traits_complex_impl<std::complex<From>, To> {};
+template <typename From, typename To>
+struct functor_traits<scalar_cast_op<From, std::complex<To>>>
+    : functor_traits_complex_impl<From, std::complex<To>> {};
+// Needed to avoid ambiguous partial specialization
+template <typename From, typename To>
+struct functor_traits<scalar_cast_op<std::complex<From>, std::complex<To>>>
+    : functor_traits_complex_impl<std::complex<From>, std::complex<To>> {};
+
+}  // namespace internal
+}  // namespace Eigen
+
+#endif  // TENSORFLOW_CORE_KERNELS_CAST_OP_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/cast_op_impl.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/cast_op_impl.h
new file mode 100644
index 0000000000000000000000000000000000000000..6f0fe7eb0fc7a67b24cbd227bb58291a6a6478f4
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/cast_op_impl.h
@@ -0,0 +1,189 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_CAST_OP_IMPL_H_
+#define TENSORFLOW_CORE_KERNELS_CAST_OP_IMPL_H_
+
+#include <cstdint>
+#include <limits>
+
+#define EIGEN_USE_THREADS
+
+#include "absl/status/status.h"
+#include "tensorflow/core/platform/errors.h"
+#include "tsl/platform/status.h"
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/kernels/cast_op.h"
+
+namespace tensorflow {
+
+namespace functor {
+
+template <class F, class I>
+struct OutOfRange {
+  bool operator()(const F f) const {
+    return f < std::numeric_limits<I>::min() ||
+           f > std::numeric_limits<I>::max();
+  }
+};
+
+#define VALIDATE_CAST(I, F)                                                  \
+  template <>                                                                \
+  struct CastFunctor<Eigen::ThreadPoolDevice, I, F> {                        \
+    void operator()(const Eigen::ThreadPoolDevice& d,                        \
+                    typename TTypes<I>::Flat out_tensor,                     \
+                    typename TTypes<F>::ConstFlat in_tensor,                 \
+                    bool truncate = false) const {                           \
+      Eigen::Tensor<bool, 0, Eigen::RowMajor> out_of_range =                 \
+          in_tensor.unaryExpr(OutOfRange<F, I>{}).any();                     \
+      if (out_of_range()) {                                                  \
+        LOG(ERROR)                                                           \
+            << "IMPORTANT! The input tensor to Cast contains values out of " \
+               "range for the target type. This is undefined behavior and "  \
+               "likely a bug in your model. A crash immediately after this " \
+               "under ubsan is expected.";                                   \
+      }                                                                      \
+      out_tensor.device(d) = in_tensor.template cast<I>();                   \
+    }                                                                        \
+  };
+
+// Add additional logging for out of range inputs when running in debug mode.
+#ifndef NDEBUG
+VALIDATE_CAST(int32, float);
+VALIDATE_CAST(int64, float);
+VALIDATE_CAST(int32, double);
+VALIDATE_CAST(int64, double);
+#endif
+
+CAST_FUNCTORS(Eigen::ThreadPoolDevice);
+
+
+}  // namespace functor
+
+#define CURRY_TYPES3(FN, arg0, arg1)   \
+  FN(arg0, arg1, bool);                \
+  FN(arg0, arg1, uint8);               \
+  FN(arg0, arg1, uint16);              \
+  FN(arg0, arg1, uint32);              \
+  FN(arg0, arg1, uint64);              \
+  FN(arg0, arg1, int8);                \
+  FN(arg0, arg1, int16);               \
+  FN(arg0, arg1, int32);               \
+  FN(arg0, arg1, int64_t);             \
+  FN(arg0, arg1, float);               \
+  FN(arg0, arg1, double);              \
+  FN(arg0, arg1, std::complex<float>); \
+  FN(arg0, arg1, std::complex<double>) \
+  FN(arg0, arg1, Eigen::half);         \
+  FN(arg0, arg1, bfloat16);
+
+#define CAST_CASE(DEVICE, IN, OUT)                                        \
+  if (DataTypeToEnum<OUT>::value == dst_dtype) {                          \
+    return [](OpKernelContext* ctx, const Tensor& inp, Tensor* out,       \
+              bool truncate) {                                            \
+      functor::CastFunctor<DEVICE, OUT, IN> func;                         \
+      func(ctx->eigen_device<DEVICE>(), out->flat<OUT>(), inp.flat<IN>(), \
+           truncate);                                                     \
+    };                                                                    \
+  }
+
+// The functions below are implemented in the cast_op_impl_*.cc files.
+CastFunctorType GetCpuCastFromBool(DataType dst_dtype);
+
+CastFunctorType GetCpuCastFromUint8(DataType dst_dtype);
+
+CastFunctorType GetCpuCastFromUint16(DataType dst_dtype);
+
+CastFunctorType GetCpuCastFromInt8(DataType dst_dtype);
+
+CastFunctorType GetCpuCastFromUint32(DataType dst_dtype);
+
+CastFunctorType GetCpuCastFromUint64(DataType dst_dtype);
+
+CastFunctorType GetCpuCastFromInt8(DataType dst_dtype);
+
+CastFunctorType GetCpuCastFromInt16(DataType dst_dtype);
+
+CastFunctorType GetCpuCastFromInt32(DataType dst_dtype);
+
+CastFunctorType GetCpuCastFromInt64(DataType dst_dtype);
+
+CastFunctorType GetCpuCastFromHalf(DataType dst_dtype);
+
+CastFunctorType GetCpuCastFromFloat(DataType dst_dtype);
+
+CastFunctorType GetCpuCastFromDouble(DataType dst_dtype);
+
+CastFunctorType GetCpuCastFromComplex64(DataType dst_dtype);
+
+CastFunctorType GetCpuCastFromComplex128(DataType dst_dtype);
+
+CastFunctorType GetCpuCastFromBfloat(DataType dst_dtype);
+
+CastFunctorType GetCpuCastFromFloat8e5m2(DataType dst_dtype);
+
+CastFunctorType GetCpuCastFromFloat8e4m3fn(DataType dst_dtype);
+
+CastFunctorType GetCpuCastFromInt4(DataType dst_dtype);
+
+CastFunctorType GetCpuCastFromUint4(DataType dst_dtype);
+
+#if (defined(GOOGLE_CUDA) && GOOGLE_CUDA) || \
+    (defined(TENSORFLOW_USE_ROCM) && TENSORFLOW_USE_ROCM)
+// Same, for GPU.
+CastFunctorType GetGpuCastFromBool(DataType dst_dtype);
+
+CastFunctorType GetGpuCastFromUint8(DataType dst_dtype);
+
+CastFunctorType GetGpuCastFromUint16(DataType dst_dtype);
+
+CastFunctorType GetGpuCastFromInt8(DataType dst_dtype);
+
+CastFunctorType GetGpuCastFromUint32(DataType dst_dtype);
+
+CastFunctorType GetGpuCastFromUint64(DataType dst_dtype);
+
+CastFunctorType GetGpuCastFromInt16(DataType dst_dtype);
+
+CastFunctorType GetGpuCastFromInt32(DataType dst_dtype);
+
+CastFunctorType GetGpuCastFromInt64(DataType dst_dtype);
+
+CastFunctorType GetGpuCastFromHalf(DataType dst_dtype);
+
+CastFunctorType GetGpuCastFromFloat(DataType dst_dtype);
+
+CastFunctorType GetGpuCastFromDouble(DataType dst_dtype);
+
+CastFunctorType GetGpuCastFromComplex64(DataType dst_dtype);
+
+CastFunctorType GetGpuCastFromComplex128(DataType dst_dtype);
+
+CastFunctorType GetGpuCastFromBfloat(DataType dst_dtype);
+
+CastFunctorType GetGpuCastFromFloat8e5m2(DataType dst_dtype);
+
+CastFunctorType GetGpuCastFromFloat8e4m3fn(DataType dst_dtype);
+
+CastFunctorType GetGpuCastFromInt4(DataType dst_dtype);
+
+CastFunctorType GetGpuCastFromUint4(DataType dst_dtype);
+
+#endif  // GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_CAST_OP_IMPL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/checkpoint_callback_manager.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/checkpoint_callback_manager.h
new file mode 100644
index 0000000000000000000000000000000000000000..ec0d7fe0275c5e6a795f53ea809b41ccb95e0107
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/checkpoint_callback_manager.h
@@ -0,0 +1,112 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0(the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_KERNELS_CHECKPOINT_CALLBACK_MANAGER_H_
+#define TENSORFLOW_CORE_KERNELS_CHECKPOINT_CALLBACK_MANAGER_H_
+
+#include <functional>
+#include <string>
+#include <utility>
+
+#include "absl/base/attributes.h"
+#include "absl/container/flat_hash_map.h"
+#include "absl/strings/string_view.h"
+#include "tensorflow/core/framework/resource_base.h"
+#include "tensorflow/core/platform/mutex.h"
+#include "tensorflow/core/platform/status.h"
+#include "tensorflow/core/platform/statusor.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+namespace checkpoint {
+
+ABSL_CONST_INIT extern const absl::string_view
+    kCheckpointCallbackManagerResourceName;
+
+// StatusOr<std::string> save_callback(absl::string_view checkpoint_id);
+using SaveCallback = std::function<StatusOr<std::string>(absl::string_view)>;
+
+// Status restore_callback(absl::string_view checkpoint_id,
+//                         absl::string_view content_from_checkpoint);
+using RestoreCallback =
+    std::function<Status(absl::string_view, absl::string_view)>;
+
+// A class to save and restore additional information for checkpointing.
+class CheckpointCallbackManager : public ResourceBase {
+ public:
+  CheckpointCallbackManager() = default;
+
+  // Not copyable or movable
+  CheckpointCallbackManager(const CheckpointCallbackManager&) = delete;
+  CheckpointCallbackManager& operator=(const CheckpointCallbackManager&) =
+      delete;
+
+  std::string DebugString() const override {
+    return "CheckpointCallbackManager";
+  }
+
+  // Infers a checkpoint id and directory from a prefix
+  // passed to SaveV2 / RestoreV2 Ops
+  static StatusOr<std::pair<std::string, std::string>>
+  GetCheckpointIdAndPathFromPrefix(absl::string_view prefix);
+
+  // Register a save callback.
+  // The passed callback will be triggered with an identified checkpoint id.
+  // The callback should return a string content needs to be stored
+  // as a part of a checkpoint, and then the content is stored as a file
+  // with the registered the file_extension.
+  Status RegisterSaveCallback(absl::string_view file_extension,
+                              SaveCallback callback);
+
+  // Checks if a registered save callback exists for an extension.
+  bool DoesSaveCallbackExist(absl::string_view file_extension);
+
+  // Register a restore callback.
+  // The passed file_extension is used to generate a file name together with
+  // an identified checkpoint_id. If the file exists, the registered callback
+  // is triggered with the content of the file.
+  Status RegisterRestoreCallback(absl::string_view file_extension,
+                                 RestoreCallback callback);
+
+  // Checks if a registered restore callback exists for an extension.
+  bool DoesRestoreCallbackExist(absl::string_view file_extension);
+
+  // Should be triggered from SaveV2()::Compute().
+  void Save(absl::string_view prefix);
+
+  // Should be triggered from RestoreV2()::Compute().
+  void Restore(absl::string_view prefix);
+
+ private:
+  mutable mutex mu_;
+
+  absl::flat_hash_map<std::string, SaveCallback> save_callbacks_
+      TF_GUARDED_BY(mu_);
+  absl::flat_hash_map<std::string, RestoreCallback> restore_callbacks_
+      TF_GUARDED_BY(mu_);
+
+  // Checkpoint save and restore could happen before save / restore callbacks
+  // are registered. The last checkpoint information is kept in these variables
+  // to trigger the registered callback lazily.
+  std::pair<std::string, std::string> last_restored_checkpoint_id_and_dir_
+      TF_GUARDED_BY(mu_);
+
+  std::pair<std::string, std::string> last_saved_checkpoint_id_and_dir_
+      TF_GUARDED_BY(mu_);
+};
+
+}  // namespace checkpoint
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_CHECKPOINT_CALLBACK_MANAGER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/collective_nccl.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/collective_nccl.h
new file mode 100644
index 0000000000000000000000000000000000000000..4fc4bebb008e3c615f76e2de01199051f3392b3d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/collective_nccl.h
@@ -0,0 +1,45 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_KERNELS_COLLECTIVE_NCCL_H_
+#define TENSORFLOW_CORE_KERNELS_COLLECTIVE_NCCL_H_
+
+#include "tensorflow/core/framework/collective.h"
+
+namespace tensorflow {
+#if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+
+class NcclBase : public CollectiveImplementationInterface {
+ public:
+  explicit NcclBase(CollectiveType type, const string& name);
+  ~NcclBase() override = default;
+
+  // No-op for this collective implementation.
+  Status InitializeCollectiveParams(CollectiveParams* col_params) override;
+
+  // Initializes the device objects and device localities.
+  Status InitializeCollectiveContext(
+      std::shared_ptr<CollectiveContext> col_ctx) override;
+
+ protected:
+  const CollectiveType type_;
+  const string name_;
+  std::shared_ptr<CollectiveContext> col_ctx_;
+  const CollectiveParams* col_params_;  // Not owned
+};
+
+#endif  // GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_COLLECTIVE_NCCL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/collective_nccl_all_to_all.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/collective_nccl_all_to_all.h
new file mode 100644
index 0000000000000000000000000000000000000000..4ba624c95779e3363ca1d73ca8b9af330caeaf35
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/collective_nccl_all_to_all.h
@@ -0,0 +1,35 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_KERNELS_COLLECTIVE_NCCL_ALL_TO_ALL_H_
+#define TENSORFLOW_CORE_KERNELS_COLLECTIVE_NCCL_ALL_TO_ALL_H_
+
+#include "tensorflow/core/kernels/collective_nccl.h"
+
+namespace tensorflow {
+#if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+
+class NcclAllToAll : public NcclBase {
+ public:
+  NcclAllToAll() : NcclBase(ALL_TO_ALL_COLLECTIVE, "NcclAllToAll") {}
+  ~NcclAllToAll() override = default;
+
+  // Hands off all-to-all to NcclManager.
+  void Run(StatusCallback done) override;
+};
+
+#endif  // GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_COLLECTIVE_NCCL_ALL_TO_ALL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/collective_nccl_broadcaster.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/collective_nccl_broadcaster.h
new file mode 100644
index 0000000000000000000000000000000000000000..9c1f6f4a7878e606a62316687e3a41a8a5b59ea2
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/collective_nccl_broadcaster.h
@@ -0,0 +1,35 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_KERNELS_COLLECTIVE_NCCL_BROADCASTER_H_
+#define TENSORFLOW_CORE_KERNELS_COLLECTIVE_NCCL_BROADCASTER_H_
+
+#include "tensorflow/core/kernels/collective_nccl.h"
+
+namespace tensorflow {
+#if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+
+class NcclBroadcaster : public NcclBase {
+ public:
+  NcclBroadcaster() : NcclBase(BROADCAST_COLLECTIVE, "NcclBroadcast") {}
+  ~NcclBroadcaster() override = default;
+
+  // Hands off broadcast to NcclManager.
+  void Run(StatusCallback done) override;
+};
+
+#endif  // GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_COLLECTIVE_NCCL_BROADCASTER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/collective_nccl_gatherer.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/collective_nccl_gatherer.h
new file mode 100644
index 0000000000000000000000000000000000000000..97d41f778a57514c2c3dbbd3d2586ce552b96b47
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/collective_nccl_gatherer.h
@@ -0,0 +1,35 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_KERNELS_COLLECTIVE_NCCL_GATHERER_H_
+#define TENSORFLOW_CORE_KERNELS_COLLECTIVE_NCCL_GATHERER_H_
+
+#include "tensorflow/core/kernels/collective_nccl.h"
+
+namespace tensorflow {
+#if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+
+class NcclGatherer : public NcclBase {
+ public:
+  NcclGatherer() : NcclBase(GATHER_COLLECTIVE, "NcclGather") {}
+  ~NcclGatherer() override = default;
+
+  // Hands off all-gather to NcclManager.
+  void Run(StatusCallback done) override;
+};
+
+#endif  // GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_COLLECTIVE_NCCL_GATHERER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/collective_nccl_reducer.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/collective_nccl_reducer.h
new file mode 100644
index 0000000000000000000000000000000000000000..b95d572067958e88cb6fa75a842a902d85c935c3
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/collective_nccl_reducer.h
@@ -0,0 +1,44 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_KERNELS_COLLECTIVE_NCCL_REDUCER_H_
+#define TENSORFLOW_CORE_KERNELS_COLLECTIVE_NCCL_REDUCER_H_
+
+#include "tensorflow/core/kernels/collective_nccl.h"
+
+namespace tensorflow {
+#if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+
+class NcclReducer : public NcclBase {
+ public:
+  NcclReducer() : NcclBase(REDUCTION_COLLECTIVE, "NcclReduce") {}
+  NcclReducer(CollectiveType type, const string& name) : NcclBase(type, name) {}
+  ~NcclReducer() override = default;
+
+  // Hands off all reduce to NcclManager.
+  void Run(StatusCallback done) override;
+};
+
+class NcclReduceScatterer : public NcclReducer {
+ public:
+  NcclReduceScatterer()
+      : NcclReducer(REDUCE_SCATTER_COLLECTIVE, "NcclReduceScatter") {}
+  ~NcclReduceScatterer() override = default;
+  // Uses same Run() as NcclReducer.
+};
+
+#endif  // GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_COLLECTIVE_NCCL_REDUCER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/composite_tensor_variant.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/composite_tensor_variant.h
new file mode 100644
index 0000000000000000000000000000000000000000..fa98f795648e8278ac75f031c591a440d32aa576
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/composite_tensor_variant.h
@@ -0,0 +1,96 @@
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_COMPOSITE_TENSOR_VARIANT_H_
+#define TENSORFLOW_CORE_KERNELS_COMPOSITE_TENSOR_VARIANT_H_
+
+#include <vector>
+
+#include "absl/types/span.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/variant_tensor_data.h"
+
+namespace tensorflow {
+
+class CompositeTensorVariantMetadata;
+
+// Encoding for a `tf.ExtensionType` value, that can be saved as a Variant.
+//
+// `tf.ExtensionType` (also known as `CompositeTensor`) is a Python base class
+// used to Python types that are supported by TensorFlow APIs.  Example
+// ExtensionTypes include `tf.RaggedTensor` and `tf.SparseTensor`.
+//
+// `CompositeTensorVariant` decomposes the `ExtensionType` value into two
+// parts:
+//
+//   * `components`: A list of Tensors, which encodes the value's dynamic
+//     data -- i.e., data that may change for different executions of a graph.
+//   * `metadata`: A serialized TypeSpec, which encodes the value's
+//     static data -- i.e., data that is the same for all executions of a graph.
+//
+// CompositeTensorVariant can be stored in a Tensor with dtype=DT_VARIANT.
+// Typically, extension type values are encoded with a scalar tensor containing
+// a single CompositeTensorVariant value.
+class CompositeTensorVariant {
+ public:
+  CompositeTensorVariant(const CompositeTensorVariantMetadata& metadata,
+                         absl::Span<Tensor> flat_components);
+
+  CompositeTensorVariant();
+  CompositeTensorVariant(const CompositeTensorVariant& other);
+  CompositeTensorVariant& operator=(CompositeTensorVariant&& other) = default;
+  CompositeTensorVariant& operator=(const CompositeTensorVariant& other) =
+      delete;
+
+  // Returns the list of Tensor components that encode this value's dynamic
+  // data.
+  absl::Span<const Tensor> flat_components() const {
+    return absl::MakeConstSpan(flat_components_);
+  }
+
+  // Returns the serialized TypeSpec that encodes the value's static data.
+  const CompositeTensorVariantMetadata& metadata() const { return *metadata_; }
+
+  // Variant methods.
+  string TypeName() const { return kTypeName; }
+
+  // Updates `VariantTensorData` with an encoding for this value.
+  void Encode(VariantTensorData* data) const;
+
+  // Updates this value to match the encoding in a given `VariantTensorData`.
+  bool Decode(const VariantTensorData& data);
+
+  // Returns a string summary for this value.
+  string DebugString() const;
+
+  // Name of this type (used for variant serialization).
+  static constexpr const char kTypeName[] = "CompositeTensorVariant";
+
+ private:
+  // Tensor components for this value.
+  std::vector<Tensor> flat_components_;
+
+  // TypeSpec for this value.  CompositeTensorVariantMetadata is a thin wrapper
+  // around a TypeSpecProto, which is used to retain flexibility to change the
+  // variant encoding.
+  //
+  // Note: we use a unique_ptr, because header files in the kernels/ directory
+  // are not allowed to import .pb.h files.
+  std::unique_ptr<CompositeTensorVariantMetadata> metadata_;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_COMPOSITE_TENSOR_VARIANT_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/concat_lib.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/concat_lib.h
new file mode 100644
index 0000000000000000000000000000000000000000..ca30908cab5c3a331067f8c854b723fc7bcb2876
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/concat_lib.h
@@ -0,0 +1,75 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_CONCAT_LIB_H_
+#define TENSORFLOW_CORE_KERNELS_CONCAT_LIB_H_
+
+#include <vector>
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/framework/device_base.h"
+#include "tensorflow/core/framework/register_types.h"
+
+namespace tensorflow {
+
+// Functors to concatenate tensors. These always take a rank-2 tensor (i.e a
+// matrix) and concatenate it along the axis 1 ("putting them next to each
+// other" as opposed to "putting them on top of one another").
+//
+// Any concatenation of n-dimensional tensors across any axis can be reduced to
+// a concatenation of two-dimensional tensors across the axis 1 by first
+// partitioning the axes of the original tensors into those less than the axis
+// to be concatenated across and the rest. Then reshape the tensors into a
+// two-dimensional tensor by collapsing these two sets of axes and concatenate
+// the resulting matrices across the axis 1, finally reshaping the result to
+// have the proper shape.
+//
+// So, for example, when stacking N tensors, reshape each to have shape
+// {1, Numelements} and reshape the result matrix to have shape
+// {1, N * NumElements} before passing it to this functor.
+
+// Assumes all elements of inputs are nonempty.
+// Assumes output is nonempty.
+template <typename T>
+void ConcatCPU(
+    DeviceBase* d,
+    const std::vector<std::unique_ptr<typename TTypes<T, 2>::ConstMatrix>>&
+        inputs,
+    typename TTypes<T, 2>::Matrix* output);
+#if (defined(GOOGLE_CUDA) && GOOGLE_CUDA) || \
+    (defined(TENSORFLOW_USE_ROCM) && TENSORFLOW_USE_ROCM)
+template <typename T>
+void ConcatGPU(
+    OpKernelContext* c,
+    const std::vector<std::unique_ptr<typename TTypes<T, 2>::ConstMatrix>>&
+        inputs_flat,
+    Tensor* output, typename TTypes<T, 2>::Tensor* output_flat);
+
+// Explicit instantiations in concat_lib_gpu.cc.
+#define REGISTER(T)                                                           \
+  extern template void ConcatGPU<T>(                                          \
+      OpKernelContext * c,                                                    \
+      const std::vector<std::unique_ptr<typename TTypes<T, 2>::ConstMatrix>>& \
+          inputs_flat,                                                        \
+      Tensor* output, typename TTypes<T, 2>::Tensor* output_flat);
+
+TF_CALL_INTEGRAL_TYPES(REGISTER);  // int32 Needed for TensorLists.
+TF_CALL_GPU_ALL_TYPES(REGISTER);
+#undef REGISTER
+#endif  // GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_CONCAT_LIB_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/concat_lib_cpu.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/concat_lib_cpu.h
new file mode 100644
index 0000000000000000000000000000000000000000..45960772875a779fa228d659a3ce67ce39d42081
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/concat_lib_cpu.h
@@ -0,0 +1,135 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_CONCAT_LIB_CPU_H_
+#define TENSORFLOW_CORE_KERNELS_CONCAT_LIB_CPU_H_
+
+#define EIGEN_USE_THREADS
+
+#include <vector>
+#include "tensorflow/core/framework/register_types.h"
+#include "tensorflow/core/kernels/concat_lib.h"
+#include "tensorflow/core/util/work_sharder.h"
+
+namespace tensorflow {
+
+// ElementCopier must be a struct with a single Copy function, which is passed
+// the output pointer, input pointer, input index, and number of elements to
+// copy from input to output.
+template <typename T, typename ElementCopier>
+void ConcatCPUImpl(
+    DeviceBase* d,
+    const std::vector<std::unique_ptr<typename TTypes<T, 2>::ConstMatrix>>&
+        inputs,
+    int64_t cost_per_unit, ElementCopier copier,
+    typename TTypes<T, 2>::Matrix* output) {
+  size_t num_inputs = inputs.size();
+
+  std::vector<ptrdiff_t> sizes;
+  sizes.reserve(num_inputs);
+  int64_t row_size = 0;
+  for (const auto& input : inputs) {
+    sizes.push_back(input->dimension(1));
+    row_size += sizes.back();
+  }
+
+  // cost_per_unit is estimated bytes to copy per output array element (for
+  // strings this includes an estimate of the number of bytes of the actual
+  // string data, as well).
+  const int64_t estimated_total_cost = output->size() * cost_per_unit;
+
+  auto worker_threads = d->tensorflow_cpu_worker_threads();
+  int num_threads = std::min(4, worker_threads->num_threads);
+  num_threads = static_cast<int>(
+      std::min<int64_t>(num_threads, estimated_total_cost / 16384));
+  // Single threaded mode.
+  // TODO(dga):  Deduplicate this code w.r.t. sharded code below.
+  if (num_threads == 0) {
+    T* out = &(*output)(0, 0);
+    std::vector<const T*> inp;
+    inp.reserve(num_inputs);
+    for (const auto& input : inputs) {
+      inp.push_back(&(*input)(0, 0));
+    }
+    const int64_t dim0 = output->dimension(0);
+    for (int64_t i = 0; i < dim0; ++i) {
+      for (int64_t j = 0; j < num_inputs; ++j) {
+        auto size = sizes[j];
+        copier.Copy(out, inp[j], j, size);
+        out += size;
+        inp[j] += size;
+      }
+    }
+    return;
+  }
+
+  // Sharded mode.
+  auto work = [&row_size, &sizes, &inputs, &output, &copier, &num_inputs](
+                  int64_t start, int64_t end) {
+    int64_t skipped_rows = start / row_size;
+    T* out = output->data() + skipped_rows * row_size;
+    T* out_start = output->data() + start;
+    T* out_end = output->data() + end;
+
+    // Handle partial row at start
+    if (out < out_start) {
+      for (size_t j = 0; j < num_inputs; ++j) {
+        ptrdiff_t size = sizes[j];
+        ptrdiff_t offset = out_start - out;
+        if (size <= offset) {
+          out += size;
+          continue;
+        }
+        const T* inp = &(*inputs[j])(skipped_rows, 0);
+        if (offset > 0) {
+          out += offset;
+          inp += offset;
+          size -= offset;
+        }
+        size = std::min(size, out_end - out);
+        if (size <= 0) break;
+        copier.Copy(out, inp, j, size);
+        out += size;
+      }
+      ++skipped_rows;
+    }
+    if (out == out_end) return;
+    CHECK(out >= out_start);
+    CHECK(out < out_end);
+
+    // Copy remaining data.
+    std::vector<const T*> inp;
+    inp.reserve(num_inputs);
+    for (const auto& input : inputs) {
+      inp.push_back(&(*input)(skipped_rows, 0));
+    }
+    const int64_t dim0 = output->dimension(0);
+    for (int64_t i = skipped_rows; i < dim0; ++i) {
+      for (int64_t j = 0; j < num_inputs; ++j) {
+        ptrdiff_t size = std::min(sizes[j], out_end - out);
+        copier.Copy(out, inp[j], j, size);
+        out += size;
+        inp[j] += size;
+        if (out == out_end) return;
+      }
+    }
+  };
+  Shard(worker_threads->num_threads, worker_threads->workers, output->size(),
+        cost_per_unit, work);
+}
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_CONCAT_LIB_CPU_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/concat_lib_gpu.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/concat_lib_gpu.h
new file mode 100644
index 0000000000000000000000000000000000000000..8e42cc1c80ba0918cc06101c0748de58c2a65fe0
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/concat_lib_gpu.h
@@ -0,0 +1,75 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_CONCAT_LIB_GPU_H_
+#define TENSORFLOW_CORE_KERNELS_CONCAT_LIB_GPU_H_
+
+#define EIGEN_USE_THREADS
+#define EIGEN_USE_GPU
+
+#include <memory>
+#include <vector>
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/framework/register_types.h"
+#include "tensorflow/core/kernels/concat_lib.h"
+#include "tensorflow/core/kernels/gpu_device_array_gpu.h"
+
+namespace tensorflow {
+
+template <typename T, typename IntType>
+void ConcatGPUSlice(
+    const Eigen::GpuDevice& gpu_device,
+    const std::vector<std::unique_ptr<typename TTypes<T, 2>::ConstMatrix>>&
+        inputs_flat,
+    typename TTypes<T, 2>::Matrix* output);
+
+template <typename T, typename IntType>
+void ConcatGPUImpl(const Eigen::GpuDevice& d,
+                   const GpuDeviceArrayStruct<const T*>& input_ptrs,
+                   const GpuDeviceArrayStruct<IntType>& ptr_offsets,
+                   bool same_size, int slice_size,
+                   typename TTypes<T, 2>::Matrix* output);
+
+// Explicit instantiations in concat_lib_gpu_impl.cu.cc.
+#define REGISTER(T)                                                           \
+  extern template void ConcatGPUSlice<T, int32>(                              \
+      const Eigen::GpuDevice& gpu_device,                                     \
+      const std::vector<std::unique_ptr<typename TTypes<T, 2>::ConstMatrix>>& \
+          inputs_flat,                                                        \
+      typename TTypes<T, 2>::Matrix* output);                                 \
+  extern template void ConcatGPUSlice<T, int64>(                              \
+      const Eigen::GpuDevice& gpu_device,                                     \
+      const std::vector<std::unique_ptr<typename TTypes<T, 2>::ConstMatrix>>& \
+          inputs_flat,                                                        \
+      typename TTypes<T, 2>::Matrix* output);                                 \
+  extern template void ConcatGPUImpl<T, int32>(                               \
+      const Eigen::GpuDevice& d,                                              \
+      const GpuDeviceArrayStruct<const T*>& input_ptrs,                       \
+      const GpuDeviceArrayStruct<int32>& ptr_offsets, bool fixed_size,        \
+      int split_size, typename TTypes<T, 2>::Matrix* output);                 \
+  extern template void ConcatGPUImpl<T, int64>(                               \
+      const Eigen::GpuDevice& d,                                              \
+      const GpuDeviceArrayStruct<const T*>& input_ptrs,                       \
+      const GpuDeviceArrayStruct<int64_t>& ptr_offsets, bool fixed_size,      \
+      int split_size, typename TTypes<T, 2>::Matrix* output);
+
+TF_CALL_INTEGRAL_TYPES(REGISTER);  // int32 Needed for TensorLists.
+TF_CALL_GPU_ALL_TYPES(REGISTER);
+#undef REGISTER
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_CONCAT_LIB_GPU_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/conditional_accumulator.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/conditional_accumulator.h
new file mode 100644
index 0000000000000000000000000000000000000000..5f901b12d43d581d2a35f5290aa5b56ce142f93a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/conditional_accumulator.h
@@ -0,0 +1,136 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_CONDITIONAL_ACCUMULATOR_H_
+#define TENSORFLOW_CORE_KERNELS_CONDITIONAL_ACCUMULATOR_H_
+
+#include "tensorflow/core/kernels/fill_functor.h"
+#include "tensorflow/core/kernels/typed_conditional_accumulator_base.h"
+
+namespace tensorflow {
+
+/**
+ * An aggregation object for adding dense gradients.
+ *
+ * The two main methods of this class are TryApplyGrad and TryTakeGrad.
+ *
+ * TryApplyGrad tries add a gradient to the accumulator. The attempt is
+ * successful if local_step >= global_step, i.e., if the gradient is not stale,
+ * having been computed using up-to-date information. Otherwise, the gradient is
+ * silently dropped.
+ *
+ * TryTakeGrad logs an attempt to read the average gradient. The attempt is
+ * blocked until the number of gradients accumulated (via TryApplyGrad) is equal
+ * or exceeds the number requested by TryTakeGrad.
+ * Once this condition is satisfied, the following actions are taken:
+ * (1) the value of the average gradient is returned
+ * (2) the count of accumulated gradients is reset to 0
+ * (3) the internal global_step value (current_global_step_) is incremented by 1
+ *
+ * ConditionalAccumulator is the datatype-dependent templated sub-class of
+ * ConditionalAccumulatorBase. It implements the virtual arithmetic methods that
+ * are used by for aggregating, averaging, allocating, returning dense Tensors.
+ */
+template <typename Device, typename T>
+class ConditionalAccumulator
+    : public TypedConditionalAccumulatorBase<const Tensor> {
+ public:
+  // Args:
+  //   dtype: The datatype of the gradients to be accumulated.
+  //   shape: The shape of the accumulated gradients.
+  //   name:  A name to use for the ConditionalAccumulator.
+  //   reduction_type: The reduction type, i.e., MEAN or SUM
+  ConditionalAccumulator(const DataType& dtype, const PartialTensorShape& shape,
+                         const string& name, const string& reduction_type)
+      : TypedConditionalAccumulatorBase<const Tensor>(dtype, shape, name,
+                                                      reduction_type) {}
+  ~ConditionalAccumulator() override{};
+
+ protected:
+  // accum_grad is the tensor that holds the aggregate gradient.
+  // It is initialized the first time ApplyGrad is called.
+  Tensor accum_grad_;
+
+  functor::SetZeroFunctor<Device, T> set_zero_functor_;
+
+  Status ValidateShape(const Tensor* tensor)
+      TF_EXCLUSIVE_LOCKS_REQUIRED(this->mu_) {
+    // Must be compatible with accumulated gradient if available
+    if (counter_ > 0) {
+      if (!accum_grad_.shape().IsSameSize(tensor->shape())) {
+        return errors::InvalidArgument("Shape mismatch: expected ",
+                                       accum_grad_.shape().DebugString(),
+                                       ", got ", tensor->shape().DebugString());
+      }
+    }
+    // Must also be compatible with given shape
+    if (!shape_.IsCompatibleWith(tensor->shape())) {
+      return errors::InvalidArgument("Shape mismatch: expected ",
+                                     shape_.DebugString(), ", got ",
+                                     tensor->shape().DebugString());
+    }
+    return OkStatus();
+  }
+
+  void AllocateAndAssignToAccumGradFunction(OpKernelContext* ctx,
+                                            const Tensor* grad) override {
+    // TODO(b/32704451): Don't just ignore the ::tensorflow::Status object!
+    ctx->allocate_temp(dtype_, grad->shape(), &accum_grad_).IgnoreError();
+    accum_grad_.flat<T>().device(ctx->template eigen_device<Device>()) =
+        grad->flat<T>();
+  }
+
+  void AddToAccumGradFunction(OpKernelContext* ctx,
+                              const Tensor* grad) override {
+    accum_grad_.flat<T>().device(ctx->template eigen_device<Device>()) +=
+        grad->flat<T>();
+  }
+
+  void DivideAccumGradByCounter(OpKernelContext* ctx) override
+      TF_EXCLUSIVE_LOCKS_REQUIRED(this->mu_) {
+    Tensor c(DataTypeToEnum<T>::value, {});
+    c.scalar<T>()() = TypeConverter<T, int>::ConvertUToT(this->counter_);
+    this->accum_grad_.template flat<T>().device(
+        ctx->template eigen_device<Device>()) =
+        this->accum_grad_.template flat<T>() / c.scalar<T>()();
+  }
+
+  bool SetOutput(OpKernelContext* ctx) override {
+    ctx->set_output(0, accum_grad_);
+    return true;
+  }
+
+  bool GetAndValidateTensorInputForApplyGrad(OpKernelContext* ctx,
+                                             const Tensor** tensor) override
+      TF_EXCLUSIVE_LOCKS_REQUIRED(this->mu_) {
+    // Get input gradient tensor
+    const Tensor* grad_tensor;
+    OP_REQUIRES_OK_BOOLEAN(ctx, ctx->input("gradient", &grad_tensor));
+    *tensor = grad_tensor;
+    OP_REQUIRES_OK_BOOLEAN(ctx, this->ValidateShape(*tensor));
+    return true;
+  }
+
+  void CleanUpGradTensor(const Tensor* tensor) override {
+    // do nothing
+  }
+
+  ConditionalAccumulator(const ConditionalAccumulator&) = delete;
+  void operator=(const ConditionalAccumulator&) = delete;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_CONDITIONAL_ACCUMULATOR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/conditional_accumulator_base.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/conditional_accumulator_base.h
new file mode 100644
index 0000000000000000000000000000000000000000..2e2fa9c441a1cfb91df7c8066133fc7d2e373287
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/conditional_accumulator_base.h
@@ -0,0 +1,201 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_CONDITIONAL_ACCUMULATOR_BASE_H_
+#define TENSORFLOW_CORE_KERNELS_CONDITIONAL_ACCUMULATOR_BASE_H_
+
+#include <deque>
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/framework/numeric_op.h"
+
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/resource_mgr.h"
+
+namespace tensorflow {
+
+/**
+ * ConditionalAccumulator/ConditionalAccumulatorBase implements an aggregation
+ * object for adding gradients.
+ * The two main methods of this class are TryApplyGrad and TryTakeGrad.
+ *
+ * TryApplyGrad tries add a gradient to the accumulator. The attempt is
+ * successful if local_step >= global_step, i.e., if the gradient is not stale,
+ * having been computed using up-to-date information. Otherwise, the gradient is
+ * silently dropped.
+ *
+ * TryTakeGrad logs an attempt to read the average gradient. The attempt is
+ * blocked until the number of gradients accumulated (via TryApplyGrad) is equal
+ * or exceeds the number requested by TryTakeGrad.
+ * Once this condition is satisfied, the following actions are taken:
+ * (1) the value of the average gradient is returned
+ * (2) the count of accumulated gradients is reset to 0
+ * (3) the internal global_step value (current_global_step_) is incremented by 1
+ */
+class ConditionalAccumulatorBase : public ResourceBase {
+ public:
+  // Args:
+  //   dtype: The datatype of the gradients to be accumulated.
+  //   shape: The shape of the accumulated gradients.
+  //   name:  A name to use for the ConditionalAccumulator.
+  ConditionalAccumulatorBase(const DataType& dtype,
+                             const PartialTensorShape& shape,
+                             const string& name, const string& reduction_type);
+
+  typedef AsyncOpKernel::DoneCallback DoneCallback;
+
+  virtual void TryApplyGrad(int64_t local_step, OpKernelContext* ctx) = 0;
+  void TryTakeGrad(int num_required, OpKernelContext* ctx,
+                   DoneCallback callback);
+
+  // Accessor methods
+  uint32 num_accumulated() {
+    mutex_lock lock(mu_);
+    return counter_;
+  }
+
+  const DataType& dtype() const { return dtype_; }
+
+  string DebugString() const override { return "A conditional accumulator"; }
+
+  // SetGlobalStep is a modifier method for current_global_step.
+  // It returns an InvalidArgument error if the new_global_step is less than
+  // current_global_step.
+  Status SetGlobalStep(int64_t new_global_step);
+
+  Status MatchesNodeDef(const NodeDef& node_def);
+
+ protected:
+  // Virtual methods to be implemented by sub-classes for different datatypes.
+  // Implements arithmetic operations specific to datatype.
+  virtual void DivideAccumGradByCounter(OpKernelContext* ctx)
+      TF_EXCLUSIVE_LOCKS_REQUIRED(mu_) = 0;
+  virtual bool SetOutput(OpKernelContext* ctx) = 0;
+
+  enum RunResult { kNoProgress, kComplete };
+
+  // Helper struct holding information about a TakeGrad attempt
+  struct Attempt;
+  typedef std::function<RunResult(Attempt*)> RunCallback;
+  struct Attempt {
+    int elements_requested;
+    DoneCallback done_callback;  // must be run outside mu_
+    OpKernelContext* context;
+    CancellationManager* cancellation_manager;  // not owned
+    CancellationToken cancellation_token;
+    RunCallback run_callback;  // must be run while holding mu_
+    bool is_cancelled;
+
+    Attempt(int elements_requested, DoneCallback done_callback,
+            OpKernelContext* context, CancellationManager* cancellation_manager,
+            CancellationToken cancellation_token, RunCallback run_callback)
+        : elements_requested(elements_requested),
+          done_callback(std::move(done_callback)),
+          context(context),
+          cancellation_manager(cancellation_manager),
+          cancellation_token(cancellation_token),
+          run_callback(std::move(run_callback)),
+          is_cancelled(false) {}
+  };
+
+  // Helper struct for deregistration of a cancellation token and executing a
+  // DoneCallback after a TakeGrad attempt is complete.
+  struct CleanUp {
+    CleanUp(DoneCallback&& f, CancellationToken ct, CancellationManager* cm)
+        : finished(f), to_deregister(ct), cm(cm) {}
+    DoneCallback finished;
+    CancellationToken to_deregister;
+    CancellationManager* cm;
+  };
+
+  // Fields
+
+  const DataType dtype_;
+  const PartialTensorShape shape_;
+  const string name_;
+  const string reduction_type_;
+  mutex mu_;
+  int counter_ TF_GUARDED_BY(mu_);
+  int64_t current_global_step_ TF_GUARDED_BY(mu_);
+
+  std::deque<Attempt> takegrad_attempts_ TF_GUARDED_BY(mu_);
+
+  // Methods
+
+  // Helper function for creating cancellation callback
+  void Cancel(CancellationManager* cancellation_manager,
+              CancellationToken token);
+
+  // Helper functions to process TakeGrad attempts.
+  // FlushUnlocked is called at the end of each TryApplyGrad and TryTakeGrad
+  // calls to try to clear the TakeGrad attempts. This in turn calls
+  // TryAttemptLocked, which then executes the RunCallback of the logged
+  // attempts.
+  // Both functions are modeled after core/kernels/queue_base.
+  // Note: ApplyGrad attempts never block -- unlike in a queue with limited
+  //       capacity, we can always add the newest gradient to our accumulator
+  //       (if it is not stale) or drop it silently (if it is stale).
+  void FlushUnlocked();
+  bool TryAttemptLocked(std::vector<CleanUp>* clean_up)
+      TF_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+
+  // Helper methods
+  //  void DeepCopy(Tensor* dst);
+  bool TakeGradLockedHelper(OpKernelContext* ctx, DoneCallback callback)
+      TF_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+};
+
+/*
+ * Modifications to convenience macros defined in core/framework/op_kernel.h.
+ * The below macros return a boolean if the test fails, so that the calling
+ * function can get an indication that a failure has occurred.
+ */
+#define OP_REQUIRES_BOOLEAN(CTX, EXP, STATUS)          \
+  do {                                                 \
+    if (!TF_PREDICT_TRUE(EXP)) {                       \
+      (CTX)->CtxFailure(__FILE__, __LINE__, (STATUS)); \
+      return false;                                    \
+    }                                                  \
+  } while (0)
+
+#define OP_REQUIRES_OK_BOOLEAN(CTX, STATUS)                 \
+  do {                                                      \
+    ::tensorflow::Status _s(STATUS);                        \
+    if (!TF_PREDICT_TRUE(_s.ok())) {                        \
+      (CTX)->CtxFailureWithWarning(__FILE__, __LINE__, _s); \
+      return false;                                         \
+    }                                                       \
+  } while (0)
+
+/*
+ * Convenience classes for helping to convert between numeric types.
+ * The specialization for Eigen::half here simplifies specialization of
+ * ConditionalAccumulator classes later.
+ */
+template <typename T, typename U>
+class TypeConverter {
+ public:
+  static T ConvertUToT(U c) { return c; /* implicit conversion */ }
+};
+
+template <typename U>
+class TypeConverter<Eigen::half, U> {
+ public:
+  static Eigen::half ConvertUToT(U c) { return static_cast<Eigen::half>(c); }
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_CONDITIONAL_ACCUMULATOR_BASE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/conditional_accumulator_base_op.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/conditional_accumulator_base_op.h
new file mode 100644
index 0000000000000000000000000000000000000000..9acf1ca1e21817f54fa48c0b6055c9afb2d56211
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/conditional_accumulator_base_op.h
@@ -0,0 +1,262 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_CONDITIONAL_ACCUMULATOR_BASE_OP_H_
+#define TENSORFLOW_CORE_KERNELS_CONDITIONAL_ACCUMULATOR_BASE_OP_H_
+
+#define EIGEN_USE_THREADS
+
+#include "tensorflow/core/kernels/conditional_accumulator_base.h"
+
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/register_types.h"
+#include "tensorflow/core/framework/resource_mgr.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/tensor_shape.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/lib/core/errors.h"
+#include "tensorflow/core/platform/macros.h"
+#include "tensorflow/core/platform/mutex.h"
+#include "tensorflow/core/platform/thread_annotations.h"
+#include "tensorflow/core/platform/types.h"
+
+typedef Eigen::ThreadPoolDevice CPUDevice;
+
+typedef std::function<void()> DoneCallback;
+
+namespace tensorflow {
+
+/**
+ * Defines a ConditionalAccumulatorBaseOp, which constructs a
+ * ConditionalAccumulatorBase (via sub-class's Creator) and returns its handle.
+ */
+class ConditionalAccumulatorBaseOp : public OpKernel {
+ public:
+  explicit ConditionalAccumulatorBaseOp(OpKernelConstruction* context)
+      : OpKernel(context), accumulator_set_(false) {
+    OP_REQUIRES_OK(context, context->allocate_temp(DT_STRING, TensorShape({2}),
+                                                   &accumulator_));
+    OP_REQUIRES_OK(context, context->GetAttr("shape", &shape_));
+    OP_REQUIRES_OK(context, context->GetAttr("dtype", &dtype_));
+    OP_REQUIRES_OK(context,
+                   context->GetAttr("reduction_type", &reduction_type_));
+  }
+
+  void Compute(OpKernelContext* ctx) override {
+    mutex_lock l(mu_);
+    if (!accumulator_set_) {
+      OP_REQUIRES_OK(ctx, SetAccumulatorHandle(ctx));
+    }
+    SetHandleToOutput(ctx);
+  }
+
+ protected:
+  ~ConditionalAccumulatorBaseOp() override {
+    // If the accumulator object was not shared, delete it.
+    if (accumulator_set_ && cinfo_.resource_is_private_to_kernel()) {
+      TF_CHECK_OK((cinfo_.resource_manager()
+                       ->template Delete<ConditionalAccumulatorBase>(
+                           cinfo_.container(), cinfo_.name())));
+    }
+  }
+
+ protected:
+  virtual void SetHandleToOutput(OpKernelContext* ctx)
+      TF_SHARED_LOCKS_REQUIRED(mu_) = 0;
+
+  virtual Status CheckSignature(OpKernelContext* ctx) = 0;
+
+ protected:
+  typedef std::function<Status(ConditionalAccumulatorBase**)> Creator;
+
+  // Subclasses must override this
+  virtual Creator GetCreator() const = 0;
+
+  // Variables required to construct ConditionalAccumulator
+  DataType dtype_;
+  PartialTensorShape shape_;
+  ContainerInfo cinfo_;
+  string reduction_type_;
+  mutex mu_;
+  Tensor accumulator_ TF_GUARDED_BY(mu_);
+  bool accumulator_set_ TF_GUARDED_BY(mu_);
+
+ private:
+  Status SetAccumulatorHandle(OpKernelContext* ctx)
+      TF_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
+    TF_RETURN_IF_ERROR(cinfo_.Init(ctx->resource_manager(), def()));
+
+    // Check input signature
+    TF_RETURN_IF_ERROR(CheckSignature(ctx));
+
+    Creator creator = GetCreator();
+    ConditionalAccumulatorBase* accumulator;
+    TF_RETURN_IF_ERROR(
+        (cinfo_.resource_manager()
+             ->template LookupOrCreate<ConditionalAccumulatorBase>(
+                 cinfo_.container(), cinfo_.name(), &accumulator, creator)));
+    core::ScopedUnref unref_me(accumulator);
+
+    // Verify that the shared accumulator is compatible
+    // with the requested arguments.
+    TF_RETURN_IF_ERROR(accumulator->MatchesNodeDef(def()));
+    auto h = accumulator_.template flat<tstring>();
+    h(0) = cinfo_.container();
+    h(1) = cinfo_.name();
+    accumulator_set_ = true;
+    return OkStatus();
+  }
+};
+
+// ------------------Sync kernels ------------------------------------------
+
+/**
+ * General OpKernel for ConditionalAccumulatorBase-related ops.
+ */
+class ConditionalAccumulatorBaseSyncOpKernel : public OpKernel {
+ public:
+  explicit ConditionalAccumulatorBaseSyncOpKernel(OpKernelConstruction* context)
+      : OpKernel(context) {}
+
+  void Compute(OpKernelContext* ctx) final {
+    ConditionalAccumulatorBase* accumulator;
+    OP_REQUIRES_OK(ctx, GetResourceFromContext(ctx, "handle", &accumulator));
+    Compute(ctx, accumulator);
+    accumulator->Unref();
+  }
+
+ protected:
+  virtual void Compute(OpKernelContext* ctx,
+                       ConditionalAccumulatorBase* accumulator) = 0;
+
+  virtual DataTypeVector GetExpectedInputs(
+      ConditionalAccumulatorBase* accumulator) = 0;
+
+  virtual void CheckSignature(OpKernelContext* ctx,
+                              ConditionalAccumulatorBase* accumulator) {
+    // Check input signature
+    DataTypeVector expected_inputs = GetExpectedInputs(accumulator);
+    OP_REQUIRES_OK(ctx, ctx->MatchSignature(expected_inputs, {}));
+  }
+};
+
+/**
+ * Defines a AccumulateGradientOp, the execution of which adds a gradient to the
+ * given ConditionalAccumulator.
+ */
+class ConditionalAccumulatorBaseApplyGradientOp
+    : public ConditionalAccumulatorBaseSyncOpKernel {
+ public:
+  explicit ConditionalAccumulatorBaseApplyGradientOp(
+      OpKernelConstruction* context)
+      : ConditionalAccumulatorBaseSyncOpKernel(context) {}
+
+ protected:
+  void Compute(OpKernelContext* ctx,
+               ConditionalAccumulatorBase* accumulator) override {
+    // Check input signature
+    CheckSignature(ctx, accumulator);
+
+    // Get input local_step
+    const Tensor* local_step_tensor;
+    OP_REQUIRES_OK(ctx, ctx->input("local_step", &local_step_tensor));
+    if (!TensorShapeUtils::IsScalar(local_step_tensor->shape())) {
+      ctx->CtxFailureWithWarning(errors::InvalidArgument(
+          "Argument local_step must be scalar, but had bad shape ",
+          local_step_tensor->shape().DebugString()));
+    }
+
+    // Actually try to apply gradient now
+    accumulator->TryApplyGrad(local_step_tensor->scalar<int64_t>()(), ctx);
+  }
+};
+
+// -------------------- Async kernels --------------------------------------
+/**
+ * General OpKernel for ConditionalAccumulatorBase-related ops.
+ */
+class ConditionalAccumulatorBaseAsyncOpKernel : public AsyncOpKernel {
+ public:
+  explicit ConditionalAccumulatorBaseAsyncOpKernel(
+      OpKernelConstruction* context)
+      : AsyncOpKernel(context) {}
+
+  void ComputeAsync(OpKernelContext* ctx, DoneCallback callback) final {
+    ConditionalAccumulatorBase* accumulator;
+    OP_REQUIRES_OK_ASYNC(
+        ctx, GetResourceFromContext(ctx, "handle", &accumulator), callback);
+    ComputeAsync(ctx, accumulator, [callback, accumulator]() {
+      accumulator->Unref();
+      callback();
+    });
+  }
+
+ protected:
+  virtual void ComputeAsync(OpKernelContext* ctx,
+                            ConditionalAccumulatorBase* accumulator,
+                            DoneCallback callback) = 0;
+
+  virtual DataTypeVector GetExpectedInputs(
+      ConditionalAccumulatorBase* accumulator) = 0;
+
+  virtual void CheckSignature(OpKernelContext* ctx,
+                              ConditionalAccumulatorBase* accumulator,
+                              DoneCallback callback) {
+    // Check input signature
+    OP_REQUIRES_OK_ASYNC(ctx,
+                         ctx->MatchSignature(GetExpectedInputs(accumulator),
+                                             {accumulator->dtype()}),
+                         callback);
+  }
+};
+
+/**
+ * Defines a TakeAccumulatedGradientOp, the execution of which adds a gradient
+ * to the given ConditionalAccumulator.
+ */
+class ConditionalAccumulatorBaseTakeGradientOp
+    : public ConditionalAccumulatorBaseAsyncOpKernel {
+ public:
+  explicit ConditionalAccumulatorBaseTakeGradientOp(
+      OpKernelConstruction* context)
+      : ConditionalAccumulatorBaseAsyncOpKernel(context) {}
+
+ protected:
+  void ComputeAsync(OpKernelContext* ctx,
+                    ConditionalAccumulatorBase* accumulator,
+                    DoneCallback callback) override {
+    // Check signature
+    CheckSignature(ctx, accumulator, callback);
+
+    // Get input num_required
+    const Tensor* num_required_tensor;
+    OP_REQUIRES_OK_ASYNC(ctx, ctx->input("num_required", &num_required_tensor),
+                         callback);
+    if (!TensorShapeUtils::IsScalar(num_required_tensor->shape())) {
+      ctx->CtxFailureWithWarning(errors::InvalidArgument(
+          "Argument num_required must be scalar, but had bad shape ",
+          num_required_tensor->shape().DebugString()));
+      callback();
+    }
+
+    // Actually try to take gradient now
+    accumulator->TryTakeGrad(num_required_tensor->scalar<int32>()(), ctx,
+                             callback);
+  }
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_CONDITIONAL_ACCUMULATOR_BASE_OP_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/constant_op.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/constant_op.h
new file mode 100644
index 0000000000000000000000000000000000000000..32f1ddb7cfdba80beac2e4ba35bd02ca374b8e44
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/constant_op.h
@@ -0,0 +1,52 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_CONSTANT_OP_H_
+#define TENSORFLOW_CORE_KERNELS_CONSTANT_OP_H_
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/tensor_types.h"
+#include "tensorflow/core/platform/macros.h"
+
+namespace tensorflow {
+
+// ConstantOp returns a tensor specified by ConstantOpDef.
+class ConstantOp : public OpKernel {
+ public:
+  explicit ConstantOp(OpKernelConstruction* ctx);
+  void Compute(OpKernelContext* ctx) override;
+  bool IsExpensive() override { return false; }
+  const Tensor* const_tensor() const override { return &tensor_; };
+  ~ConstantOp() override;
+
+ private:
+  Tensor tensor_;
+  ConstantOp(const ConstantOp&) = delete;
+  void operator=(const ConstantOp&) = delete;
+};
+
+class PlaceholderOp : public OpKernel {
+ public:
+  explicit PlaceholderOp(OpKernelConstruction* ctx);
+  void Compute(OpKernelContext* ctx) override;
+
+ private:
+  PartialTensorShape expected_shape_;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_CONSTANT_OP_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/control_flow_ops.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/control_flow_ops.h
new file mode 100644
index 0000000000000000000000000000000000000000..138693178cf7567e14cda25e3436c40249b67140
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/control_flow_ops.h
@@ -0,0 +1,140 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_CONTROL_FLOW_OPS_H_
+#define TENSORFLOW_CORE_KERNELS_CONTROL_FLOW_OPS_H_
+
+#include "tensorflow/core/framework/op_kernel.h"
+
+namespace tensorflow {
+
+// A ControlTriggerOp is similar to a NoOp. However, it always treats the input
+// control edges as Live edges. Its primary use so far is in the scheduling of
+// recvs, where we add ControlTrigger nodes and use them to trigger recvs. We
+// allow ControlTrigger nodes to be enabled by dead nodes.
+class ControlTriggerOp : public OpKernel {
+ public:
+  explicit ControlTriggerOp(OpKernelConstruction* context)
+      : OpKernel(context) {}
+  void Compute(OpKernelContext* context) override {}
+  bool IsExpensive() override { return false; }
+};
+
+// A switch op has two inputs and two outputs. It forwards the value of
+// Input:0 to the output specified by input:1. Input:1 is a boolean tensor.
+// Input:0 is forwarded to output:0 if input:1 is false, otherwise to
+// output:1.
+class SwitchOp : public OpKernel {
+ public:
+  explicit SwitchOp(OpKernelConstruction* context) : OpKernel(context) {}
+  void Compute(OpKernelContext* context) override;
+  bool IsExpensive() override { return false; }
+  ~SwitchOp() override {}
+
+  SwitchOp(const SwitchOp&) = delete;
+  void operator=(const SwitchOp&) = delete;
+};
+
+// An n-way switch op has two inputs and N outputs. It forwards the value of
+// Input:0 to the output specified by Input:1. Input:1 is an integer tensor.
+// Input:0 is forwarded to output:0 if Input:1 is 0, to output:1 if 1, and so
+// forth. If Input:1 is <0 or >=num_outputs(), Input:0 is forwarded to
+// output:num_outputs()-1.
+class SwitchNOp : public OpKernel {
+ public:
+  explicit SwitchNOp(OpKernelConstruction* context) : OpKernel(context) {}
+  void Compute(OpKernelContext* context) override;
+  bool IsExpensive() override { return false; }
+  ~SwitchNOp() override {}
+
+  SwitchNOp(const SwitchNOp&) = delete;
+  void operator=(const SwitchNOp&) = delete;
+};
+
+// A merge op has n inputs and two outputs. It forwards the value of the
+// first input that becomes available to its first output, and the
+// index of the first input to its second output.
+class MergeOp : public OpKernel {
+ public:
+  explicit MergeOp(OpKernelConstruction* context);
+  void Compute(OpKernelContext* context) override;
+  bool IsExpensive() override { return false; }
+  ~MergeOp() override {}
+
+  MergeOp(const MergeOp&) = delete;
+  void operator=(const MergeOp&) = delete;
+};
+
+// An enter op has one input and one output. It creates or finds
+// the child frame that is uniquely identified by the frame_name,
+// and makes its input available to the child frame.
+class EnterOp : public OpKernel {
+ public:
+  explicit EnterOp(OpKernelConstruction* context) : OpKernel(context) {}
+  void Compute(OpKernelContext* context) override;
+  bool IsExpensive() override { return false; }
+  ~EnterOp() override {}
+
+  EnterOp(const EnterOp&) = delete;
+  void operator=(const EnterOp&) = delete;
+};
+
+// An exit op has one input and one output. It exits the current
+// frame to its parent frame, and makes its input available to the
+// parent frame.
+class ExitOp : public OpKernel {
+ public:
+  explicit ExitOp(OpKernelConstruction* context) : OpKernel(context) {}
+  void Compute(OpKernelContext* context) override;
+  bool IsExpensive() override { return false; }
+  ~ExitOp() override {}
+
+  ExitOp(const ExitOp&) = delete;
+  void operator=(const ExitOp&) = delete;
+};
+
+// A next_iteration op has one input and one output. It makes its input
+// available to the next iteration.
+class NextIterationOp : public OpKernel {
+ public:
+  explicit NextIterationOp(OpKernelConstruction* context) : OpKernel(context) {}
+  void Compute(OpKernelContext* context) override;
+  bool IsExpensive() override { return false; }
+  ~NextIterationOp() override {}
+
+  NextIterationOp(const NextIterationOp&) = delete;
+  void operator=(const NextIterationOp&) = delete;
+};
+
+// A LoopCond op has one input and one output. The input is a boolean
+// scalar representing the taken branches of the "pivot" Switch that
+// determines loop termination. As a contract, any high-level front-end
+// should always use port '0' of the "pivot" switches for loop exit.
+class LoopCondOp : public OpKernel {
+ public:
+  explicit LoopCondOp(OpKernelConstruction* context);
+  ~LoopCondOp() override;
+
+  void Compute(OpKernelContext* context) override;
+
+  bool IsExpensive() override;
+
+  LoopCondOp(const LoopCondOp&) = delete;
+  void operator=(const LoopCondOp&) = delete;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_CONTROL_FLOW_OPS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/conv_2d.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/conv_2d.h
new file mode 100644
index 0000000000000000000000000000000000000000..3354b6e0bad61ab47048bfa424a9e379cbdb2a05
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/conv_2d.h
@@ -0,0 +1,585 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_CONV_2D_H_
+#define TENSORFLOW_CORE_KERNELS_CONV_2D_H_
+
+#include "absl/strings/string_view.h"
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/framework/tensor_types.h"
+#include "tensorflow/core/kernels/eigen_backward_spatial_convolutions.h"
+#include "tensorflow/core/util/tensor_format.h"
+#include "tsl/framework/convolution/eigen_spatial_convolutions.h"
+
+// Returns true if TF_CONV2D_USE_FP16_ACCUMULATE == 1, false otherwise.
+static bool Conv2dUseFp16Accumulate() {
+  static bool use_fp16_accumulate = []() {
+    const char* env = std::getenv("TF_CONV2D_USE_FP16_ACCUMULATE");
+    return (env != nullptr) && (absl::string_view(env) == "1");
+  }();
+  return use_fp16_accumulate;
+}
+
+namespace tensorflow {
+namespace functor {
+
+template <typename Device, typename Input, typename Filter, typename Output,
+          typename OutputKernel>
+void SpatialConvolutionFunc(const Device& d, Output output, Input input,
+                            Filter filter, int row_stride, int col_stride,
+                            int row_dilation, int col_dilation,
+                            const Eigen::PaddingType& padding,
+                            const OutputKernel& output_kernel,
+                            int padding_top = 0, int padding_bottom = 0,
+                            int padding_left = 0, int padding_right = 0) {
+  // Need to swap row/col, padding_top/padding_left, and
+  // padding_bottom/padding_right when calling Eigen. Eigen expects the tensor
+  // in NWHC format, but the tensor given is in NHWC.
+  output.device(d) = Eigen::SpatialConvolution(
+      input, filter, col_stride, row_stride, padding, col_dilation,
+      row_dilation, output_kernel, padding_left, padding_right, padding_top,
+      padding_bottom);
+}
+
+// TODO(ezhulenev): Non-templated `operator()` are required by explicit template
+// instantiations for the GPU device. However they are almost certainly not used
+// in any of the kernel implementation. Check if they can be removed.
+template <typename Device, typename T,
+          typename OutputKernel = const Eigen::NoOpOutputKernel>
+struct SpatialConvolution {
+  void operator()(const Device& d, typename TTypes<T, 4>::Tensor output,
+                  typename TTypes<T, 4>::ConstTensor input,
+                  typename TTypes<T, 4>::ConstTensor filter, int row_stride,
+                  int col_stride, int row_dilation, int col_dilation,
+                  const Eigen::PaddingType& padding,
+                  const OutputKernel& output_kernel = OutputKernel()) {
+    SpatialConvolutionFunc(d, output, input, filter, row_stride, col_stride,
+                           row_dilation, col_dilation, padding, output_kernel);
+  }
+
+  template <typename Input, typename Filter, typename Output>
+  void operator()(const Device& d, Output output, Input input, Filter filter,
+                  int row_stride, int col_stride, int row_dilation,
+                  int col_dilation, const Eigen::PaddingType& padding,
+                  const OutputKernel& output_kernel = OutputKernel()) {
+    SpatialConvolutionFunc(d, output, input, filter, row_stride, col_stride,
+                           row_dilation, col_dilation, padding, output_kernel);
+  }
+
+  void operator()(const Device& d, typename TTypes<T, 4>::Tensor output,
+                  typename TTypes<T, 4>::ConstTensor input,
+                  typename TTypes<T, 4>::ConstTensor filter, int row_stride,
+                  int col_stride, int row_dilation, int col_dilation,
+                  int padding_top, int padding_bottom, int padding_left,
+                  int padding_right,
+                  const OutputKernel& output_kernel = OutputKernel()) {
+    SpatialConvolutionFunc(
+        d, output, input, filter, row_stride, col_stride, row_dilation,
+        col_dilation, Eigen::PaddingType::PADDING_VALID, output_kernel,
+        padding_top, padding_bottom, padding_left, padding_right);
+  }
+
+  template <typename Input, typename Filter, typename Output>
+  void operator()(const Device& d, Output output, Input input, Filter filter,
+                  int row_stride, int col_stride, int row_dilation,
+                  int col_dilation, int padding_top, int padding_bottom,
+                  int padding_left, int padding_right,
+                  const OutputKernel& output_kernel = OutputKernel()) {
+    SpatialConvolutionFunc(
+        d, output, input, filter, row_stride, col_stride, row_dilation,
+        col_dilation, Eigen::PaddingType::PADDING_VALID, output_kernel,
+        padding_top, padding_bottom, padding_left, padding_right);
+  }
+};
+
+template <typename Device, typename OutputKernel>
+struct SpatialConvolution<Device, Eigen::half, OutputKernel> {
+  void operator()(const Device& d,
+                  typename TTypes<Eigen::half, 4>::Tensor output,
+                  typename TTypes<Eigen::half, 4>::ConstTensor input,
+                  typename TTypes<Eigen::half, 4>::ConstTensor filter,
+                  int row_stride, int col_stride, int row_dilation,
+                  int col_dilation, const Eigen::PaddingType& padding,
+                  const OutputKernel& output_kernel = OutputKernel()) {
+    if (Conv2dUseFp16Accumulate()) {
+      output.device(d) = Eigen::SpatialConvolution(
+          input, filter, col_stride, row_stride, padding, col_dilation,
+          row_dilation, output_kernel);
+    } else {
+      output.device(d) =
+          Eigen::SpatialConvolution(input.cast<float>(), filter.cast<float>(),
+                                    col_stride, row_stride, padding,
+                                    col_dilation, row_dilation, output_kernel)
+              .template cast<Eigen::half>();
+    }
+  }
+
+  template <typename Input, typename Filter, typename Output>
+  void operator()(const Device& d, Output output, Input input, Filter filter,
+                  int row_stride, int col_stride, int row_dilation,
+                  int col_dilation, const Eigen::PaddingType& padding,
+                  const OutputKernel& output_kernel = OutputKernel()) {
+    if (Conv2dUseFp16Accumulate()) {
+      output.device(d) = Eigen::SpatialConvolution(
+          input, filter, col_stride, row_stride, padding, col_dilation,
+          row_dilation, output_kernel);
+    } else {
+      output.device(d) =
+          Eigen::SpatialConvolution(input.template cast<float>(),
+                                    filter.template cast<float>(), col_stride,
+                                    row_stride, padding, col_dilation,
+                                    row_dilation, output_kernel)
+              .template cast<Eigen::half>();
+    }
+  }
+
+  void operator()(const Device& d,
+                  typename TTypes<Eigen::half, 4>::Tensor output,
+                  typename TTypes<Eigen::half, 4>::ConstTensor input,
+                  typename TTypes<Eigen::half, 4>::ConstTensor filter,
+                  int row_stride, int col_stride, int row_dilation,
+                  int col_dilation, int padding_top, int padding_bottom,
+                  int padding_left, int padding_right,
+                  const OutputKernel& output_kernel = OutputKernel()) {
+    if (Conv2dUseFp16Accumulate()) {
+      output.device(d) = Eigen::SpatialConvolution(
+          input, filter, col_stride, row_stride,
+          Eigen::PaddingType::PADDING_VALID, col_dilation, row_dilation,
+          output_kernel, padding_left, padding_right, padding_top,
+          padding_bottom);
+    } else {
+      output.device(d) =
+          Eigen::SpatialConvolution(
+              input.cast<float>(), filter.cast<float>(), col_stride, row_stride,
+              Eigen::PaddingType::PADDING_VALID, col_dilation, row_dilation,
+              output_kernel, padding_left, padding_right, padding_top,
+              padding_bottom)
+              .template cast<Eigen::half>();
+    }
+  }
+
+  template <typename Input, typename Filter, typename Output>
+  void operator()(const Device& d, Output output, Input input, Filter filter,
+                  int row_stride, int col_stride, int row_dilation,
+                  int col_dilation, int padding_top, int padding_bottom,
+                  int padding_left, int padding_right,
+                  const OutputKernel& output_kernel = OutputKernel()) {
+    if (Conv2dUseFp16Accumulate()) {
+      output.device(d) = Eigen::SpatialConvolution(
+          input, filter, col_stride, row_stride,
+          Eigen::PaddingType::PADDING_VALID, col_dilation, row_dilation,
+          output_kernel, padding_left, padding_right, padding_top,
+          padding_bottom);
+    } else {
+      output.device(d) =
+          Eigen::SpatialConvolution(
+              input.template cast<float>(), filter.template cast<float>(),
+              col_stride, row_stride, Eigen::PaddingType::PADDING_VALID,
+              col_dilation, row_dilation, output_kernel, padding_left,
+              padding_right, padding_top, padding_bottom)
+              .template cast<Eigen::half>();
+    }
+  }
+};
+
+// Use float32 accumulation for bfloat16 to deal with precision accumulation
+// issues.
+template <typename Device, typename OutputKernel>
+struct SpatialConvolution<Device, Eigen::bfloat16, OutputKernel> {
+  void operator()(const Device& d,
+                  typename TTypes<Eigen::bfloat16, 4>::Tensor output,
+                  typename TTypes<Eigen::bfloat16, 4>::ConstTensor input,
+                  typename TTypes<Eigen::bfloat16, 4>::ConstTensor filter,
+                  int row_stride, int col_stride, int row_dilation,
+                  int col_dilation, const Eigen::PaddingType& padding,
+                  const OutputKernel& output_kernel = OutputKernel()) {
+    output.device(d) =
+        Eigen::SpatialConvolution(input.cast<float>(), filter.cast<float>(),
+                                  col_stride, row_stride, padding, col_dilation,
+                                  row_dilation, output_kernel)
+            .template cast<Eigen::bfloat16>();
+  }
+
+  template <typename Input, typename Filter, typename Output>
+  void operator()(const Device& d, Output output, Input input, Filter filter,
+                  int row_stride, int col_stride, int row_dilation,
+                  int col_dilation, const Eigen::PaddingType& padding,
+                  const OutputKernel& output_kernel = OutputKernel()) {
+    output.device(d) =
+        Eigen::SpatialConvolution(input.template cast<float>(),
+                                  filter.template cast<float>(), col_stride,
+                                  row_stride, padding, col_dilation,
+                                  row_dilation, output_kernel)
+            .template cast<Eigen::bfloat16>();
+  }
+
+  void operator()(const Device& d,
+                  typename TTypes<Eigen::bfloat16, 4>::Tensor output,
+                  typename TTypes<Eigen::bfloat16, 4>::ConstTensor input,
+                  typename TTypes<Eigen::bfloat16, 4>::ConstTensor filter,
+                  int row_stride, int col_stride, int row_dilation,
+                  int col_dilation, int padding_top, int padding_bottom,
+                  int padding_left, int padding_right,
+                  const OutputKernel& output_kernel = OutputKernel()) {
+    output.device(d) =
+        Eigen::SpatialConvolution(
+            input.cast<float>(), filter.cast<float>(), col_stride, row_stride,
+            Eigen::PaddingType::PADDING_VALID, col_dilation, row_dilation,
+            output_kernel, padding_left, padding_right, padding_top,
+            padding_bottom)
+            .template cast<Eigen::bfloat16>();
+  }
+
+  template <typename Input, typename Filter, typename Output>
+  void operator()(const Device& d, Output output, Input input, Filter filter,
+                  int row_stride, int col_stride, int row_dilation,
+                  int col_dilation, int padding_top, int padding_bottom,
+                  int padding_left, int padding_right,
+                  const OutputKernel& output_kernel = OutputKernel()) {
+    output.device(d) =
+        Eigen::SpatialConvolution(
+            input.template cast<float>(), filter.template cast<float>(),
+            col_stride, row_stride, Eigen::PaddingType::PADDING_VALID,
+            col_dilation, row_dilation, output_kernel, padding_left,
+            padding_right, padding_top, padding_bottom)
+            .template cast<Eigen::bfloat16>();
+  }
+};
+
+template <typename Device, typename T>
+struct SpatialConvolutionBackwardInputFunc {
+  void operator()(const Device& d, typename TTypes<T, 4>::Tensor input_backward,
+                  typename TTypes<T, 4>::ConstTensor filter,
+                  typename TTypes<T, 4>::ConstTensor output_backward,
+                  Eigen::DenseIndex col_stride, Eigen::DenseIndex row_stride,
+                  Eigen::DenseIndex col_dilation,
+                  Eigen::DenseIndex row_dilation) {
+    input_backward.device(d) = Eigen::SpatialConvolutionBackwardInput(
+        filter, output_backward, input_backward.dimension(2),
+        input_backward.dimension(1), col_stride, row_stride, col_dilation,
+        row_dilation);
+  }
+};
+
+// GPU version requires all tensors to be indexable by int32.
+template <typename T>
+struct SpatialConvolutionBackwardInputFunc<Eigen::GpuDevice, T> {
+  void operator()(const Eigen::GpuDevice& d,
+                  typename TTypes<T, 4>::Tensor input_backward,
+                  typename TTypes<T, 4>::ConstTensor filter,
+                  typename TTypes<T, 4>::ConstTensor output_backward,
+                  Eigen::DenseIndex col_stride, Eigen::DenseIndex row_stride,
+                  Eigen::DenseIndex col_dilation,
+                  Eigen::DenseIndex row_dilation) {
+    To32Bit(input_backward).device(d) = Eigen::SpatialConvolutionBackwardInput(
+        To32Bit(filter), To32Bit(output_backward), input_backward.dimension(2),
+        input_backward.dimension(1), col_stride, row_stride, col_dilation,
+        row_dilation);
+  }
+};
+
+template <typename Device, typename T>
+struct SpatialConvolutionBackwardInputWithExplicitPaddingFunc {
+  void operator()(const Device& d, typename TTypes<T, 4>::Tensor input_backward,
+                  typename TTypes<T, 4>::ConstTensor filter,
+                  typename TTypes<T, 4>::ConstTensor output_backward,
+                  Eigen::DenseIndex padded_cols, Eigen::DenseIndex padded_rows,
+                  Eigen::DenseIndex col_stride, Eigen::DenseIndex row_stride,
+                  Eigen::DenseIndex col_dilation,
+                  Eigen::DenseIndex row_dilation, Eigen::DenseIndex pad_left,
+                  Eigen::DenseIndex pad_top) {
+    // We have to slice the result of a spatial convolution backward
+    // input, before assigning it to the `input_backward` to remove padding.
+    //
+    // TODO(ezhulenev): Pass explicit paddings to Eigen and do not materialize
+    // intermediate result in memory before slicing.
+    input_backward.device(d) =
+        Eigen::SpatialConvolutionBackwardInput(
+            filter, output_backward, padded_cols, padded_rows, col_stride,
+            row_stride, col_dilation, row_dilation)
+            .eval()
+            .slice(Eigen::DSizes<Eigen::DenseIndex, 4>{0, pad_left, pad_top, 0},
+                   input_backward.dimensions());
+  }
+};
+
+// GPU version requires all tensors to be indexable by int32.
+template <typename T>
+struct SpatialConvolutionBackwardInputWithExplicitPaddingFunc<Eigen::GpuDevice,
+                                                              T> {
+  void operator()(const Eigen::GpuDevice& d,
+                  typename TTypes<T, 4>::Tensor input_backward,
+                  typename TTypes<T, 4>::ConstTensor filter,
+                  typename TTypes<T, 4>::ConstTensor output_backward,
+                  Eigen::DenseIndex padded_cols, Eigen::DenseIndex padded_rows,
+                  Eigen::DenseIndex col_stride, Eigen::DenseIndex row_stride,
+                  Eigen::DenseIndex col_dilation,
+                  Eigen::DenseIndex row_dilation, Eigen::DenseIndex pad_left,
+                  Eigen::DenseIndex pad_top) {
+    To32Bit(input_backward).device(d) =
+        Eigen::SpatialConvolutionBackwardInput(
+            To32Bit(filter), To32Bit(output_backward), padded_cols, padded_rows,
+            col_stride, row_stride, col_dilation, row_dilation)
+            .eval()
+            .slice(Eigen::DSizes<Eigen::DenseIndex, 4>{0, pad_left, pad_top, 0},
+                   input_backward.dimensions());
+  }
+};
+
+// TODO(vrv): Figure out how to use the MatMulFunctor in matmul_op.h.
+// My initial attempt to do this compiled but failed in the pytest
+// due to a swigdeps error.
+template <typename Device, typename T,
+          typename OutputKernel = const Eigen::NoOpOutputKernel>
+struct MatMulConvFunctor {
+  // Computes on device "d": out = in0 * in1, where * is matrix
+  // multiplication.
+  void operator()(
+      const Device& d, typename TTypes<T, 2>::Tensor out,
+      typename TTypes<T, 2>::ConstTensor in0,
+      typename TTypes<T, 2>::ConstTensor in1,
+      const Eigen::array<Eigen::IndexPair<Eigen::DenseIndex>, 1>& dim_pair,
+      const OutputKernel& output_kernel = OutputKernel()) {
+    out.device(d) = in0.contract(in1, dim_pair, output_kernel);
+  }
+};
+
+// Use float32 accumulation for float16 by default to deal with precision
+// accumulation issues.  To enable float16 accumulation, set the environment
+// variable TF_CONV2D_USE_FP16_ACCUMULATE.
+template <typename Device, typename OutputKernel>
+struct MatMulConvFunctor<Device, Eigen::half, OutputKernel> {
+  // Computes on device "d": out = in0 * in1, where * is matrix
+  // multiplication.
+  void operator()(
+      const Device& d, typename TTypes<Eigen::half, 2>::Tensor out,
+      typename TTypes<Eigen::half, 2>::ConstTensor in0,
+      typename TTypes<Eigen::half, 2>::ConstTensor in1,
+      const Eigen::array<Eigen::IndexPair<Eigen::DenseIndex>, 1>& dim_pair,
+      const OutputKernel& output_kernel = OutputKernel()) {
+    if (Conv2dUseFp16Accumulate()) {
+      out.device(d) = in0.contract(in1, dim_pair, output_kernel);
+    } else {
+      out.device(d) =
+          in0.cast<float>()
+              .contract(in1.template cast<float>(), dim_pair, output_kernel)
+              .template cast<Eigen::half>();
+    }
+  }
+};
+
+// Use float32 accumulation for bfloat16 to deal with precision accumulation
+// issues.
+template <typename Device, typename OutputKernel>
+struct MatMulConvFunctor<Device, Eigen::bfloat16, OutputKernel> {
+  void operator()(
+      const Device& d, typename TTypes<Eigen::bfloat16, 2>::Tensor out,
+      typename TTypes<Eigen::bfloat16, 2>::ConstTensor in0,
+      typename TTypes<Eigen::bfloat16, 2>::ConstTensor in1,
+      const Eigen::array<Eigen::IndexPair<Eigen::DenseIndex>, 1>& dim_pair,
+      const OutputKernel& output_kernel = OutputKernel()) {
+    out.device(d) = in0.cast<float>()
+                        .contract(in1.cast<float>(), dim_pair, output_kernel)
+                        .template cast<Eigen::bfloat16>();
+  }
+};
+
+// Shuffles a filter tensor from TensorFlow format HWIO to dst_filter_format.
+//
+// Note: Currently supports OIHW and OHWI destination formats.
+template <typename Device, typename T, typename IndexType, int NDIMS>
+struct TransformFilter {
+  void operator()(const Device& d, FilterTensorFormat dst_filter_format,
+                  typename TTypes<T, NDIMS, IndexType>::ConstTensor in,
+                  typename TTypes<T, NDIMS, IndexType>::Tensor out) {
+    // NOTE: Source filter format is always HWIO.
+    Eigen::DSizes<IndexType, NDIMS - 2> spatial_dims;
+    for (int i = 0; i < spatial_dims.rank(); ++i) {
+      spatial_dims[i] = in.dimension(i);
+    }
+
+    // Merge the spatial dimensions together to speed up the shuffle operation.
+    Eigen::DSizes<IndexType, 3> merged_dims;
+    merged_dims[0] = spatial_dims.TotalSize();  // product of spatial dims [H*W]
+    merged_dims[1] = in.dimension(NDIMS - 2);   // input filters           [I]
+    merged_dims[2] = in.dimension(NDIMS - 1);   // output filters          [O]
+
+    // Shuffle tensor with merged spatial dimensions.
+    Eigen::DSizes<IndexType, 3> shuffling_perm;
+    // Expand shuffled tensor into final dimensions.
+    Eigen::DSizes<IndexType, NDIMS> expanded_dims;
+
+    if (dst_filter_format == FORMAT_OIHW) {
+      shuffling_perm = Eigen::DSizes<IndexType, 3>(2, 1, 0);
+
+      expanded_dims[0] = merged_dims[2];  // [O]
+      expanded_dims[1] = merged_dims[1];  // [I]
+      for (int i = 0; i < spatial_dims.rank(); ++i) {
+        expanded_dims[2 + i] = spatial_dims[i];
+      }
+
+    } else if (dst_filter_format == FORMAT_OHWI) {
+      shuffling_perm = Eigen::DSizes<IndexType, 3>(2, 0, 1);
+
+      expanded_dims[0] = merged_dims[2];          // [O]
+      expanded_dims[NDIMS - 1] = merged_dims[1];  // [I]
+      for (int i = 0; i < spatial_dims.rank(); ++i) {
+        expanded_dims[1 + i] = spatial_dims[i];
+      }
+
+    } else {
+      DCHECK(false) << "Unsupported destination filter format: "
+                    << ToString(dst_filter_format);
+    }
+
+    out.device(d) =
+        in.reshape(merged_dims).shuffle(shuffling_perm).reshape(expanded_dims);
+  }
+};
+
+// TODO This functor is not used anywhere and should be removed,
+// but it defines some eigen templates that are referenced in other kernels.
+template <typename Device, typename T, typename IndexType>
+struct TransformDepth {
+  void operator()(const Device& d,
+                  typename TTypes<T, 4, IndexType>::ConstTensor in,
+                  const Eigen::DSizes<IndexType, 4>& shuffle,
+                  typename TTypes<T, 4, IndexType>::Tensor out) {
+    Eigen::DSizes<IndexType, 3> merged_dims;
+    Eigen::DSizes<IndexType, 4> expanded_dims;
+    Eigen::DSizes<IndexType, 3> new_shuffle;
+
+    // Merge dimensions that won't be shuffled together to speed things up.
+    if (shuffle[1] == 2 && shuffle[2] == 3) {
+      merged_dims[0] = in.dimension(0);
+      merged_dims[1] = in.dimension(1);
+      merged_dims[2] = in.dimension(2) * in.dimension(3);
+      new_shuffle[0] = shuffle[0];
+      new_shuffle[1] = 2;
+      new_shuffle[2] = shuffle[3];
+      expanded_dims[0] = in.dimension(shuffle[0]);
+      expanded_dims[1] = in.dimension(2);
+      expanded_dims[2] = in.dimension(3);
+      expanded_dims[3] = in.dimension(shuffle[3]);
+    } else if (shuffle[0] == 2 && shuffle[1] == 3) {
+      merged_dims[0] = in.dimension(0);
+      merged_dims[1] = in.dimension(1);
+      merged_dims[2] = in.dimension(2) * in.dimension(3);
+      new_shuffle[0] = 2;
+      new_shuffle[1] = shuffle[2];
+      new_shuffle[2] = shuffle[3];
+      expanded_dims[0] = in.dimension(2);
+      expanded_dims[1] = in.dimension(3);
+      expanded_dims[2] = in.dimension(shuffle[2]);
+      expanded_dims[3] = in.dimension(shuffle[3]);
+    } else if (shuffle[0] == 0 && shuffle[1] == 3 && shuffle[2] == 1 &&
+               shuffle[3] == 2) {
+      merged_dims[0] = in.dimension(0);
+      merged_dims[1] = in.dimension(1) * in.dimension(2);
+      merged_dims[2] = in.dimension(3);
+      new_shuffle[0] = 0;
+      new_shuffle[1] = 2;
+      new_shuffle[2] = 1;
+      expanded_dims[0] = in.dimension(0);
+      expanded_dims[1] = in.dimension(3);
+      expanded_dims[2] = in.dimension(1);
+      expanded_dims[3] = in.dimension(2);
+    } else {
+      assert(false && "unexpected shuffle");
+    }
+
+    out.device(d) =
+        in.reshape(merged_dims).shuffle(new_shuffle).reshape(expanded_dims);
+  }
+};
+
+template <typename Device, typename T, typename IndexType, int NDIMS>
+struct PadInput {
+  void operator()(const Device& d,
+                  typename TTypes<T, NDIMS, IndexType>::ConstTensor in,
+                  const std::array<int, NDIMS - 2>& padding_left,
+                  const std::array<int, NDIMS - 2>& padding_right,
+                  typename TTypes<T, NDIMS, IndexType>::Tensor out,
+                  TensorFormat format, const T& padding_value) {
+    Eigen::array<Eigen::IndexPair<IndexType>, NDIMS> padding;
+    padding[GetTensorDimIndex<NDIMS - 2>(format, 'N')] = {0, 0};
+    for (int i = 0; i < NDIMS - 2; ++i) {
+      padding[GetTensorDimIndex<NDIMS - 2>(format, '0' + i)] = {
+          padding_left[i], padding_right[i]};
+    }
+    padding[GetTensorDimIndex<NDIMS - 2>(format, 'C')] = {0, 0};
+    out.device(d) = in.pad(padding, padding_value);
+  }
+};
+
+// Converts a tensor from:
+//   [batch, <spatial>, filters]
+// to:
+//   [batch, filters, <spatial>]
+template <typename Device, typename T, int NDIMS>
+struct NHWCToNCHW {
+  void operator()(const Device& d, typename TTypes<T, NDIMS>::ConstTensor in,
+                  typename TTypes<T, NDIMS>::Tensor out);
+};
+
+// Converts a tensor from:
+//   [batch, filters, <spatial>]
+// to:
+//   [batch, <spatial>, filters]
+template <typename Device, typename T, int NDIMS>
+struct NCHWToNHWC {
+  void operator()(const Device& d, typename TTypes<T, NDIMS>::ConstTensor in,
+                  typename TTypes<T, NDIMS>::Tensor out);
+};
+
+// Converts a tensor from:
+//   [dim0, dim1, dim2]
+// to:
+//   [dim0, dim2, dim1]
+template <typename Device, typename T, bool conjugate = false>
+struct SwapDimension1And2InTensor3 {
+  void operator()(const Device& d, const T* in,
+                  const gtl::ArraySlice<int64_t>& input_dims, T* out);
+};
+
+// Converts a tensor from:
+//   [dim0, dim1, dim2]
+// to:
+//   [dim2, dim1, dim0]
+template <typename Device, typename T, bool conjugate = false>
+struct SwapDimension0And2InTensor3 {
+  void operator()(const Device& d, const T* in,
+                  const gtl::ArraySlice<int64_t>& input_dims, T* out);
+};
+
+// Transforms back filter from OIHW or OHWI to HWOI format to reverse effect of
+// TransformFilter above.
+template <typename Device, typename T, int NDIMS>
+struct ReverseTransformFilter {
+  void operator()(const Device& d, FilterTensorFormat src_filter_format,
+                  typename TTypes<T, NDIMS>::ConstTensor in,
+                  typename TTypes<T, NDIMS>::Tensor out);
+};
+
+}  // namespace functor
+
+template <class T>
+class ConvAlgorithmMap;
+
+template <>
+class ConvAlgorithmMap<Eigen::ThreadPoolDevice> {};
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_CONV_2D_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/conv_2d_gpu.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/conv_2d_gpu.h
new file mode 100644
index 0000000000000000000000000000000000000000..60d2e83194eefa9fa6f7d27ee4c67a80a9fda894
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/conv_2d_gpu.h
@@ -0,0 +1,1147 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_CONV_2D_GPU_H_
+#define TENSORFLOW_CORE_KERNELS_CONV_2D_GPU_H_
+
+#if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+
+#define EIGEN_USE_GPU
+
+#include <algorithm>
+#include <array>
+#include <limits>
+#include <utility>
+
+#if GOOGLE_CUDA
+#include "third_party/gpus/cuda/include/cuda.h"
+#endif
+#include "tensorflow/core/framework/register_types.h"
+#include "tensorflow/core/kernels/conv_2d.h"
+#include "tensorflow/core/lib/math/math_util.h"
+#include "tensorflow/core/util/gpu_kernel_helper.h"
+#include "tensorflow/core/util/tensor_format.h"
+
+namespace tensorflow {
+
+typedef Eigen::GpuDevice GPUDevice;
+
+namespace functor {
+
+template <typename T, bool conjugate>
+struct maybe_conj {
+  __device__ static __inline__ T run(T x) {
+    if (conjugate) {
+      return Eigen::numext::conj(x);
+    } else {
+      return x;
+    }
+  }
+};
+
+// Partial specializations for Gpu types used to store complex numbers.
+template <bool conjugate>
+struct maybe_conj<float2, conjugate> {
+  __device__ static __inline__ float2 run(float2 c) {
+    if (conjugate) {
+      float2 c_conj;
+      c_conj.x = c.x;
+      c_conj.y = -c.y;
+      return c_conj;
+    } else {
+      return c;
+    }
+  }
+};
+
+template <bool conjugate>
+struct maybe_conj<double2, conjugate> {
+  __device__ static __inline__ double2 run(double2 c) {
+    if (conjugate) {
+      double2 c_conj;
+      c_conj.x = c.x;
+      c_conj.y = -c.y;
+      return c_conj;
+    } else {
+      return c;
+    }
+  }
+};
+
+// TODO(mjanusz): Move this to a shared util file.
+// A simple array that contains data that can be passed between CPU and GPU.
+template <typename T, int IndexCount, T DefaultValue>
+struct Array {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const T& operator[](int index) const {
+    return data[index];
+  }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T& operator[](int index) {
+    return data[index];
+  }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Array() {
+    for (int i = 0; i < IndexCount; i++) {
+      data[i] = DefaultValue;
+    }
+  }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Array(T a0) {
+    data[0] = a0;
+    for (int i = 1; i < IndexCount; i++) {
+      data[i] = DefaultValue;
+    }
+  }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Array(T a0, T a1) {
+    data[0] = a0;
+    data[1] = a1;
+    for (int i = 2; i < IndexCount; i++) {
+      data[i] = DefaultValue;
+    }
+  }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Array(T a0, T a1, T a2) {
+    data[0] = a0;
+    data[1] = a1;
+    data[2] = a2;
+    for (int i = 3; i < IndexCount; i++) {
+      data[i] = DefaultValue;
+    }
+  }
+  EIGEN_STRONG_INLINE Array(const std::array<T, IndexCount>& array) {
+    for (int i = 0; i < IndexCount; i++) {
+      data[i] = array[i];
+    }
+  }
+  T data[IndexCount];
+};
+
+// A dimension type with compile-time known size.
+template <int IndexCount>
+struct Dimension : Array<int, IndexCount, 1> {
+  typedef Array<int, IndexCount, 1> Base;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Dimension() : Base() {}
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Dimension(int a0) : Base(a0) {}
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Dimension(int a0, int a1)
+      : Base(a0, a1) {}
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Dimension(int a0, int a1, int a2)
+      : Base(a0, a1, a2) {}
+  EIGEN_STRONG_INLINE Dimension(const std::array<int, IndexCount>& array)
+      : Base(array) {}
+};
+
+// An index type with compile-time known size.
+template <int IndexCount>
+struct Index : Array<int, IndexCount, 0> {
+  typedef Array<int, IndexCount, 0> Base;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index() : Base() {}
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index(int a0) : Base(a0) {}
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index(int a0, int a1) : Base(a0, a1) {}
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index(int a0, int a1, int a2)
+      : Base(a0, a1, a2) {}
+};
+
+// A helper function that converts a tensor index into a flat array index.
+template <int IndexCount>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE int TensorIndexToFlat(
+    const Index<IndexCount>& index, const Dimension<IndexCount>& dims) {
+  int flat_index = index[0];
+  for (int i = 1; i < IndexCount; i++) {
+    flat_index = flat_index * dims[i] + index[i];
+  }
+  return flat_index;
+}
+
+// A helper function that converts a flat array index into a tensor index.
+template <int IndexCount>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index<IndexCount> FlatToTensorIndex(
+    int index, const Dimension<IndexCount>& dims) {
+  Index<IndexCount> tensor_index;
+  for (int i = IndexCount - 1; i >= 0; i--) {
+    int new_index = index / dims[i];
+    tensor_index[i] = index - dims[i] * new_index;
+    index = new_index;
+  }
+  return tensor_index;
+}
+
+// A simple CUDA custom kernel to shuffle dimensions of a 3D tensor according to
+// the given shuffle permutation in template parameters. Shuffle permutation
+// <sp0, sp1, sp2> shuffles dimensions such that input dimension 0 goes to sp0,
+// 1 goes to sp1 and 2 goes to sp2. For example, shuffle permutation <2, 0, 1>
+// will populate output so that input[x][y][z] is equal to (*output)[y][z][x].
+//
+// Requires that nthreads is equal to the total number of elements in the input
+// tensor.
+template <typename T, int sp0, int sp1, int sp2, bool conjugate = false>
+__global__ void ShuffleInTensor3Simple(int nthreads,
+                                       const T* __restrict__ input,
+                                       Dimension<3> input_dims,
+                                       T* __restrict__ output) {
+  Dimension<3> output_dims;
+  output_dims[sp0] = input_dims[0];
+  output_dims[sp1] = input_dims[1];
+  output_dims[sp2] = input_dims[2];
+
+  // Iterate over output as opposed to iterating over input for better
+  // performance. Iterating over output will generate sequential writes and
+  // random reads that performs better compared to sequential reads and random
+  // writes.
+  GPU_1D_KERNEL_LOOP(output_index, nthreads) {
+    Index<3> output_tensor_index = FlatToTensorIndex(output_index, output_dims);
+
+    Index<3> input_tensor_index;
+    input_tensor_index[0] = output_tensor_index[sp0];
+    input_tensor_index[1] = output_tensor_index[sp1];
+    input_tensor_index[2] = output_tensor_index[sp2];
+
+    int input_index = TensorIndexToFlat(input_tensor_index, input_dims);
+
+    output[output_index] =
+        maybe_conj<T, conjugate>::run(ldg(input + input_index));
+  }
+}
+
+static constexpr int kUnroll = 4;
+
+template <typename T, int sp0, int sp1, int sp2, bool conjugate = false>
+__global__ void ShuffleInTensor3SimpleVector(int nthreads,
+                                             const T* __restrict__ input,
+                                             Dimension<3> input_dims,
+                                             T* __restrict__ output) {
+  Dimension<3> output_dims;
+  output_dims[sp0] = input_dims[0];
+  output_dims[sp1] = input_dims[1];
+  output_dims[sp2] = input_dims[2];
+
+  const int stride = blockDim.x * gridDim.x * kUnroll;
+  const int tid = blockIdx.x * blockDim.x + threadIdx.x;
+  T buf[kUnroll];
+
+  int output_index;
+  for (output_index = tid * kUnroll; output_index + kUnroll - 1 < nthreads;
+       output_index += stride) {
+#pragma unroll
+    for (int i = 0; i < kUnroll; i++) {
+      int output_index_i = output_index + i;
+      Index<3> output_tensor_index =
+          FlatToTensorIndex(output_index_i, output_dims);
+      Index<3> input_tensor_index;
+      input_tensor_index[0] = output_tensor_index[sp0];
+      input_tensor_index[1] = output_tensor_index[sp1];
+      input_tensor_index[2] = output_tensor_index[sp2];
+
+      int input_index_i = TensorIndexToFlat(input_tensor_index, input_dims);
+      buf[i] = maybe_conj<T, conjugate>::run(ldg(input + input_index_i));
+    }
+    float2* out = reinterpret_cast<float2*>(output + output_index);
+    *out = *reinterpret_cast<float2*>(buf);
+  }
+
+  for (; output_index < nthreads; ++output_index) {
+    Index<3> output_tensor_index = FlatToTensorIndex(output_index, output_dims);
+
+    Index<3> input_tensor_index;
+    input_tensor_index[0] = output_tensor_index[sp0];
+    input_tensor_index[1] = output_tensor_index[sp1];
+    input_tensor_index[2] = output_tensor_index[sp2];
+
+    int input_index = TensorIndexToFlat(input_tensor_index, input_dims);
+
+    output[output_index] =
+        maybe_conj<T, conjugate>::run(ldg(input + input_index));
+  }
+}
+
+// Use shared memory tiles to swap dimension-1 and dimension-2 of a 3D tensor,
+// where dimensions are zero-based: output[i][j][k] = input[i][k][j].
+//
+// Each thread block operates on a single tile, a rectangle of dimensions
+// TileSizeI x TileSizeJ.
+//
+// In general, for best performance, you should probably set TileSizeI,
+// TileSizeJ equal to the number of threads in a warp (32 in nvidia GPUs).
+// With a TileSizeI, TileSizeJ of 32, NumThreads of 128 or 256 seems to get
+// the best performance on K40 GPUs.
+template <typename T, int NumThreads, int TileSizeI, int TileSizeJ,
+          bool conjugate = false>
+__global__ void SwapDimension1And2InTensor3UsingTiles(
+    const T* __restrict__ input, Dimension<3> input_dims,
+    T* __restrict__ output) {
+  eigen_assert(blockDim.x == NumThreads);
+  eigen_assert(blockDim.y == 1);
+  eigen_assert(blockDim.z == 1);
+  eigen_assert(gridDim.y == 1);
+  eigen_assert(gridDim.z == 1);
+
+  constexpr int ReadRowPerPass = NumThreads / TileSizeJ;
+  constexpr int WriteRowPerPass = NumThreads / TileSizeI;
+  // One extra line in the inner dimension to avoid share memory bank conflict.
+  // This is to mimic the following, but no constructor of T can be invoked.
+  //     __shared__ T shared_memory_tile[TileSizeI][TileSizeJ + 1];
+#if GOOGLE_CUDA
+  __shared__ __align__(
+      alignof(T)) char shared_mem_raw[TileSizeI * (TileSizeJ + 1) * sizeof(T)];
+  typedef T(*SharedMemoryTile)[TileSizeJ + 1];
+  SharedMemoryTile shared_memory_tile =
+      reinterpret_cast<SharedMemoryTile>(shared_mem_raw);
+#elif TENSORFLOW_USE_ROCM
+  __shared__ T shared_memory_tile[TileSizeI][TileSizeJ + 1];
+#endif
+
+  int x = threadIdx.x;
+
+  Dimension<3> output_dims = {
+      input_dims[0],
+      input_dims[2],
+      input_dims[1],
+  };
+
+  Dimension<3> input_dims_in_tiles = {
+      input_dims[0],
+      (input_dims[1] + TileSizeI - 1) / TileSizeI,
+      (input_dims[2] + TileSizeJ - 1) / TileSizeJ,
+  };
+
+  Index<3> input_tile_index =
+      FlatToTensorIndex(blockIdx.x, input_dims_in_tiles);
+
+  Index<3> input_tile_origin = {
+      input_tile_index[0],
+      input_tile_index[1] * TileSizeI,
+      input_tile_index[2] * TileSizeJ,
+  };
+
+  int input_origin_flat_index =
+      TensorIndexToFlat(input_tile_origin, input_dims);
+
+  bool full_tile = true;
+  int tile_width = TileSizeJ;
+
+  // Only the last row or column may not have the full size.
+  if (input_tile_index[2] == input_dims_in_tiles[2] - 1) {
+    tile_width = input_dims[2] - (input_dims_in_tiles[2] - 1) * TileSizeJ;
+    full_tile &= false;
+  }
+
+  int tile_height = TileSizeI;
+
+  if (input_tile_index[1] == input_dims_in_tiles[1] - 1) {
+    tile_height = input_dims[1] - (input_dims_in_tiles[1] - 1) * TileSizeI;
+    full_tile &= false;
+  }
+
+  // Calculate effective thread number. This ensures that we use the largest
+  // number of threads available to form a regular thread block with no
+  // trailing incomplete lines.
+  constexpr int in_effective_thread_num = NumThreads / TileSizeJ * TileSizeJ;
+
+  if (x < in_effective_thread_num) {
+    // Orient the logical thread block with respect to the input array.
+    // ie. align the contiguous dimension of thread blocks with the contiguous
+    // dimension of the input array.
+    int ti = x / TileSizeJ;
+    int tj = x % TileSizeJ;
+    int input_index = input_origin_flat_index + ti * input_dims[2] + tj;
+    int input_increment = ReadRowPerPass * input_dims[2];
+
+    if (full_tile) {
+#pragma unroll
+      for (int i_loc = ti; i_loc < (TileSizeI); i_loc += ReadRowPerPass) {
+        shared_memory_tile[i_loc][tj] =
+            maybe_conj<T, conjugate>::run(input[input_index]);
+        input_index += input_increment;
+      }
+    } else {
+      if (tj < tile_width) {
+        for (int i_loc = ti; i_loc < (tile_height); i_loc += ReadRowPerPass) {
+          shared_memory_tile[i_loc][tj] =
+              maybe_conj<T, conjugate>::run(input[input_index]);
+          input_index += input_increment;
+        }
+      }
+    }
+  }
+
+  __syncthreads();
+
+  Index<3> output_tile_index = {
+      input_tile_index[0],
+      input_tile_index[2],
+      input_tile_index[1],
+  };
+
+  Index<3> output_tile_origin = {
+      output_tile_index[0],
+      output_tile_index[1] * TileSizeJ,
+      output_tile_index[2] * TileSizeI,
+  };
+
+  int output_origin_flat_index =
+      TensorIndexToFlat(output_tile_origin, output_dims);
+
+  constexpr int out_effective_thread_num = NumThreads / TileSizeI * TileSizeI;
+
+  if (x < out_effective_thread_num) {
+    // Re-orient the logical thread block with respect to the output array.
+    // ie. align the contiguous dimension of thread blocks with contiguous
+    // dimension of the output array.
+    int ti = x / TileSizeI;
+    int tj = x % TileSizeI;
+    int output_index = output_origin_flat_index + ti * output_dims[2] + tj;
+    int output_increment = WriteRowPerPass * output_dims[2];
+
+    if (full_tile) {
+#pragma unroll
+      for (int i_loc = ti; i_loc < (TileSizeJ); i_loc += WriteRowPerPass) {
+        output[output_index] = shared_memory_tile[tj][i_loc];
+        output_index += output_increment;
+      }
+    } else {
+      if (tj < tile_height) {
+        for (int i_loc = ti; i_loc < (tile_width); i_loc += WriteRowPerPass) {
+          output[output_index] = shared_memory_tile[tj][i_loc];
+          output_index += output_increment;
+        }
+      }
+    }
+  }
+}
+
+// A Gpu custom kernel that convert input to output, given proper padding on
+// the left and the top.
+template <typename T, int NDIMS>
+__global__ void PadInputCustomKernelNHWC(
+    int nthreads, const T* __restrict__ input, Dimension<NDIMS> input_dims,
+    T* __restrict__ output, Dimension<NDIMS> output_dims,
+    Dimension<NDIMS - 2> padding_left, T padding_value) {
+  GPU_1D_KERNEL_LOOP(index, nthreads) {
+    int output_index = index;
+    Index<NDIMS> output_tensor_index =
+        FlatToTensorIndex(output_index, output_dims);
+
+    Index<NDIMS> input_tensor_index;
+    input_tensor_index[0] = output_tensor_index[0];  // batch
+    bool ok = true;
+    for (int i = 1; i < NDIMS - 1; i++) {
+      input_tensor_index[i] = output_tensor_index[i] - padding_left[i - 1];
+      ok &=
+          (input_tensor_index[i] >= 0 && input_tensor_index[i] < input_dims[i]);
+    }
+    input_tensor_index[NDIMS - 1] = output_tensor_index[NDIMS - 1];  // channels
+
+    if (ok) {
+      const int input_index = TensorIndexToFlat(input_tensor_index, input_dims);
+      output[output_index] = input[input_index];
+    } else {
+      output[output_index] = padding_value;
+    }
+  }
+}
+
+template <typename T, int NDIMS>
+__global__ void PadInputCustomKernelNCHW(
+    int nthreads, const T* __restrict__ input, Dimension<NDIMS> input_dims,
+    T* __restrict__ output, Dimension<NDIMS> output_dims,
+    Dimension<NDIMS - 2> padding_left, T padding_value) {
+  GPU_1D_KERNEL_LOOP(index, nthreads) {
+    int output_index = index;
+    Index<NDIMS> output_tensor_index =
+        FlatToTensorIndex(output_index, output_dims);
+
+    Index<NDIMS> input_tensor_index;
+    input_tensor_index[0] = output_tensor_index[0];  // batch
+    input_tensor_index[1] = output_tensor_index[1];  // channels
+    bool ok = true;
+    for (int i = 2; i < NDIMS; i++) {
+      input_tensor_index[i] = output_tensor_index[i] - padding_left[i - 2];
+      ok &=
+          (input_tensor_index[i] >= 0 && input_tensor_index[i] < input_dims[i]);
+    }
+
+    if (ok) {
+      const int input_index = TensorIndexToFlat(input_tensor_index, input_dims);
+      output[output_index] = input[input_index];
+    } else {
+      output[output_index] = padding_value;
+    }
+  }
+}
+
+// A GPU helper function that converts TensorFlow filter format to Cudnn filter
+// format.
+template <typename T, int NDIMS>
+struct TransformFilter<GPUDevice, T, int, NDIMS> {
+  typedef GPUDevice Device;
+  void operator()(const Device& d, FilterTensorFormat dst_filter_format,
+                  typename TTypes<T, NDIMS, int>::ConstTensor in,
+                  typename TTypes<T, NDIMS, int>::Tensor out) {
+    Dimension<3> combined_dims;
+    combined_dims[0] = in.dimension(0);  // spatial dimensions
+    for (int i = 1; i < NDIMS - 2; i++) {
+      combined_dims[0] *= in.dimension(i);
+    }
+    combined_dims[1] = in.dimension(NDIMS - 2);  // input filters
+    combined_dims[2] = in.dimension(NDIMS - 1);  // output filters
+    GpuLaunchConfig config = GetGpuLaunchConfig(out.size(), d);
+
+    if (dst_filter_format == FORMAT_OIHW) {
+      TF_CHECK_OK(GpuLaunchKernel(ShuffleInTensor3Simple<T, 2, 1, 0>,
+                                  config.block_count, config.thread_per_block,
+                                  0, d.stream(), config.virtual_thread_count,
+                                  in.data(), combined_dims, out.data()));
+
+    } else if (dst_filter_format == FORMAT_OHWI) {
+      TF_CHECK_OK(GpuLaunchKernel(ShuffleInTensor3Simple<T, 1, 2, 0>,
+                                  config.block_count, config.thread_per_block,
+                                  0, d.stream(), config.virtual_thread_count,
+                                  in.data(), combined_dims, out.data()));
+
+    } else {
+      LOG(ERROR) << "Unsupported filter format: "
+                 << ToString(dst_filter_format);
+    }
+  }
+};
+
+// Converts Cudnn filter format OIHW or OHWI back to TensorFlow filter format
+// HWIO.
+template <typename T, int NDIMS>
+struct ReverseTransformFilter<GPUDevice, T, NDIMS> {
+  typedef GPUDevice Device;
+  void operator()(const Device& d, FilterTensorFormat src_filter_format,
+                  typename TTypes<T, NDIMS>::ConstTensor in,
+                  typename TTypes<T, NDIMS>::Tensor out) {
+    Dimension<3> combined_dims;
+
+    if (src_filter_format == FORMAT_OIHW) {
+      combined_dims[0] = in.dimension(0);  // output filters
+      combined_dims[1] = in.dimension(1);  // input filters
+      combined_dims[2] = in.dimension(2);  // spatial dimensions
+      for (int i = 3; i < NDIMS; ++i) {
+        combined_dims[2] *= in.dimension(i);
+      }
+
+      GpuLaunchConfig config = GetGpuLaunchConfig(out.size(), d);
+      TF_CHECK_OK(GpuLaunchKernel(ShuffleInTensor3Simple<T, 2, 1, 0>,
+                                  config.block_count, config.thread_per_block,
+                                  0, d.stream(), config.virtual_thread_count,
+                                  in.data(), combined_dims, out.data()));
+
+    } else if (src_filter_format == FORMAT_OHWI) {
+      combined_dims[0] = in.dimension(0);  // output filters
+      combined_dims[1] = in.dimension(1);  // spatial dimensions
+      for (int i = 2; i < NDIMS - 1; i++) {
+        combined_dims[1] *= in.dimension(i);
+      }
+      combined_dims[2] = in.dimension(NDIMS - 1);  // input filters
+
+      GpuLaunchConfig config = GetGpuLaunchConfig(out.size(), d);
+      TF_CHECK_OK(GpuLaunchKernel(ShuffleInTensor3Simple<T, 2, 0, 1>,
+                                  config.block_count, config.thread_per_block,
+                                  0, d.stream(), config.virtual_thread_count,
+                                  in.data(), combined_dims, out.data()));
+
+    } else {
+      // TODO(ezhulenev): Set error status in OpKernelContext instead.
+      LOG(FATAL) << "Unsupported filter format: "
+                 << ToString(src_filter_format);
+    }
+  }
+};
+
+// A GPU helper function that converts input tensor to a larger output tensor,
+// given proper padding values. The padded value is zero.
+template <typename T, int NDIMS>
+struct PadInput<GPUDevice, T, int, NDIMS> {
+  typedef GPUDevice Device;
+  void operator()(const Device& d,
+                  typename TTypes<T, NDIMS, int>::ConstTensor in,
+                  const std::array<int, NDIMS - 2>& padding_left,
+                  const std::array<int, NDIMS - 2>& padding_right,
+                  typename TTypes<T, NDIMS, int>::Tensor out,
+                  TensorFormat format, const T& padding_value) {
+    GpuLaunchConfig config = GetGpuLaunchConfig(out.size(), d);
+    Dimension<NDIMS> input_dims;
+    for (int i = 0; i < NDIMS; ++i) {
+      input_dims[i] = in.dimension(i);
+    }
+    Dimension<NDIMS> output_dims;
+    for (int i = 0; i < NDIMS; ++i) {
+      output_dims[i] = out.dimension(i);
+    }
+
+    const Dimension<NDIMS - 2> padding_left_dim(padding_left);
+
+    if (format == FORMAT_NHWC) {
+      TF_CHECK_OK(GpuLaunchKernel(
+          PadInputCustomKernelNHWC<T, NDIMS>, config.block_count,
+          config.thread_per_block, 0, d.stream(), config.virtual_thread_count,
+          in.data(), input_dims, out.data(), output_dims, padding_left_dim,
+          padding_value));
+    } else if (format == FORMAT_NCHW) {
+      TF_CHECK_OK(GpuLaunchKernel(
+          PadInputCustomKernelNCHW<T, NDIMS>, config.block_count,
+          config.thread_per_block, 0, d.stream(), config.virtual_thread_count,
+          in.data(), input_dims, out.data(), output_dims, padding_left_dim,
+          padding_value));
+    } else {
+      LOG(FATAL) << "Invalid data format: " << format;
+    }
+  }
+};
+
+// We want std::equal_to and std::greater, but they're not constexpr until
+// C++14.
+struct EqualTo {
+  constexpr bool operator()(int a, int b) const { return a == b; }
+};
+
+struct GreaterThan {
+  constexpr bool operator()(int a, int b) const { return a > b; }
+};
+
+// For each data type, the tile size possibility frontier denotes the tile size
+// combinations that consume the most computational resources constrained by
+// - number of threads per SM limit,
+// - limit on size of the short dimension (<=15) due to the definition of
+//   narrow matrix,
+// - shared memory limit and
+// - some experimentally determined, type-specific constraint on the product of
+//   two side lengths to increase grid-level parallelism.
+//
+// A tile size combination lies on the frontier if and only if one or more
+// constraint mentioned above is hit. Tile size combinations lying outside this
+// frontier are either not possible, or are slower than the alternatives.
+//
+// It is instrumental to consider, for each data type, two subsets of the
+// corresponding frontier:
+// - long side frontier: the union of the biggest tile size combination for
+//   each legal long side len.
+// - non long side frontier: the frontier set minus the long side frontier.
+//
+// TileSizePossibilityFrontierCheck defines the frontier using only the long
+// side frontier tile size combinations (since one can easily extrapolate
+// the entire frontier from this subset). It serves as a utility function
+// to help us determine where a tile size combination of interest lies with
+// resepect to the frontier.
+template <typename Op>
+constexpr bool TileSizePossibilityFrontierCheck(int TileLongSide,
+                                                int TileShortSide,
+                                                int size_of_t, Op op) {
+  // clang-format off
+
+  return (size_of_t == 16 && ((TileLongSide == 32   && op(TileShortSide, 4))  ||
+                             (TileLongSide == 64   && op(TileShortSide, 4))  ||
+                             (TileLongSide == 128  && op(TileShortSide, 4))  ||
+                             (TileLongSide == 256  && op(TileShortSide, 2)))) ||
+          (size_of_t == 8 && ((TileLongSide == 32   && op(TileShortSide, 15)) ||
+                             (TileLongSide == 64   && op(TileShortSide, 15)) ||
+                             (TileLongSide == 128  && op(TileShortSide, 8))  ||
+                             (TileLongSide == 256  && op(TileShortSide, 4))  ||
+                             (TileLongSide == 512  && op(TileShortSide, 2)))) ||
+          (size_of_t == 4 && ((TileLongSide == 32   && op(TileShortSide, 15)) ||
+                             (TileLongSide == 64   && op(TileShortSide, 15)) ||
+                             (TileLongSide == 128  && op(TileShortSide, 15)) ||
+                             (TileLongSide == 256  && op(TileShortSide, 8))  ||
+                             (TileLongSide == 512  && op(TileShortSide, 4))  ||
+                             (TileLongSide == 1024 && op(TileShortSide, 2)))) ||
+          (size_of_t == 2 && ((TileLongSide == 32   && op(TileShortSide, 15)) ||
+                             (TileLongSide == 64   && op(TileShortSide, 15)) ||
+                             (TileLongSide == 128  && op(TileShortSide, 15)) ||
+                             (TileLongSide == 256  && op(TileShortSide, 8))  ||
+                             (TileLongSide == 512  && op(TileShortSide, 4))  ||
+                             (TileLongSide == 1024 && op(TileShortSide, 2)))) ||
+          (size_of_t == 1 && ((TileLongSide == 32   && op(TileShortSide, 15)) ||
+                             (TileLongSide == 64   && op(TileShortSide, 15)) ||
+                             (TileLongSide == 128  && op(TileShortSide, 15)) ||
+                             (TileLongSide == 256  && op(TileShortSide, 8))  ||
+                             (TileLongSide == 512  && op(TileShortSide, 4))  ||
+                             (TileLongSide == 1024 && op(TileShortSide, 2))));
+
+  // clang-format on
+}
+
+constexpr bool TileSizeOnLongSideFrontier(int TileLongSide, int TileShortSide,
+                                          int size_of_t) {
+  return TileSizePossibilityFrontierCheck(TileLongSide, TileShortSide,
+                                          size_of_t, EqualTo());
+}
+constexpr bool TileSizeOutsideFrontier(int TileLongSide, int TileShortSide,
+                                       int size_of_t) {
+  return TileSizePossibilityFrontierCheck(TileLongSide, TileShortSide,
+                                          size_of_t, GreaterThan());
+}
+constexpr bool TileSizeOnNonLongSideFrontier(int TileLongSide,
+                                             int TileShortSide, int size_of_t) {
+  // For a tile size combination (longside, shortside), lying on the frontier
+  // implies that (longside, shortside) is on or within the frontier but
+  // (longside*2, shortside) or (longside, shortside+1) is not. With the above
+  // criterion, we simply need to use !TileSizeOnLongSideFrontier to ensure that
+  // it is not on the long side frontier.
+  return !TileSizeOutsideFrontier(TileLongSide, TileShortSide, size_of_t) &&
+         (TileSizeOutsideFrontier(TileLongSide * 2, TileShortSide, size_of_t) ||
+          TileSizeOutsideFrontier(TileLongSide, TileShortSide + 1,
+                                  size_of_t)) &&
+         !TileSizeOnLongSideFrontier(TileLongSide, TileShortSide, size_of_t);
+}
+
+// Helper function to launch a batch narrow matirx transpose kernel.
+template <typename T, int TileLongSide, int TileShortSide, bool conjugate>
+void LaunchBatchNarrowMatrixTransposeKernel(
+    const GPUDevice& d, int tile_size_i, int tile_size_j, int total_tiles_count,
+    const T* input, const Dimension<3>& input_dims, T* output) {
+  constexpr int NumThreads = TileLongSide;
+  if (tile_size_i <= TileLongSide && tile_size_j <= TileShortSide) {
+    TF_CHECK_OK(GpuLaunchKernel(
+        SwapDimension1And2InTensor3UsingTiles<T, NumThreads, TileLongSide,
+                                              TileShortSide, conjugate>,
+        total_tiles_count, NumThreads, 0, d.stream(), input, input_dims,
+        output));
+  } else {
+    TF_CHECK_OK(GpuLaunchKernel(
+        SwapDimension1And2InTensor3UsingTiles<T, NumThreads, TileShortSide,
+                                              TileLongSide, conjugate>,
+        total_tiles_count, NumThreads, 0, d.stream(), input, input_dims,
+        output));
+  }
+}
+
+// Recursive template function to search, in a trial-and-error manner, for the
+// minimum tile size configuration satisfying the requested tile side lengths.
+// An important invariant of this search procedure is that for an unsatisfied
+// request, we always try doubling the long side len first, and only after
+// the request is satisfied for the long side len do we begin incrementing
+// the short side len.
+//
+// We have three specializations of this search function depending on where the
+// current tile size combination lies with respect to the frontier.
+// - It lies within the frontier. If request is not satisfied, for the next tile
+// size combination, we first try doubling the long side len and if that does
+// not work, we then increment the short side len.
+// - It lies on the non long side frontier. If the request is not satisfied, we
+// can only increment the short side len.
+// - It lies on the long side frontier. We launch the kernel without checking if
+// the request is satisfied or not.
+template <typename T, int TileLongSide, int TileShortSide, bool conjugate,
+          typename dummy = void>
+struct BatchNarrowMatrixTransposeDispatcher {
+  static void DoIt(const GPUDevice& d, int tile_size_i, int tile_size_j,
+                   int total_tiles_count, const T* input,
+                   const Dimension<3>& input_dims, T* output) {
+    static_assert(
+        (TileLongSide & (TileLongSide - 1)) == 0,
+        "The length of the longer side of the tile is always a power of 2.");
+    bool request_satisfied =
+        std::max(tile_size_i, tile_size_j) <= TileLongSide &&
+        std::min(tile_size_i, tile_size_j) <= TileShortSide;
+
+    if (request_satisfied) {
+      LaunchBatchNarrowMatrixTransposeKernel<T, TileLongSide, TileShortSide,
+                                             conjugate>(
+          d, tile_size_i, tile_size_j, total_tiles_count, input, input_dims,
+          output);
+      return;
+    }
+
+    // If the execution reaches here, then the kernel was not launched; we then
+    // determine whether it is the long side or the short side that falls short
+    // of the request and increase that parameter accordingly.
+    const bool long_side_request_not_satisfied =
+        std::max(tile_size_i, tile_size_j) > TileLongSide;
+
+    if (long_side_request_not_satisfied) {
+      BatchNarrowMatrixTransposeDispatcher<T, TileLongSide * 2, TileShortSide,
+                                           conjugate>::DoIt(d, tile_size_i,
+                                                            tile_size_j,
+                                                            total_tiles_count,
+                                                            input, input_dims,
+                                                            output);
+    } else {
+      BatchNarrowMatrixTransposeDispatcher<T, TileLongSide, TileShortSide + 1,
+                                           conjugate>::DoIt(d, tile_size_i,
+                                                            tile_size_j,
+                                                            total_tiles_count,
+                                                            input, input_dims,
+                                                            output);
+    }
+  }
+};
+
+template <typename T, int TileLongSide, int TileShortSide, bool conjugate>
+struct BatchNarrowMatrixTransposeDispatcher<
+    T, TileLongSide, TileShortSide, conjugate,
+    typename std::enable_if<TileSizeOnNonLongSideFrontier(
+                                TileLongSide, TileShortSide, sizeof(T)),
+                            void>::type> {
+  static void DoIt(const GPUDevice& d, int tile_size_i, int tile_size_j,
+                   int total_tiles_count, const T* input,
+                   const Dimension<3>& input_dims, T* output) {
+    static_assert(
+        (TileLongSide & (TileLongSide - 1)) == 0,
+        "The length of the longer side of the tile is always a power of 2.");
+    bool request_satisfied =
+        std::max(tile_size_i, tile_size_j) <= TileLongSide &&
+        std::min(tile_size_i, tile_size_j) <= TileShortSide;
+
+    if (request_satisfied) {
+      LaunchBatchNarrowMatrixTransposeKernel<T, TileLongSide, TileShortSide,
+                                             conjugate>(
+          d, tile_size_i, tile_size_j, total_tiles_count, input, input_dims,
+          output);
+      return;
+    }
+
+    // If the execution reaches here, then the kernel was not launched; since
+    // we are on the non long side frontier, we increment the short dimension
+    // and try again.
+    BatchNarrowMatrixTransposeDispatcher<T, TileLongSide, TileShortSide + 1,
+                                         conjugate>::DoIt(d, tile_size_i,
+                                                          tile_size_j,
+                                                          total_tiles_count,
+                                                          input, input_dims,
+                                                          output);
+  }
+};
+
+template <typename T, int TileLongSide, int TileShortSide, bool conjugate>
+struct BatchNarrowMatrixTransposeDispatcher<
+    T, TileLongSide, TileShortSide, conjugate,
+    typename std::enable_if<TileSizeOnLongSideFrontier(
+                                TileLongSide, TileShortSide, sizeof(T)),
+                            void>::type> {
+  static void DoIt(const GPUDevice& d, int tile_size_i, int tile_size_j,
+                   int total_tiles_count, const T* input,
+                   const Dimension<3>& input_dims, T* output) {
+    static_assert(
+        (TileLongSide & (TileLongSide - 1)) == 0,
+        "The length of the longer side of the tile is always a power of 2.");
+
+    LaunchBatchNarrowMatrixTransposeKernel<T, TileLongSide, TileShortSide,
+                                           conjugate>(
+        d, tile_size_i, tile_size_j, total_tiles_count, input, input_dims,
+        output);
+  }
+};
+
+// This function tries to recover, in a brute force way, the frontier defined in
+// TileSizePossibilityFrontierCheck as a vector of tile size combinations lying
+// on the long side frontier. This vector is sufficient to determine the entire
+// frontier.
+//
+// Note that if one changes the frontier definition in
+// TileSizePossibilityFrontierCheck and forgets to set the largest short
+// side len of the largest legal long side len to 2, this function will fail
+// and crash the program.
+template <int SizeOfT>
+const std::vector<std::pair<int, int>>& GetTileSizesFrontier() {
+  static_assert(
+      SizeOfT <= 16,
+      "Currently, only data types of sizes 16 bytes or less are supported.");
+  static_assert((SizeOfT & (SizeOfT - 1)) == 0,
+                "Data types must have sizes that are powers of 2.");
+
+  // Expensive work to populate sizes, lazily run in a thread-safe
+  // manner the first time GetTileSizesFrontier<N> is called.
+  static auto* frontier = [] {
+    auto* frontier = new std::vector<std::pair<int, int>>();
+    const int kMaxLongSideLen = 1024;
+    const int kMaxShortSideLen = 15;
+    for (int long_side = 32; long_side <= kMaxLongSideLen; long_side *= 2) {
+      for (int short_side = 2; short_side <= kMaxShortSideLen;
+           short_side += 1) {
+        if (TileSizeOnLongSideFrontier(long_side, short_side, SizeOfT)) {
+          // The current combination lies on the frontier, thus we
+          // add it to the frontier definition.
+          frontier->push_back(std::make_pair(long_side, short_side));
+
+          // The long side length is the largest one allowed iff its
+          // corresponding short side length is 2.
+          if (short_side == 2) return frontier;
+
+          // We have exhausted all the possibilities in the frontier
+          // with the given long side length.
+          break;
+        }
+      }
+    }
+    LOG(FATAL)
+        << "The corresponding short side length of the largest long side "
+           "length has to be 2.";
+  }();
+  return *frontier;
+}
+
+// Helper structs to help determine which data type to use given the size of
+// the matrix data type. A transpose of elements of size N will use a kernel
+// which operates on an array of TransposeElemType<N>::type.
+template <int ElemBytes>
+struct TransposeElemType;
+template <>
+struct TransposeElemType<1> {
+  using type = uint8;
+};
+template <>
+struct TransposeElemType<2> {
+  using type = uint16;
+};
+template <>
+struct TransposeElemType<4> {
+  using type = uint32;
+};
+template <>
+struct TransposeElemType<8> {
+  using type = float2;
+};
+template <>
+struct TransposeElemType<16> {
+  using type = double2;
+};
+
+// A helper function to make RunSwapDimension1And2InTensor3 concise. This
+// helper function looks at the data type and input matrix sizes and decides
+// the thread numbers and tile sizes to use.
+template <typename T, bool conjugate = false>
+void SwapDimension1And2InTensor3WithNarrowMatrices(
+    const GPUDevice& d, const T* input, const Dimension<3>& input_dims,
+    T* output, const int kMinDimensionToUseTiles) {
+  // Get available tile sizes here for the data type requested:
+  const auto& tile_spec = GetTileSizesFrontier<sizeof(T)>();
+
+  int tile_long_side_len = 0;
+  int tile_short_side_len = 0;
+  float lowest_cost = std::numeric_limits<float>::max();
+  int data_long_side = std::max(input_dims[1], input_dims[2]);
+
+  for (auto tile_size_pair : tile_spec) {
+    int proposed_tile_long_side_len = tile_size_pair.first;
+
+    // Number of threads that will not be doing anything useful when reading
+    // the matrix because the thread block size is bigger than the data block
+    // size.
+    int num_wasted_threads =
+        data_long_side - MathUtil::FloorOfRatio<int>(
+                             data_long_side, proposed_tile_long_side_len) *
+                             proposed_tile_long_side_len;
+
+    int num_full_tiles = MathUtil::FloorOfRatio<int>(
+        data_long_side, proposed_tile_long_side_len);
+
+    float cost = 0;
+
+    // However, if we can execute two or more full tiles, then we gladly
+    // accept any number of wasted threads and ignore its cost.
+    if (num_full_tiles <= 1) cost = num_wasted_threads;
+
+    // Using less than or equal to here because given the same cost, we
+    // would like to launch as many threads as possible.
+    if (cost <= lowest_cost) {
+      tile_long_side_len = proposed_tile_long_side_len;
+      tile_short_side_len = tile_size_pair.second;
+      lowest_cost = cost;
+    }
+  }
+
+  // Request tile sizes such that the longer side of threadblock aligns with
+  // the longer side of input data block to maximize read throughput.
+  // The ideal tile shape is one where the length of the shorter side of the
+  // tile is equal to the length of the shorter side of the input matrix.
+  int requested_tile_size_i = input_dims[1] >= kMinDimensionToUseTiles
+                                  ? tile_long_side_len
+                                  : input_dims[1];
+  int requested_tile_size_j = input_dims[1] >= kMinDimensionToUseTiles
+                                  ? input_dims[2]
+                                  : tile_long_side_len;
+
+  // Truncate the shorter size requested according to the manual limit set in
+  // tile_spec to make sure that we do not launch configurations violating
+  // hardware limits.
+  requested_tile_size_i =
+      requested_tile_size_i == tile_long_side_len
+          ? tile_long_side_len
+          : std::min(requested_tile_size_i, tile_short_side_len);
+  requested_tile_size_j =
+      requested_tile_size_j == tile_long_side_len
+          ? tile_long_side_len
+          : std::min(requested_tile_size_j, tile_short_side_len);
+
+  Dimension<3> input_dims_in_tiles = {
+      input_dims[0],
+      MathUtil::CeilOfRatio<int>(input_dims[1], requested_tile_size_i),
+      MathUtil::CeilOfRatio<int>(input_dims[2], requested_tile_size_j),
+  };
+
+  int total_tiles_count =
+      input_dims_in_tiles[0] * input_dims_in_tiles[1] * input_dims_in_tiles[2];
+
+  using ElemType = typename TransposeElemType<sizeof(T)>::type;
+  static_assert(alignof(T) >= alignof(ElemType), "Unexpected data alignment.");
+  BatchNarrowMatrixTransposeDispatcher<ElemType, 32, 2, conjugate>::DoIt(
+      d, requested_tile_size_i, requested_tile_size_j, total_tiles_count,
+      reinterpret_cast<const ElemType*>(input), input_dims,
+      reinterpret_cast<ElemType*>(output));
+}
+
+// Launch the GPU kernel that would swap dimension-1 and dimension-2 in a
+// 3D tensor. It looks at the shape of the incoming data, and decides the best
+// strategy to launch.
+template <typename T, bool conjugate = false>
+void RunSwapDimension1And2InTensor3(const GPUDevice& d, const T* input,
+                                    const Dimension<3>& input_dims, T* output) {
+  // If both dimensions are not trivial, use tiles for the actual swapping.
+  // If one dimension is trivial, use SmallDim kernel for swapping.
+  // Otherwise, the trivial swapping relying on the ldg cache is more efficient.
+  static const int kMinDimensionToUseTiles = 16;
+  static const int kMinDimensionToUseRectTiles = 96;
+
+  bool large_matrix = input_dims[1] >= kMinDimensionToUseTiles &&
+                      input_dims[2] >= kMinDimensionToUseTiles;
+  bool narrow_matrix = input_dims[1] >= kMinDimensionToUseRectTiles ||
+                       input_dims[2] >= kMinDimensionToUseRectTiles;
+  if (large_matrix) {
+    // We get best performance when kTileSize is the number of threads in a warp
+    // (32 on our GPUs) and NumSubTiles is 8, so our block size is 8 * 32 = 256
+    // threads.
+    constexpr int kTileSize = 32;
+    constexpr int kNumThreads = 256;
+
+    Dimension<3> input_dims_in_tiles = {
+        input_dims[0],
+        MathUtil::CeilOfRatio<int>(input_dims[1], kTileSize),
+        MathUtil::CeilOfRatio<int>(input_dims[2], kTileSize),
+    };
+
+    int total_tiles_count = input_dims_in_tiles[0] * input_dims_in_tiles[1] *
+                            input_dims_in_tiles[2];
+    TF_CHECK_OK(GpuLaunchKernel(
+        SwapDimension1And2InTensor3UsingTiles<T, kNumThreads, kTileSize,
+                                              kTileSize, conjugate>,
+        total_tiles_count, kNumThreads, 0, d.stream(), input, input_dims,
+        output));
+
+  } else if (narrow_matrix) {
+    SwapDimension1And2InTensor3WithNarrowMatrices<T, conjugate>(
+        d, input, input_dims, output, kMinDimensionToUseTiles);
+  } else {
+    int total_element_count = input_dims[0] * input_dims[1] * input_dims[2];
+    GpuLaunchConfig config = GetGpuLaunchConfig(total_element_count, d);
+    TF_CHECK_OK(GpuLaunchKernel(ShuffleInTensor3Simple<T, 0, 2, 1, conjugate>,
+                                config.block_count, config.thread_per_block, 0,
+                                d.stream(), config.virtual_thread_count, input,
+                                input_dims, output));
+  }
+}
+
+// A GPU helper functor that does general dimension 1 and 2 switch for 3D
+// tensor.
+template <typename T, bool conjugate>
+struct SwapDimension1And2InTensor3<GPUDevice, T, conjugate> {
+  typedef GPUDevice Device;
+  void operator()(const Device& d, const T* in,
+                  const gtl::ArraySlice<int64_t>& combined_dims, T* out) {
+    Dimension<3> input_dims = {static_cast<int>(combined_dims[0]),
+                               static_cast<int>(combined_dims[1]),
+                               static_cast<int>(combined_dims[2])};
+    RunSwapDimension1And2InTensor3<T, conjugate>(d, in, input_dims, out);
+  }
+};
+
+// A GPU helper functor that does general dimension 0 and 2 switch for 3D
+// tensor.
+template <typename T, bool conjugate>
+struct SwapDimension0And2InTensor3<GPUDevice, T, conjugate> {
+  typedef GPUDevice Device;
+  void operator()(const Device& d, const T* in,
+                  const gtl::ArraySlice<int64_t>& combined_dims, T* out) {
+    Dimension<3> input_dims = {static_cast<int>(combined_dims[0]),
+                               static_cast<int>(combined_dims[1]),
+                               static_cast<int>(combined_dims[2])};
+    size_t total_size = combined_dims[0] * combined_dims[1] * combined_dims[2];
+    GpuLaunchConfig config = GetGpuLaunchConfig(total_size, d);
+
+    auto out_ptr = reinterpret_cast<uintptr_t>(out);
+    bool aligned = out_ptr % 16 == 0;
+
+    bool use_vector = false;
+    bool use_custom_config = false;
+    if ((input_dims[0] <= 128 && input_dims[2] <= 128) ||
+        input_dims[0] * input_dims[1] <= 128 ||
+        input_dims[1] * input_dims[2] <= 8) {
+      use_vector = true;
+      use_custom_config = true;
+    } else if (input_dims[1] * input_dims[2] <= 16384) {
+      use_vector = true;
+    }
+
+    if (sizeof(T) == 2 && aligned && use_vector) {
+      int block_count;
+      if (use_custom_config) {
+        block_count = (total_size + config.thread_per_block - 1) /
+                      config.thread_per_block;
+      } else {
+        block_count = config.block_count;
+      }
+
+      TF_CHECK_OK(
+          GpuLaunchKernel(ShuffleInTensor3SimpleVector<T, 2, 1, 0, conjugate>,
+                          block_count, config.thread_per_block / kUnroll, 0,
+                          d.stream(), total_size, in, input_dims, out));
+    } else {
+      TF_CHECK_OK(GpuLaunchKernel(ShuffleInTensor3Simple<T, 2, 1, 0, conjugate>,
+                                  config.block_count, config.thread_per_block,
+                                  0, d.stream(), config.virtual_thread_count,
+                                  in, input_dims, out));
+    }
+  }
+};
+
+// A GPU helper functor that converts NHWC TensorFlow data format to
+// NCHW format that is accepted by Cudnn.
+template <typename T, int NDIMS>
+struct NHWCToNCHW<GPUDevice, T, NDIMS> {
+  typedef GPUDevice Device;
+  void operator()(const Device& d, typename TTypes<T, NDIMS>::ConstTensor in,
+                  typename TTypes<T, NDIMS>::Tensor out) {
+    Dimension<3> combined_dims;
+    combined_dims[0] = in.dimension(0);  // N (batch)
+    combined_dims[1] = in.dimension(1);  // spatial dimensions (HW)
+    for (int i = 2; i < NDIMS - 1; ++i) {
+      combined_dims[1] *= in.dimension(i);
+    }
+    combined_dims[2] = in.dimension(NDIMS - 1);  // C (channels)
+    RunSwapDimension1And2InTensor3(d, in.data(), combined_dims, out.data());
+  }
+};
+
+// A GPU helper functor that converts NCHW Cudnn data format to NHWC TensorFlow
+// Format.
+template <typename T, int NDIMS>
+struct NCHWToNHWC<GPUDevice, T, NDIMS> {
+  typedef GPUDevice Device;
+  void operator()(const Device& d, typename TTypes<T, NDIMS>::ConstTensor in,
+                  typename TTypes<T, NDIMS>::Tensor out) {
+    Dimension<3> combined_dims;
+    combined_dims[0] = in.dimension(0);  // N (batch)
+    combined_dims[1] = in.dimension(1);  // C (channel)
+    combined_dims[2] = in.dimension(2);  // spatial dimensions (HW)
+    for (int i = 3; i < NDIMS; ++i) {
+      combined_dims[2] *= in.dimension(i);
+    }
+    RunSwapDimension1And2InTensor3(d, in.data(), combined_dims, out.data());
+  }
+};
+
+}  // namespace functor
+}  // namespace tensorflow
+
+#endif  // GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+
+#endif  // TENSORFLOW_CORE_KERNELS_CONV_2D_GPU_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/conv_3d.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/conv_3d.h
new file mode 100644
index 0000000000000000000000000000000000000000..b4cdbd5b6177022ef7cd19e1ad4fa26206fe66e7
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/conv_3d.h
@@ -0,0 +1,128 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// Functors for 3d convolution.
+
+#ifndef TENSORFLOW_CORE_KERNELS_CONV_3D_H_
+#define TENSORFLOW_CORE_KERNELS_CONV_3D_H_
+
+#include <array>
+
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/ops_util.h"
+#include "tensorflow/core/framework/tensor_types.h"
+#include "tensorflow/core/kernels/eigen_backward_cuboid_convolutions.h"
+#include "tensorflow/core/kernels/eigen_cuboid_convolution.h"
+
+namespace tensorflow {
+namespace functor {
+
+// Applies a 3D convolution to a batch of multi-channel volumes.
+template <typename Device, typename T>
+struct CuboidConvolution;
+
+// Backward input pass for the cuboid convolution.
+template <typename Device, typename T>
+struct CuboidConvolutionBackwardInput;
+
+// Backward filter pass for the cuboid convolution.
+template <typename Device, typename T>
+struct CuboidConvolutionBackwardFilter;
+
+typedef Eigen::ThreadPoolDevice CPUDevice;
+
+template <typename T>
+struct CuboidConvolution<CPUDevice, T> {
+  void operator()(const CPUDevice& d, typename TTypes<T, 5>::Tensor output,
+                  typename TTypes<T, 5>::ConstTensor input,
+                  typename TTypes<T, 5>::ConstTensor filter, int stride_planes,
+                  int stride_rows, int stride_cols,
+                  const Eigen::PaddingType& padding) {
+    output.device(d) = Eigen::CuboidConvolution(
+        input, filter, stride_planes, stride_rows, stride_cols, padding);
+  }
+};
+
+template <typename T>
+struct CuboidConvolutionBackwardInput<CPUDevice, T> {
+  void operator()(const CPUDevice& d,
+                  typename TTypes<T, 5>::Tensor input_backward,
+                  typename TTypes<T, 5>::ConstTensor filter,
+                  typename TTypes<T, 5>::ConstTensor output_backward,
+                  int stride_planes, int stride_rows, int stride_cols) {
+    // Need to swap the order of plane/row/col strides when calling Eigen.
+    input_backward.device(d) = Eigen::CuboidConvolutionBackwardInput(
+        filter, output_backward,
+        input_backward.dimension(3),  // input_planes
+        input_backward.dimension(2),  // input_rows
+        input_backward.dimension(1),  // input_cols
+        stride_cols, stride_rows, stride_planes);
+  }
+};
+
+template <typename T>
+struct CuboidConvolutionBackwardFilter<CPUDevice, T> {
+  void operator()(const CPUDevice& d,
+                  typename TTypes<T, 5>::Tensor filter_backward,
+                  typename TTypes<T, 5>::ConstTensor input,
+                  typename TTypes<T, 5>::ConstTensor output_backward,
+                  int stride_planes, int stride_rows, int stride_cols) {
+    // Need to swap the order of plane/row/col strides when calling Eigen.
+    filter_backward.device(d) = Eigen::CuboidConvolutionBackwardKernel(
+        input, output_backward,
+        filter_backward.dimension(2),  // kernel_planes
+        filter_backward.dimension(1),  // kernel_rows
+        filter_backward.dimension(0),  // kernel_cols
+        stride_cols, stride_rows, stride_planes);
+  }
+};
+
+}  // namespace functor
+
+typedef Eigen::ThreadPoolDevice CPUDevice;
+
+template <typename Device, typename T>
+struct LaunchConv3DOp;
+
+template <typename T>
+struct LaunchConv3DOp<CPUDevice, T> {
+  static void launch(OpKernelContext* context, bool cudnn_use_autotune,
+                     const Tensor& input, const Tensor& filter,
+                     const std::array<int64, 3>& dilations,
+                     const std::array<int64, 3>& strides, const Padding padding,
+                     TensorFormat data_format, Tensor* output) {
+    OP_REQUIRES(context, data_format == FORMAT_NHWC,
+                absl::InvalidArgumentError("CPU implementation of Conv3D "
+                                           "currently only supports the NHWC "
+                                           "tensor format."));
+    OP_REQUIRES(
+        context, dilations[0] == 1 && dilations[1] == 1 && dilations[2] == 1,
+        absl::InvalidArgumentError("CPU implementation of Conv3D "
+                                   "currently only supports dilated rates "
+                                   "of 1."));
+    OP_REQUIRES(context, filter.dim_size(3) == input.dim_size(input.dims() - 1),
+                absl::InvalidArgumentError(absl::StrCat(
+                    "Number of channels in filter (", filter.dim_size(3),
+                    ") must match last dimension of input (",
+                    input.dim_size(input.dims() - 1), ")")));
+    functor::CuboidConvolution<CPUDevice, T>()(
+        context->eigen_device<CPUDevice>(), output->tensor<T, 5>(),
+        input.tensor<T, 5>(), filter.tensor<T, 5>(), strides[2], strides[1],
+        strides[0], BrainPadding2EigenPadding(padding));
+  }
+};
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_CONV_3D_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/conv_grad_input_ops.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/conv_grad_input_ops.h
new file mode 100644
index 0000000000000000000000000000000000000000..60f35fe6111db6938643e62ec523ac68456b4a00
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/conv_grad_input_ops.h
@@ -0,0 +1,718 @@
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// See docs in ../ops/nn_ops.cc.
+
+#ifndef TENSORFLOW_CORE_KERNELS_CONV_GRAD_INPUT_OPS_H_
+#define TENSORFLOW_CORE_KERNELS_CONV_GRAD_INPUT_OPS_H_
+
+#define USE_EIGEN_TENSOR
+#define EIGEN_USE_THREADS
+
+#include <algorithm>
+#include <limits>
+#include <vector>
+
+#include "absl/base/dynamic_annotations.h"
+#include "tensorflow/core/framework/bounds_check.h"
+#include "tensorflow/core/framework/kernel_shape_util.h"
+#include "tensorflow/core/framework/numeric_op.h"
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/register_types.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/tensor_shape.h"
+#include "tensorflow/core/framework/tensor_slice.h"
+#include "tensorflow/core/kernels/conv_2d.h"
+#include "tensorflow/core/kernels/conv_grad_ops.h"
+#include "tensorflow/core/kernels/conv_grad_shape_utils.h"
+#include "tensorflow/core/kernels/fill_functor.h"
+#include "tensorflow/core/lib/core/errors.h"
+#include "tensorflow/core/lib/gtl/array_slice.h"
+#include "tensorflow/core/platform/logging.h"
+#include "tensorflow/core/platform/macros.h"
+#include "tensorflow/core/util/padding.h"
+#include "tensorflow/core/util/tensor_format.h"
+#include "tensorflow/core/util/use_cudnn.h"
+#include "tensorflow/core/util/work_sharder.h"
+
+#if defined(TENSORFLOW_USE_CUSTOM_CONTRACTION_KERNEL)
+#include "tsl/framework/contraction/eigen_contraction_kernel.h"
+#endif
+
+#if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+#include "tensorflow/core/kernels/conv_ops_gpu.h"
+#include "tensorflow/core/platform/stream_executor.h"
+#include "tensorflow/core/util/proto/proto_utils.h"
+#endif  // GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+#if GOOGLE_CUDA
+#include "xla/stream_executor/gpu/gpu_asm_opts.h"
+#include "xla/stream_executor/gpu/redzone_allocator.h"
+#include "xla/stream_executor/tf_allocator_adapter.h"
+#endif  // GOOGLE_CUDA
+
+namespace tensorflow {
+
+typedef Eigen::ThreadPoolDevice CPUDevice;
+typedef Eigen::GpuDevice GPUDevice;
+
+// Returns in 'im_data' (assumes to be zero-initialized) image patch in storage
+// order (height, width, depth), constructed from patches in 'col_data', which
+// is required to be in storage order (out_height * out_width, filter_height,
+// filter_width, in_depth).  Implementation by Yangqing Jia (jiayq).
+template <typename T>
+void Col2im(const T* col_data, const int depth, const int height,
+            const int width, const int filter_h, const int filter_w,
+            const int pad_t, const int pad_l, const int pad_b, const int pad_r,
+            const int stride_h, const int stride_w, T* __restrict im_data) {
+  int height_col = (height + pad_t + pad_b - filter_h) / stride_h + 1;
+  int width_col = (width + pad_l + pad_r - filter_w) / stride_w + 1;
+  int h_pad = -pad_t;
+  for (int h = 0; h < height_col; ++h) {
+    int w_pad = -pad_l;
+    for (int w = 0; w < width_col; ++w) {
+      T* im_patch_data = im_data + (h_pad * width + w_pad) * depth;
+      for (int ih = h_pad; ih < h_pad + filter_h; ++ih) {
+        for (int iw = w_pad; iw < w_pad + filter_w; ++iw) {
+          if (ih >= 0 && ih < height && iw >= 0 && iw < width) {
+            for (int i = 0; i < depth; ++i) {
+              im_patch_data[i] += col_data[i];
+            }
+          }
+          im_patch_data += depth;
+          col_data += depth;
+        }
+        // Jump over remaining number of depth.
+        im_patch_data += depth * (width - filter_w);
+      }
+      w_pad += stride_w;
+    }
+    h_pad += stride_h;
+  }
+}
+
+// Computes backprop input using Eigen::SpatialConvolutionBackwardInput on CPU
+// and GPU (for int32 only).
+template <typename Device, typename T>
+struct LaunchConv2DBackpropInputOpImpl {
+  void operator()(OpKernelContext* ctx, bool use_cudnn, bool cudnn_use_autotune,
+                  const Tensor& out_backprop, const Tensor& filter,
+                  int row_dilation, int col_dilation, int row_stride,
+                  int col_stride, const Padding& padding,
+                  const std::vector<int64_t>& explicit_paddings,
+                  Tensor* in_backprop, TensorFormat data_format) {
+    std::vector<int32> strides(4, 1);
+    std::vector<int32> dilations(4, 1);
+
+    auto input_h = GetTensorDimIndex(data_format, 'H');
+    auto input_w = GetTensorDimIndex(data_format, 'W');
+    strides[input_h] = row_stride;
+    strides[input_w] = col_stride;
+    dilations[input_h] = row_dilation;
+    dilations[input_w] = col_dilation;
+
+    const TensorShape& input_shape = in_backprop->shape();
+    const TensorShape& filter_shape = filter.shape();
+
+    ConvBackpropDimensions dims;
+    OP_REQUIRES_OK(
+        ctx, ConvBackpropComputeDimensionsV2(
+                 "Conv2DBackpropInput", /*num_spatial_dims=*/2, input_shape,
+                 filter_shape, out_backprop.shape(), dilations, strides,
+                 padding, explicit_paddings, data_format, &dims));
+
+    int64_t padding_top = -1, padding_bottom = -1;
+    int64_t padding_left = -1, padding_right = -1;
+    if (padding == EXPLICIT) {
+      GetExplicitPaddingForDim(explicit_paddings, data_format, 'H',
+                               &padding_top, &padding_bottom);
+      GetExplicitPaddingForDim(explicit_paddings, data_format, 'W',
+                               &padding_left, &padding_right);
+    }
+
+    int64_t expected_out_rows, expected_out_cols;
+    // The function is guaranteed to succeed because we checked the output and
+    // padding was valid earlier.
+    TF_CHECK_OK(GetWindowedOutputSizeVerbose(
+        dims.spatial_dims[0].input_size, dims.spatial_dims[0].filter_size,
+        row_dilation, row_stride, padding, &expected_out_rows, &padding_top,
+        &padding_bottom));
+    DCHECK_EQ(dims.spatial_dims[0].output_size, expected_out_rows);
+
+    TF_CHECK_OK(GetWindowedOutputSizeVerbose(
+        dims.spatial_dims[1].input_size, dims.spatial_dims[1].filter_size,
+        col_dilation, col_stride, padding, &expected_out_cols, &padding_left,
+        &padding_right));
+    DCHECK_EQ(dims.spatial_dims[1].output_size, expected_out_cols);
+
+    if (std::is_same<Device, GPUDevice>::value) {
+      int64_t size = 1;
+#define REQUIRES_32BIT(x)                                                   \
+  size *= x;                                                                \
+  OP_REQUIRES(ctx,                                                          \
+              FastBoundsCheck(x, std::numeric_limits<int32>::max()) &&      \
+                  FastBoundsCheck(size, std::numeric_limits<int32>::max()), \
+              errors::InvalidArgument("Tensor too large"))
+
+      REQUIRES_32BIT(in_backprop->dim_size(0));
+      REQUIRES_32BIT(in_backprop->dim_size(1) + padding_top + padding_bottom);
+      REQUIRES_32BIT(in_backprop->dim_size(2) + padding_left + padding_right);
+      REQUIRES_32BIT(in_backprop->dim_size(3));
+#undef REQUIRES_32BIT
+    }
+
+    auto in_backprop_t = in_backprop->tensor<T, 4>();
+    auto out_backprop_t = out_backprop.tensor<T, 4>();
+    auto filter_t = filter.tensor<T, 4>();
+
+    // WARNING: Need to swap row/col, padding_top/padding_left, and
+    // padding_bottom/padding_right when calling Eigen. Eigen expects tensors
+    // in NWHC format, but Tensorflow uses NHWC.
+
+    if (padding != EXPLICIT) {
+      // If padding was not explicitly defined, Eigen spatial convolution
+      // backward input will infer correct forward paddings from input tensors.
+      functor::SpatialConvolutionBackwardInputFunc<Device, T>()(
+          ctx->eigen_device<Device>(), in_backprop_t, filter_t, out_backprop_t,
+          col_stride, row_stride, col_dilation, row_dilation);
+    } else {
+      functor::SpatialConvolutionBackwardInputWithExplicitPaddingFunc<Device,
+                                                                      T>()(
+          ctx->eigen_device<Device>(), in_backprop_t, filter_t, out_backprop_t,
+          in_backprop_t.dimension(2) + (padding_left + padding_right),
+          in_backprop_t.dimension(1) + (padding_top + padding_bottom),
+          col_stride, row_stride, col_dilation, row_dilation, padding_top,
+          padding_left);
+    }
+  }
+};
+
+// Computes backprop input using Eigen::SpatialConvolutionBackwardInput on CPU.
+template <typename T>
+struct LaunchConv2DBackpropInputOp<CPUDevice, T> {
+  void operator()(OpKernelContext* ctx, bool use_cudnn, bool cudnn_use_autotune,
+                  const Tensor& out_backprop, const Tensor& filter,
+                  int row_dilation, int col_dilation, int row_stride,
+                  int col_stride, const Padding& padding,
+                  const std::vector<int64_t>& explicit_paddings,
+                  Tensor* in_backprop, TensorFormat data_format) {
+    LaunchConv2DBackpropInputOpImpl<CPUDevice, T> launcher;
+    launcher(ctx, use_cudnn, cudnn_use_autotune, out_backprop, filter,
+             row_dilation, col_dilation, row_stride, col_stride, padding,
+             explicit_paddings, in_backprop, data_format);
+  }
+};
+
+template <typename T>
+struct Conv2DCustomBackpropInputMatMulFunctor {
+  using MatrixMap = Eigen::Map<
+      Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>>;
+  using ConstMatrixMap = Eigen::Map<
+      const Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>>;
+
+  void operator()(OpKernelContext* ctx, const T* out_data, const T* filter_data,
+                  const int filter_total_size, const int output_image_size,
+                  const int dims_out_depth, T* im2col_buf) {
+    // Compute gradient into 'im2col_buf'.
+    MatrixMap C(im2col_buf, output_image_size, filter_total_size);
+
+    ConstMatrixMap A(out_data, output_image_size, dims_out_depth);
+    ConstMatrixMap B(filter_data, filter_total_size, dims_out_depth);
+
+    C.noalias() = A * B.transpose();
+  }
+};
+
+#if defined(TENSORFLOW_USE_MKLDNN_CONTRACTION_KERNEL)
+template <>
+struct Conv2DCustomBackpropInputMatMulFunctor<float> {
+  using T = float;
+
+  void operator()(OpKernelContext* ctx, const T* out_data, const T* filter_data,
+                  const int filter_total_size, const int output_image_size,
+                  const int dims_out_depth, T* im2col_buf) {
+    // Inputs are in RowMajor order.
+    //   im2col      = out_data    * filter_data^T
+    //   [ois x fts] = [ois x dod] * [fts x dod]^T
+    //
+    // Dimension names:
+    //   out_image_size    -> ois
+    //   filter_total_size -> fts
+    //   dims_out_depth    -> dod
+
+    const int m = output_image_size;
+    const int n = filter_total_size;
+    const int k = dims_out_depth;  // contraction dim
+
+    const char transposeA = 'N';  // sgemm(A) == filter_data
+    const char transposeB = 'T';  // sgemm(B) == out_data
+
+    const int ldA = dims_out_depth;
+    const int ldB = dims_out_depth;
+    const int ldC = filter_total_size;
+
+    const float alpha = 1.0;
+    const float beta = 0.0;
+
+    // dnnl_sgemm code can't be instrumented with msan.
+    ANNOTATE_MEMORY_IS_INITIALIZED(
+        im2col_buf, filter_total_size * output_image_size * sizeof(T));
+
+    dnnl_status_t st =
+        dnnl_sgemm(transposeA, transposeB, m, n, k, alpha, out_data, ldA,
+                   filter_data, ldB, beta, im2col_buf, ldC);
+
+    OP_REQUIRES(
+        ctx, st == 0,
+        errors::Internal("Failed to call dnnl_sgemm. Error code: ", st));
+  }
+};
+#endif
+
+template <typename Device, class T>
+class Conv2DBackpropInputOp : public OpKernel {
+ public:
+  explicit Conv2DBackpropInputOp(OpKernelConstruction* context)
+      : OpKernel(context) {
+    string data_format;
+    OP_REQUIRES_OK(context, context->GetAttr("data_format", &data_format));
+    OP_REQUIRES(context, FormatFromString(data_format, &data_format_),
+                errors::InvalidArgument("Invalid data format"));
+
+    OP_REQUIRES_OK(context, context->GetAttr("strides", &strides_));
+    OP_REQUIRES(context, strides_.size() == 4,
+                errors::InvalidArgument("Sliding window strides field must "
+                                        "specify 4 dimensions"));
+    int stride_n = GetTensorDim(strides_, data_format_, 'N');
+    int stride_c = GetTensorDim(strides_, data_format_, 'C');
+    int stride_h = GetTensorDim(strides_, data_format_, 'H');
+    int stride_w = GetTensorDim(strides_, data_format_, 'W');
+    OP_REQUIRES(
+        context, (stride_n == 1 && stride_c == 1),
+        errors::Unimplemented("Current implementation does not yet support "
+                              "strides in the batch and depth dimensions."));
+    OP_REQUIRES(context, stride_h > 0 && stride_w > 0,
+                errors::InvalidArgument(
+                    "Row and column strides should be larger than 0."));
+
+    OP_REQUIRES_OK(context, context->GetAttr("dilations", &dilations_));
+    OP_REQUIRES(context, dilations_.size() == 4,
+                errors::InvalidArgument("Sliding window dilations field must "
+                                        "specify 4 dimensions"));
+    int dilation_n = GetTensorDim(dilations_, data_format_, 'N');
+    int dilation_c = GetTensorDim(dilations_, data_format_, 'C');
+    int dilation_h = GetTensorDim(dilations_, data_format_, 'H');
+    int dilation_w = GetTensorDim(dilations_, data_format_, 'W');
+    OP_REQUIRES(
+        context, (dilation_n == 1 && dilation_c == 1),
+        errors::Unimplemented("Current implementation does not yet support "
+                              "dilations in the batch and depth dimensions."));
+    OP_REQUIRES(
+        context, dilation_h > 0 && dilation_w > 0,
+        errors::InvalidArgument("Dilated rates should be larger than 0."));
+
+    OP_REQUIRES_OK(context, context->GetAttr("padding", &padding_));
+    OP_REQUIRES_OK(context,
+                   context->GetAttr("explicit_paddings", &explicit_paddings_));
+    OP_REQUIRES_OK(context, CheckValidPadding(padding_, explicit_paddings_,
+                                              /*num_dims=*/4, data_format_));
+
+    OP_REQUIRES_OK(context, context->GetAttr("use_cudnn_on_gpu", &use_cudnn_));
+    cudnn_use_autotune_ = CudnnUseAutotune();
+
+    if (std::is_same<Device, CPUDevice>::value ||
+        std::is_same<T, int32>::value) {
+      OP_REQUIRES(
+          context, data_format_ == FORMAT_NHWC,
+          errors::InvalidArgument("Conv2DBackpropInputOp [CPU or GPU(int32)] "
+                                  "only supports NHWC data format."));
+
+      // TODO(yangzihao): Add a CPU implementation for dilated convolution.
+      OP_REQUIRES(
+          context, (dilation_h == 1 && dilation_w == 1),
+          errors::InvalidArgument(
+              "Conv2DBackpropInputOp [CPU or GPU(int32)] not yet support "
+              "dilation rates larger than 1."));
+    }
+  }
+
+  void Compute(OpKernelContext* context) override {
+    const Tensor& input_sizes = context->input(0);
+    const Tensor& filter = context->input(1);
+    const Tensor& out_backprop = context->input(2);
+
+    OP_REQUIRES(
+        context, out_backprop.dims() == 4,
+        errors::InvalidArgument("input_sizes must be 4-dimensional, got: ",
+                                out_backprop.dims()));
+
+    TensorShape input_shape;
+    OP_REQUIRES_OK(context,
+                   Conv2DBackpropComputeInputShape(input_sizes, filter.shape(),
+                                                   out_backprop.shape(),
+                                                   data_format_, &input_shape));
+
+    Tensor* in_backprop = nullptr;
+    OP_REQUIRES_OK(context,
+                   context->allocate_output(0, input_shape, &in_backprop));
+
+    // If there is nothing to compute, return.
+    if (input_shape.num_elements() == 0) {
+      return;
+    }
+
+    // If shapes are valid but `out_backprop` is empty, in_backprop should be
+    // set to all zeros.  Otherwise, cudnn/dnnl fail with an empty input.
+    if (out_backprop.NumElements() == 0) {
+      functor::SetZeroFunctor<Device, T> set_zero;
+      set_zero(context->eigen_device<Device>(),
+               in_backprop->template flat<T>());
+      return;
+    }
+
+    // For now we take the stride from the second and third dimensions only (we
+    // do not support striding on the batch or depth dimension).
+    const int stride_rows = GetTensorDim(strides_, data_format_, 'H');
+    const int stride_cols = GetTensorDim(strides_, data_format_, 'W');
+    const int dilation_rows = GetTensorDim(dilations_, data_format_, 'H');
+    const int dilation_cols = GetTensorDim(dilations_, data_format_, 'W');
+
+    VLOG(2) << "Conv2DBackpropInput:"
+            << " input: " << input_shape.DebugString()
+            << " filter:" << filter.shape().DebugString()
+            << " out_backprop: " << out_backprop.shape().DebugString()
+            << " strides: [" << stride_rows << ", " << stride_cols << "]"
+            << " dilations: [" << dilation_rows << ", " << dilation_cols << "]";
+
+    LaunchConv2DBackpropInputOp<Device, T> launch;
+    launch(context, use_cudnn_, cudnn_use_autotune_, out_backprop, filter,
+           dilation_rows, dilation_cols, stride_rows, stride_cols, padding_,
+           explicit_paddings_, in_backprop, data_format_);
+  }
+
+ private:
+  std::vector<int32> dilations_;
+  std::vector<int32> strides_;
+  TensorFormat data_format_;
+  Padding padding_;
+  std::vector<int64_t> explicit_paddings_;
+
+  bool use_cudnn_ = false;
+  bool cudnn_use_autotune_ = false;
+
+  Conv2DBackpropInputOp(const Conv2DBackpropInputOp&) = delete;
+  void operator=(const Conv2DBackpropInputOp&) = delete;
+};
+
+// Based on implementation written by Yangqing Jia (jiayq).
+template <typename Device, class T>
+class Conv2DCustomBackpropInputOp : public OpKernel {
+ public:
+  explicit Conv2DCustomBackpropInputOp(OpKernelConstruction* context)
+      : OpKernel(context) {
+    string data_format;
+    OP_REQUIRES_OK(context, context->GetAttr("data_format", &data_format));
+    OP_REQUIRES(context, FormatFromString(data_format, &data_format_),
+                errors::InvalidArgument("Invalid data format"));
+    OP_REQUIRES(context, data_format_ == FORMAT_NHWC,
+                errors::InvalidArgument(
+                    "Conv2DCustomBackpropInputOp only supports NHWC."));
+    OP_REQUIRES_OK(context, context->GetAttr("strides", &strides_));
+    OP_REQUIRES(context, strides_.size() == 4,
+                errors::InvalidArgument("Sliding window strides field must "
+                                        "specify 4 dimensions"));
+    OP_REQUIRES(
+        context, (strides_[0] == 1 && strides_[3] == 1),
+        errors::Unimplemented("Current implementation does not yet support "
+                              "strides in the batch and depth dimensions."));
+    OP_REQUIRES(context, strides_[1] > 0 && strides_[2] > 0,
+                errors::InvalidArgument(
+                    "Row and column strides should be larger than 0."));
+    OP_REQUIRES_OK(context, context->GetAttr("padding", &padding_));
+    OP_REQUIRES_OK(context, context->GetAttr("dilations", &dilations_));
+    OP_REQUIRES(context, dilations_.size() == 4,
+                errors::InvalidArgument("Sliding window dilations field must "
+                                        "specify 4 dimensions"));
+    OP_REQUIRES(
+        context, (dilations_[0] == 1 && dilations_[3] == 1),
+        errors::Unimplemented("Current implementation does not yet support "
+                              "dilations in the batch and depth dimensions."));
+    // TODO(yangzihao): Add a CPU implementation for dilated convolution.
+    OP_REQUIRES(
+        context, (dilations_[1] == 1 && dilations_[2] == 1),
+        errors::InvalidArgument("Current CPU implementations do not yet "
+                                "support dilation rates larger than 1."));
+    OP_REQUIRES_OK(context,
+                   context->GetAttr("explicit_paddings", &explicit_paddings_));
+    OP_REQUIRES_OK(context, CheckValidPadding(padding_, explicit_paddings_,
+                                              /*num_dims=*/4, data_format_));
+  }
+
+  void Compute(OpKernelContext* context) override {
+    const Tensor& input_sizes = context->input(0);
+    const Tensor& filter = context->input(1);
+    const Tensor& out_backprop = context->input(2);
+    OP_REQUIRES(
+        context, out_backprop.dims() == 4,
+        errors::InvalidArgument("input_sizes must be 4-dimensional, got: ",
+                                out_backprop.dims()));
+
+    TensorShape input_shape;
+    OP_REQUIRES_OK(context,
+                   Conv2DBackpropComputeInputShape(input_sizes, filter.shape(),
+                                                   out_backprop.shape(),
+                                                   data_format_, &input_shape));
+
+    ConvBackpropDimensions dims;
+    OP_REQUIRES_OK(context,
+                   ConvBackpropComputeDimensionsV2(
+                       "Conv2DCustomBackpropInput", /*num_spatial_dims=*/2,
+                       input_shape, filter.shape(), out_backprop.shape(),
+                       /*dilations=*/{1, 1, 1, 1}, strides_, padding_,
+                       explicit_paddings_, data_format_, &dims));
+
+    OP_REQUIRES(context, dims.in_depth == filter.shape().dim_size(2),
+                errors::InvalidArgument(
+                    "Gradients for grouped convolutions are not "
+                    "supported on CPU. Please file a feature request if you "
+                    "run into this issue. Computed input depth ",
+                    dims.in_depth, " doesn't match filter input depth ",
+                    filter.shape().dim_size(2)));
+    OP_REQUIRES(
+        context, dims.out_depth == filter.shape().dim_size(3),
+        errors::InvalidArgument("Computed output depth ", dims.out_depth,
+                                " doesn't match filter output depth ",
+                                filter.shape().dim_size(3)));
+
+    Tensor* in_backprop = nullptr;
+    OP_REQUIRES_OK(context,
+                   context->allocate_output(0, input_shape, &in_backprop));
+
+    // If there is nothing to compute, return.
+    if (input_shape.num_elements() == 0) {
+      return;
+    }
+
+    // If shapes are valid but `out_backprop` is empty, in_backprop should be
+    // set to all zeros.  Otherwise, cudnn/dnnl fail with an empty input.
+    if (out_backprop.NumElements() == 0) {
+      functor::SetZeroFunctor<Device, T> set_zero;
+      set_zero(context->eigen_device<Device>(),
+               in_backprop->template flat<T>());
+      return;
+    }
+
+    int64_t pad_top, pad_bottom;
+    int64_t pad_left, pad_right;
+
+    if (padding_ == Padding::EXPLICIT) {
+      pad_top = explicit_paddings_[2];
+      pad_bottom = explicit_paddings_[3];
+      pad_left = explicit_paddings_[4];
+      pad_right = explicit_paddings_[5];
+    }
+    OP_REQUIRES_OK(
+        context,
+        GetWindowedOutputSizeVerbose(
+            dims.spatial_dims[0].input_size, dims.spatial_dims[0].filter_size,
+            /*dilation_rate=*/1, dims.spatial_dims[0].stride, padding_,
+            &dims.spatial_dims[0].output_size, &pad_top, &pad_bottom));
+    OP_REQUIRES_OK(
+        context,
+        GetWindowedOutputSizeVerbose(
+            dims.spatial_dims[1].input_size, dims.spatial_dims[1].filter_size,
+            /*dilation_rate=*/1, dims.spatial_dims[1].stride, padding_,
+            &dims.spatial_dims[1].output_size, &pad_left, &pad_right));
+
+    // The total dimension size of each kernel.
+    const int filter_total_size = dims.spatial_dims[0].filter_size *
+                                  dims.spatial_dims[1].filter_size *
+                                  dims.in_depth;
+    // The output image size is the spatial size of the output.
+    const int output_image_size =
+        dims.spatial_dims[0].output_size * dims.spatial_dims[1].output_size;
+
+    // TODO(andydavis) Get L2/L3 cache sizes from device.
+    const size_t l2_cache_size = 256LL << 10;
+    const size_t l3_cache_size = 30LL << 20;
+
+    // Use L3 cache size as target working set size.
+    const size_t target_working_set_size = l3_cache_size / sizeof(T);
+
+    // Calculate size of matrices involved in MatMul: C = A x B.
+    const size_t size_A = output_image_size * dims.out_depth;
+
+    const size_t size_B = filter_total_size * dims.out_depth;
+
+    const size_t size_C = output_image_size * filter_total_size;
+
+    const size_t work_unit_size = size_A + size_B + size_C;
+
+    auto worker_threads = *(context->device()->tensorflow_cpu_worker_threads());
+
+    // Calculate per-thread work unit size.
+    const size_t thread_work_unit_size =
+        work_unit_size / worker_threads.num_threads;
+
+    // Set minimum per-thread work unit size to size of L2 cache.
+    const size_t min_thread_work_unit_size = l2_cache_size / sizeof(T);
+
+    // Use parallel tensor contractions if there is no batching, or if the
+    // minimum per-thread work unit size threshold has been exceeded.
+    // Otherwise, revert to multiple single-threaded matmul ops running in
+    // parallel to keep all threads busy.
+    // TODO(andydavis) Explore alternatives to branching the code in this way
+    // (i.e. run multiple, parallel tensor contractions in another thread pool).
+    const bool use_parallel_contraction =
+        dims.batch_size == 1 ||
+        thread_work_unit_size >= min_thread_work_unit_size;
+
+    OP_REQUIRES(
+        context, work_unit_size > 0,
+        errors::InvalidArgument("input, filter_sizes and out_backprop tensors "
+                                "must all have at least 1 element"));
+
+    const size_t shard_size =
+        use_parallel_contraction
+            ? 1
+            : (target_working_set_size + work_unit_size - 1) / work_unit_size;
+
+    Tensor col_buffer;
+    OP_REQUIRES_OK(context,
+                   context->allocate_temp(
+                       DataTypeToEnum<T>::value,
+                       TensorShape({static_cast<int64_t>(shard_size),
+                                    static_cast<int64_t>(output_image_size),
+                                    static_cast<int64_t>(filter_total_size)}),
+                       &col_buffer));
+
+    // The input offset corresponding to a single input image.
+    const int input_offset = dims.spatial_dims[0].input_size *
+                             dims.spatial_dims[1].input_size * dims.in_depth;
+    // The output offset corresponding to a single output image.
+    const int output_offset = dims.spatial_dims[0].output_size *
+                              dims.spatial_dims[1].output_size * dims.out_depth;
+
+    const T* filter_data = filter.template flat<T>().data();
+    T* col_buffer_data = col_buffer.template flat<T>().data();
+    const T* out_backprop_data = out_backprop.template flat<T>().data();
+
+    auto in_backprop_flat = in_backprop->template flat<T>();
+    T* input_backprop_data = in_backprop_flat.data();
+    in_backprop_flat.device(context->eigen_device<Device>()) =
+        in_backprop_flat.constant(T(0));
+
+    if (use_parallel_contraction) {
+      typedef Eigen::TensorMap<Eigen::Tensor<T, 2, Eigen::RowMajor>,
+                               Eigen::Unaligned>
+          TensorMap;
+      typedef Eigen::TensorMap<Eigen::Tensor<const T, 2, Eigen::RowMajor>,
+                               Eigen::Unaligned>
+          ConstTensorMap;
+
+      // Initialize contraction dims (we need to transpose 'B' below).
+      Eigen::array<Eigen::IndexPair<Eigen::DenseIndex>, 1> contract_dims;
+      contract_dims[0].first = 1;
+      contract_dims[0].second = 1;
+
+      for (int image_id = 0; image_id < dims.batch_size; ++image_id) {
+        // Compute gradient into col_buffer.
+        TensorMap C(col_buffer_data, output_image_size, filter_total_size);
+
+        ConstTensorMap A(out_backprop_data + output_offset * image_id,
+                         output_image_size, dims.out_depth);
+        ConstTensorMap B(filter_data, filter_total_size, dims.out_depth);
+
+        C.device(context->eigen_cpu_device()) = A.contract(B, contract_dims);
+
+        Col2im<T>(
+            col_buffer_data, dims.in_depth, dims.spatial_dims[0].input_size,
+            dims.spatial_dims[1].input_size, dims.spatial_dims[0].filter_size,
+            dims.spatial_dims[1].filter_size, pad_top, pad_left, pad_bottom,
+            pad_right, dims.spatial_dims[0].stride, dims.spatial_dims[1].stride,
+            input_backprop_data);
+
+        input_backprop_data += input_offset;
+      }
+    } else {
+      for (int image_id = 0; image_id < dims.batch_size;
+           image_id += shard_size) {
+        const int shard_limit =
+            std::min(static_cast<int>(shard_size),
+                     static_cast<int>(dims.batch_size) - image_id);
+
+        auto shard = [&context, &dims, &pad_top, &pad_left, &pad_bottom,
+                      &pad_right, &output_image_size, &filter_total_size,
+                      &input_backprop_data, &col_buffer_data,
+                      &out_backprop_data, &filter_data, &input_offset,
+                      &output_offset, &size_C](int64_t start, int64_t limit) {
+          for (int shard_id = start; shard_id < limit; ++shard_id) {
+            T* im2col_buf = col_buffer_data + shard_id * size_C;
+            T* input_data = input_backprop_data + shard_id * input_offset;
+            const T* out_data = out_backprop_data + shard_id * output_offset;
+
+            Conv2DCustomBackpropInputMatMulFunctor<T>()(
+                context, out_data, filter_data, filter_total_size,
+                output_image_size, dims.out_depth, im2col_buf);
+
+            Col2im<T>(im2col_buf, dims.in_depth,
+                      dims.spatial_dims[0].input_size,
+                      dims.spatial_dims[1].input_size,
+                      dims.spatial_dims[0].filter_size,
+                      dims.spatial_dims[1].filter_size, pad_top, pad_left,
+                      pad_bottom, pad_right, dims.spatial_dims[0].stride,
+                      dims.spatial_dims[1].stride, input_data);
+          }
+        };
+        Shard(worker_threads.num_threads, worker_threads.workers, shard_limit,
+              work_unit_size, shard);
+
+        input_backprop_data += input_offset * shard_limit;
+        out_backprop_data += output_offset * shard_limit;
+      }
+    }
+  }
+
+ private:
+  std::vector<int32> dilations_;
+  std::vector<int32> strides_;
+  Padding padding_;
+  std::vector<int64_t> explicit_paddings_;
+  TensorFormat data_format_;
+
+  Conv2DCustomBackpropInputOp(const Conv2DCustomBackpropInputOp&) = delete;
+  void operator=(const Conv2DCustomBackpropInputOp&) = delete;
+};
+
+// TODO(ezhulenev): Add a cost model to switch between custom/Eigen ops.
+#define DEFAULT_CONV_2D_BACKPROP_CPU_OP Conv2DCustomBackpropInputOp
+
+#define REGISTER_CONV_2D_BACKPROP_CPU_KERNELS(T)                             \
+  REGISTER_KERNEL_BUILDER(                                                   \
+      Name("Conv2DBackpropInput").Device(DEVICE_CPU).TypeConstraint<T>("T"), \
+      DEFAULT_CONV_2D_BACKPROP_CPU_OP<CPUDevice, T>);                        \
+  REGISTER_KERNEL_BUILDER(Name("Conv2DBackpropInput")                        \
+                              .Device(DEVICE_CPU)                            \
+                              .Label("custom")                               \
+                              .TypeConstraint<T>("T"),                       \
+                          Conv2DCustomBackpropInputOp<CPUDevice, T>);        \
+  REGISTER_KERNEL_BUILDER(Name("Conv2DBackpropInput")                        \
+                              .Device(DEVICE_CPU)                            \
+                              .Label("eigen_tensor")                         \
+                              .TypeConstraint<T>("T"),                       \
+                          Conv2DBackpropInputOp<CPUDevice, T>);
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_CONV_GRAD_INPUT_OPS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/conv_grad_ops.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/conv_grad_ops.h
new file mode 100644
index 0000000000000000000000000000000000000000..40e03b2b594ab7afdf849834cfbede4dfe5bb033
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/conv_grad_ops.h
@@ -0,0 +1,215 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// This is the common header for the input and filter backprop kernels.
+//
+// The operation to compute Conv2D gradients.
+//
+// To compute the gradients for Conv2D, we need three input tensors:
+//    input, filter, and backprop for output.
+// And we need to compute two backprops: one for input and one for filter. We
+// compute them in two different kernels.
+//
+// Both backprops can be computed as straightforward conv2d.
+//
+// Consider a case where the input is 3x3 and the filter is 2x1:
+//
+// INPUT = [ A  B  C ]
+//         [ D  E  F ]
+//         [ G  H  I ]
+//
+// where each "A", "B", etc is batch x in_depth
+//
+// FILTER = [ X  Y ]
+//
+// where both "X" and "Y" are in_depth x out_depth
+//
+// With VALID padding, the output is 3x2:
+//
+// OUTPUT = [ a  b ]
+//          [ c  d ]
+//          [ e  f ]
+//
+// where each "a", "b", etc is batch x out_depth
+//
+// So we have:
+//
+//   a = A * X + B * Y
+//   b = B * X + C * Y
+//   c = D * X + E * Y
+//   d = E * X + F * Y
+//   e = G * X + H * Y
+//   f = H * X + I * Y
+//
+// So when we have backprops for the outputs (we denote them by
+// a', b', ... ):
+//
+// The backprops for the input are:
+//
+//   A' = a' * X^t
+//   B' = a' * Y^t + b' * X^t
+//   C' = b' * Y^t
+//   ...
+//
+// This is essentially computing a 2d conv of
+//
+// INPUT = [ 0  a'  b'  0 ]
+//         [ 0  c'  d'  0 ]
+//         [ 0  e'  f'  0 ]
+// and
+//
+// FILTER = [ Y^t X^t ]
+//
+// The backprops for the filter are:
+//
+//   X' = A^t * a' + B^t * b' + D^t * c' + E^t * d' + G^t * e' + H^t * f'
+//   Y' = B^t * a' + C^t * b' + E^t + c' + F^t * d' + H^t * e' + I^t * f'
+//
+// This is essentially computing a 2d conv of
+//
+// INPUT = [ A^t  B^t  C^t ]
+//         [ D^t  E^t  F^t ]
+//         [ G^t  H^t  I^t ]
+//
+// and
+//
+// FILTER = [ a'  b' ]
+//          [ c'  d' ]
+//          [ e'  f' ]
+//
+//
+//////////////////////////////////////////////////////////
+//
+// With stride more than one, it's a bit more complicated (we will need to
+// create holes to the backprop).
+//
+// Consider the case where
+//
+// INPUT = [ A B C D E ]
+//         [ F G H I J ]
+//         [ K L M N O ]
+// and
+//
+// FILTER = [ X Y Z ]
+//
+// with stride 2.
+//
+// The output will be
+//
+// OUTPUT = [ a b ]
+//          [ c d ]
+//
+// where:
+//
+//   a = A * X + B * Y + C * Z
+//   b = C * X + D * Y + E * Z
+//   c = K * X + L * Y + M * Z
+//   d = M * X + N * Y + O * Z
+//
+//
+// To compute the backprop for INPUT, we need to convolve
+//
+// INPUT = [ 0  0  a' 0  b' 0  0 ]
+//         [ 0  0  0  0  0  0  0 ]
+//         [ 0  0  c' 0  d' 0  0 ]
+//
+// (notice the holes in INPUT)
+//
+// and
+//
+// FILTER = [ Z^t  Y^t  X^t ]
+//
+// with stride 1.
+//
+// To compute the backprop for FILTER, we need to convolve
+
+//
+// INPUT = [ A^t  B^t  C^t  D^t  E^t ]
+//         [ F^t  G^t  H^t  I^t  J^t ]
+//         [ K^t  L^t  M^t  N^t  O^t ]
+// and
+//
+// FILTER = [ a' 0  b' ]
+//          [ 0  0  0  ]
+//          [ c' 0  d' ]
+//
+// (notice the holes in FILTER)
+//
+//
+// with stride 1
+//
+//////////////////////////////////////////////////////////
+//
+//
+// The case for SAME padding is in fact very similar to VALID -- we just
+// need to pad the input tensor a bit when computing the filter_backprop.
+
+#ifndef TENSORFLOW_CORE_KERNELS_CONV_GRAD_OPS_H_
+#define TENSORFLOW_CORE_KERNELS_CONV_GRAD_OPS_H_
+
+#include <vector>
+
+#include "tensorflow/core/util/padding.h"
+#include "tensorflow/core/util/tensor_format.h"
+
+namespace tensorflow {
+
+// Forward declaration.
+class OpKernelContext;
+
+template <typename Device, typename T>
+struct LaunchConv2DBackpropInputOp {
+  void operator()(OpKernelContext* ctx, bool use_cudnn, bool cudnn_use_autotune,
+                  const Tensor& out_backprop, const Tensor& filter,
+                  int row_dilation, int col_dilation, int row_stride,
+                  int col_stride, const Padding& padding,
+                  const std::vector<int64_t>& explicit_paddings,
+                  Tensor* in_backprop, TensorFormat data_format);
+};
+
+template <typename Device, typename T>
+struct LaunchConv2DBackpropFilterOp {
+  void operator()(OpKernelContext* ctx, bool use_cudnn, bool cudnn_use_autotune,
+                  const Tensor& out_backprop, const Tensor& input,
+                  int row_dilation, int col_dilation, int row_stride,
+                  int col_stride, const Padding& padding,
+                  const std::vector<int64_t>& explicit_paddings,
+                  Tensor* filter_backprop, TensorFormat data_format);
+};
+
+#if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+template <typename T>
+struct LaunchConv2DBackpropInputOp<Eigen::GpuDevice, T> {
+  void operator()(OpKernelContext* ctx, bool use_cudnn, bool cudnn_use_autotune,
+                  const Tensor& input, const Tensor& filter, int row_dilation,
+                  int col_dilation, int row_stride, int col_stride,
+                  const Padding& padding,
+                  const std::vector<int64_t>& explicit_paddings, Tensor* output,
+                  TensorFormat data_format);
+};
+
+template <typename T>
+struct LaunchConv2DBackpropFilterOp<Eigen::GpuDevice, T> {
+  void operator()(OpKernelContext* ctx, bool use_cudnn, bool cudnn_use_autotune,
+                  const Tensor& out_backprop, const Tensor& input,
+                  int row_dilation, int col_dilation, int row_stride,
+                  int col_stride, const Padding& padding,
+                  const std::vector<int64_t>& explicit_paddings,
+                  Tensor* filter_backprop, TensorFormat data_format);
+};
+#endif  // GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_CONV_GRAD_OPS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/conv_grad_shape_utils.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/conv_grad_shape_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..37affc8455c696fdd5897ace2c0cbd7868ac8374
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/conv_grad_shape_utils.h
@@ -0,0 +1,95 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_CONV_GRAD_SHAPE_UTILS_H_
+#define TENSORFLOW_CORE_KERNELS_CONV_GRAD_SHAPE_UTILS_H_
+
+#include <vector>
+
+#include "tensorflow/core/framework/tensor_shape.h"
+#include "tensorflow/core/lib/core/stringpiece.h"
+#include "tensorflow/core/util/padding.h"
+#include "tensorflow/core/util/tensor_format.h"
+
+namespace tensorflow {
+// Information about a single spatial dimension for a convolution
+// backpropagation.
+struct ConvBackpropSpatialDimension {
+  int64_t input_size;
+  int64_t filter_size;
+  int64_t output_size;
+  int64_t stride;
+  int64_t dilation;
+
+  // Output size after scaling by the stride.
+  int64_t expanded_output_size;
+
+  // Number of padding elements to be added before/after this dimension of
+  // the input when computing Conv?DBackpropInput.
+  int64_t pad_before, pad_after;
+};
+
+// Computed dimensions for a backwards convolution.
+struct ConvBackpropDimensions {
+  // Information about each spatial dimension.
+  gtl::InlinedVector<ConvBackpropSpatialDimension, 3> spatial_dims;
+
+  // Batch size.
+  int64_t batch_size;
+
+  // Input and output feature depth.
+  int64_t in_depth, out_depth;
+
+  // Convenience access methods for spatial dimensions properties.
+  int64_t input_size(int dim) const { return spatial_dims[dim].input_size; }
+  int64_t filter_size(int dim) const { return spatial_dims[dim].filter_size; }
+  int64_t output_size(int dim) const { return spatial_dims[dim].output_size; }
+  int64_t stride(int dim) const { return spatial_dims[dim].stride; }
+  int64_t dilation(int dim) const { return spatial_dims[dim].dilation; }
+
+  // Compute padding for the given spatial dimension.
+  int SpatialPadding(const Padding& padding, int dim) const;
+};
+
+// Common code between implementations of Conv?DBackpropInput and
+// Conv?DBackpropFilter. Verifies that the dimensions all match, and computes
+// sizes/padding for the spatial dimensions. Does not support explicit padding.
+Status ConvBackpropComputeDimensions(StringPiece label, int num_spatial_dims,
+                                     const TensorShape& input_shape,
+                                     const TensorShape& filter_shape,
+                                     const TensorShape& out_backprop_shape,
+                                     const std::vector<int32>& strides,
+                                     Padding padding, TensorFormat data_format,
+                                     ConvBackpropDimensions* dims);
+
+// The V2 version computes the same outputs with arbitrary dilation rate and
+// supports explicit padding.
+// TODO(b/67112639): Merge V2 versions and the original versions eventually.
+Status ConvBackpropComputeDimensionsV2(
+    StringPiece label, int num_spatial_dims, const TensorShape& input_shape,
+    const TensorShape& filter_shape, const TensorShape& out_backprop_shape,
+    const gtl::ArraySlice<int32>& dilations, const std::vector<int32>& strides,
+    Padding padding, absl::Span<const int64_t> explicit_paddings,
+    TensorFormat data_format, ConvBackpropDimensions* dims);
+
+// Computes the shape of the in_backprop.
+Status Conv2DBackpropComputeInputShape(const Tensor& input_sizes,
+                                       const TensorShape& filter_shape,
+                                       const TensorShape& out_backprop_shape,
+                                       const TensorFormat& data_format,
+                                       TensorShape* input_shape);
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_CONV_GRAD_SHAPE_UTILS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/conv_ops.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/conv_ops.h
new file mode 100644
index 0000000000000000000000000000000000000000..aaa496422796745eb86e6e5f0e1da5abbccaac0a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/conv_ops.h
@@ -0,0 +1,140 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_CONV_OPS_H_
+#define TENSORFLOW_CORE_KERNELS_CONV_OPS_H_
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/framework/resource_mgr.h"
+#include "tensorflow/core/platform/mem.h"
+#include "tensorflow/core/util/tensor_format.h"
+
+#if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+#include "tensorflow/core/kernels/conv_ops_gpu.h"
+#include "tensorflow/core/platform/stream_executor.h"
+#endif  // GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+
+namespace tensorflow {
+
+// Forward declaration.
+class OpKernelContext;
+
+template <typename Device, typename T>
+struct LaunchConv2DOp {
+  void operator()(OpKernelContext* ctx, bool use_cudnn, bool cudnn_use_autotune,
+                  const Tensor& input, const Tensor& filter, int row_dilation,
+                  int col_dilation, int row_stride, int col_stride,
+                  const Padding& padding,
+                  const std::vector<int64_t>& explicit_paddings, Tensor* output,
+                  TensorFormat data_format);
+};
+
+template <typename Device, typename T>
+struct LaunchConvOp {
+  void operator()(OpKernelContext* context, bool cudnn_use_autotune,
+                  const Tensor& input, const Tensor& filter,
+                  const std::vector<int64>& dilations,
+                  const std::vector<int64>& strides, Padding padding,
+                  const std::vector<int64_t>& explicit_paddings,
+                  TensorFormat data_format, Tensor* output);
+};
+
+#if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+template <typename T>
+struct LaunchConv2DOp<Eigen::GpuDevice, T> {
+  void operator()(OpKernelContext* ctx, bool use_cudnn, bool cudnn_use_autotune,
+                  const Tensor& input, const Tensor& filter, int row_dilation,
+                  int col_dilation, int row_stride, int col_stride,
+                  const Padding& padding,
+                  const std::vector<int64_t>& explicit_paddings, Tensor* output,
+                  TensorFormat data_format);
+};
+
+template <typename T>
+struct LaunchConvOp<Eigen::GpuDevice, T> {
+  void operator()(OpKernelContext* context, bool cudnn_use_autotune,
+                  const Tensor& input, const Tensor& filter,
+                  const std::vector<int64>& dilations,
+                  const std::vector<int64>& strides, const Padding padding,
+                  const std::vector<int64_t>& explicit_paddings,
+                  TensorFormat data_format, Tensor* output);
+};
+#endif  // GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+
+// Used to keep track of persistent memory buffers used within the op.
+// It uses malloc and free to avoid the time cost of initializing the memory.
+template <class T, size_t size>
+struct Im2ColBufferResource : public ResourceBase {
+  Im2ColBufferResource<T, size>() {
+    data = static_cast<T*>(port::Malloc(size * sizeof(T)));
+  }
+  ~Im2ColBufferResource<T, size>() { port::Free(data); }
+  // This mutex ensures that only a single operation at a time is able to use
+  // the buffer memory held by this resource.
+  mutex mu;
+  T* data;
+  string DebugString() const { return "Im2ColBufferResource"; }
+};
+
+// Convolution parameters specified by Op attributes.
+struct Conv2DParameters {
+  std::vector<int32> dilations;
+  std::vector<int32> strides;
+  Padding padding;
+  TensorFormat data_format;
+  std::vector<int64_t> explicit_paddings;
+};
+
+// Convolution dimensions inferred from parameters, input and filter tensors.
+struct Conv2DDimensions {
+  int batch;
+  int input_rows;
+  int input_cols;
+  int in_depth;
+
+  int filter_rows;
+  int filter_cols;
+  int patch_depth;
+  int out_depth;
+
+  int stride_rows;
+  int stride_cols;
+
+  int dilation_rows;
+  int dilation_cols;
+
+  int64_t out_rows;
+  int64_t out_cols;
+  int64_t pad_rows_before;
+  int64_t pad_rows_after;
+  int64_t pad_cols_before;
+  int64_t pad_cols_after;
+};
+
+// Initializes and validates Conv2D parameters configured by OpKernel
+// attributes.
+Status InitConv2DParameters(const OpKernelConstruction* context,
+                            Conv2DParameters* params);
+
+// Computes and validates convolutions dimensions from Conv2D parameters. If
+// parameters are valid, dimensions will be updated with derived convolution
+// dimensions, otherwise an error will be returned.
+Status ComputeConv2DDimension(const Conv2DParameters& params,
+                              const Tensor& input, const Tensor& filter,
+                              Conv2DDimensions* dimensions);
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_CONV_OPS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/conv_ops_fused_impl.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/conv_ops_fused_impl.h
new file mode 100644
index 0000000000000000000000000000000000000000..1b2f2a6e17d395ec92b283f9a60b42efd939cc93
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/conv_ops_fused_impl.h
@@ -0,0 +1,845 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// Implements convolution operations with other kernels baked into the
+// processing, to optimize latency and memory usage:
+//  - Conv2D + BiasAdd + <Activation>
+//  - Conv2D + FusedBatchNorm + <Activation>
+//
+// Activation: Relu, Relu6, Elu, etc...
+//
+// Kernels for convolutions fused with image transformations (resize and mirror
+// padding) defined in `conv_ops_fused_image_transform.cc`.
+//
+// For the CPU device we implement fusion with an Eigen tensor contraction
+// output kernel. For the GPU device we rely on CuDNN primitives.
+//
+// NOTE: GPU only supports fusion of Conv2D + BiasAdd + <optional Relu>.
+
+#ifndef TENSORFLOW_CORE_KERNELS_CONV_OPS_FUSED_IMPL_H_
+#define TENSORFLOW_CORE_KERNELS_CONV_OPS_FUSED_IMPL_H_
+
+#define USE_EIGEN_TENSOR
+#define EIGEN_USE_THREADS
+
+#if GOOGLE_CUDA
+#define EIGEN_USE_GPU
+#endif  // GOOGLE_CUDA
+
+#include <string>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include "tensorflow/core/framework/bounds_check.h"
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/register_types.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/tensor_shape.h"
+#include "tensorflow/core/kernels/conv_2d.h"
+#include "tensorflow/core/kernels/conv_ops.h"
+#include "tensorflow/core/kernels/fused_eigen_output_kernels.h"
+#include "tensorflow/core/kernels/ops_util.h"
+#include "tensorflow/core/profiler/lib/scoped_annotation.h"
+#include "tensorflow/core/util/tensor_format.h"
+#include "tensorflow/core/util/use_cudnn.h"
+
+#if GOOGLE_CUDA
+#include "third_party/gpus/cudnn/cudnn.h"
+#include "xla/stream_executor/gpu/gpu_asm_opts.h"
+#include "xla/stream_executor/gpu/redzone_allocator.h"
+#include "xla/stream_executor/tf_allocator_adapter.h"
+#include "tensorflow/core/kernels/conv_ops_gpu.h"
+#include "tensorflow/core/platform/stream_executor.h"
+#include "tensorflow/core/util/autotune_maps/conv_autotune_maps.h"
+#include "tensorflow/core/util/autotune_maps/conv_parameters.h"
+#include "tensorflow/core/util/proto/proto_utils.h"
+#endif  // GOOGLE_CUDA
+
+namespace tensorflow {
+
+typedef Eigen::ThreadPoolDevice CPUDevice;
+typedef Eigen::GpuDevice GPUDevice;
+
+template <typename Device, typename T>
+struct LaunchFusedConv2DOp {
+  void operator()(OpKernelContext* context, bool use_cudnn,
+                  bool cudnn_use_autotune, const Tensor& input,
+                  const Tensor& filter, FusedComputationType fusion,
+                  const FusedComputationArgs& fusion_args,
+                  const Conv2DParameters& params,
+                  const Conv2DDimensions& dimensions, Tensor* output);
+};
+
+// This is CPU-only implementation that uses Eigen contraction output kernels.
+//
+// Dispatch 2D convolution to the appropriate primitive operation:
+//   (1) MatMul for the case of 1x1 convolution.
+//   (2) MatMul for the case when filter size equals to the input size.
+//   (3) General spatial 2D convolution for all other cases.
+template <typename T>
+class LaunchFusedConv2DWithOutputKernel {
+ public:
+  LaunchFusedConv2DWithOutputKernel(
+      int row_stride, int col_stride,      //
+      int row_dilation, int col_dilation,  //
+      Padding padding, const std::vector<int64_t>& explicit_paddings)
+      : row_stride_(row_stride),
+        col_stride_(col_stride),
+        row_dilation_(row_dilation),
+        col_dilation_(col_dilation),
+        padding_(padding),
+        explicit_paddings_(explicit_paddings) {}
+
+  template <typename OutputKernel>
+  void operator()(const OutputKernel& output_kernel, OpKernelContext* ctx,
+                  const Tensor& input, const Tensor& filter, Tensor* output) {
+    // Wrap output_kernel into type erased wrapper to reduce the number of
+    // unique template instantiations for Eigen Tensor contraction expressions.
+    OutputKernelWrapper output_kernel_wrapper(
+        [&output_kernel](
+            const ContractionOutputMapper<T, Eigen::Index>& output_mapper,
+            const Eigen::TensorContractionParams& params, Eigen::Index i,
+            Eigen::Index j, Eigen::Index num_rows, Eigen::Index num_cols) {
+          output_kernel(output_mapper, params, i, j, num_rows, num_cols);
+        });
+
+    if (filter.dim_size(0) == 1 && filter.dim_size(1) == 1 &&
+        row_stride_ == 1 && col_stride_ == 1 && padding_ != EXPLICIT) {
+      int conv_width = 1;  // Width for the convolution step.
+      for (int i = 0; i < 3; ++i) {
+        conv_width *= output->dim_size(i);
+      }
+
+      Eigen::array<Eigen::IndexPair<Eigen::DenseIndex>, 1> dim_pair;
+      dim_pair[0] = Eigen::IndexPair<Eigen::DenseIndex>(1, 0);
+      functor::MatMulConvFunctor<CPUDevice, T, OutputKernelWrapper>()(
+          ctx->eigen_device<CPUDevice>(),
+          output->shaped<T, 2>({conv_width, filter.dim_size(3)}),
+          input.shaped<T, 2>({conv_width, filter.dim_size(2)}),
+          filter.shaped<T, 2>({filter.dim_size(2), filter.dim_size(3)}),
+          dim_pair, std::move(output_kernel_wrapper));
+
+    } else if (filter.dim_size(0) == input.dim_size(1) &&
+               filter.dim_size(1) == input.dim_size(2) && row_dilation_ == 1 &&
+               col_dilation_ == 1 && padding_ == VALID) {
+      // If the input data and filter have the same height/width,
+      // reduce the 2D convolution to matrix multiplication.
+      const auto k =  // Length of reduction dimension.
+          filter.dim_size(0) * filter.dim_size(1) * filter.dim_size(2);
+
+      Eigen::array<Eigen::IndexPair<Eigen::DenseIndex>, 1> dim_pair;
+      dim_pair[0] = Eigen::IndexPair<Eigen::DenseIndex>(1, 0);
+      functor::MatMulConvFunctor<CPUDevice, T, OutputKernelWrapper>()(
+          ctx->eigen_device<CPUDevice>(),
+          output->shaped<T, 2>({input.dim_size(0), filter.dim_size(3)}),
+          input.shaped<T, 2>({input.dim_size(0), k}),
+          filter.shaped<T, 2>({k, filter.dim_size(3)}), dim_pair,
+          std::move(output_kernel_wrapper));
+
+    } else {
+      if (padding_ == EXPLICIT) {
+        functor::SpatialConvolution<CPUDevice, T, OutputKernelWrapper>()(
+            ctx->eigen_device<CPUDevice>(), output->tensor<T, 4>(),
+            input.tensor<T, 4>(), filter.tensor<T, 4>(), row_stride_,
+            col_stride_, row_dilation_, col_dilation_,
+            static_cast<int>(explicit_paddings_[2]),
+            static_cast<int>(explicit_paddings_[3]),
+            static_cast<int>(explicit_paddings_[4]),
+            static_cast<int>(explicit_paddings_[5]),
+            std::move(output_kernel_wrapper));
+      } else {
+        functor::SpatialConvolution<CPUDevice, T, OutputKernelWrapper>()(
+            ctx->eigen_device<CPUDevice>(), output->tensor<T, 4>(),
+            input.tensor<T, 4>(), filter.tensor<T, 4>(), row_stride_,
+            col_stride_, row_dilation_, col_dilation_,
+            BrainPadding2EigenPadding(padding_),
+            std::move(output_kernel_wrapper));
+      }
+    }
+  }
+
+ private:
+  // Wrap output_kernel into type erased struct to reduce the number of unique
+  // template instantiations for Eigen Tensor contraction expressions.
+  //
+  // We do not pass std::function directly as an output kernel because it blows
+  // up the binary size in debug mode with super long symbol names.
+  struct OutputKernelWrapper {
+    using OutputKernelFn =
+        std::function<void(const ContractionOutputMapper<T, Eigen::Index>&,
+                           const Eigen::TensorContractionParams&, Eigen::Index,
+                           Eigen::Index, Eigen::Index, Eigen::Index)>;
+
+    explicit OutputKernelWrapper(OutputKernelFn fn)
+        : output_kernel_fn(std::move(fn)) {}
+
+    void operator()(
+        const ContractionOutputMapper<T, Eigen::Index>& output_mapper,
+        const Eigen::TensorContractionParams& params, Eigen::Index i,
+        Eigen::Index j, Eigen::Index num_rows, Eigen::Index num_cols) const {
+      output_kernel_fn(output_mapper, params, i, j, num_rows, num_cols);
+    }
+
+    OutputKernelFn output_kernel_fn;
+  };
+
+  int row_stride_;
+  int col_stride_;
+  int row_dilation_;
+  int col_dilation_;
+  const Padding padding_;
+  const std::vector<int64_t>& explicit_paddings_;
+};
+
+template <typename T>
+struct LaunchFusedConv2DOp<CPUDevice, T> {
+  void operator()(OpKernelContext* context, bool use_cudnn,
+                  bool cudnn_use_autotune, const Tensor& input,
+                  const Tensor& filter, const FusedComputationType fusion,
+                  const FusedComputationArgs& fusion_args,
+                  const Conv2DParameters& params,
+                  const Conv2DDimensions& dimensions, Tensor* output) {
+    OP_REQUIRES(context, dimensions.in_depth == filter.dim_size(2),
+                errors::Unimplemented("Fused conv implementation does not "
+                                      "support grouped convolutions for now."));
+    OP_REQUIRES(context, params.data_format == FORMAT_NHWC,
+                errors::Unimplemented("Fused conv implementation only supports "
+                                      "NHWC tensor format for now."));
+    OP_REQUIRES(context, DataTypeToEnum<T>::value != DT_HALF,
+                errors::Unimplemented("Fused conv implementation with half "
+                                      "precision is not supported on CPU."));
+
+    BiasAddArgs<T> bias_add_args;
+    if (BiasAddArgs<T>::IsSupported(fusion)) {
+      if (fusion == FusedComputationType::kBiasAddWithLeakyRelu) {
+        OP_REQUIRES_OK(context, InitBiasAddArgs(context, &bias_add_args,
+                                                &fusion_args.leakyrelu_alpha));
+      } else {
+        OP_REQUIRES_OK(context, InitBiasAddArgs(context, &bias_add_args));
+      }
+    }
+
+    FusedBatchNormArgs<T> fused_batch_norm_args;
+    if (FusedBatchNormArgs<T>::IsSupported(fusion)) {
+      if (fusion == FusedComputationType::kFusedBatchNormWithLeakyRelu) {
+        OP_REQUIRES_OK(context,
+                       InitFusedBatchNormArgs(context, fusion_args.epsilon,
+                                              &fused_batch_norm_args,
+                                              &fusion_args.leakyrelu_alpha));
+      } else {
+        OP_REQUIRES_OK(context,
+                       InitFusedBatchNormArgs(context, fusion_args.epsilon,
+                                              &fused_batch_norm_args));
+      }
+    }
+
+    LaunchFusedConv2DWithOutputKernel<T> conv2d(
+        dimensions.stride_rows, dimensions.stride_cols,
+        dimensions.dilation_rows, dimensions.dilation_cols, params.padding,
+        params.explicit_paddings);
+
+    switch (fusion) {
+      case FusedComputationType::kUndefined:
+        OP_REQUIRES_OK(context, errors::Internal("Fusion type is undefined"));
+        break;
+      case FusedComputationType::kBiasAdd:
+        conv2d(WithBiasAdd<T>(bias_add_args), context, input, filter, output);
+        break;
+      case FusedComputationType::kBiasAddWithRelu:
+        conv2d(WithBiasAddAndRelu<T>(bias_add_args), context, input, filter,
+               output);
+        break;
+      case FusedComputationType::kBiasAddWithRelu6:
+        conv2d(WithBiasAddAndRelu6<T>(bias_add_args), context, input, filter,
+               output);
+        break;
+      case FusedComputationType::kBiasAddWithLeakyRelu:
+        conv2d(WithBiasAddAndLeakyRelu<T>(bias_add_args), context, input,
+               filter, output);
+        break;
+      case FusedComputationType::kBiasAddWithElu:
+        conv2d(WithBiasAddAndElu<T>(bias_add_args), context, input, filter,
+               output);
+        break;
+      case FusedComputationType::kFusedBatchNorm:
+        conv2d(
+            WithFusedBatchNorm<T>(fusion_args.epsilon, fused_batch_norm_args),
+            context, input, filter, output);
+        break;
+      case FusedComputationType::kFusedBatchNormWithRelu:
+        conv2d(WithFusedBatchNormAndRelu<T>(fusion_args.epsilon,
+                                            fused_batch_norm_args),
+               context, input, filter, output);
+        break;
+      case FusedComputationType::kFusedBatchNormWithRelu6:
+        conv2d(WithFusedBatchNormAndRelu6<T>(fusion_args.epsilon,
+                                             fused_batch_norm_args),
+               context, input, filter, output);
+        break;
+      case FusedComputationType::kFusedBatchNormWithLeakyRelu:
+        conv2d(WithFusedBatchNormAndLeakyRelu<T>(fusion_args.epsilon,
+                                                 fused_batch_norm_args),
+               context, input, filter, output);
+        break;
+      case FusedComputationType::kFusedBatchNormWithElu:
+        conv2d(WithFusedBatchNormAndElu<T>(fusion_args.epsilon,
+                                           fused_batch_norm_args),
+               context, input, filter, output);
+        break;
+      default:
+        OP_REQUIRES_OK(context, errors::Internal("Fusion type is unsupported"));
+        break;
+    }
+  }
+};
+
+template <>
+struct LaunchFusedConv2DOp<CPUDevice, int8>;
+
+template <>
+struct LaunchFusedConv2DOp<CPUDevice, qint8>;
+
+#if GOOGLE_CUDA
+
+inline int64_t ConvolveScratchSize() {
+  static int64_t convolve_scratch_size = GetDnnWorkspaceLimit(
+      // default value is in bytes despite the name of the environment variable
+      "TF_CUDNN_WORKSPACE_LIMIT_IN_MB", 1LL << 32  // 4GB
+  );
+  return convolve_scratch_size;
+}
+
+template <typename T>
+struct LaunchFusedConv2DOp<GPUDevice, T> {
+  void operator()(OpKernelContext* context, bool use_cudnn,
+                  bool cudnn_use_autotune, const Tensor& input_param,
+                  const Tensor& filter, FusedComputationType fusion,
+                  const FusedComputationArgs& fusion_args,
+                  const Conv2DParameters& params,
+                  const Conv2DDimensions& dimensions, Tensor* output) {
+    OP_REQUIRES(
+        context,
+        params.data_format == FORMAT_NHWC || params.data_format == FORMAT_NCHW,
+        errors::Unimplemented("Fused conv implementation only supports "
+                              "NHWC and HCHW tensor formats for now."));
+
+    auto* stream = context->op_device_context()->stream();
+    OP_REQUIRES(context, stream, errors::Internal("No GPU stream available."));
+    OP_REQUIRES(
+        context, use_cudnn,
+        errors::Unimplemented("FusedConv2D for GPU is not currently supported "
+                              "without cudnn"));
+
+    bool is_supported_activation =
+        fusion == FusedComputationType::kBiasAddWithRelu ||
+        fusion == FusedComputationType::kBiasAddWithRelu6 ||
+        fusion == FusedComputationType::kBiasAddWithElu ||
+        fusion == FusedComputationType::kBiasAddWithLeakyRelu;
+    OP_REQUIRES(
+        context, is_supported_activation,
+        errors::Unimplemented("FusedConv2D implementation only supports "
+                              "fusing with `BiasAdd + Relu|Relu6|Elu|LeakyRlue`"
+                              " for now."));
+
+    Tensor input = input_param;
+
+    const int64_t in_batch = GetTensorDim(input, params.data_format, 'N');
+    int64_t in_rows = GetTensorDim(input, params.data_format, 'H');
+    int64_t in_cols = GetTensorDim(input, params.data_format, 'W');
+    const int64_t in_depths = GetTensorDim(input, params.data_format, 'C');
+
+    const int64_t patch_rows = filter.dim_size(0);
+    const int64_t patch_cols = filter.dim_size(1);
+    const int64_t patch_depths = filter.dim_size(2);
+
+    const int64_t out_batch = GetTensorDim(*output, params.data_format, 'N');
+    const int64_t out_rows = GetTensorDim(*output, params.data_format, 'H');
+    const int64_t out_cols = GetTensorDim(*output, params.data_format, 'W');
+    const int64_t out_depths = GetTensorDim(*output, params.data_format, 'C');
+
+    // Bias of the following dimensions: [ output_depth ]
+    const Tensor& bias = context->input(2);
+    OP_REQUIRES(context, bias.dims() == 1,
+                errors::InvalidArgument("bias must be 1-dimensional",
+                                        bias.shape().DebugString()));
+    OP_REQUIRES(context, bias.dim_size(0) == out_depths,
+                errors::InvalidArgument("bias depth must be equal to out depth",
+                                        bias.shape().DebugString()));
+
+    const int64_t common_padding_rows =
+        std::min(dimensions.pad_rows_before, dimensions.pad_rows_after);
+    const int64_t common_padding_cols =
+        std::min(dimensions.pad_cols_before, dimensions.pad_cols_after);
+    if (dimensions.pad_rows_before != dimensions.pad_rows_after ||
+        dimensions.pad_cols_before != dimensions.pad_cols_after) {
+      // cuDNN only supports padding the same amount on the left and right
+      // sides, and on the top and bottom sides. So we manually create a new
+      // padded input tensor such that we can pass it to cuDNN.
+
+      // TODO(reedwm): In some cases, we can avoid an allocation even if the two
+      // padding sides are different. For example, if the input is 2x2, the
+      // filter is 1x1, the stride is 2, and the padding is (1, 0, 1, 0), the
+      // result is equivalent to as if the padding is (1, 1, 1, 1). Changing the
+      // padding in such a way would allow us to avoid the allocation.
+      Tensor transformed_input;
+      const int64_t padding_rows_diff =
+          std::abs(dimensions.pad_rows_after - dimensions.pad_rows_before);
+      const int64_t padding_cols_diff =
+          std::abs(dimensions.pad_cols_after - dimensions.pad_cols_before);
+      const int64_t new_in_rows = in_rows + padding_rows_diff;
+      const int64_t new_in_cols = in_cols + padding_cols_diff;
+      TensorShape transformed_input_shape;
+      OP_REQUIRES_OK(context,
+                     ShapeFromFormatWithStatus(
+                         params.data_format, in_batch, new_in_rows, new_in_cols,
+                         in_depths, &transformed_input_shape));
+      OP_REQUIRES_OK(context, context->allocate_temp(DataTypeToEnum<T>::value,
+                                                     transformed_input_shape,
+                                                     &transformed_input));
+      const int64_t input_pad_top =
+          dimensions.pad_rows_before - common_padding_rows;
+      const int64_t input_pad_bottom =
+          dimensions.pad_rows_after - common_padding_rows;
+      const int64_t input_pad_left =
+          dimensions.pad_cols_before - common_padding_cols;
+      const int64_t input_pad_right =
+          dimensions.pad_cols_after - common_padding_cols;
+      bool in_bounds =
+          FastBoundsCheck(input_pad_top, std::numeric_limits<int>::max()) &&
+          FastBoundsCheck(input_pad_bottom, std::numeric_limits<int>::max()) &&
+          FastBoundsCheck(input_pad_left, std::numeric_limits<int>::max()) &&
+          FastBoundsCheck(input_pad_right, std::numeric_limits<int>::max());
+      if (!in_bounds) {
+        context->SetStatus(errors::InvalidArgument("Padding is too large."));
+        return;
+      }
+      functor::PadInput<GPUDevice, T, int, 4>()(
+          context->eigen_device<GPUDevice>(),
+          To32Bit(input_param.tensor<T, 4>()),
+          {{static_cast<int>(input_pad_top), static_cast<int>(input_pad_left)}},
+          {{static_cast<int>(input_pad_bottom),
+            static_cast<int>(input_pad_right)}},
+          To32Bit(transformed_input.tensor<T, 4>()), params.data_format, T{});
+      input = transformed_input;
+      in_rows = new_in_rows;
+      in_cols = new_in_cols;
+    }
+
+    const bool compute_in_nhwc = DataTypeToEnum<T>::value == DT_HALF &&
+                                 stream->GetCudaComputeCapability().IsAtLeast(
+                                     se::CudaComputeCapability::VOLTA);
+    if (!compute_in_nhwc && params.data_format == FORMAT_NHWC) {
+      // Convert the input tensor from NHWC to NCHW.
+      TensorShape nchw_shape;
+      OP_REQUIRES_OK(
+          context, ShapeFromFormatWithStatus(FORMAT_NCHW, in_batch, in_rows,
+                                             in_cols, in_depths, &nchw_shape));
+      if (in_depths > 1) {
+        Tensor transformed_input;
+        OP_REQUIRES_OK(context,
+                       context->allocate_temp(DataTypeToEnum<T>::value,
+                                              nchw_shape, &transformed_input));
+        functor::NHWCToNCHW<GPUDevice, T, 4>()(
+            context->eigen_device<GPUDevice>(),
+            const_cast<const Tensor&>(input).tensor<T, 4>(),
+            transformed_input.tensor<T, 4>());
+        input = transformed_input;
+      } else {
+        // If depth <= 1, then just reshape.
+        CHECK(input.CopyFrom(input, nchw_shape));  // Crash OK
+      }
+    }
+
+    CHECK(common_padding_rows >= 0) << "Negative padding rows";  // Crash OK
+    CHECK(common_padding_rows >= 0) << "Negative padding cols";  // Crash OK
+
+    se::dnn::ActivationMode dnn_activation_mode;
+    switch (fusion) {
+      case FusedComputationType::kBiasAddWithRelu:
+        dnn_activation_mode = se::dnn::ActivationMode::kRelu;
+        break;
+      case FusedComputationType::kBiasAddWithRelu6:
+        dnn_activation_mode = se::dnn::ActivationMode::kRelu6;
+        break;
+      case FusedComputationType::kBiasAddWithElu:
+        dnn_activation_mode = se::dnn::ActivationMode::kElu;
+        break;
+      case FusedComputationType::kBiasAddWithLeakyRelu:
+        dnn_activation_mode = se::dnn::ActivationMode::kLeakyRelu;
+        break;
+      default:
+        LOG(FATAL) << "Unsupported fusion type";  // Crash OK
+    }
+
+    const TensorFormat compute_data_format =
+        compute_in_nhwc ? FORMAT_NHWC : FORMAT_NCHW;
+    constexpr auto kComputeInNHWC =
+        std::make_tuple(se::dnn::DataLayout::kBatchYXDepth,
+                        se::dnn::FilterLayout::kOutputYXInput);
+    constexpr auto kComputeInNCHW =
+        std::make_tuple(se::dnn::DataLayout::kBatchDepthYX,
+                        se::dnn::FilterLayout::kOutputInputYX);
+    se::dnn::DataLayout compute_data_layout;
+    se::dnn::FilterLayout filter_layout;
+    std::tie(compute_data_layout, filter_layout) =
+        compute_in_nhwc ? kComputeInNHWC : kComputeInNCHW;
+
+    se::dnn::BatchDescriptor input_desc;
+    input_desc.set_count(in_batch)
+        .set_feature_map_count(in_depths)
+        .set_height(in_rows)
+        .set_width(in_cols)
+        .set_layout(compute_data_layout);
+    se::dnn::FilterDescriptor filter_desc;
+    filter_desc.set_input_filter_height(patch_rows)
+        .set_input_filter_width(patch_cols)
+        .set_input_feature_map_count(patch_depths)
+        .set_output_feature_map_count(filter.dim_size(3))
+        .set_layout(filter_layout);
+    se::dnn::BatchDescriptor bias_desc;
+    bias_desc.set_count(1)
+        .set_height(1)
+        .set_width(1)
+        .set_feature_map_count(out_depths)
+        .set_layout(compute_data_layout);
+    se::dnn::ConvolutionDescriptor conv_desc;
+    conv_desc.set_vertical_dilation_rate(dimensions.dilation_rows)
+        .set_horizontal_dilation_rate(dimensions.dilation_cols)
+        .set_vertical_filter_stride(dimensions.stride_rows)
+        .set_horizontal_filter_stride(dimensions.stride_cols)
+        .set_zero_padding_height(common_padding_rows)
+        .set_zero_padding_width(common_padding_cols)
+        .set_group_count(in_depths / patch_depths);
+    se::dnn::BatchDescriptor output_desc;
+    output_desc.set_count(out_batch)
+        .set_height(out_rows)
+        .set_width(out_cols)
+        .set_feature_map_count(out_depths)
+        .set_layout(compute_data_layout);
+
+    Tensor transformed_filter;
+    const auto transform_filter = [&](FilterTensorFormat dst_format) -> Status {
+      VLOG(4) << "Transform filter tensor from " << ToString(FORMAT_HWIO)
+              << " to " << ToString(dst_format);
+
+      TensorShape dst_shape =
+          dst_format == FORMAT_OIHW
+              ? TensorShape({filter.dim_size(3), filter.dim_size(2),
+                             filter.dim_size(0), filter.dim_size(1)})
+              : TensorShape({filter.dim_size(3), filter.dim_size(0),
+                             filter.dim_size(1), filter.dim_size(2)});
+
+      TF_RETURN_IF_ERROR(context->allocate_temp(
+          DataTypeToEnum<T>::value, dst_shape, &transformed_filter));
+      functor::TransformFilter<GPUDevice, T, int, 4>()(
+          context->eigen_device<GPUDevice>(), dst_format,
+          To32Bit(filter.tensor<T, 4>()),
+          To32Bit(transformed_filter.tensor<T, 4>()));
+
+      return OkStatus();
+    };
+
+    if (compute_in_nhwc) {
+      OP_REQUIRES_OK(context, transform_filter(FORMAT_OHWI));
+    } else {
+      OP_REQUIRES_OK(context, transform_filter(FORMAT_OIHW));
+    }
+
+    Tensor transformed_output;
+    if (!compute_in_nhwc && params.data_format == FORMAT_NHWC) {
+      // Only allocate temporary memory when a layout transformation is needed.
+      TensorShape transformed_output_shape;
+      OP_REQUIRES_OK(context, ShapeFromFormatWithStatus(
+                                  FORMAT_NCHW, out_batch, out_rows, out_cols,
+                                  out_depths, &transformed_output_shape));
+      OP_REQUIRES_OK(context, context->allocate_temp(DataTypeToEnum<T>::value,
+                                                     transformed_output_shape,
+                                                     &transformed_output));
+    } else {
+      transformed_output = *output;
+    }
+
+    const auto tensor_on_device = [](const Tensor& t) -> se::DeviceMemory<T> {
+      return AsDeviceMemory(t.template flat<T>().data(),
+                            t.template flat<T>().size());
+    };
+
+    se::DeviceMemory<T> input_ptr = tensor_on_device(input);
+    se::DeviceMemory<T> filter_ptr = tensor_on_device(transformed_filter);
+    se::DeviceMemory<T> bias_ptr = tensor_on_device(bias);
+    se::DeviceMemory<T> output_ptr = tensor_on_device(transformed_output);
+
+    // We do not use side inputs, so we can safely pass nullptr.
+    se::DeviceMemory<T> side_input_ptr =
+        AsDeviceMemory(static_cast<T*>(nullptr), 0);
+
+    constexpr double kConvScale = 1.0;
+    constexpr double kSideInputScale = 0.0;
+    double leakyrelu_alpha = fusion_args.leakyrelu_alpha;
+
+    DataType dtype = input.dtype();
+    ConvParameters conv_parameters = {
+        stream->parent(),
+        in_batch,                      // batch
+        in_depths,                     // in_depths
+        {{in_rows,                     // in_rows
+          in_cols}},                   // in_cols
+        compute_data_format,           // compute_data_format
+        out_depths,                    // out_depths
+        {{patch_rows,                  // filter_rows
+          patch_cols,                  // filter_cols
+          patch_depths}},              // filter_depths
+        {{dimensions.dilation_rows,    // dilation_rows
+          dimensions.dilation_cols}},  // dilation_cols
+        {{dimensions.stride_rows,      // stride_rows
+          dimensions.stride_cols}},    // stride_cols
+        {{common_padding_rows,         // padding_rows
+          common_padding_cols}},       // padding_cols
+        dtype,                         // tensor datatype
+        conv_desc.group_count(),
+        ConvParameters::FusionInfo{kConvScale, kSideInputScale, leakyrelu_alpha,
+                                   dnn_activation_mode,  // activation_mode
+                                   /*is_contrib=*/false}};
+
+    se::dnn::DataType element_type = se::dnn::ToDataType<T>::value;
+
+    auto entry_or = AutotuneFusedConv<T>(
+        cudnn_use_autotune, FusedConvAutotuneMap::GetInstance(),
+        conv_parameters, context, input_desc, filter_desc, bias_desc,
+        output_desc, conv_desc, dnn_activation_mode, kConvScale,
+        kSideInputScale, leakyrelu_alpha, input_ptr, filter_ptr, output_ptr,
+        bias_ptr, side_input_ptr, ConvolveScratchSize());
+    OP_REQUIRES_OK(context, entry_or.status());
+    auto autotune_entry = std::move(entry_or).value();
+
+    DnnScratchAllocator scratch_allocator(ConvolveScratchSize(), context);
+    Status cudnn_launch_status;
+    if (!autotune_entry.is_algorithm_config()) {
+      auto& runners = autotune_entry.GetOpRunners();
+      se::dnn::FusedConvOp::Config config{se::dnn::ConvolutionKind::FORWARD,
+                                          element_type,
+                                          element_type,
+                                          element_type,
+                                          kConvScale,
+                                          kSideInputScale,
+                                          leakyrelu_alpha,
+                                          input_desc,
+                                          filter_desc,
+                                          bias_desc,
+                                          output_desc,
+                                          conv_desc,
+                                          dnn_activation_mode};
+      auto primary_or = runners.primary->GetOrCreateRunner(config, stream);
+      OP_REQUIRES_OK(context, primary_or.status());
+      auto* primary = primary_or.value();
+
+      const se::dnn::FusedConvRunner* no_scratch_fallback = nullptr;
+      if (runners.no_scratch_fallback) {
+        auto no_scratch_fallback_or =
+            runners.no_scratch_fallback->GetOrCreateRunner(config, stream);
+        OP_REQUIRES_OK(context, no_scratch_fallback_or.status());
+        no_scratch_fallback = no_scratch_fallback_or.value();
+      }
+
+      auto runner_and_scratch_or =
+          AllocateScratchOrFallback<se::dnn::FusedConvOp::Signature>(
+              &scratch_allocator, primary, no_scratch_fallback);
+      OP_REQUIRES_OK(context, runner_and_scratch_or.status());
+      auto runner_and_scratch = std::move(runner_and_scratch_or).value();
+      auto& runner =
+          *std::get<const se::dnn::FusedConvRunner*>(runner_and_scratch);
+      cudnn_launch_status = runner(
+          stream, nullptr, std::get<se::DeviceMemoryBase>(runner_and_scratch),
+          input_ptr, filter_ptr, side_input_ptr, bias_ptr, output_ptr);
+    } else {
+      cudnn_launch_status = stream->FusedConvolveWithAlgorithm(
+          input_desc, input_ptr,            // input
+          kConvScale,                       // input_scale
+          filter_desc, filter_ptr,          // filter
+          conv_desc,                        // conv
+          side_input_ptr, kSideInputScale,  // side_input
+          bias_desc, bias_ptr,              // bias
+          dnn_activation_mode,              // activation
+          output_desc, &output_ptr,         // output
+          &scratch_allocator, autotune_entry.GetAlgorithmConfig(), nullptr);
+    }
+
+    OP_REQUIRES_OK(context, cudnn_launch_status);
+
+    // Convert the output tensor back from NCHW to NHWC.
+    if (!compute_in_nhwc && params.data_format == FORMAT_NHWC) {
+      functor::NCHWToNHWC<GPUDevice, T, 4>()(
+          context->eigen_device<GPUDevice>(),
+          const_cast<const Tensor&>(transformed_output).tensor<T, 4>(),
+          output->tensor<T, 4>());
+    }
+  }
+};
+
+template <>
+struct LaunchFusedConv2DOp<GPUDevice, int8>;
+
+template <>
+struct LaunchFusedConv2DOp<GPUDevice, qint8>;
+
+#endif  // GOOGLE_CUDA
+
+template <typename Device, typename T>
+class FusedConv2DOp : public OpKernel {
+ public:
+  explicit FusedConv2DOp(OpKernelConstruction* context) : OpKernel(context) {
+    OP_REQUIRES_OK(context, InitConv2DParameters(context, &params_));
+
+    OP_REQUIRES_OK(context, context->GetAttr("use_cudnn_on_gpu", &use_cudnn_));
+    cudnn_use_autotune_ = CudnnUseAutotune();
+
+    using FCT = FusedComputationType;
+
+    std::vector<FusedComputationPattern> patterns;
+    if (std::is_same<Device, CPUDevice>::value) {
+      patterns = {
+          {FCT::kBiasAdd, {"BiasAdd"}},
+          {FCT::kBiasAddWithRelu, {"BiasAdd", "Relu"}},
+          {FCT::kBiasAddWithRelu6, {"BiasAdd", "Relu6"}},
+          {FCT::kBiasAddWithElu, {"BiasAdd", "Elu"}},
+          {FCT::kBiasAddWithLeakyRelu, {"BiasAdd", "LeakyRelu"}},
+          {FCT::kFusedBatchNorm, {"FusedBatchNorm"}},
+          {FCT::kFusedBatchNormWithRelu, {"FusedBatchNorm", "Relu"}},
+          {FCT::kFusedBatchNormWithRelu6, {"FusedBatchNorm", "Relu6"}},
+          {FCT::kFusedBatchNormWithElu, {"FusedBatchNorm", "Elu"}},
+          {FCT::kFusedBatchNormWithLeakyRelu, {"FusedBatchNorm", "LeakyRelu"}},
+      };
+    }
+
+    // NOTE(ezhulenev): CuDNN `cudnnConvolutionBiasActivationForward` supports
+    // identity activation function, it in theory should allow to fuse
+    // convolution with BiasAdd, but in practice it doesn't work, cuDNN ignores
+    // this parameter and always does Relu activation.
+    if (std::is_same<Device, GPUDevice>::value) {
+      if (std::is_same<T, int8>::value || std::is_same<T, qint8>::value) {
+        patterns = {{FCT::kBiasAdd, {"BiasAdd"}},
+                    {FCT::kBiasAddWithRelu, {"BiasAdd", "Relu"}}};
+      } else {
+        patterns = {
+            {FCT::kBiasAddWithRelu, {"BiasAdd", "Relu"}},
+            {FCT::kBiasAddWithRelu6, {"BiasAdd", "Relu6"}},
+            {FCT::kBiasAddWithElu, {"BiasAdd", "Elu"}},
+            {FCT::kBiasAddWithLeakyRelu, {"BiasAdd", "LeakyRelu"}},
+        };
+      }
+    }
+
+    OP_REQUIRES_OK(context, InitializeFusedComputation(
+                                context, "Conv2D", patterns,
+                                &fused_computation_, &fused_computation_args_));
+  }
+
+  void Compute(OpKernelContext* context) override {
+    // Input tensor is of the following dimensions:
+    // [ batch, in_rows, in_cols, in_depth ]
+    const Tensor& input = context->input(0);
+
+    // Input filter is of the following dimensions:
+    // [ filter_rows, filter_cols, in_depth, out_depth]
+    const Tensor& filter = context->input(1);
+
+    Conv2DDimensions dimensions;
+    OP_REQUIRES_OK(context,
+                   ComputeConv2DDimension(params_, input, filter, &dimensions));
+
+    TensorShape out_shape;
+    OP_REQUIRES_OK(
+        context, ShapeFromFormatWithStatus(
+                     params_.data_format, dimensions.batch, dimensions.out_rows,
+                     dimensions.out_cols, dimensions.out_depth, &out_shape));
+
+    // Output tensor is of the following dimensions:
+    // [ in_batch, out_rows, out_cols, out_depth ]
+    Tensor* output = nullptr;
+    OP_REQUIRES_OK(context, context->allocate_output(0, out_shape, &output));
+
+    VLOG(2) << "FusedConv2D: in_depth = " << dimensions.in_depth
+            << ", patch_depth = " << dimensions.patch_depth
+            << ", input_cols = " << dimensions.input_cols
+            << ", filter_cols = " << dimensions.filter_cols
+            << ", input_rows = " << dimensions.input_rows
+            << ", filter_rows = " << dimensions.filter_rows
+            << ", stride_rows = " << dimensions.stride_rows
+            << ", stride_cols = " << dimensions.stride_cols
+            << ", dilation_rows = " << dimensions.dilation_rows
+            << ", dilation_cols = " << dimensions.dilation_cols
+            << ", out_depth = " << dimensions.out_depth;
+
+    // If there is nothing to compute, return.
+    if (out_shape.num_elements() == 0) {
+      return;
+    }
+
+    LaunchFusedConv2DOp<Device, T>()(context, use_cudnn_, cudnn_use_autotune_,
+                                     input, filter, fused_computation_,
+                                     fused_computation_args_, params_,
+                                     dimensions, output);
+  }
+
+ private:
+  Conv2DParameters params_;
+  bool use_cudnn_;
+  bool cudnn_use_autotune_;
+
+  FusedComputationType fused_computation_ = FusedComputationType::kUndefined;
+  FusedComputationArgs fused_computation_args_;
+
+  FusedConv2DOp(const FusedConv2DOp&) = delete;
+  void operator=(const FusedConv2DOp&) = delete;
+};
+
+// Registration of the CPU implementations.
+#define REGISTER_FUSED_CPU_CONV2D(T)                                  \
+  REGISTER_KERNEL_BUILDER(                                            \
+      Name("_FusedConv2D").Device(DEVICE_CPU).TypeConstraint<T>("T"), \
+      FusedConv2DOp<CPUDevice, T>);
+
+#if GOOGLE_CUDA
+
+#define DECLARE_FUNCTOR_GPU_SPEC(T)                                     \
+  template <>                                                           \
+  void TransformFilter<GPUDevice, T, int, 4>::operator()(               \
+      const GPUDevice& d, FilterTensorFormat dst_filter_format,         \
+      typename TTypes<T, 4, int>::ConstTensor in,                       \
+      typename TTypes<T, 4, int>::Tensor out);                          \
+  extern template struct TransformFilter<GPUDevice, T, int, 4>;         \
+  template <>                                                           \
+  void PadInput<GPUDevice, T, int, 4>::operator()(                      \
+      const GPUDevice& d, typename TTypes<T, 4, int>::ConstTensor in,   \
+      const std::array<int, 2>& padding_left,                           \
+      const std::array<int, 2>& padding_right,                          \
+      typename TTypes<T, 4, int>::Tensor out, TensorFormat data_format, \
+      const T& padding_value);                                          \
+  extern template struct PadInput<GPUDevice, T, int, 4>
+
+// Registration of the GPU implementations.
+#define REGISTER_FUSED_GPU_CONV2D(T)                    \
+  REGISTER_KERNEL_BUILDER(Name("_FusedConv2D")          \
+                              .Device(DEVICE_GPU)       \
+                              .TypeConstraint<T>("T")   \
+                              .HostMemory("host_args"), \
+                          FusedConv2DOp<GPUDevice, T>);
+
+#endif  // GOOGLE_CUDA
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_CONV_OPS_FUSED_IMPL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/conv_ops_gpu.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/conv_ops_gpu.h
new file mode 100644
index 0000000000000000000000000000000000000000..80646badbade7d5e2323a2d10a59f5e56720232a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/conv_ops_gpu.h
@@ -0,0 +1,209 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_CONV_OPS_GPU_H_
+#define TENSORFLOW_CORE_KERNELS_CONV_OPS_GPU_H_
+
+#if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+
+#include <tuple>
+#include <unordered_map>
+
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_format.h"
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/kernels/gpu_utils.h"
+#include "tensorflow/core/lib/gtl/inlined_vector.h"
+#include "tensorflow/core/lib/hash/hash.h"
+#include "tensorflow/core/util/autotune_maps/conv_parameters.h"
+#include "tensorflow/core/util/tensor_format.h"
+
+namespace tensorflow {
+
+bool ComputeInNhwcEnabled(DataType data_type, se::Stream* stream,
+                          bool use_4d_tensor = true);
+
+// Get the Dnn workspace limit from the environment variable, which is in MB.
+// Return the workspace memory limit in bytes. If no value is set, return the
+// default value.
+int64 GetDnnWorkspaceLimit(const string& envvar_in_mb,
+                           int64_t default_value_in_bytes);
+
+// Call the Dnn workspace limit from TF_CUDNN_WORKSPACE_LIMIT_IN_MB or default.
+int64 GetDnnWorkspaceLimitOrDefault();
+
+// A class to provide scratch-space allocator for Stream-Executor Cudnn
+// callback. TensorFlow is responsible for releasing the temporary buffers after
+// the kernel finishes.
+class DnnScratchAllocator : public se::ScratchAllocator {
+ public:
+  virtual ~DnnScratchAllocator() {}
+  DnnScratchAllocator(int64_t memory_limit, OpKernelContext* context)
+      : memory_limit_(memory_limit), total_byte_size_(0), context_(context) {}
+  int64 GetMemoryLimitInBytes() override { return memory_limit_; }
+  tsl::StatusOr<se::DeviceMemory<uint8>> AllocateBytes(
+      int64_t byte_size) override {
+    Tensor temporary_memory;
+    if (byte_size < 0) {
+      return tsl::Status{absl::StatusCode::kInvalidArgument,
+                         "Requested negative byte size!"};
+    }
+    if (byte_size > memory_limit_) {
+      return tsl::Status{absl::StatusCode::kUnavailable,
+                         absl::StrCat("Requested memory size (", byte_size,
+                                      ") exceeds the max memory limit (",
+                                      memory_limit_, ").")};
+    }
+    AllocationAttributes allocation_attr;
+    allocation_attr.retry_on_failure = false;
+    Status allocation_status(context_->allocate_temp(
+        DT_UINT8, TensorShape({byte_size}), &temporary_memory,
+        AllocatorAttributes(), allocation_attr));
+    if (!allocation_status.ok()) {
+      return tsl::Status{
+          absl::StatusCode::kUnavailable,
+          absl::StrCat("Failed to allocate the requested memory size (",
+                       byte_size, ").")};
+    }
+    // Hold the reference of the allocated tensors until the end of the
+    // allocator.
+    allocated_tensors_.push_back(temporary_memory);
+    total_byte_size_ += byte_size;
+    return tsl::StatusOr<se::DeviceMemory<uint8>>(
+        AsDeviceMemory(temporary_memory.flat<uint8>().data(),
+                       temporary_memory.flat<uint8>().size()));
+  }
+  int64 TotalByteSize() { return total_byte_size_; }
+
+ private:
+  int64 memory_limit_;
+  int64 total_byte_size_;
+  OpKernelContext* context_;
+  std::vector<Tensor> allocated_tensors_;
+};
+
+typedef Eigen::GpuDevice GPUDevice;
+
+// Select an algorithm for the given convolution, either by running actual
+// autotuning with a cache, or by falling back to a default if
+// 'cudnn_use_autotune' is true and cuDNN is the statically-chosen DNN backend.
+template <typename T>
+StatusOr<AutotuneEntry<se::dnn::FusedConvOp>> AutotuneFusedConv(
+    bool cudnn_use_autotune,
+    AutotuneMap<ConvParameters, AutotuneEntry<se::dnn::FusedConvOp>>*
+        autotune_map,
+    const ConvParameters& params, OpKernelContext* ctx,
+    const se::dnn::BatchDescriptor& input_desc,
+    const se::dnn::FilterDescriptor& filter_desc,
+    const se::dnn::BatchDescriptor& bias_desc,
+    const se::dnn::BatchDescriptor& output_desc,
+    const se::dnn::ConvolutionDescriptor& conv_desc,
+    const se::dnn::ActivationMode activation_mode, double conv_input_scale,
+    double side_input_scale, double leakyrelu_alpha,
+    se::DeviceMemory<T> input_ptr, se::DeviceMemory<T> filter_ptr,
+    se::DeviceMemory<T> output_ptr, se::DeviceMemory<T> bias_ptr,
+    se::DeviceMemory<T> side_input_ptr, int64_t scratch_size);
+
+template <typename T>
+StatusOr<AutotuneEntry<se::dnn::ConvOp>> AutotuneUnfusedConv(
+    bool cudnn_use_autotune,
+    AutotuneMap<ConvParameters, AutotuneEntry<se::dnn::ConvOp>>* autotune_map,
+    const ConvParameters& conv_parameters, OpKernelContext* ctx,
+    se::dnn::ConvolutionKind kind, const se::dnn::BatchDescriptor& input_desc,
+    se::DeviceMemory<T> input_ptr, const se::dnn::FilterDescriptor& filter_desc,
+    se::DeviceMemory<T> filter_ptr,
+    const se::dnn::ConvolutionDescriptor& conv_desc,
+    const se::dnn::BatchDescriptor& output_desc, se::DeviceMemory<T> output_ptr,
+    int64_t scratch_size_limit);
+
+// Returns a pointer to the primary 'OpRunner' of 'runners' and allocated
+// scratch memory if allocatable; else a pointer to its fallback
+// no-scratch-space runner, and a null 'DeviceMemoryBase'.
+template <typename Sig>
+StatusOr<std::tuple<const se::dnn::OpRunner<Sig>*, se::DeviceMemoryBase>>
+AllocateScratchOrFallback(se::ScratchAllocator* scratch_allocator,
+                          const se::dnn::OpRunner<Sig>* primary,
+                          const se::dnn::OpRunner<Sig>* no_scratch_fallback) {
+  const se::dnn::OpRunner<Sig>* selected_runner = primary;
+
+  auto workspace_size = selected_runner->GetWorkspaceSize();
+
+  se::DeviceMemoryBase scratch_memory;
+  if (workspace_size > 0) {
+    auto scratch_or = scratch_allocator->AllocateBytes(workspace_size);
+    if (scratch_or.ok()) {
+      scratch_memory = scratch_or.value();
+    } else if ((selected_runner = no_scratch_fallback)) {
+      if (selected_runner->GetWorkspaceSize() > 0) {
+        return errors::Internal(
+            "No-scratch fallback runner requires nonzero scratch space");
+      }
+    } else {
+      return errors::Unknown(
+          "CUDNN failed to allocate the scratch space for the runner or to "
+          "find a working no-scratch runner.");
+    }
+  }
+
+  return std::make_tuple(selected_runner, scratch_memory);
+}
+
+template <typename T>
+Status LaunchAutotunedConv(const AutotuneEntry<se::dnn::ConvOp>& autotune_entry,
+                           DnnScratchAllocator* scratch_allocator,
+                           se::dnn::ConvolutionKind kind, se::Stream* stream,
+                           const se::dnn::BatchDescriptor& input_desc,
+                           se::DeviceMemory<T> in_ptr,
+                           const se::dnn::FilterDescriptor& filter_desc,
+                           se::DeviceMemory<T> filter_ptr,
+                           const se::dnn::ConvolutionDescriptor& conv_desc,
+                           const se::dnn::BatchDescriptor& output_desc,
+                           se::DeviceMemory<T> out_ptr) {
+  if (!autotune_entry.is_algorithm_config()) {
+    const auto& runners = autotune_entry.GetOpRunners();
+    se::dnn::DataType element_type = se::dnn::ToDataType<T>::value;
+    se::dnn::ConvOp::Config config{kind,       element_type, element_type,
+                                   input_desc, filter_desc,  output_desc,
+                                   conv_desc};
+    TF_ASSIGN_OR_RETURN(auto* primary,
+                        runners.primary->GetOrCreateRunner(config, stream));
+
+    const se::dnn::ConvRunner* no_scratch_fallback = nullptr;
+    if (runners.no_scratch_fallback) {
+      TF_ASSIGN_OR_RETURN(
+          no_scratch_fallback,
+          runners.no_scratch_fallback->GetOrCreateRunner(config, stream));
+    }
+
+    TF_ASSIGN_OR_RETURN(auto runner_and_scratch,
+                        AllocateScratchOrFallback<se::dnn::ConvOp::Signature>(
+                            scratch_allocator, primary, no_scratch_fallback));
+    auto& runner = *std::get<const se::dnn::ConvRunner*>(runner_and_scratch);
+    return runner(stream, nullptr,
+                  std::get<se::DeviceMemoryBase>(runner_and_scratch), in_ptr,
+                  filter_ptr, out_ptr);
+  } else {
+    return stream->ConvolveWithAlgorithm(
+        kind, input_desc, in_ptr, filter_desc, filter_ptr, output_desc, out_ptr,
+        conv_desc, scratch_allocator, autotune_entry.GetAlgorithmConfig(),
+        nullptr);
+  }
+}
+
+}  // namespace tensorflow
+
+#endif  // GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+
+#endif  // TENSORFLOW_CORE_KERNELS_CONV_OPS_GPU_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/conv_ops_impl.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/conv_ops_impl.h
new file mode 100644
index 0000000000000000000000000000000000000000..3d28c6e67800e209afa9686ec98126a54581751f
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/conv_ops_impl.h
@@ -0,0 +1,1279 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// See docs in ../ops/nn_ops.cc.
+
+#ifndef TENSORFLOW_CORE_KERNELS_CONV_OPS_IMPL_H_
+#define TENSORFLOW_CORE_KERNELS_CONV_OPS_IMPL_H_
+
+#include <cstdint>
+
+#include "absl/status/status.h"
+#include "absl/strings/str_cat.h"
+#include "tensorflow/core/framework/op_requires.h"
+
+#define USE_EIGEN_TENSOR
+#define EIGEN_USE_THREADS
+
+#if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+#define EIGEN_USE_GPU
+#endif  // GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+
+#include <string.h>
+
+#include <array>
+#include <atomic>
+#include <functional>
+#include <limits>
+#include <map>
+#include <numeric>
+#include <utility>
+#include <vector>
+
+#include "absl/synchronization/blocking_counter.h"
+#include "tensorflow/core/framework/allocator.h"
+#include "tensorflow/core/framework/bounds_check.h"
+#include "tensorflow/core/framework/kernel_shape_util.h"
+#include "tensorflow/core/framework/numeric_op.h"
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/register_types.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/tensor_shape.h"
+#include "tensorflow/core/framework/tensor_slice.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/kernels/conv_2d.h"
+#include "tensorflow/core/kernels/conv_3d.h"
+#include "tensorflow/core/kernels/conv_ops.h"
+#include "tensorflow/core/kernels/deep_conv2d.h"
+#include "tensorflow/core/kernels/fill_functor.h"
+#include "tensorflow/core/kernels/ops_util.h"
+#include "tensorflow/core/lib/core/errors.h"
+#include "tensorflow/core/lib/gtl/array_slice.h"
+#include "tensorflow/core/lib/strings/numbers.h"
+#include "tensorflow/core/lib/strings/str_util.h"
+#include "tensorflow/core/platform/logging.h"
+#include "tensorflow/core/platform/macros.h"
+#include "tensorflow/core/profiler/lib/scoped_annotation.h"
+#include "tensorflow/core/util/padding.h"
+#include "tensorflow/core/util/tensor_format.h"
+#include "tensorflow/core/util/use_cudnn.h"
+
+#if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+#include "tensorflow/core/kernels/cast_op.h"
+#include "tensorflow/core/kernels/conv_ops_gpu.h"
+#include "tensorflow/core/kernels/numeric_options_utils.h"
+#include "tensorflow/core/platform/stream_executor.h"
+#include "tensorflow/core/util/autotune_maps/conv_autotune_maps.h"
+#include "tensorflow/core/util/autotune_maps/conv_parameters.h"
+#include "tensorflow/core/util/proto/proto_utils.h"
+#endif  // GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+#if GOOGLE_CUDA
+#include "xla/stream_executor/gpu/gpu_asm_opts.h"
+#include "xla/stream_executor/gpu/redzone_allocator.h"
+#include "xla/stream_executor/tf_allocator_adapter.h"
+#endif  // GOOGLE_CUDA
+
+namespace tensorflow {
+
+typedef Eigen::ThreadPoolDevice CPUDevice;
+typedef Eigen::GpuDevice GPUDevice;
+
+template <typename Device, typename T>
+struct LaunchGeneric {
+  void operator()(OpKernelContext* ctx, const Tensor& input,
+                  const Tensor& filter, int row_stride, int col_stride,
+                  int row_dilation, int col_dilation, const Padding& padding,
+                  const std::vector<int64_t>& explicit_paddings, Tensor* output,
+                  TensorFormat data_format) {
+    DCHECK(data_format == FORMAT_NHWC)
+        << "Generic conv implementation only "
+           "supports NHWC tensor format for now.";
+    if (filter.dim_size(0) == 1 && filter.dim_size(1) == 1 && row_stride == 1 &&
+        col_stride == 1 && (padding == SAME || padding == VALID)) {
+      // For 1x1 kernel, the 2D convolution is reduced to matrix
+      // multiplication.
+      //
+      // TODO(vrv): We should be able to call SpatialConvolution
+      // and it will produce the same result, but doing so
+      // led to NaNs during training.  Using matmul instead for now.
+      int conv_width = 1;  // Width for the convolution step.
+      for (int i = 0; i < 3; ++i) {
+        conv_width *= output->dim_size(i);
+      }
+
+      Eigen::array<Eigen::IndexPair<Eigen::DenseIndex>, 1> dim_pair;
+      dim_pair[0] = Eigen::IndexPair<Eigen::DenseIndex>(1, 0);
+      functor::MatMulConvFunctor<Device, T>()(
+          ctx->eigen_device<Device>(),
+          output->shaped<T, 2>({conv_width, filter.dim_size(3)}),
+          input.shaped<T, 2>({conv_width, filter.dim_size(2)}),
+          filter.shaped<T, 2>({filter.dim_size(2), filter.dim_size(3)}),
+          dim_pair);
+    } else if (filter.dim_size(0) == input.dim_size(1) &&
+               filter.dim_size(1) == input.dim_size(2) && row_dilation == 1 &&
+               col_dilation == 1 && padding == VALID) {
+      // If the input data and filter have the same height/width,
+      // the 2D convolution is reduced to matrix multiplication.
+      const int k =  // Length of reduction dimension.
+          filter.dim_size(0) * filter.dim_size(1) * filter.dim_size(2);
+
+      Eigen::array<Eigen::IndexPair<Eigen::DenseIndex>, 1> dim_pair;
+      dim_pair[0] = Eigen::IndexPair<Eigen::DenseIndex>(1, 0);
+      functor::MatMulConvFunctor<Device, T>()(
+          ctx->eigen_device<Device>(),
+          output->shaped<T, 2>({input.dim_size(0), filter.dim_size(3)}),
+          input.shaped<T, 2>({input.dim_size(0), k}),
+          filter.shaped<T, 2>({k, filter.dim_size(3)}), dim_pair);
+    } else {
+      if (padding == EXPLICIT) {
+        functor::SpatialConvolution<Device, T>()(
+            ctx->eigen_device<Device>(), output->tensor<T, 4>(),
+            input.tensor<T, 4>(), filter.tensor<T, 4>(), row_stride, col_stride,
+            row_dilation, col_dilation, static_cast<int>(explicit_paddings[2]),
+            static_cast<int>(explicit_paddings[3]),
+            static_cast<int>(explicit_paddings[4]),
+            static_cast<int>(explicit_paddings[5]));
+      } else {
+        functor::SpatialConvolution<Device, T>()(
+            ctx->eigen_device<Device>(), output->tensor<T, 4>(),
+            input.tensor<T, 4>(), filter.tensor<T, 4>(), row_stride, col_stride,
+            row_dilation, col_dilation, BrainPadding2EigenPadding(padding));
+      }
+    }
+  }
+};
+
+// Compute grouped 2D convolutions on CPU. Unlike grouped convolution
+// implementation in cuDNN this is faaaaaar from optimal and needs more work
+// to deliver competitive performance. Currently it exists to close the feature
+// parity gap between convolution operations on different devices.
+template <typename T>
+struct LaunchGrouped {
+  void operator()(OpKernelContext* ctx, const Tensor& input,
+                  const Tensor& filter, int row_stride, int col_stride,
+                  int row_dilation, int col_dilation, const Padding& padding,
+                  const std::vector<int64_t>& explicit_paddings, Tensor* output,
+                  TensorFormat data_format) {
+    DCHECK(data_format == FORMAT_NHWC)
+        << "Grouped conv implementation only "
+           "supports NHWC tensor format for now.";
+
+    const int64_t in_depth = input.dim_size(3);
+    const int64_t patch_depth = filter.dim_size(2);
+    const int64_t num_groups = in_depth / patch_depth;
+
+    // Shuffle input/filter tensors to have group as a leading dimension.
+    std::array<int64_t, 5> shuffle({3, 0, 1, 2, 4});
+
+    // Compute pre shuffle dimemnsions.
+    auto pre_shuffle = [&](const Tensor& tensor) -> std::array<int64, 5> {
+      return {tensor.dim_size(0), tensor.dim_size(1), tensor.dim_size(2),
+              num_groups, tensor.dim_size(3) / num_groups};
+    };
+
+    // Compute post shuffle dimemnsions.
+    auto post_shuffle = [&](const Tensor& tensor) -> std::array<int64, 5> {
+      return {num_groups, tensor.dim_size(0), tensor.dim_size(1),
+              tensor.dim_size(2), tensor.dim_size(3) / num_groups};
+    };
+
+    auto& device = ctx->eigen_device<CPUDevice>();
+
+    absl::BlockingCounter shuffles_completed(2);
+    auto on_shuffled = [&]() { shuffles_completed.DecrementCount(); };
+
+    // Shuffle input into temporary tensor.
+    Tensor input_shuffled;
+    OP_REQUIRES_OK(
+        ctx, ctx->allocate_temp(input.dtype(), TensorShape(post_shuffle(input)),
+                                &input_shuffled));
+    input_shuffled.tensor<T, 5>().device(device, on_shuffled) =
+        input.shaped<T, 5>(pre_shuffle(input)).shuffle(shuffle);
+
+    // Shuffle filter into temporary tensor.
+    Tensor filter_shuffled;
+    OP_REQUIRES_OK(ctx, ctx->allocate_temp(filter.dtype(),
+                                           TensorShape(post_shuffle(filter)),
+                                           &filter_shuffled));
+    filter_shuffled.tensor<T, 5>().device(device, on_shuffled) =
+        filter.shaped<T, 5>(pre_shuffle(filter)).shuffle(shuffle);
+
+    // Wait for the completion of input/filter shuffles.
+    shuffles_completed.Wait();
+
+    // Write group convolution results into temporary output tensor.
+    Tensor output_shuffled;
+    OP_REQUIRES_OK(ctx, ctx->allocate_temp(output->dtype(),
+                                           TensorShape(post_shuffle(*output)),
+                                           &output_shuffled));
+
+    for (int64_t i = 0; i < num_groups; ++i) {
+      // TODO(ezhulenev): Run this loop using `parallelFor` (regular parallelFor
+      // will lead to deadlock, SpatialConvolution has to use async Eigen
+      // assignment). This requires small changes to Eigen to support async
+      // exeuction for tensor chipping operation.
+
+      // TODO(ezhulenev): Grouped convolution should also support 1x1 filter
+      // optimization.
+
+      auto input_slice = input_shuffled.tensor<T, 5>().template chip<0>(i);
+      auto filter_slice = filter_shuffled.tensor<T, 5>().template chip<0>(i);
+      auto output_slice = output_shuffled.tensor<T, 5>().template chip<0>(i);
+
+      if (padding == EXPLICIT) {
+        functor::SpatialConvolution<CPUDevice, T>()(
+            ctx->eigen_device<CPUDevice>(), output_slice, input_slice,
+            filter_slice, row_stride, col_stride, row_dilation, col_dilation,
+            static_cast<int>(explicit_paddings[2]),
+            static_cast<int>(explicit_paddings[3]),
+            static_cast<int>(explicit_paddings[4]),
+            static_cast<int>(explicit_paddings[5]));
+      } else {
+        functor::SpatialConvolution<CPUDevice, T>()(
+            ctx->eigen_device<CPUDevice>(), output_slice, input_slice,
+            filter_slice, row_stride, col_stride, row_dilation, col_dilation,
+            BrainPadding2EigenPadding(padding));
+      }
+    }
+
+    // Shuffle temporary output back into pre-shuffled shape.
+    std::array<int64_t, 5> rev_shuffle({1, 2, 3, 0, 4});
+    output->shaped<T, 5>(pre_shuffle(*output)).device(device) =
+        output_shuffled.tensor<T, 5>().shuffle(rev_shuffle);
+  }
+};
+
+template <typename Device, typename T>
+struct LaunchConvOp;
+
+template <typename T>
+struct LaunchConvOp<CPUDevice, T> {
+  void operator()(OpKernelContext* context, bool cudnn_use_autotune,
+                  const Tensor& input, const Tensor& filter,
+                  const std::vector<int64>& dilations,
+                  const std::vector<int64>& strides, const Padding padding,
+                  const std::vector<int64_t>& explicit_paddings,
+                  TensorFormat data_format, Tensor* output) {
+    // For now just calling existing launchers based on spatial dimensions.
+    int spatial_dims = input.dims() - 2;
+
+    if (spatial_dims == 2) {
+      LaunchConv2DOp<CPUDevice, T>()(context, true, cudnn_use_autotune, input,
+                                     filter, dilations[1], dilations[2],
+                                     strides[1], strides[2], padding,
+                                     explicit_paddings, output, data_format);
+    } else {
+      LaunchConv3DOp<CPUDevice, T>().launch(
+          context, cudnn_use_autotune, input, filter,
+          {dilations[1], dilations[2], dilations[3]},
+          {strides[1], strides[2], strides[3]}, padding, data_format, output);
+    }
+  }
+};
+
+template <typename Device, typename T>
+class ConvOp : public BinaryOp<T> {
+ public:
+  explicit ConvOp(OpKernelConstruction* context) : BinaryOp<T>(context) {
+    // TODO(b/290223810) Add support for grouped and depthwise convolutions.
+    OP_REQUIRES_OK(context, context->GetAttr("groups", &groups_));
+    OP_REQUIRES(context, groups_ == 1,
+                absl::UnimplementedError(
+                    "Grouped/Depthwise Convolutions are not supported yet."));
+    string data_format_str;
+    OP_REQUIRES_OK(context, context->GetAttr("data_format", &data_format_str));
+    OP_REQUIRES(context,
+                data_format_str == "CHANNELS_LAST" ||
+                    data_format_str == "CHANNELS_FIRST",
+                absl::InvalidArgumentError(
+                    absl::StrCat("Unknown data format: ", data_format_str)));
+    data_format_ =
+        data_format_str == "CHANNELS_LAST" ? FORMAT_NHWC : FORMAT_NCHW;
+
+    // Always assume filter_format is HWIO / DHWIO.
+    filter_format_ = FilterTensorFormat::FORMAT_HWIO;
+
+    // These parameters are checked against spatial dimensions on compute.
+    OP_REQUIRES_OK(context, context->GetAttr("batch_dims", &batch_dims_));
+    OP_REQUIRES_OK(context, context->GetAttr("strides", &strides_));
+    OP_REQUIRES_OK(context, context->GetAttr("dilations", &dilations_));
+    if (context->HasAttr("explicit_paddings")) {
+      OP_REQUIRES_OK(
+          context, context->GetAttr("explicit_paddings", &explicit_paddings_));
+    }
+    OP_REQUIRES_OK(context, context->GetAttr("padding", &padding_));
+    cudnn_use_autotune_ = CudnnUseAutotune();
+  }
+
+  void Compute(OpKernelContext* context) override {
+    // Input tensor is of the following dimensions:
+    // [ batch, [spatial_dims], in_depth ].
+    const Tensor& input = context->input(0);
+    size_t original_input_dims = context->input(0).dims();
+    const TensorShape original_input_shape = context->input(0).shape();
+    int spatial_dims = original_input_dims - 1 - batch_dims_;
+
+    // Input filter is of the following dimensions:
+    // [ batch, [spatial dims], in_depth ].
+    const Tensor& filter = context->input(1);
+
+    OP_REQUIRES(context, (spatial_dims == 2 || spatial_dims == 3),
+                absl::InvalidArgumentError(absl::StrCat(
+                    "The input must have 2 or 3 spatial dimensions but got ",
+                    spatial_dims)));
+
+    OP_REQUIRES(
+        context, filter.NumElements() > 0,
+        absl::InvalidArgumentError("filter must not have zero elements "
+                                   "(i.e. all dimensions must be non-zero)"));
+
+    // Flatten tensor for computation.
+    Tensor input_flat;
+    if (batch_dims_ == 1) {
+      input_flat = input;
+    } else {
+      std::vector<int64_t> in_flat_shape_vec(1, 1);
+      for (int i = 0; i < batch_dims_; ++i) {
+        in_flat_shape_vec[0] *= original_input_shape.dim_size(i);
+      }
+      for (int i = batch_dims_; i < original_input_shape.dims(); ++i) {
+        in_flat_shape_vec.push_back(original_input_shape.dim_size(i));
+      }
+      TensorShape in_flat_shape(in_flat_shape_vec);
+      if (!input_flat.CopyFrom(input, in_flat_shape)) {
+        // This should never happen, since the output sizes should always be the
+        // same after expanding batches.
+        context->SetStatus(absl::InternalError(absl::StrCat(
+            "Could not flatten input shape ",
+            original_input_shape.DebugString(), " and flat input shape ",
+            in_flat_shape.DebugString())));
+      }
+    }
+
+    OP_REQUIRES(context, filter.dims() == 4 || filter.dims() == 5,
+                absl::InvalidArgumentError(absl::StrCat(
+                    "The filter must be rank 4 or 5 but got ", filter.dims())));
+    for (int i = 0; i < spatial_dims; i++) {
+      OP_REQUIRES(
+          context,
+          FastBoundsCheck(filter.dim_size(i), std::numeric_limits<int>::max()),
+          absl::InvalidArgumentError("filter too large"));
+    }
+
+    // Validate operation parameters based on inferred spatial dims.
+    OP_REQUIRES(context, strides_.size() == spatial_dims + 2,
+                absl::InvalidArgumentError(
+                    absl::StrCat("Sliding window strides field must specify ",
+                                 spatial_dims + 2, " dimensions")));
+
+    OP_REQUIRES(context,
+                (GetTensorDim(strides_, data_format_, 'C') == 1 &&
+                 GetTensorDim(strides_, data_format_, 'N') == 1),
+                absl::InvalidArgumentError(
+                    "Current implementation does not support "
+                    "strides in the batch and depth dimensions."));
+    bool stride_valid = true;
+    for (int i = 0; i < spatial_dims; ++i) {
+      stride_valid =
+          stride_valid && (GetTensorDim(strides_, data_format_,
+                                        static_cast<char>(i + '0')) > 0);
+    }
+    OP_REQUIRES(
+        context, stride_valid,
+        absl::InvalidArgumentError("Spatial strides should be larger than 0."));
+    if (dilations_.empty()) {
+      dilations_ = std::vector<int64_t>(spatial_dims + 2, 1);
+    } else {
+      OP_REQUIRES(context, dilations_.size() == spatial_dims + 2,
+                  absl::InvalidArgumentError(
+                      absl::StrCat("Dilation rates field must specify",
+                                   spatial_dims + 2, "dimensions")));
+      OP_REQUIRES(context,
+                  (GetTensorDim(dilations_, data_format_, 'N') == 1 &&
+                   GetTensorDim(dilations_, data_format_, 'C') == 1),
+                  absl::InvalidArgumentError(
+                      "Current implementation does not support "
+                      "dilation rates in the batch and depth dimensions."));
+      bool dilation_valid = true;
+      for (int i = 0; i < spatial_dims; ++i) {
+        dilation_valid =
+            dilation_valid && (GetTensorDim(dilations_, data_format_,
+                                            static_cast<char>(i + '0')) > 0);
+      }
+      OP_REQUIRES(
+          context, dilation_valid,
+          absl::InvalidArgumentError("Dilated rates should be larger than 0."));
+    }
+    OP_REQUIRES_OK(context, CheckValidPadding(padding_, explicit_paddings_,
+                                              spatial_dims + 2, data_format_));
+
+    const int64_t in_depth_raw = GetTensorDim(input_flat, data_format_, 'C');
+    const int64_t patch_depth_raw = GetFilterDim(filter, filter_format_, 'I');
+    OP_REQUIRES(context,
+                FastBoundsCheck(in_depth_raw, std::numeric_limits<int>::max()),
+                absl::InvalidArgumentError("Input depth too large"));
+    OP_REQUIRES(
+        context,
+        FastBoundsCheck(patch_depth_raw, std::numeric_limits<int>::max()),
+        absl::InvalidArgumentError("Patch depth too large"));
+    const int in_depth = static_cast<int>(in_depth_raw);
+    const int patch_depth = static_cast<int>(patch_depth_raw);
+    OP_REQUIRES(
+        context, patch_depth > 0,
+        absl::InvalidArgumentError(absl::StrCat(
+            "filter depth must be stricly positive, got ", patch_depth)));
+    OP_REQUIRES(context, in_depth == patch_depth,
+                absl::InvalidArgumentError(absl::StrCat(
+                    "Input depth must be equal to filter depth: ", in_depth,
+                    " vs ", patch_depth)));
+
+    const int out_depth =
+        static_cast<int>(GetFilterDim(filter, filter_format_, 'O'));
+
+    std::vector<int64_t> input_dims_raw(spatial_dims);
+    std::vector<int> input_dims(spatial_dims);
+    std::vector<int> filter_dims(spatial_dims);
+    for (int i = 0; i < spatial_dims; ++i) {
+      input_dims_raw[i] =
+          GetTensorDim(input_flat, data_format_, static_cast<char>(i + '0'));
+      OP_REQUIRES(
+          context,
+          FastBoundsCheck(input_dims_raw[i], std::numeric_limits<int>::max()),
+          absl::InvalidArgumentError(
+              absl::StrCat("Input spatial dimension ", i, " too large")));
+      input_dims[i] = static_cast<int>(input_dims_raw[i]);
+      filter_dims[i] = static_cast<int>(
+          GetFilterDim(filter, filter_format_, static_cast<char>(i + '0')));
+    }
+    // The first dimension for input is batch.
+    const int64_t batch_raw = GetTensorDim(input_flat, data_format_, 'N');
+    OP_REQUIRES(context,
+                FastBoundsCheck(batch_raw, std::numeric_limits<int>::max()),
+                absl::InvalidArgumentError("Batch is too large"));
+    const int batch = static_cast<int>(batch_raw);
+
+    // Take the stride and dilation from the spatial dimensions only (we
+    // do not support striding or dilation on the batch or depth dimension).
+    std::vector<int64_t> stride_dims(spatial_dims);
+    std::vector<int64_t> dilation_dims(spatial_dims);
+    for (int i = 0; i < spatial_dims; ++i) {
+      stride_dims[i] =
+          GetTensorDim(strides_, data_format_, static_cast<char>(i + '0'));
+      dilation_dims[i] =
+          GetTensorDim(dilations_, data_format_, static_cast<char>(i + '0'));
+    }
+    std::vector<int64_t> pad_before(spatial_dims, -1);
+    std::vector<int64_t> pad_after(spatial_dims, -1);
+    if (padding_ == Padding::EXPLICIT) {
+      GetExplicitPaddingForDim(explicit_paddings_, data_format_, 'H',
+                               &pad_before[0], &pad_after[0]);
+      GetExplicitPaddingForDim(explicit_paddings_, data_format_, 'W',
+                               &pad_before[1], &pad_after[1]);
+    }
+
+    // Compute windowed output sizes for spatial dimensions.
+    std::vector<int64_t> out_dims(spatial_dims);
+    for (int i = 0; i < spatial_dims; ++i) {
+      OP_REQUIRES_OK(context, GetWindowedOutputSizeVerbose(
+                                  input_dims[i], filter_dims[i],
+                                  dilation_dims[i], stride_dims[i], padding_,
+                                  &out_dims[i], &pad_before[i], &pad_after[i]));
+    }
+    TensorShape out_shape;
+    OP_REQUIRES_OK(context,
+                   ShapeFromFormatWithStatus(data_format_, batch, out_dims,
+                                             out_depth, &out_shape));
+
+    Tensor* output;
+    OP_REQUIRES_OK(context, context->allocate_output(0, out_shape, &output));
+
+    // If there is nothing to compute, return.
+    if (out_shape.num_elements() == 0) {
+      return;
+    }
+
+    // If the input is empty, result can only be due to padding.
+    if (input_flat.NumElements() == 0) {
+      // Zero-out output and return.
+      functor::SetZeroFunctor<Device, T>()(context->eigen_device<Device>(),
+                                           output->template flat<T>());
+
+      return;
+    }
+
+    launcher_(context, cudnn_use_autotune_, input_flat, filter, dilations_,
+              strides_, padding_, explicit_paddings_, data_format_, output);
+
+    // Reshape the output to preserve original batch dimensions.
+    if (batch_dims_ != 1) {
+      std::vector<int64_t> reshape_vect(batch_dims_);
+      for (int i = 0; i < batch_dims_; ++i) {
+        reshape_vect[i] = original_input_shape.dim_size(i);
+      }
+      for (int i = 1; i < out_shape.dims(); ++i) {
+        reshape_vect.push_back(out_shape.dim_size(i));
+      }
+      TensorShape expanded_out_shape(reshape_vect);
+      if (!output->CopyFrom(*output, expanded_out_shape)) {
+        // This should never happen, since the output sizes should always be the
+        // same after expanding batches.
+        context->SetStatus(absl::InternalError(
+            absl::StrCat("Could not expand dimension with flat output shape ",
+                         out_shape.DebugString(), " and expanded output shape ",
+                         expanded_out_shape.DebugString())));
+      }
+    }
+  }
+
+ private:
+  std::vector<int64_t> strides_;
+  Padding padding_;
+  std::vector<int64_t> explicit_paddings_;
+  TensorFormat data_format_;
+  FilterTensorFormat filter_format_;
+  std::vector<int64_t> dilations_;
+  int batch_dims_;
+  int groups_;
+  bool cudnn_use_autotune_;
+
+  LaunchConvOp<Device, T> launcher_;
+
+  ConvOp(const ConvOp&) = delete;
+  void operator=(const ConvOp&) = delete;
+};
+
+template <typename T>
+struct LaunchConv2DOp<CPUDevice, T> {
+  void operator()(OpKernelContext* ctx, bool use_cudnn, bool cudnn_use_autotune,
+                  const Tensor& input, const Tensor& filter, int row_dilation,
+                  int col_dilation, int row_stride, int col_stride,
+                  const Padding& padding,
+                  const std::vector<int64_t>& explicit_paddings, Tensor* output,
+                  TensorFormat data_format) {
+    if (data_format != FORMAT_NHWC) {
+      ctx->SetStatus(errors::Unimplemented(
+          "The Conv2D op currently only supports the NHWC tensor format on the "
+          "CPU. The op was given the format: ",
+          ToString(data_format)));
+      return;
+    }
+
+    for (int64_t explicit_padding : explicit_paddings) {
+      if (!FastBoundsCheck(explicit_padding, std::numeric_limits<int>::max())) {
+        ctx->SetStatus(errors::InvalidArgument("filter too large"));
+        return;
+      }
+    }
+
+    const int64_t in_depth = input.dim_size(3);
+    const int64_t out_depth = output->dim_size(3);
+    const int64_t patch_depth = filter.dim_size(2);
+
+    if (patch_depth <= 0) {
+      ctx->SetStatus(errors::InvalidArgument(
+          "filter depth must be stricly positive, got ", patch_depth));
+      return;
+    }
+    if (in_depth % patch_depth != 0) {
+      ctx->SetStatus(errors::InvalidArgument(
+          "input depth must be evenly divisible by filter depth: ", in_depth,
+          " vs ", patch_depth));
+      return;
+    }
+    if (filter.NumElements() <= 0) {
+      ctx->SetStatus(
+          errors::InvalidArgument("filter must not have zero elements "
+                                  "(i.e. all dimensions must be non-zero)"));
+      return;
+    }
+
+    const int64_t num_groups = in_depth / patch_depth;
+    if (num_groups <= 0) {
+      ctx->SetStatus(errors::InvalidArgument(
+          "number of groups must be stricly positive, got ", num_groups));
+      return;
+    }
+    if (out_depth % num_groups != 0 || out_depth < num_groups) {
+      ctx->SetStatus(errors::InvalidArgument(
+          "output depth must be evenly divisible by number of groups: ",
+          out_depth, " vs ", num_groups));
+      return;
+    }
+
+    if (in_depth != patch_depth) {
+      LaunchGrouped<T>()(ctx, input, filter, row_stride, col_stride,
+                         row_dilation, col_dilation, padding, explicit_paddings,
+                         output, data_format);
+    } else {
+      LaunchGeneric<CPUDevice, T>()(ctx, input, filter, row_stride, col_stride,
+                                    row_dilation, col_dilation, padding,
+                                    explicit_paddings, output, data_format);
+    }
+  }
+};
+extern template struct LaunchConv2DOp<CPUDevice, Eigen::bfloat16>;
+extern template struct LaunchConv2DOp<CPUDevice, Eigen::half>;
+extern template struct LaunchConv2DOp<CPUDevice, float>;
+extern template struct LaunchConv2DOp<CPUDevice, double>;
+extern template struct LaunchConv2DOp<CPUDevice, int32>;
+
+template <typename Device, typename T>
+class LaunchDeepConvOp {
+ public:
+  static bool Run(OpKernelContext* ctx, const Tensor& input,
+                  const Tensor& filter, int batch, int input_rows,
+                  int input_cols, int in_depth, int filter_rows,
+                  int filter_cols, int pad_rows, int pad_cols, int out_rows,
+                  int /*out_cols*/, int /*out_depth*/, int /*dilation_rows*/,
+                  int /*dilation_cols*/, int /*stride_rows*/,
+                  int /*stride_cols*/, Tensor* /*output*/,
+                  TensorFormat /*data_format*/) {
+    return false;
+  }
+};
+
+template <typename Device, typename T>
+class Conv2DOp : public BinaryOp<T> {
+ public:
+  explicit Conv2DOp(OpKernelConstruction* context) : BinaryOp<T>(context) {
+    OP_REQUIRES_OK(context, InitConv2DParameters(context, &params_));
+
+    OP_REQUIRES_OK(context, context->GetAttr("use_cudnn_on_gpu", &use_cudnn_));
+    cudnn_use_autotune_ = CudnnUseAutotune();
+  }
+
+  void Compute(OpKernelContext* context) override {
+    // Input tensor is of the following dimensions:
+    // [ batch, in_rows, in_cols, in_depth ]
+    const Tensor& input = context->input(0);
+
+    // Input filter is of the following dimensions:
+    // [ filter_rows, filter_cols, in_depth, out_depth]
+    const Tensor& filter = context->input(1);
+
+    Conv2DDimensions dimensions;
+    OP_REQUIRES_OK(context,
+                   ComputeConv2DDimension(params_, input, filter, &dimensions));
+
+    TensorShape out_shape;
+    OP_REQUIRES_OK(
+        context, ShapeFromFormatWithStatus(
+                     params_.data_format, dimensions.batch, dimensions.out_rows,
+                     dimensions.out_cols, dimensions.out_depth, &out_shape));
+
+    // Output tensor is of the following dimensions:
+    // [ in_batch, out_rows, out_cols, out_depth ]
+    Tensor* output = nullptr;
+    OP_REQUIRES_OK(context, context->allocate_output(0, out_shape, &output));
+
+    VLOG(2) << "Conv2D: in_depth = " << dimensions.in_depth
+            << ", patch_depth = " << dimensions.patch_depth
+            << ", input_cols = " << dimensions.input_cols
+            << ", filter_cols = " << dimensions.filter_cols
+            << ", input_rows = " << dimensions.input_rows
+            << ", filter_rows = " << dimensions.filter_rows
+            << ", stride_rows = " << dimensions.stride_rows
+            << ", stride_cols = " << dimensions.stride_cols
+            << ", dilation_rows = " << dimensions.dilation_rows
+            << ", dilation_cols = " << dimensions.dilation_cols
+            << ", out_depth = " << dimensions.out_depth;
+
+    // If there is nothing to compute, return.
+    if (out_shape.num_elements() == 0) {
+      return;
+    }
+
+    // If the input is empty, result can only be due to padding.
+    if (input.NumElements() == 0) {
+      // Zero-out output and return.
+      functor::SetZeroFunctor<Device, T>()(context->eigen_device<Device>(),
+                                           output->template flat<T>());
+
+      return;
+    }
+
+    if (params_.padding != EXPLICIT &&
+        LaunchDeepConvOp<Device, T>::Run(
+            context, input, filter, dimensions.batch, dimensions.input_rows,
+            dimensions.input_cols, dimensions.in_depth, dimensions.filter_rows,
+            dimensions.filter_cols, dimensions.pad_rows_before,
+            dimensions.pad_cols_before, dimensions.out_rows,
+            dimensions.out_cols, dimensions.out_depth, dimensions.dilation_rows,
+            dimensions.dilation_cols, dimensions.stride_rows,
+            dimensions.stride_cols, output, params_.data_format)) {
+      return;
+    }
+
+    launcher_(context, use_cudnn_, cudnn_use_autotune_, input, filter,
+              dimensions.dilation_rows, dimensions.dilation_cols,
+              dimensions.stride_rows, dimensions.stride_cols, params_.padding,
+              params_.explicit_paddings, output, params_.data_format);
+  }
+
+ private:
+  Conv2DParameters params_;
+  bool use_cudnn_;
+  bool cudnn_use_autotune_;
+
+  LaunchConv2DOp<Device, T> launcher_;
+
+  Conv2DOp(const Conv2DOp&) = delete;
+  void operator=(const Conv2DOp&) = delete;
+};
+extern template struct Conv2DOp<CPUDevice, Eigen::bfloat16>;
+extern template struct Conv2DOp<CPUDevice, Eigen::half>;
+extern template struct Conv2DOp<CPUDevice, float>;
+extern template struct Conv2DOp<CPUDevice, double>;
+extern template struct Conv2DOp<CPUDevice, int32>;
+
+#if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+template <typename T>
+void LaunchConvOpImpl(OpKernelContext* context, bool cudnn_use_autotune,
+                      const Tensor& input_param, const Tensor& filter,
+                      const gtl::InlinedVector<int64_t, 3>& dilations,
+                      const gtl::InlinedVector<int64_t, 3>& strides,
+                      const Padding& padding,
+                      const std::vector<int64_t>& explicit_paddings,
+                      TensorFormat data_format, Tensor* output) {
+  auto* stream = context->op_device_context()->stream();
+  OP_REQUIRES(context, stream, absl::InternalError("No GPU stream available."));
+
+  Tensor input = input_param;
+
+  int spatial_dims = input.dims() - 2;
+  std::vector<int64_t> in_dims(spatial_dims);
+
+  const int64_t in_batch = GetTensorDim(input, data_format, 'N');
+  for (int i = 0; i < spatial_dims; ++i) {
+    in_dims[i] = GetTensorDim(input, data_format, static_cast<char>('0' + i));
+  }
+  const int64_t in_depth = GetTensorDim(input, data_format, 'C');
+
+  std::vector<int64_t> filter_dims(spatial_dims);
+  for (int i = 0; i < spatial_dims; ++i) {
+    filter_dims[i] = filter.dim_size(i);
+  }
+  const int64_t filter_depth = filter.dim_size(spatial_dims);
+  const int64_t out_depth = filter.dim_size(spatial_dims + 1);
+
+  OP_REQUIRES(
+      context, filter.NumElements() > 0,
+      absl::InvalidArgumentError("filter must not have zero elements "
+                                 "(i.e. all dimensions must be non-zero)"));
+
+  bool is_grouped_convolution = filter_depth != in_depth;
+  // check if filter is 1x1 and stride/dilation are all ones
+  bool one_filter = true;
+  bool one_dilations = true;
+  bool one_stride = true;
+  for (int i = 0; i < spatial_dims; ++i) {
+    one_filter = one_filter && (filter_dims[i] == 1);
+    one_dilations = one_dilations && (dilations[i] == 1);
+    one_stride = one_stride && (strides[i] == 1);
+  }
+  // check if filter is same spatial shape as input
+  bool filter_same_dims = true;
+  for (int i = 0; i < spatial_dims; ++i) {
+    if (filter_dims[i] != in_dims[i]) filter_same_dims = false;
+  }
+
+  if (!is_grouped_convolution && one_filter && one_dilations && one_stride &&
+      data_format == FORMAT_NHWC && (padding == VALID || padding == SAME)) {
+    // 1x1 filter, so call cublas directly.
+    const uint64 m = in_batch * std::accumulate(in_dims.begin(), in_dims.end(),
+                                                1, std::multiplies<>{});
+    const uint64 k = in_depth;
+    const uint64 n = out_depth;
+
+    auto a_ptr = AsDeviceMemory(input.template flat<T>().data(),
+                                input.template flat<T>().size());
+    auto b_ptr = AsDeviceMemory(filter.template flat<T>().data(),
+                                filter.template flat<T>().size());
+    auto c_ptr = AsDeviceMemory(output->template flat<T>().data(),
+                                output->template flat<T>().size());
+
+    auto no_transpose = se::blas::Transpose::kNoTranspose;
+    OP_REQUIRES_OK(context, stream->ThenBlasGemm(
+                                no_transpose, no_transpose, n, m, k, b_ptr, n,
+                                a_ptr, k, &c_ptr, n, GetNumericOptions()));
+    return;
+  } else if (!is_grouped_convolution && filter_same_dims && padding == VALID &&
+             data_format == FORMAT_NHWC) {
+    // The input data and filter have the same spatial dimensions, so call
+    // cublas directly.
+    const uint64 m = in_batch;
+    const uint64 k = in_depth * std::accumulate(in_dims.begin(), in_dims.end(),
+                                                1, std::multiplies<>{});
+    const uint64 n = out_depth;
+
+    auto a_ptr = AsDeviceMemory(input.template flat<T>().data(),
+                                input.template flat<T>().size());
+    auto b_ptr = AsDeviceMemory(filter.template flat<T>().data(),
+                                filter.template flat<T>().size());
+    auto c_ptr = AsDeviceMemory(output->template flat<T>().data(),
+                                output->template flat<T>().size());
+
+    auto no_transpose = se::blas::Transpose::kNoTranspose;
+    OP_REQUIRES_OK(context, stream->ThenBlasGemm(
+                                no_transpose, no_transpose, n, m, k, b_ptr, n,
+                                a_ptr, k, &c_ptr, n, GetNumericOptions()));
+    return;
+  }
+
+  const bool compute_in_nhwc = ComputeInNhwcEnabled(
+      DataTypeToEnum<T>::value, stream, /*use_4d_tensor=*/(spatial_dims == 2));
+  const TensorFormat compute_data_format =
+      (compute_in_nhwc && data_format == FORMAT_NHWC) ? FORMAT_NHWC
+                                                      : FORMAT_NCHW;
+
+  VLOG(3) << "Compute Conv with cuDNN:"
+          << " data_format=" << ToString(data_format)
+          << " compute_data_format=" << ToString(compute_data_format);
+
+  std::vector<int64_t> out_dims(output->dims());
+  for (int i = 0; i < output->dims(); ++i) {
+    out_dims[i] = output->dim_size(i);
+  }
+  std::vector<std::pair<int64_t, int64_t>> paddings(spatial_dims, {-1, -1});
+  // Explicit only on 2D case.
+  if (padding == EXPLICIT) {
+    GetExplicitPaddingForDim(explicit_paddings, data_format, 'H',
+                             &paddings[0].first, &paddings[0].second);
+    GetExplicitPaddingForDim(explicit_paddings, data_format, 'W',
+                             &paddings[1].first, &paddings[1].second);
+  }
+
+  // Get padding values, output should be valid, since it was checked before.
+  std::vector<int64_t> out_dims_check(spatial_dims);
+  for (int i = 0; i < spatial_dims; ++i) {
+    OP_REQUIRES_OK(context, GetWindowedOutputSizeVerbose(
+                                in_dims[i], filter_dims[i], dilations[i],
+                                strides[i], padding, &out_dims_check[i],
+                                &paddings[i].first, &paddings[i].second));
+    OP_REQUIRES(context,
+                (out_dims_check[i] == GetTensorDim(*output, data_format,
+                                                   static_cast<char>('0' + i))),
+                absl::InternalError("Output dimension doesn't match yo"));
+  }
+
+  bool assymmetric_padding = false;
+  std::vector<int64_t> common_padding(spatial_dims);
+  for (int i = 0; i < spatial_dims; ++i) {
+    common_padding[i] = std::min(paddings[i].first, paddings[i].second);
+    assymmetric_padding =
+        assymmetric_padding || (paddings[i].first != paddings[i].second);
+  }
+
+  if (assymmetric_padding) {
+    // cuDNN only supports padding the same amount on either side. So we
+    // manually create a new padded input tensor.
+    Tensor transformed_input;
+    std::vector<int64_t> new_in_dims(input.dims());
+    new_in_dims[0] = in_batch;
+    for (int i = 0; i < spatial_dims; ++i) {
+      int index = GetTensorSpatialDimIndex(input.dims(), data_format, i);
+      new_in_dims[index] =
+          in_dims[i] + std::abs(paddings[i].first - paddings[i].second);
+    }
+    new_in_dims[GetTensorDimIndex(data_format, 'C', input.dims())] = in_depth;
+    TensorShape transformed_input_shape(new_in_dims);
+    OP_REQUIRES_OK(context, context->allocate_temp(DataTypeToEnum<T>::value,
+                                                   transformed_input_shape,
+                                                   &transformed_input));
+
+    // Padding to add on transformed input.
+    std::vector<std::pair<int64_t, int64_t>> transformed_input_padding(
+        paddings);
+    for (int i = 0; i < spatial_dims; ++i) {
+      transformed_input_padding[i].first -= common_padding[i];
+      transformed_input_padding[i].second -= common_padding[i];
+    }
+
+    // Check padding size.
+    bool padding_bounds_valid = true;
+    for (int i = 0; i < spatial_dims; ++i) {
+      padding_bounds_valid =
+          padding_bounds_valid &&
+          FastBoundsCheck(transformed_input_padding[i].first,
+                          std::numeric_limits<int>::max()) &&
+          FastBoundsCheck(transformed_input_padding[i].second,
+                          std::numeric_limits<int>::max());
+    }
+    OP_REQUIRES(context, padding_bounds_valid,
+                absl::InvalidArgumentError("Padding is too large."));
+
+    // Pad new input.
+    if (input.dims() == 4) {
+      std::array<int, 2> pad_left{
+          static_cast<int>(transformed_input_padding[0].first),
+          static_cast<int>(transformed_input_padding[1].first)};
+      std::array<int, 2> pad_right{
+          static_cast<int>(transformed_input_padding[0].second),
+          static_cast<int>(transformed_input_padding[1].second)};
+      functor::PadInput<GPUDevice, T, int, 4>()(
+          context->eigen_device<GPUDevice>(),
+          To32Bit(static_cast<const Tensor&>(input).tensor<T, 4>()), pad_left,
+          pad_right, To32Bit(transformed_input.tensor<T, 4>()), data_format,
+          T{});
+    } else if (input.dims() == 5) {
+      std::array<int, 3> pad_left{
+          static_cast<int>(transformed_input_padding[0].first),
+          static_cast<int>(transformed_input_padding[1].first),
+          static_cast<int>(transformed_input_padding[2].first)};
+      std::array<int, 3> pad_right{
+          static_cast<int>(transformed_input_padding[0].second),
+          static_cast<int>(transformed_input_padding[1].second),
+          static_cast<int>(transformed_input_padding[2].second)};
+      functor::PadInput<GPUDevice, T, int, 5>()(
+          context->eigen_device<GPUDevice>(),
+          To32Bit(static_cast<const Tensor&>(input).tensor<T, 5>()), pad_left,
+          pad_right, To32Bit(transformed_input.tensor<T, 5>()), data_format,
+          T{});
+    } else {
+      context->SetStatus(
+          absl::InternalError("Failed to pad input, invalid dimensions."));
+    }
+
+    input = transformed_input;
+    for (int i = 0; i < spatial_dims; ++i) {
+      in_dims[i] = new_in_dims[GetTensorDimIndex(
+          data_format, static_cast<char>('0' + i), input.dims())];
+    }
+  }
+
+  if (data_format == FORMAT_NHWC && compute_data_format == FORMAT_NCHW) {
+    VLOG(4) << "Convert the input tensor from NHWC to NCHW.";
+
+    TensorShape channels_first_shape;
+    OP_REQUIRES_OK(context,
+                   ShapeFromFormatWithStatus(FORMAT_NCHW, in_batch, in_dims,
+                                             in_depth, &channels_first_shape));
+
+    if (in_depth > 1) {
+      Tensor transformed_input;
+      OP_REQUIRES_OK(context, context->allocate_temp(DataTypeToEnum<T>::value,
+                                                     channels_first_shape,
+                                                     &transformed_input));
+      if (input.dims() == 4) {
+        functor::NHWCToNCHW<GPUDevice, T, 4>()(
+            context->eigen_device<GPUDevice>(),
+            const_cast<const Tensor&>(input).tensor<T, 4>(),
+            transformed_input.tensor<T, 4>());
+      } else if (input.dims() == 5) {
+        functor::NHWCToNCHW<GPUDevice, T, 5>()(
+            context->eigen_device<GPUDevice>(),
+            const_cast<const Tensor&>(input).tensor<T, 5>(),
+            transformed_input.tensor<T, 5>());
+      } else {
+        context->SetStatus(
+            absl::InternalError("Failed to reshape input to channels first "
+                                "format, invalid dimensions."));
+      }
+      input = transformed_input;
+    } else {
+      // Depth = 1, reshape.
+      if (!input.CopyFrom(input, channels_first_shape)) {
+        context->SetStatus(absl::InternalError(
+            "Failed to reshape input to channels first format."));
+      }
+    }
+  } else {
+    DCHECK(data_format == compute_data_format)  // Crash OK.
+        << "Illegal data and compute format pair:"
+        << " data_format=" << ToString(data_format)
+        << " compute_data_format=" << ToString(compute_data_format);
+  }
+
+  // Check paddings are not negative.
+  bool non_negative_paddings = true;
+  for (int i = 0; i < spatial_dims; ++i) {
+    non_negative_paddings = non_negative_paddings && common_padding[i] >= 0;
+  }
+  OP_REQUIRES(context, non_negative_paddings,
+              absl::InvalidArgumentError("Padding is negative."));
+
+  constexpr auto kComputeInNHWC =
+      std::make_tuple(se::dnn::DataLayout::kBatchYXDepth,
+                      se::dnn::FilterLayout::kOutputYXInput);
+  constexpr auto kComputeInNCHW =
+      std::make_tuple(se::dnn::DataLayout::kBatchDepthYX,
+                      se::dnn::FilterLayout::kOutputInputYX);
+
+  se::dnn::DataLayout compute_data_layout;
+  se::dnn::FilterLayout filter_layout;
+
+  std::tie(compute_data_layout, filter_layout) =
+      compute_data_format == FORMAT_NHWC ? kComputeInNHWC : kComputeInNCHW;
+
+  se::dnn::BatchDescriptor input_desc(spatial_dims);
+  input_desc.set_count(in_batch).set_feature_map_count(in_depth).set_layout(
+      compute_data_layout);
+  if (spatial_dims == 2) {
+    input_desc.set_spatial_dim(stream_executor::dnn::DimIndex::X, in_dims[1])
+        .set_spatial_dim(stream_executor::dnn::DimIndex::Y, in_dims[0]);
+  } else if (spatial_dims == 3) {
+    input_desc.set_spatial_dim(stream_executor::dnn::DimIndex::X, in_dims[2])
+        .set_spatial_dim(stream_executor::dnn::DimIndex::Y, in_dims[1])
+        .set_spatial_dim(stream_executor::dnn::DimIndex::Z, in_dims[0]);
+  } else {
+    context->SetStatus(
+        absl::InternalError("Failed to set Input Descripitor:"
+                            " invalid number of spatial dimensions"));
+  }
+
+  se::dnn::BatchDescriptor output_desc(spatial_dims);
+  output_desc.set_count(GetTensorDim(*output, data_format, 'N'))
+      .set_feature_map_count(GetTensorDim(*output, data_format, 'C'))
+      .set_layout(compute_data_layout);
+  if (spatial_dims == 2) {
+    output_desc
+        .set_spatial_dim(
+            stream_executor::dnn::DimIndex::X,
+            GetTensorDim(*output, data_format, static_cast<int>('1')))
+        .set_spatial_dim(
+            stream_executor::dnn::DimIndex::Y,
+            GetTensorDim(*output, data_format, static_cast<int>('0')));
+  } else if (spatial_dims == 3) {
+    output_desc
+        .set_spatial_dim(
+            stream_executor::dnn::DimIndex::X,
+            GetTensorDim(*output, data_format, static_cast<int>('2')))
+        .set_spatial_dim(
+            stream_executor::dnn::DimIndex::Y,
+            GetTensorDim(*output, data_format, static_cast<int>('1')))
+        .set_spatial_dim(
+            stream_executor::dnn::DimIndex::Z,
+            GetTensorDim(*output, data_format, static_cast<int>('0')));
+  } else {
+    context->SetStatus(
+        absl::InternalError("Failed to set Output Descripitor: invalid "
+                            "number of spatial dimensions"));
+  }
+
+  se::dnn::FilterDescriptor filter_desc(spatial_dims);
+  filter_desc.set_input_feature_map_count(filter_depth)
+      .set_output_feature_map_count(out_depth)
+      .set_layout(filter_layout);
+  if (spatial_dims == 2) {
+    filter_desc
+        .set_spatial_dim(stream_executor::dnn::DimIndex::X, filter_dims[1])
+        .set_spatial_dim(stream_executor::dnn::DimIndex::Y, filter_dims[0]);
+  } else if (spatial_dims == 3) {
+    filter_desc
+        .set_spatial_dim(stream_executor::dnn::DimIndex::X, filter_dims[2])
+        .set_spatial_dim(stream_executor::dnn::DimIndex::Y, filter_dims[1])
+        .set_spatial_dim(stream_executor::dnn::DimIndex::Z, filter_dims[0]);
+  } else {
+    context->SetStatus(
+        absl::InternalError("Failed to set Filter Descripitor: invalid "
+                            "number of spatial dimensions"));
+  }
+
+  se::dnn::ConvolutionDescriptor conv_desc(spatial_dims);
+  if (spatial_dims == 2) {
+    conv_desc.set_dilation_rate(stream_executor::dnn::DimIndex::X, dilations[1])
+        .set_dilation_rate(stream_executor::dnn::DimIndex::Y, dilations[0])
+        .set_filter_stride(stream_executor::dnn::DimIndex::X, strides[1])
+        .set_filter_stride(stream_executor::dnn::DimIndex::Y, strides[0])
+        .set_zero_padding(stream_executor::dnn::DimIndex::X, common_padding[1])
+        .set_zero_padding(stream_executor::dnn::DimIndex::Y, common_padding[0]);
+  } else if (spatial_dims == 3) {
+    conv_desc.set_dilation_rate(stream_executor::dnn::DimIndex::X, dilations[2])
+        .set_dilation_rate(stream_executor::dnn::DimIndex::Y, dilations[1])
+        .set_dilation_rate(stream_executor::dnn::DimIndex::Z, dilations[0])
+        .set_filter_stride(stream_executor::dnn::DimIndex::X, strides[2])
+        .set_filter_stride(stream_executor::dnn::DimIndex::Y, strides[1])
+        .set_filter_stride(stream_executor::dnn::DimIndex::Z, strides[0])
+        .set_zero_padding(stream_executor::dnn::DimIndex::X, common_padding[2])
+        .set_zero_padding(stream_executor::dnn::DimIndex::Y, common_padding[1])
+        .set_zero_padding(stream_executor::dnn::DimIndex::Z, common_padding[0]);
+  } else {
+    context->SetStatus(
+        absl::InternalError("Failed to set Convolution Descripitor: invalid "
+                            "number of spatial dimensions"));
+  }
+  conv_desc.set_group_count(1);
+  // TODO(b/290223810) Change group count when implementing group/depthwise.
+  Tensor transformed_filter;
+  auto dst_format =
+      compute_data_format == FORMAT_NCHW ? FORMAT_OIHW : FORMAT_OHWI;
+  VLOG(4) << "Transform filter tensor from " << ToString(FORMAT_HWIO) << " to "
+          << ToString(dst_format);
+  std::vector<int64_t> dst_shape_vec(spatial_dims + 2);
+  dst_shape_vec[0] = out_depth;
+  if (dst_format == FORMAT_OIHW) {
+    dst_shape_vec[1] = filter_depth;
+    for (int i = 2; i < filter.dims(); ++i) {
+      dst_shape_vec[i] = filter_dims[i - 2];
+    }
+  } else {
+    // Format OHWI
+    dst_shape_vec[filter.dims() - 1] = filter_depth;
+    for (int i = 1; i < filter.dims() - 1; ++i) {
+      dst_shape_vec[i] = filter_dims[i - 1];
+    }
+  }
+  TensorShape dst_shape(dst_shape_vec);
+  OP_REQUIRES_OK(context,
+                 context->allocate_temp(DataTypeToEnum<T>::value, dst_shape,
+                                        &transformed_filter));
+
+  // Filter: [(spatial_dims), in, out] (HWIO)
+  // T_filter: [out, in, (spatial_dims)] (OIHW) or
+  // T_filter: [out, (spatial_dims), in] (OHWI)
+  if (spatial_dims == 2) {
+    functor::TransformFilter<GPUDevice, T, int, 4>()(
+        context->eigen_device<GPUDevice>(), dst_format,
+        To32Bit(filter.tensor<T, 4>()),
+        To32Bit(transformed_filter.tensor<T, 4>()));
+  } else if (spatial_dims == 3) {
+    functor::TransformFilter<GPUDevice, T, int, 5>()(
+        context->eigen_device<GPUDevice>(), dst_format,
+        To32Bit(filter.tensor<T, 5>()),
+        To32Bit(transformed_filter.tensor<T, 5>()));
+  } else {
+    context->SetStatus(absl::InternalError(
+        "Failed to reshape filter, invalid spatial dimensions."));
+  }
+
+  Tensor transformed_output;
+  if (data_format != compute_data_format) {
+    VLOG(4) << "Allocate temporary memory for output in compute data format";
+    TensorShape transformed_output_shape;
+    OP_REQUIRES_OK(context, ShapeFromFormatWithStatus(
+                                FORMAT_NCHW, in_batch, out_dims_check,
+                                out_depth, &transformed_output_shape));
+    OP_REQUIRES_OK(context, context->allocate_temp(DataTypeToEnum<T>::value,
+                                                   transformed_output_shape,
+                                                   &transformed_output));
+  } else {
+    transformed_output = *output;
+  }
+
+  auto input_ptr = AsDeviceMemory(input.template flat<T>().data(),
+                                  input.template flat<T>().size());
+  auto filter_ptr =
+      AsDeviceMemory(transformed_filter.template flat<T>().data(),
+                     transformed_filter.template flat<T>().size());
+  auto output_ptr =
+      AsDeviceMemory(transformed_output.template flat<T>().data(),
+                     transformed_output.template flat<T>().size());
+
+  static int64_t ConvolveScratchSize = GetDnnWorkspaceLimitOrDefault();
+
+  if (spatial_dims == 2) {
+    filter_dims.push_back(filter_depth);
+  }
+  ConvParameters conv_parameters = {
+      stream->parent(),
+      in_batch,             // batch
+      in_depth,             // in_depths
+      in_dims,              // input spatial dims
+      compute_data_format,  // compute_data_format
+      out_depth,            // out_depths
+      filter_dims,          // filter spatial dims
+      dilations,            // dilations
+      strides,              // strides
+      common_padding,       // paddings (symmetrical)
+      input.dtype(),        // tensor datatype
+      conv_desc.group_count(),
+  };
+
+  auto entry_or = AutotuneUnfusedConv(
+      cudnn_use_autotune, ConvAutotuneMap::GetInstance(), conv_parameters,
+      context, se::dnn::ConvolutionKind::FORWARD, input_desc, input_ptr,
+      filter_desc, filter_ptr, conv_desc, output_desc, output_ptr,
+      ConvolveScratchSize);
+  OP_REQUIRES_OK(context, entry_or.status());
+  auto autotune_entry = std::move(entry_or).value();
+
+  DnnScratchAllocator scratch_allocator(ConvolveScratchSize, context);
+  Status cudnn_launch_status = LaunchAutotunedConv(
+      autotune_entry, &scratch_allocator, se::dnn::ConvolutionKind::FORWARD,
+      stream, input_desc, input_ptr, filter_desc, filter_ptr, conv_desc,
+      output_desc, output_ptr);
+  if (!cudnn_launch_status.ok()) {
+    context->SetStatus(cudnn_launch_status);
+    return;
+  }
+
+  if (data_format == FORMAT_NHWC && compute_data_format == FORMAT_NCHW) {
+    VLOG(4) << "Convert the output tensor back from NCHW to NHWC.";
+    if (spatial_dims == 2) {
+      functor::NCHWToNHWC<GPUDevice, T, 4>()(
+          context->eigen_device<GPUDevice>(),
+          const_cast<const Tensor&>(transformed_output).tensor<T, 4>(),
+          output->tensor<T, 4>());
+    } else if (spatial_dims == 3) {
+      functor::NCHWToNHWC<GPUDevice, T, 5>()(
+          context->eigen_device<GPUDevice>(),
+          const_cast<const Tensor&>(transformed_output).tensor<T, 5>(),
+          output->tensor<T, 5>());
+    } else {
+      context->SetStatus(absl::InternalError(
+          "Failed to convert output data foramt, invalid spatial dimensions."));
+    }
+  }
+}
+
+template <typename T>
+void LaunchConvOp<GPUDevice, T>::operator()(
+    OpKernelContext* context, bool cudnn_use_autotune, const Tensor& input,
+    const Tensor& filter, const std::vector<int64>& dilations,
+    const std::vector<int64>& strides, const Padding padding,
+    const std::vector<int64_t>& explicit_paddings, TensorFormat data_format,
+    Tensor* output) {
+  // Get spatial dims for dilations and strides.
+  int spatial_dims = input.dims() - 2;
+  gtl::InlinedVector<int64_t, 3> strides_spatial(spatial_dims);
+  gtl::InlinedVector<int64_t, 3> dilations_spatial(spatial_dims);
+  for (int i = 0; i < spatial_dims; ++i) {
+    strides_spatial[i] =
+        GetTensorDim(strides, data_format, static_cast<char>(i + '0'));
+    dilations_spatial[i] =
+        GetTensorDim(dilations, data_format, static_cast<char>(i + '0'));
+  }
+  LaunchConvOpImpl<T>(context, cudnn_use_autotune, input, filter,
+                      dilations_spatial, strides_spatial, padding,
+                      explicit_paddings, data_format, output);
+}
+
+template <typename T>
+void LaunchConv2DOp<GPUDevice, T>::operator()(
+    OpKernelContext* ctx, bool use_cudnn, bool cudnn_use_autotune,
+    const Tensor& input_param, const Tensor& filter, int row_dilation,
+    int col_dilation, int row_stride, int col_stride, const Padding& padding,
+    const std::vector<int64_t>& explicit_paddings, Tensor* output,
+    TensorFormat data_format) {
+  // Cast strides and dilations.
+  gtl::InlinedVector<int64_t, 3> casted_strides = {row_stride, col_stride};
+  gtl::InlinedVector<int64_t, 3> casted_dilations = {row_dilation,
+                                                     col_dilation};
+  LaunchConvOpImpl<T>(ctx, cudnn_use_autotune, input_param, filter,
+                      casted_dilations, casted_strides, padding,
+                      explicit_paddings, data_format, output);
+}
+
+// To be used inside depthwise_conv_op.cc.
+extern template struct LaunchConv2DOp<GPUDevice, float>;
+// extern template struct LaunchConv2DOp<GPUDevice, Eigen::bfloat16>;
+extern template struct LaunchConv2DOp<GPUDevice, Eigen::half>;
+extern template struct LaunchConv2DOp<GPUDevice, double>;
+
+#endif  // GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_CONV_OPS_IMPL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/cross_op.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/cross_op.h
new file mode 100644
index 0000000000000000000000000000000000000000..cf5956ac9a2cdfb8bf6aaa920d61b6f3527a6416
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/cross_op.h
@@ -0,0 +1,54 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_CROSS_OP_H_
+#define TENSORFLOW_CORE_KERNELS_CROSS_OP_H_
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/framework/tensor_shape.h"
+#include "tensorflow/core/framework/tensor_types.h"
+
+namespace tensorflow {
+
+namespace functor {
+
+template <typename Device, typename Type>
+struct Cross {
+  void operator()(const Device &d,
+                  typename TTypes<Type, 2>::ConstTensor in0_data,
+                  typename TTypes<Type, 2>::ConstTensor in1_data,
+                  typename TTypes<Type, 2>::Tensor output_data) {
+    auto s1 = output_data.template chip<1>(0);
+    auto s2 = output_data.template chip<1>(1);
+    auto s3 = output_data.template chip<1>(2);
+
+    auto u1 = in0_data.template chip<1>(0);
+    auto u2 = in0_data.template chip<1>(1);
+    auto u3 = in0_data.template chip<1>(2);
+
+    auto v1 = in1_data.template chip<1>(0);
+    auto v2 = in1_data.template chip<1>(1);
+    auto v3 = in1_data.template chip<1>(2);
+
+    s1.device(d) = u2 * v3 - u3 * v2;
+    s2.device(d) = u3 * v1 - u1 * v3;
+    s3.device(d) = u1 * v2 - u2 * v1;
+  }
+};
+
+}  // namespace functor
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_CROSS_OP_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/cudnn_pooling_gpu.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/cudnn_pooling_gpu.h
new file mode 100644
index 0000000000000000000000000000000000000000..970eb533318bb43fa78f6eb65596ea890d75124e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/cudnn_pooling_gpu.h
@@ -0,0 +1,70 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// Helper functions to run 3d pooling on GPU using CuDNN.
+
+#ifndef TENSORFLOW_CORE_KERNELS_CUDNN_POOLING_GPU_H_
+#define TENSORFLOW_CORE_KERNELS_CUDNN_POOLING_GPU_H_
+
+#include <array>
+
+#include "tensorflow/core/framework/op_kernel.h"
+
+#if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+#include "tensorflow/core/platform/stream_executor.h"
+#endif
+
+#include "tensorflow/core/util/padding.h"
+
+namespace tensorflow {
+
+#if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+
+// Runs (avg/max)pooling on GPU.
+// Dimension order for all array arguments is: x, y, z.
+template <typename T>
+class DnnPooling3dOp {
+ public:
+  static void Compute(OpKernelContext* context,
+                      se::dnn::PoolingMode pooling_mode,
+                      const std::array<int64, 3>& size,
+                      const std::array<int64, 3>& stride,
+                      const std::array<int64, 3>& padding,
+                      TensorFormat data_format, const Tensor& tensor_in,
+                      Tensor* output);
+};
+
+// Computes the gradient of (avg/max)pooling on GPU.
+// Dimension order for all array arguments is: x, y, z.
+template <typename T>
+class DnnPooling3dGradOp {
+ public:
+  static void Compute(OpKernelContext* context,
+                      se::dnn::PoolingMode pooling_mode,
+                      const std::array<int64, 3>& window,
+                      const std::array<int64, 3>& stride,
+                      const std::array<int64, 3>& padding,
+                      const std::array<int64, 3>& output_size,
+                      TensorFormat data_format, const Tensor& out_backprop,
+                      const TensorShape& tensor_in_shape,
+                      const Tensor* tensor_in, const Tensor* tensor_out,
+                      Tensor* input_backprop);
+};
+
+#endif
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_CUDNN_POOLING_GPU_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/cwise_op_clip.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/cwise_op_clip.h
new file mode 100644
index 0000000000000000000000000000000000000000..171b6932c2d7935e2cdec76aebe4643926df7580
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/cwise_op_clip.h
@@ -0,0 +1,61 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_CWISE_OP_CLIP_H_
+#define TENSORFLOW_CORE_KERNELS_CWISE_OP_CLIP_H_
+
+#include "tensorflow/core/kernels/cwise_ops_common.h"
+
+namespace tensorflow {
+namespace functor {
+// Unary functor for clip [Tensor, Scalar, Scalar]
+template <typename Device, typename T>
+struct UnaryClipOp {
+  void operator()(const Device &d, typename TTypes<T>::ConstFlat &in0_flat,
+                  typename TTypes<T>::ConstFlat &in1_flat,
+                  typename TTypes<T>::ConstFlat &in2_flat,
+                  typename TTypes<T>::Flat &out_flat) const;
+};
+
+// Binary functor for clip [Tensor, Scalar, Tensor]
+template <typename Device, typename T>
+struct BinaryRightClipOp {
+  void operator()(const Device &d, typename TTypes<T>::ConstFlat &in0_flat,
+                  typename TTypes<T>::ConstFlat &in1_flat,
+                  typename TTypes<T>::ConstFlat &in2_flat,
+                  typename TTypes<T>::Flat &out_flat) const;
+};
+
+// Binary functor for clip [Tensor, Tensor, Scalar]
+template <typename Device, typename T>
+struct BinaryLeftClipOp {
+  void operator()(const Device &d, typename TTypes<T>::ConstFlat &in0_flat,
+                  typename TTypes<T>::ConstFlat &in1_flat,
+                  typename TTypes<T>::ConstFlat &in2_flat,
+                  typename TTypes<T>::Flat &out_flat) const;
+};
+
+// Ternary functor for clip [Tensor, Tensor, Tensor]
+template <typename Device, typename T>
+struct TernaryClipOp {
+  void operator()(const Device &d, typename TTypes<T>::ConstFlat &in0_flat,
+                  typename TTypes<T>::ConstFlat &in1_flat,
+                  typename TTypes<T>::ConstFlat &in2_flat,
+                  typename TTypes<T>::Flat &out_flat) const;
+};
+}  // namespace functor
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_CWISE_OP_CLIP_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/cwise_ops.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/cwise_ops.h
new file mode 100644
index 0000000000000000000000000000000000000000..2694b0d1b89e1995665d47d3a1fa24fcb0a45967
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/cwise_ops.h
@@ -0,0 +1,1340 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_CWISE_OPS_H_
+#define TENSORFLOW_CORE_KERNELS_CWISE_OPS_H_
+
+#define _USE_MATH_DEFINES
+#include <cmath>
+#include <functional>
+#include <type_traits>
+
+#include "Eigen/Core"  // from @eigen_archive
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/framework/bounds_check.h"
+#include "tensorflow/core/framework/numeric_types.h"
+#include "tensorflow/core/framework/tensor_types.h"
+
+namespace Eigen {
+namespace internal {
+
+#if GOOGLE_CUDA
+template <>
+struct scalar_arg_op<std::complex<float>> {
+  typedef typename Eigen::NumTraits<std::complex<float>>::Real result_type;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float operator()(
+      const std::complex<float>& a) const {
+    return ::atan2f(a.imag(), a.real());
+  }
+};
+
+template <>
+struct scalar_arg_op<std::complex<double>> {
+  typedef typename Eigen::NumTraits<std::complex<double>>::Real result_type;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double operator()(
+      const std::complex<double>& a) const {
+    return ::atan2(a.imag(), a.real());
+  }
+};
+#endif
+
+template <typename Scalar, typename Exponent>
+struct safe_scalar_binary_pow_op {
+  static_assert(std::is_integral<Scalar>::value, "Integer type expected");
+  static_assert(std::is_integral<Exponent>::value &&
+                    std::is_signed<Exponent>::value,
+                "Signed integer type expected");
+
+  bool* const error;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE safe_scalar_binary_pow_op(bool* error)
+      : error(error) {}
+
+  EIGEN_DEVICE_FUNC inline Scalar operator()(const Scalar& a,
+                                             const Exponent& b) const {
+    const Exponent safe_b = tensorflow::internal::SubtleMustCopy(b);
+    if (TF_PREDICT_TRUE(safe_b >= 0)) {
+      return numext::pow(a, safe_b);
+    } else {
+      *error = true;
+      return 0;
+    }
+  }
+};
+
+template <typename Scalar, typename Exponent>
+struct functor_traits<safe_scalar_binary_pow_op<Scalar, Exponent>> {
+  enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = false };
+};
+
+template <typename T, typename DivOrMod>
+struct safe_div_or_mod_op {
+  static_assert(std::is_integral<T>::value, "Integer type expected");
+
+  bool* const error;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE safe_div_or_mod_op(bool* error)
+      : error(error) {}
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T operator()(const T& a,
+                                                     const T& b) const {
+    const T safe_b = tensorflow::internal::SubtleMustCopy(b);
+    if (TF_PREDICT_TRUE(safe_b != 0)) {
+      // Avoid FPE for INT_MIN/-1.
+      const T safe_a = tensorflow::internal::SubtleMustCopy(a);
+      if (TF_PREDICT_FALSE(std::is_signed<T>::value &&
+                           safe_a == std::numeric_limits<T>::min() &&
+                           safe_b == T(-1))) {
+        // Prefer to overflow 'a' instead of crashing.
+        return DivOrMod()(-safe_a, 1);
+      }
+      return DivOrMod()(safe_a, safe_b);
+    } else {
+      *error = true;
+      return 0;
+    }
+  }
+};
+
+template <typename T, typename DivOrMod>
+struct functor_traits<safe_div_or_mod_op<T, DivOrMod>> {
+  enum {
+    Cost = functor_traits<DivOrMod>::Cost + NumTraits<T>::AddCost,
+    PacketAccess = false,
+  };
+};
+
+template <typename T, typename Binary>
+struct no_nan_op {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T operator()(const T& a,
+                                                     const T& b) const {
+    if (b != T(0)) {
+      return Binary()(a, b);
+    } else {
+      return T(0);
+    }
+  }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& a,
+                                                        const Packet& b) const {
+    const Packet mask = pcmp_eq(b, pzero(b));
+    const Packet quotient = Binary().packetOp(a, b);
+    return pandnot(quotient, mask);
+  }
+};
+
+template <typename T, bool IsComplex = Eigen::NumTraits<T>::IsComplex>
+struct div_no_nan_op;
+
+template <typename T>
+struct div_no_nan_op<T, /*IsComplex=*/false>
+    : public no_nan_op<T, scalar_quotient_op<T>> {
+};
+
+template <typename T>
+struct functor_traits<div_no_nan_op<T, /*IsComplex=*/false>> {
+  enum {
+    Cost = functor_traits<scalar_quotient_op<T>>::Cost + NumTraits<T>::AddCost,
+    PacketAccess = true,
+  };
+};
+
+// Whether or not complex division produces a NaN depends on the underlying
+// implementation. Some compilers (e.g. gcc) use a simple method that divides
+// by |b|^2, which may underflow to 0 for b != 0.
+template <typename T>
+struct div_no_nan_op<T, /*IsComplex=*/true> {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T operator()(const T& a,
+                                                     const T& b) const {
+    if (b == T(0)) {
+      return T(0);
+    } else {
+      // If the numerator is zero, then the result must be zero even if |b|^2
+      // underflows to zero.
+      const T numerator =
+          scalar_product_op<T>()(a, scalar_conjugate_op<T>()(b));
+      if (numerator == T(0)) {
+        return T(0);
+      }
+    }
+    return scalar_quotient_op<T>()(a, b);
+  }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& a,
+                                                        const Packet& b) const {
+    const Packet numerator = pmul(a, pconj(b));
+    const Packet mask = por(pcmp_eq(b, pzero(a)), pcmp_eq(numerator, pzero(a)));
+    const Packet quotient = pdiv(a, b);
+    return pandnot(quotient, mask);
+  }
+};
+
+template <typename T>
+struct functor_traits<div_no_nan_op<T, /*IsComplex=*/true>> {
+  enum {
+    Cost = functor_traits<scalar_quotient_op<T>>::Cost + NumTraits<T>::MulCost,
+    PacketAccess = packet_traits<T>::HasMul && packet_traits<T>::HasDiv &&
+                   packet_traits<T>::HasConj,
+  };
+};
+
+template <typename T>
+struct mul_no_nan_op : public no_nan_op<T, scalar_product_op<T>> {
+};
+
+template <typename T>
+struct functor_traits<mul_no_nan_op<T>> {
+  enum {
+    Cost = functor_traits<scalar_product_op<T>>::Cost + NumTraits<T>::AddCost,
+    PacketAccess = true,
+  };
+};
+
+// scalar_left and scalar_right are template helpers to partially
+// apply a binary function.
+//
+// Suppose Binary is a binary functor f(x, y), scalar_left<> is a
+// unary functor g_x(y) = f(x, y), where x is provided via the
+// constructor. Similarly, scalar_right<> is a unary functor g_y(x) =
+// f(x, y).
+
+template <typename Tout, typename Tin, typename Binary>
+struct scalar_left : private Binary {
+  using result_type = Tout;
+
+  const Tin* left;
+
+  inline scalar_left(const scalar_left& other) = default;
+
+  template <typename... Args>
+  EIGEN_DEVICE_FUNC inline explicit scalar_left(const Tin* c, Args... args)
+      : Binary(args...), left(c) {}
+
+  EIGEN_DEVICE_FUNC inline Tout operator()(const Tin& right) const {
+    return Binary::operator()(*left, right);
+  }
+
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& right_packet) const {
+    return Binary::packetOp(Eigen::internal::pset1<Packet>(*left),
+                            right_packet);
+  }
+};
+
+template <typename Tout, typename Tin, typename Binary>
+struct functor_traits<scalar_left<Tout, Tin, Binary>> {
+  enum {
+    Cost = functor_traits<Binary>::Cost,
+    PacketAccess = functor_traits<Binary>::PacketAccess,
+  };
+};
+
+template <typename Tout, typename Tin, typename Binary>
+struct scalar_right : private Binary {
+  using result_type = Tout;
+
+  const Tin* right;
+
+  inline scalar_right(const scalar_right& other) = default;
+
+  template <typename... Args>
+  EIGEN_DEVICE_FUNC inline explicit scalar_right(const Tin* c, Args... args)
+      : Binary(args...), right(c) {}
+
+  EIGEN_DEVICE_FUNC inline Tout operator()(const Tin& left) const {
+    return Binary::operator()(left, *right);
+  }
+
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& left_packet) const {
+    return Binary::packetOp(left_packet,
+                            Eigen::internal::pset1<Packet>(*right));
+  }
+};
+
+template <typename Tout, typename Tin, typename Binary>
+struct functor_traits<scalar_right<Tout, Tin, Binary>> {
+  enum {
+    Cost = functor_traits<Binary>::Cost,
+    PacketAccess = functor_traits<Binary>::PacketAccess,
+  };
+};
+
+// similar to std::equal_to, but with the DEVICE_FUNC qualifier
+template <class T>
+struct equal_to : std::function<bool(T, T)> {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator()(const T& x,
+                                                        const T& y) const {
+    return x == y;
+  }
+};
+
+// similar to std::not_equal_to, but with the DEVICE_FUNC qualifier
+template <class T>
+struct not_equal_to : std::function<bool(T, T)> {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator()(const T& x,
+                                                        const T& y) const {
+    return x != y;
+  }
+};
+
+// similar to std::greater, but with the DEVICE_FUNC qualifier
+template <class T>
+struct greater : std::function<bool(T, T)> {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator()(const T& x,
+                                                        const T& y) const {
+    return x > y;
+  }
+};
+
+// similar to std::less, but with the DEVICE_FUNC qualifier
+template <class T>
+struct less : std::function<bool(T, T)> {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator()(const T& x,
+                                                        const T& y) const {
+    return x < y;
+  }
+};
+
+// similar to std::greater_equal, but with the DEVICE_FUNC qualifier
+template <class T>
+struct greater_equal : std::function<bool(T, T)> {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator()(const T& x,
+                                                        const T& y) const {
+    return x >= y;
+  }
+};
+
+// similar to std::less_equal, but with the DEVICE_FUNC qualifier
+template <class T>
+struct less_equal : std::function<bool(T, T)> {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator()(const T& x,
+                                                        const T& y) const {
+    return x <= y;
+  }
+};
+
+// Functor that enables squared difference functor.
+template <typename Scalar>
+struct scalar_squared_difference_op {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar
+  operator()(const Scalar& a, const Scalar& b) const {
+    const Scalar v = scalar_difference_op<Scalar>()(a, b);
+    return scalar_product_op<Scalar>()(v, scalar_conjugate_op<Scalar>()(v));
+  }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& a,
+                                                        const Packet& b) const {
+    const Packet v = scalar_difference_op<Scalar>().packetOp(a, b);
+    return scalar_product_op<Scalar>().packetOp(
+        v, scalar_conjugate_op<Scalar>().packetOp(v));
+  }
+};
+
+template <typename Scalar>
+struct functor_traits<scalar_squared_difference_op<Scalar>> {
+  enum {
+    Cost = functor_traits<scalar_difference_op<Scalar>>::Cost +
+           functor_traits<scalar_conjugate_op<Scalar>>::Cost +
+           functor_traits<scalar_product_op<Scalar>>::Cost,
+    PacketAccess = functor_traits<scalar_difference_op<Scalar>>::PacketAccess &&
+                   functor_traits<scalar_conjugate_op<Scalar>>::PacketAccess &&
+                   functor_traits<scalar_product_op<Scalar>>::PacketAccess
+  };
+};
+
+// TODO(b/32239616): This kernel should be moved into Eigen and vectorized.
+template <typename T, typename Enable = void>
+struct google_floor_div {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T operator()(const T& x,
+                                                     const T& y) const {
+    const T z = x / y;
+    // Subtract one if there is a remainder and if the inputs have opposite
+    // signs. This approach avoids unnecessary overflows.
+    return z * y != x && (x < T(0) != y < T(0)) ? z - T(1) : z;
+  }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x,
+                                                        const Packet& y) const {
+    Packet zeros = pzero(x);
+    Packet x_mask = pcmp_lt(x, zeros);
+    Packet y_mask = pcmp_lt(y, zeros);
+    Packet x_div_y = pdiv(x, y);
+    Packet x_div_y_times_y = pmul(x_div_y, y);
+    return pselect(por(peq(x_div_y_times_y, x), peq(x_mask, y_mask)), x_div_y,
+                   psub(x_div_y, pones(x)));
+  }
+};
+
+template <typename T>
+struct google_floor_div<
+    T, typename std::enable_if<std::is_unsigned<T>::value>::type> {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T operator()(const T& x,
+                                                     const T& y) const {
+    return x / y;
+  }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x,
+                                                        const Packet& y) const {
+    return pdiv(x, y);
+  }
+};
+
+template <typename Scalar>
+struct functor_traits<google_floor_div<Scalar>> {
+  enum {
+    Cost = 2 * Eigen::internal::scalar_div_cost<
+                   Scalar, packet_traits<Scalar>::HasDiv>::value +
+           NumTraits<Scalar>::AddCost,
+    PacketAccess = packet_traits<Scalar>::HasDiv
+  };
+};
+
+template <typename T, typename Enable = void>
+struct google_floor_div_real {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T operator()(const T& x,
+                                                     const T& y) const {
+    return Eigen::numext::floor(x / y);
+  }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x,
+                                                        const Packet& y) const {
+    return pfloor(pdiv(x, y));
+  }
+};
+
+template <typename Scalar>
+struct functor_traits<google_floor_div_real<Scalar>> {
+  enum {
+    Cost = 2 * Eigen::internal::scalar_div_cost<
+                   Scalar, packet_traits<Scalar>::HasDiv>::value +
+           2 * NumTraits<Scalar>::AddCost,
+    PacketAccess =
+        packet_traits<Scalar>::HasDiv && packet_traits<Scalar>::HasFloor
+  };
+};
+
+// TODO(rmlarsen): Add vectorized mod & fmod in Eigen and use it here.
+template <typename T>
+struct google_floor_fmod {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T operator()(const T& x,
+                                                     const T& y) const {
+    // EIGEN_STATIC_ASSERT(NUMERIC_TYPE_MUST_BE_REAL);
+    T trunc_mod = scalar_fmod_op<T>()(x, y);
+    return trunc_mod != T(0) && (y < T(0) != trunc_mod < T(0)) ? trunc_mod + y
+                                                               : trunc_mod;
+  }
+};
+
+template <typename Scalar>
+struct functor_traits<google_floor_fmod<Scalar>> {
+  enum {
+    Cost = functor_traits<Eigen::internal::scalar_fmod_op<Scalar>>::Cost +
+           NumTraits<Scalar>::AddCost,
+    PacketAccess = false
+  };
+};
+
+// TODO(rmlarsen): Add vectorized mod & fmod in Eigen and use it here.
+template <typename T>
+struct google_floor_mod {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T operator()(const T& x,
+                                                     const T& y) const {
+    // EIGEN_STATIC_ASSERT(!NUMERIC_TYPE_MUST_BE_REAL);
+    T trunc_mod = Eigen::internal::scalar_mod2_op<T>()(x, y);
+    return trunc_mod != T(0) && (y < T(0) != trunc_mod < T(0)) ? trunc_mod + y
+                                                               : trunc_mod;
+  }
+};
+
+template <typename Scalar>
+struct functor_traits<google_floor_mod<Scalar>> {
+  enum {
+    Cost = functor_traits<Eigen::internal::scalar_mod2_op<Scalar>>::Cost +
+           NumTraits<Scalar>::AddCost,
+    PacketAccess = false
+  };
+};
+
+template <typename T, typename Enable = void>
+struct google_truncate_div_real {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T operator()(const T& x,
+                                                     const T& y) const {
+    EIGEN_USING_STD(trunc)
+    return static_cast<T>(trunc(x / y));
+  }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x,
+                                                        const Packet& y) const {
+    const Packet z = pdiv(x, y);
+    return pselect(pcmp_lt(z, pzero(z)), pceil(z), pfloor(z));
+  }
+};
+
+template <typename Scalar>
+struct functor_traits<google_truncate_div_real<Scalar>> {
+  enum {
+    Cost = 2 * Eigen::internal::scalar_div_cost<
+                   Scalar, packet_traits<Scalar>::HasDiv>::value +
+           3 * NumTraits<Scalar>::AddCost,
+    PacketAccess =
+        packet_traits<Scalar>::HasDiv && packet_traits<Scalar>::HasFloor &&
+        packet_traits<Scalar>::HasCeil && packet_traits<Scalar>::HasCmp
+  };
+};
+
+#if EIGEN_COMP_GNUC && __cplusplus > 199711L
+#define DISABLE_FLOAT_EQUALITY_WARNING \
+  _Pragma("GCC diagnostic push")       \
+      _Pragma("GCC diagnostic ignored \"-Wfloat-equal\"")
+#define ENABLE_FLOAT_EQUALITY_WARNING _Pragma("GCC diagnostic pop")
+#else
+#define DISABLE_FLOAT_EQUALITY_WARNING
+#define ENABLE_FLOAT_EQUALITY_WARNING
+#endif
+
+template <typename Scalar, bool IsInteger = Eigen::NumTraits<Scalar>::IsInteger,
+          bool HasRint = packet_traits<Scalar>::HasRint>
+struct scalar_round_half_to_even_op {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar
+  operator()(const Scalar& x) const {
+    EIGEN_STATIC_ASSERT((!NumTraits<Scalar>::IsComplex),
+                        NUMERIC_TYPE_MUST_BE_REAL)
+
+    const Scalar round_val = Eigen::numext::floor(x + Scalar(0.5));
+    const Scalar fraction = round_val - x;
+    if (TF_PREDICT_FALSE(fraction == Scalar(.5))) {
+      return Scalar(2) * Eigen::numext::floor(Scalar(.5) * x + Scalar(0.5));
+    } else {
+      return round_val;
+    }
+  }
+
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x) const {
+    Packet half = pset1<Packet>(Scalar(0.5));
+    Packet round_val = pfloor(padd(x, half));
+    Packet fraction = psub(round_val, x);
+    Packet half_mask = pcmp_eq(fraction, half);
+    bool any_halves = predux_any(half_mask);
+    if (TF_PREDICT_FALSE(any_halves)) {
+      Packet two = pset1<Packet>(Scalar(2));
+      Packet nearest_even = pmul(two, pfloor(pmadd(half, x, half)));
+      return pselect(half_mask, nearest_even, round_val);
+    } else {
+      return round_val;
+    }
+  }
+};
+
+template <typename Scalar>
+struct scalar_round_half_to_even_op<Scalar, true, false> {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar
+  operator()(const Scalar& x) const {
+    return x;
+  }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x) const {
+    return x;
+  }
+};
+
+template <typename Scalar>
+struct scalar_round_half_to_even_op<Scalar, false, true> {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar
+  operator()(const Scalar& x) const {
+    return Eigen::numext::rint(x);
+  }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x) const {
+    return print(x);
+  }
+};
+
+template <typename Scalar>
+struct functor_traits<scalar_round_half_to_even_op<Scalar>> {
+  enum {
+    Cost = Eigen::NumTraits<Scalar>::IsInteger ? 0
+                                               : 4 * NumTraits<Scalar>::AddCost,
+    PacketAccess = packet_traits<Scalar>::HasFloor &&
+                   packet_traits<Scalar>::HasAdd &&
+                   packet_traits<Scalar>::HasMul,
+  };
+};
+
+template <typename Scalar, bool IsInteger = Eigen::NumTraits<Scalar>::IsInteger>
+struct scalar_round_up_op {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar
+  operator()(const Scalar& x) const {
+    EIGEN_STATIC_ASSERT((!NumTraits<Scalar>::IsComplex),
+                        NUMERIC_TYPE_MUST_BE_REAL)
+    return Eigen::numext::floor(x + Scalar(0.5));
+  }
+
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x) const {
+    return pfloor(padd(x, pset1<Packet>(0.5)));
+  }
+};
+
+template <typename Scalar>
+struct scalar_round_up_op<Scalar, true> {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar
+  operator()(const Scalar& x) const {
+    return x;
+  }
+
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x) const {
+    return x;
+  }
+};
+
+template <typename Scalar, bool IsInteger>
+struct functor_traits<scalar_round_up_op<Scalar, IsInteger>> {
+  enum {
+    Cost = IsInteger ? 0 : 4 * NumTraits<Scalar>::AddCost,
+    PacketAccess = IsInteger || packet_traits<Scalar>::HasFloor
+  };
+};
+
+#undef ENABLE_FLOAT_EQUALITY_WARNING
+#undef DISABLE_FLOAT_EQUALITY_WARNING
+
+template <typename Scalar>
+struct bitwise_xor_op {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar
+  operator()(const Scalar& x, const Scalar& y) const {
+    return x ^ y;
+  }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& a,
+                                                        const Packet& b) const {
+    return Eigen::internal::pxor(a, b);
+  }
+};
+
+template <typename Scalar>
+struct functor_traits<bitwise_xor_op<Scalar>> {
+  enum { Cost = Eigen::NumTraits<Scalar>::AddCost, PacketAccess = true };
+};
+
+template <typename Scalar>
+struct xlogy_op {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar
+  operator()(const Scalar& x, const Scalar& y) const {
+    if (x == Scalar(0.)) {
+      return Scalar(0.);
+    }
+    return x * numext::log(y);
+  }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x,
+                                                        const Packet& y) const {
+    Packet zeros = pzero(x);
+    Packet mask = pcmp_eq(x, zeros);
+    scalar_log_op<Scalar> log_op;
+    Packet log_y = log_op.packetOp(y);
+    Packet x_log_y = pmul(x, log_y);
+    return pselect(mask, x, x_log_y);
+  }
+};
+
+template <typename Scalar>
+struct functor_traits<xlogy_op<Scalar>> {
+  enum {
+    Cost = functor_traits<scalar_log_op<Scalar>>::Cost +
+           Eigen::NumTraits<Scalar>::MulCost,
+    PacketAccess = functor_traits<scalar_log_op<Scalar>>::PacketAccess
+  };
+};
+
+template <typename Scalar>
+struct xlog1py_op {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar
+  operator()(const Scalar& x, const Scalar& y) const {
+    if (x == Scalar(0.)) {
+      return Scalar(0.);
+    }
+    return x * numext::log1p(y);
+  }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x,
+                                                        const Packet& y) const {
+    Packet zeros = pzero(x);
+    Packet mask = pcmp_eq(x, zeros);
+    scalar_log1p_op<Scalar> log1p_op;
+    Packet log1p_y = log1p_op.packetOp(y);
+    Packet x_log1p_y = pmul(x, log1p_y);
+    return pselect(mask, x, x_log1p_y);
+  }
+};
+
+template <typename Scalar>
+struct functor_traits<xlog1py_op<Scalar>> {
+  enum {
+    Cost = functor_traits<scalar_log1p_op<Scalar>>::Cost +
+           Eigen::NumTraits<Scalar>::MulCost,
+#if TENSORFLOW_USE_ROCM
+    PacketAccess = false,
+#else
+    PacketAccess = functor_traits<scalar_log1p_op<Scalar>>::PacketAccess
+#endif
+  };
+};
+
+template <typename Scalar>
+struct xdivy_op {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar
+  operator()(const Scalar& x, const Scalar& y) const {
+    if (x == Scalar(0.)) {
+      return Scalar(0.);
+    }
+    return x / y;
+  }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x,
+                                                        const Packet& y) const {
+    Packet zeros = pzero(x);
+    Packet mask = pcmp_eq(x, zeros);
+    Packet x_div_y = pdiv(x, y);
+    return pselect(mask, x, x_div_y);
+  }
+};
+
+template <typename Scalar>
+struct functor_traits<xdivy_op<Scalar>> {
+  enum {
+    Cost =
+        Eigen::NumTraits<Scalar>::AddCost +
+        Eigen::internal::scalar_div_cost<Scalar,
+                                         packet_traits<Scalar>::HasDiv>::value,
+    PacketAccess = packet_traits<Scalar>::HasDiv
+  };
+};
+
+template <typename T>
+struct scalar_erfinv_op {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T operator()(const T& x) const {
+    constexpr T half = T(0.5);
+    T y = numext::ndtri(half * x + half);
+    constexpr T half_sqrt = T(M_SQRT1_2);
+    return y * half_sqrt;
+  }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x) const {
+    Packet half = pset1<Packet>(T(0.5));
+    Packet y = pndtri<Packet>(pmadd(half, x, half));
+    Packet half_sqrt = pset1<Packet>(T(M_SQRT1_2));
+    return pmul(y, half_sqrt);
+  }
+};
+
+template <typename T>
+struct functor_traits<scalar_erfinv_op<T>> {
+  enum {
+    Cost = functor_traits<scalar_ndtri_op<T>>::Cost + NumTraits<T>::AddCost,
+    PacketAccess = packet_traits<T>::HasNdtri,
+  };
+};
+
+}  // end namespace internal
+}  // end namespace Eigen
+
+namespace tensorflow {
+namespace functor {
+
+////////////////////////////////////////////////////////////////////////////////
+// Helpers
+////////////////////////////////////////////////////////////////////////////////
+
+// Base template for functors whose input scalar type is T and
+// output scalar type is R.
+template <typename T, typename F, typename R = T>
+struct base {
+  // func defines operator() and its vectorized version packetOp().
+  typedef F func;
+
+  // If true, the functor's corresponding binary op will instantiate
+  // specialized kernels to perform an optimized broadcast
+  // operation. Each functor for which this is enabled increases the
+  // code size, so by default this is disabled for binary functors and
+  // is enabled on a per-op basis as needed.
+  static constexpr bool use_bcast_optimization = false;
+
+  // operator() has the signature:
+  //  out_type operator()(in_type in0, in_type in1 ...)
+  typedef R out_type;
+  typedef T in_type;
+
+  // TensorFlow provides tensor-ized version of "func". Roughly
+  // speaking, the tensorflow operation has the signature:
+  //   tout_type op(tin_type in0)
+  //   tout_type op(tin_type in0, tin_type in1)
+  //   tout_type op(tin_type in0, in_type scalar)
+  typedef typename TTypes<out_type>::Flat tout_type;
+  typedef typename TTypes<in_type>::ConstFlat tin_type;
+  typedef typename TTypes<in_type>::ConstScalar tscalar_type;
+
+  // Whether the functor can error out.  Currently applies only to integer
+  // div and mod.
+  static constexpr bool has_errors = false;
+};
+
+// For now, we only apply certain speed optimization for
+// float/double's broadcast binary op.
+template <typename T>
+struct use_bcast_optimization {
+  static constexpr bool value = false;
+};
+
+template <>
+struct use_bcast_optimization<float> {
+  static constexpr bool value = true;
+};
+
+template <>
+struct use_bcast_optimization<double> {
+  static constexpr bool value = true;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// Unary functors
+////////////////////////////////////////////////////////////////////////////////
+
+// abs(x) = |x|
+// neg(x) = - x
+// inverse(x) = 1 / x
+// square(x) = x^2
+// sqrt(x) = x^(1/2)
+// rsqrt(x) = x^(-1/2)
+// exp(x) = e^x
+// expm1(x) = e^x - 1
+// log(x) = natural logarithm of x
+// log1p(x) = natural logarithm of 1 + x
+// tanh = (exp(x) - exp(-x)) / (exp(x) + exp(-x))
+// sigmoid = 1 / (1 + exp(-x))  // a.k.a, logistic
+//
+// NOTE: We may eventually implement common functions used in NN
+// here. E.g., rectifier, softplus, derivatives of tanh, sigmod, etc.
+// For reference, see speech/lstm/eigen_functors.h.
+
+template <typename T>
+struct abs : base<T, Eigen::internal::scalar_abs_op<T>,
+                  typename Eigen::internal::scalar_abs_op<T>::result_type> {};
+
+template <typename T>
+struct neg : base<T, Eigen::internal::scalar_opposite_op<T>> {};
+
+template <typename T>
+struct inverse : base<T, Eigen::internal::scalar_inverse_op<T>> {};
+
+template <typename T>
+struct square : base<T, Eigen::internal::scalar_square_op<T>> {};
+
+template <typename T>
+struct sqrt : base<T, Eigen::internal::scalar_sqrt_op<T>> {};
+
+template <typename T>
+struct rsqrt : base<T, Eigen::internal::scalar_rsqrt_op<T>> {};
+
+template <typename T>
+struct exp : base<T, Eigen::internal::scalar_exp_op<T>> {};
+
+template <typename T>
+struct expm1 : base<T, Eigen::internal::scalar_expm1_op<T>> {};
+
+template <typename T>
+struct log : base<T, Eigen::internal::scalar_log_op<T>> {};
+
+template <typename T>
+struct log1p : base<T, Eigen::internal::scalar_log1p_op<T>> {};
+
+template <typename T>
+struct sign : base<T, Eigen::internal::scalar_sign_op<T>> {};
+
+template <typename T>
+struct sinh : base<T, Eigen::internal::scalar_sinh_op<T>> {};
+
+template <typename T>
+struct cosh : base<T, Eigen::internal::scalar_cosh_op<T>> {};
+
+template <typename T>
+struct tanh : base<T, Eigen::internal::scalar_tanh_op<T>> {};
+
+template <typename T>
+struct asinh : base<T, Eigen::internal::scalar_asinh_op<T>> {};
+
+template <typename T>
+struct acosh : base<T, Eigen::internal::scalar_acosh_op<T>> {};
+
+template <typename T>
+struct atanh : base<T, Eigen::internal::scalar_atanh_op<T>> {};
+
+template <typename T>
+struct lgamma : base<T, Eigen::internal::scalar_lgamma_op<T>> {};
+
+template <typename T>
+struct digamma : base<T, Eigen::internal::scalar_digamma_op<T>> {};
+
+template <typename T>
+struct erf : base<T, Eigen::internal::scalar_erf_op<T>> {};
+
+template <typename T>
+struct erfc : base<T, Eigen::internal::scalar_erfc_op<T>> {};
+
+template <typename T>
+struct ndtri : base<T, Eigen::internal::scalar_ndtri_op<T>> {};
+
+template <typename T>
+struct erfinv : base<T, Eigen::internal::scalar_erfinv_op<T>> {};
+
+template <typename T>
+struct sigmoid : base<T, Eigen::internal::scalar_logistic_op<T>> {};
+
+template <typename T>
+struct sin : base<T, Eigen::internal::scalar_sin_op<T>> {};
+
+template <typename T>
+struct cos : base<T, Eigen::internal::scalar_cos_op<T>> {};
+
+template <typename T>
+struct tan : base<T, Eigen::internal::scalar_tan_op<T>> {};
+
+template <typename T>
+struct asin : base<T, Eigen::internal::scalar_asin_op<T>> {};
+
+template <typename T>
+struct acos : base<T, Eigen::internal::scalar_acos_op<T>> {};
+
+template <typename T>
+struct atan : base<T, Eigen::internal::scalar_atan_op<T>> {};
+
+struct logical_not : base<bool, Eigen::internal::scalar_boolean_not_op<bool>> {
+};
+
+// Flip all bits. Named invert to be consistent with numpy.
+template <typename T>
+struct invert_op {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T operator()(const T& a) const {
+    return ~a;
+  }
+};
+
+template <typename T>
+struct invert : base<T, invert_op<T>> {};
+
+// NOTE: std::isinf, std::isnan, std::isfinite are plain function.
+// Therefore we need to wrap them in functors to be used with Eigen's
+// type system.
+template <typename T>
+struct isinf : base<T, Eigen::internal::scalar_isinf_op<T>, bool> {};
+
+template <typename T>
+struct isnan : base<T, Eigen::internal::scalar_isnan_op<T>, bool> {};
+
+template <typename T>
+struct isfinite : base<T, Eigen::internal::scalar_isfinite_op<T>, bool> {};
+
+template <typename T>
+struct floor : base<T, Eigen::internal::scalar_floor_op<T>> {};
+
+template <typename T>
+struct round : base<T, Eigen::internal::scalar_round_half_to_even_op<T>> {};
+
+template <typename T>
+struct ceil : base<T, Eigen::internal::scalar_ceil_op<T>> {};
+
+// Note: rint rounds half values to even, just like round_half_to_even_op.
+template <typename T>
+struct rint : base<T, Eigen::internal::scalar_rint_op<T>> {};
+
+////////////////////////////////////////////////////////////////////////////////
+// Binary functors
+////////////////////////////////////////////////////////////////////////////////
+
+// Binary functors:
+//
+// add(x, y) = x + y
+// sub(x, y) = x - y
+// mul(x, y) = x * y
+// div(x, y) = x / y
+// mod(x, y) = x % y         (int32 and int64 only)
+// fmod(x, y) = fmod(x, y)   (float and double only)
+// pow(x, y) = x ^ y
+// maximum(x, y) = x > y ? x : y
+// minimum(x, y) = x < y ? x : y
+// squared_difference(x, y) = conj(x - y) * (x - y)
+
+template <typename T>
+struct add : base<T, Eigen::internal::scalar_sum_op<T>> {
+  static constexpr bool use_bcast_optimization = true;
+};
+
+template <typename T>
+struct sub : base<T, Eigen::internal::scalar_difference_op<T>> {
+  static constexpr bool use_bcast_optimization = true;
+};
+
+template <typename T>
+struct mul : base<T, Eigen::internal::scalar_product_op<T>> {
+  static constexpr bool use_bcast_optimization = true;
+};
+
+template <typename T>
+struct mul_no_nan : base<T, Eigen::internal::mul_no_nan_op<T>> {};
+
+template <typename T>
+struct div : base<T, Eigen::internal::scalar_quotient_op<T>> {};
+
+template <typename T>
+struct safe_div : base<T, Eigen::internal::safe_div_or_mod_op<
+                              T, Eigen::internal::scalar_quotient_op<T>>> {
+  static constexpr bool has_errors = true;
+};
+
+template <typename T>
+struct div_no_nan : base<T, Eigen::internal::div_no_nan_op<T>> {};
+
+template <typename T>
+struct fmod : base<T, Eigen::internal::scalar_fmod_op<T>> {};
+
+template <typename T>
+struct mod : base<T, Eigen::internal::scalar_mod2_op<T>> {};
+
+template <typename T>
+struct safe_mod : base<T, Eigen::internal::safe_div_or_mod_op<
+                              T, Eigen::internal::scalar_mod2_op<T>>> {
+  static constexpr bool has_errors = true;
+};
+
+template <typename T>
+struct floor_fmod : base<T, Eigen::internal::google_floor_fmod<T>> {};
+
+template <typename T>
+struct safe_floor_mod : base<T, Eigen::internal::safe_div_or_mod_op<
+                                    T, Eigen::internal::google_floor_mod<T>>> {
+  static constexpr bool has_errors = true;
+};
+
+template <typename T>
+struct floor_div : base<T, Eigen::internal::google_floor_div<T>> {};
+
+template <typename T>
+struct safe_floor_div : base<T, Eigen::internal::safe_div_or_mod_op<
+                                    T, Eigen::internal::google_floor_div<T>>> {
+  static constexpr bool has_errors = true;
+};
+
+template <typename T>
+struct floor_div_real : base<T, Eigen::internal::google_floor_div_real<T>> {};
+
+template <typename T>
+struct truncate_div_real
+    : base<T, Eigen::internal::google_truncate_div_real<T>> {};
+
+template <typename T>
+struct pow : base<T, Eigen::internal::scalar_pow_op<T, T>> {};
+
+template <typename T>
+struct safe_pow : base<T, Eigen::internal::safe_scalar_binary_pow_op<T, T>> {
+  static constexpr bool has_errors = true;
+};
+
+// Version of safe_pow for integers which returns 0 if RHS is negative and LHS
+// is not 1 or -1. For use on GPUs, where we cannot raise an error.
+template <typename T>
+struct safe_pow_ignore_error_op {
+  static_assert(std::is_integral<T>::value, "Integer type expected");
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T operator()(const T& x,
+                                                     const T& y) const {
+    if (TF_PREDICT_FALSE(y < 0)) {
+      if (x == T(-1)) {
+        T trunc_mod = Eigen::internal::scalar_mod2_op<T>()(y, T(2));
+        return trunc_mod == T(-1) ? T(-1) : T(1);
+      }
+      return x == T(1) ? T(1) : T(0);
+    }
+    return Eigen::internal::scalar_pow_op<T, T>{}(x, y);
+  }
+};
+
+template <typename T>
+struct safe_pow_ignore_error : base<T, safe_pow_ignore_error_op<T>> {};
+
+template <typename T>
+struct maximum
+    : base<T, Eigen::internal::scalar_max_op<T, T, Eigen::PropagateNaN>> {};
+
+template <typename T>
+struct minimum
+    : base<T, Eigen::internal::scalar_min_op<T, T, Eigen::PropagateNaN>> {};
+
+template <typename T>
+struct igamma : base<T, Eigen::internal::scalar_igamma_op<T>> {};
+
+template <typename T>
+struct random_gamma_grad
+    : base<T, Eigen::internal::scalar_gamma_sample_der_alpha_op<T>> {};
+
+template <typename T>
+struct igammac : base<T, Eigen::internal::scalar_igammac_op<T>> {};
+
+template <typename T>
+struct zeta : base<T, Eigen::internal::scalar_zeta_op<T>> {};
+
+template <typename T>
+struct polygamma : base<T, Eigen::internal::scalar_polygamma_op<T>> {};
+
+template <typename T>
+struct atan2 : base<T, Eigen::internal::scalar_atan2_op<T, T>> {};
+
+template <typename T>
+struct squared_difference
+    : base<T, Eigen::internal::scalar_squared_difference_op<T>> {};
+
+template <typename T>
+struct xdivy : base<T, Eigen::internal::xdivy_op<T>> {};
+
+template <typename T>
+struct xlogy : base<T, Eigen::internal::xlogy_op<T>> {};
+
+template <typename T>
+struct xlog1py : base<T, Eigen::internal::xlog1py_op<T>> {};
+
+template <typename T>
+struct less : base<T, Eigen::internal::less<T>, bool> {};
+
+template <typename T>
+struct less_equal : base<T, Eigen::internal::less_equal<T>, bool> {};
+
+template <typename T>
+struct greater : base<T, Eigen::internal::greater<T>, bool> {};
+
+template <typename T>
+struct greater_equal : base<T, Eigen::internal::greater_equal<T>, bool> {};
+
+template <typename T>
+struct equal_to : base<T, Eigen::internal::equal_to<T>, bool> {};
+
+template <typename T>
+struct not_equal_to : base<T, Eigen::internal::not_equal_to<T>, bool> {};
+
+struct logical_and : base<bool, Eigen::internal::scalar_boolean_and_op<bool>> {
+};
+
+struct logical_or : base<bool, Eigen::internal::scalar_boolean_or_op<bool>> {};
+
+template <typename T>
+struct bitwise_and_op {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T operator()(const T& x,
+                                                     const T& y) const {
+    return x & y;
+  }
+};
+
+template <typename T>
+struct bitwise_or_op {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T operator()(const T& x,
+                                                     const T& y) const {
+    return x | y;
+  }
+};
+
+template <typename T>
+struct bitwise_and : base<T, bitwise_and_op<T>> {};
+
+template <typename T>
+struct bitwise_or : base<T, bitwise_or_op<T>> {};
+
+template <typename T>
+struct bitwise_xor : base<T, Eigen::internal::bitwise_xor_op<T>> {};
+
+template <typename T>
+struct left_shift_op {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T operator()(const T& x,
+                                                     const T& y) const {
+    // Avoids UB: don't shift by larger than the bitwidth of T, and
+    // performs left shifts as unsigned shifts.
+    T y_clamped = y;
+    if (y_clamped < 0) {
+      y_clamped = 0;
+    } else if (y_clamped > sizeof(T) * CHAR_BIT - 1) {
+      y_clamped = sizeof(T) * CHAR_BIT - 1;
+    }
+    using U = typename std::make_unsigned<T>::type;
+    return static_cast<T>(static_cast<U>(x) << static_cast<U>(y_clamped));
+  }
+};
+
+template <typename T>
+struct right_shift_op {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T operator()(const T& x,
+                                                     const T& y) const {
+    // Avoids UB: don't shift by larger than the bitwidth of T.
+    T y_clamped = y;
+    if (y_clamped < 0) {
+      y_clamped = 0;
+    } else if (y_clamped > sizeof(T) * CHAR_BIT - 1) {
+      y_clamped = sizeof(T) * CHAR_BIT - 1;
+    }
+    // Technically right shifts of signed integers are not necessarily
+    // arithmetic shifts according to the C++ standard. However in practice most
+    // implementations are arithmetic shifts. If this proves to be a problem in
+    // practice, we may need to use an alternative implementation.
+    return x >> y_clamped;
+  }
+};
+
+template <typename T>
+struct left_shift : base<T, left_shift_op<T>> {};
+
+template <typename T>
+struct right_shift : base<T, right_shift_op<T>> {};
+
+template <typename T>
+struct make_complex_func {
+  typedef std::complex<T> result_type;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type operator()(T real,
+                                                               T imag) const {
+    return std::complex<T>(real, imag);
+  }
+};
+
+template <typename T>
+struct make_complex : base<T, make_complex_func<T>, std::complex<T>> {};
+
+template <typename T>
+struct get_real
+    : base<T, Eigen::internal::scalar_real_op<T>, typename T::value_type> {};
+
+template <typename T>
+struct get_imag
+    : base<T, Eigen::internal::scalar_imag_op<T>, typename T::value_type> {};
+
+template <typename T>
+struct get_angle
+    : base<T, Eigen::internal::scalar_arg_op<T>, typename T::value_type> {};
+
+template <typename T>
+struct conj : base<T, Eigen::internal::scalar_conjugate_op<T>> {};
+
+////////////////////////////////////////////////////////////////////////////////
+// Functors takes 1 or 2 tensors, computes the base functor on
+// coefficient of the input tensors and puts the results in the output
+// tensor.
+////////////////////////////////////////////////////////////////////////////////
+template <typename Device, typename Functor>
+struct UnaryFunctor {
+  // Computes on device "d": out[i] = Functor(in[i])
+  void operator()(const Device& d, typename Functor::tout_type out,
+                  typename Functor::tin_type in);
+};
+
+template <typename Device, typename Functor, typename Targ>
+struct UnaryFunctorWithArg {
+  // Computes on device "d": out[i] = Functor(in[i])
+  void operator()(const Device& d, typename Functor::tout_type out,
+                  typename Functor::tin_type in, Targ val);
+};
+
+template <typename Device, typename Functor, int NDIMS,
+          bool has_errors = Functor::has_errors>
+struct BinaryFunctor {
+  // Computes on device "d": out[i] = Functor(in0[i], in1[i])
+  void operator()(const Device& d, typename Functor::tout_type out,
+                  typename Functor::tin_type in0,
+                  typename Functor::tin_type in1, bool* error);
+
+  // Computes on device "d": out[i] = Functor(scalar[0], in[i])
+  void Left(const Device& d, typename Functor::tout_type out,
+            typename Functor::tscalar_type scalar,
+            typename Functor::tin_type in, bool* error);
+
+  // Computes on device "d": out[i] = Functor(in[i], scalar[0])
+  void Right(const Device& d, typename Functor::tout_type out,
+             typename Functor::tin_type in,
+             typename Functor::tscalar_type scalar, bool* error);
+
+  // Computes on device "d":
+  //   out = Functor(in0.broadcast(bcast0), in1.broadcast(bcast1))
+  //
+  // TODO(zhifengc): makes BCast a template member function on NDIMS
+  // instead making BinaryFunctor templates on NDIMS.
+  void BCast(const Device& d,
+             typename TTypes<typename Functor::out_type, NDIMS>::Tensor out,
+             typename TTypes<typename Functor::in_type, NDIMS>::ConstTensor in0,
+             typename Eigen::array<Eigen::DenseIndex, NDIMS> bcast0,
+             typename TTypes<typename Functor::in_type, NDIMS>::ConstTensor in1,
+             typename Eigen::array<Eigen::DenseIndex, NDIMS> bcast1,
+             bool* error);
+};
+
+template <typename Device, typename T>
+struct ApproximateEqual {
+  void operator()(const Device& d, typename TTypes<T>::ConstFlat x,
+                  typename TTypes<T>::ConstFlat y, T tolerance,
+                  typename TTypes<bool>::Flat z);
+};
+
+template <int NDIMS>
+bool AllOne(const typename Eigen::array<Eigen::DenseIndex, NDIMS>& a) {
+  for (size_t i = 0; i < a.size(); ++i) {
+    if (a[i] != 1) return false;
+  }
+  return true;
+}
+
+template <typename Device, typename T>
+struct SelectFunctor {
+  void operator()(const Device& d, typename TTypes<T>::Flat out,
+                  typename TTypes<bool>::ConstFlat cond_flat,
+                  typename TTypes<T>::ConstFlat then_flat,
+                  typename TTypes<T>::ConstFlat else_flat);
+};
+
+template <typename Device, typename T>
+struct SelectScalarFunctor {
+  void operator()(const Device& d, typename TTypes<T>::Flat out,
+                  typename TTypes<bool>::ConstScalar cond,
+                  typename TTypes<T>::ConstFlat then_flat,
+                  typename TTypes<T>::ConstFlat else_flat);
+};
+
+template <typename Device, typename T>
+struct BatchSelectFunctor {
+  void operator()(const Device& d,
+                  typename TTypes<T>::Matrix output_flat_outer_dims,
+                  TTypes<bool>::ConstVec cond_vec,
+                  typename TTypes<T>::ConstMatrix then_flat_outer_dims,
+                  typename TTypes<T>::ConstMatrix else_flat_outer_dims);
+};
+
+template <typename Device, typename T, int NDIMS>
+struct BCastSelectFunctor {
+  void operator()(const Device& d,
+                  typename TTypes<T, NDIMS>::Tensor output_tensor,
+                  typename TTypes<bool, NDIMS>::ConstTensor cond_tensor,
+                  typename TTypes<T, NDIMS>::ConstTensor then_tensor,
+                  typename TTypes<T, NDIMS>::ConstTensor else_tensor,
+                  typename Eigen::array<Eigen::DenseIndex, NDIMS> cond_bcast,
+                  typename Eigen::array<Eigen::DenseIndex, NDIMS> then_bcast,
+                  typename Eigen::array<Eigen::DenseIndex, NDIMS> else_bcast);
+};
+
+}  // end namespace functor
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_CWISE_OPS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/cwise_ops_common.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/cwise_ops_common.h
new file mode 100644
index 0000000000000000000000000000000000000000..fd7ee451daadace1a6028857382f5d02461e5761
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/cwise_ops_common.h
@@ -0,0 +1,683 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_CWISE_OPS_COMMON_H_
+#define TENSORFLOW_CORE_KERNELS_CWISE_OPS_COMMON_H_
+
+// See docs in ../ops/math_ops.cc.
+#define _USE_MATH_DEFINES
+#include <cmath>
+
+#define EIGEN_USE_THREADS
+
+#include "tensorflow/core/platform/bfloat16.h"
+
+
+#include "tensorflow/core/framework/op.h"
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/tensor_types.h"
+#include "tensorflow/core/framework/variant_op_registry.h"
+#include "tensorflow/core/kernels/cwise_ops.h"
+#include "tensorflow/core/kernels/cwise_ops_gradients.h"
+#include "tensorflow/core/kernels/fill_functor.h"
+#include "tensorflow/core/platform/logging.h"
+#include "tensorflow/core/util/bcast.h"
+
+namespace tensorflow {
+
+typedef Eigen::ThreadPoolDevice CPUDevice;
+typedef Eigen::GpuDevice GPUDevice;
+
+class BinaryOpShared : public OpKernel {
+ public:
+  explicit BinaryOpShared(OpKernelConstruction* ctx, DataType out, DataType in);
+
+ protected:
+  struct BinaryOpState {
+    // Sets up bcast with the shape of in0 and in1, ensures that the bcast
+    // is valid, and if so, set out, either by allocating a new buffer using
+    // ctx->output(...) or by creating an alias for an owned input buffer for
+    // in-place computation.
+    // Caller must check ctx->status() upon return for non-ok status.
+    // If ctx->status().ok() is true, then out is guaranteed to be allocated.
+    explicit BinaryOpState(OpKernelContext* ctx);
+
+    const Tensor& in0;
+    const Tensor& in1;
+
+    BCast bcast;
+    Tensor* out = nullptr;
+    int64_t out_num_elements;
+
+    int64_t in0_num_elements;
+    int64_t in1_num_elements;
+
+    int ndims;
+    bool result;
+  };
+
+  void SetUnimplementedError(OpKernelContext* ctx);
+  void SetComputeError(OpKernelContext* ctx);
+};
+
+// Coefficient-wise binary operations:
+//   Device: E.g., CPUDevice, GPUDevice.
+//   Functor: defined in cwise_ops.h. E.g., functor::add.
+template <typename Device, typename Functor>
+class BinaryOp : public BinaryOpShared {
+ public:
+  typedef typename Functor::in_type Tin;    // Input scalar data type.
+  typedef typename Functor::out_type Tout;  // Output scalar data type.
+
+  explicit BinaryOp(OpKernelConstruction* ctx)
+      : BinaryOpShared(ctx, DataTypeToEnum<Tout>::v(),
+                       DataTypeToEnum<Tin>::v()) {}
+
+  void Compute(OpKernelContext* ctx) override {
+    const Tensor& input_0 = ctx->input(0);
+    OP_REQUIRES(ctx, input_0.dtype() == DataTypeToEnum<Tin>::v(),
+                errors::InvalidArgument(
+                    "Expected tensor of type ",
+                    DataTypeString(DataTypeToEnum<Tin>::v()), " but got type ",
+                    DataTypeString(input_0.dtype())));
+    const Tensor& input_1 = ctx->input(1);
+    OP_REQUIRES(ctx, input_1.dtype() == DataTypeToEnum<Tin>::v(),
+                errors::InvalidArgument(
+                    "Expected tensor of type ",
+                    DataTypeString(DataTypeToEnum<Tin>::v()), " but got type ",
+                    DataTypeString(input_1.dtype())));
+    const Device& eigen_device = ctx->eigen_device<Device>();
+    bool error = false;
+    bool* const error_ptr = Functor::has_errors ? &error : nullptr;
+
+    // NOTE: Handle three simple cases before building the BinaryOpState, which
+    // is relatively expensive for small operations.
+    if (input_0.shape() == input_1.shape()) {
+      // tensor op tensor with no broadcasting.
+      Tensor* out;
+      OP_REQUIRES_OK(ctx, ctx->forward_input_or_allocate_output(
+                              {0, 1}, 0, input_0.shape(), &out));
+      functor::BinaryFunctor<Device, Functor, 1>()(
+          eigen_device, out->template flat<Tout>(),
+          input_0.template flat<Tin>(), input_1.template flat<Tin>(),
+          error_ptr);
+      if (Functor::has_errors && error) {
+        SetComputeError(ctx);
+      }
+      return;
+    } else if (input_0.shape().dims() == 0) {
+      // scalar op tensor.
+      Tensor* out;
+      OP_REQUIRES_OK(ctx, ctx->forward_input_or_allocate_output(
+                              {1}, 0, input_1.shape(), &out));
+
+      functor::BinaryFunctor<Device, Functor, 1>().Left(
+          eigen_device, out->template flat<Tout>(),
+          input_0.template scalar<Tin>(), input_1.template flat<Tin>(),
+          error_ptr);
+      if (Functor::has_errors && error) {
+        SetComputeError(ctx);
+      }
+      return;
+    } else if (input_1.shape().dims() == 0) {
+      // tensor op scalar.
+      Tensor* out;
+      OP_REQUIRES_OK(ctx, ctx->forward_input_or_allocate_output(
+                              {0}, 0, input_0.shape(), &out));
+      functor::BinaryFunctor<Device, Functor, 1>().Right(
+          eigen_device, out->template flat<Tout>(),
+          input_0.template flat<Tin>(), input_1.template scalar<Tin>(),
+          error_ptr);
+      if (Functor::has_errors && error) {
+        SetComputeError(ctx);
+      }
+      return;
+    }
+
+    // 'state': Shared helper not dependent on T to reduce code size
+    BinaryOpState state(ctx);
+    if (ctx->status().code() == error::RESOURCE_EXHAUSTED) {
+      // Stop when BinaryOpState's constructor failed due to OOM.
+      return;
+    }
+    auto& bcast = state.bcast;
+    Tensor* out = state.out;
+    if (!bcast.IsValid()) {
+      if (ctx->status().ok()) {
+        if (state.result) {
+          functor::SetOneFunctor<Device, bool>()(eigen_device,
+                                                 out->flat<bool>());
+        } else {
+          functor::SetZeroFunctor<Device, bool>()(eigen_device,
+                                                  out->flat<bool>());
+        }
+      }
+      return;
+    }
+
+    auto& in0 = state.in0;
+    auto& in1 = state.in1;
+    if (state.out_num_elements == 0) {
+      return;
+    }
+
+    const int ndims = state.ndims;
+    if (ndims <= 1) {
+      auto out_flat = out->flat<Tout>();
+      if (state.in1_num_elements == 1) {
+        // tensor op scalar
+        functor::BinaryFunctor<Device, Functor, 1>().Right(
+            eigen_device, out_flat, in0.template flat<Tin>(),
+            in1.template scalar<Tin>(), error_ptr);
+      } else if (state.in0_num_elements == 1) {
+        // scalar op tensor
+        functor::BinaryFunctor<Device, Functor, 1>().Left(
+            eigen_device, out_flat, in0.template scalar<Tin>(),
+            in1.template flat<Tin>(), error_ptr);
+      } else {
+        functor::BinaryFunctor<Device, Functor, 1>()(
+            eigen_device, out_flat, in0.template flat<Tin>(),
+            in1.template flat<Tin>(), error_ptr);
+      }
+    } else if (ndims == 2) {
+      functor::BinaryFunctor<Device, Functor, 2>().BCast(
+          eigen_device, out->shaped<Tout, 2>(bcast.result_shape()),
+          in0.template shaped<Tin, 2>(bcast.x_reshape()),
+          BCast::ToIndexArray<2>(bcast.x_bcast()),
+          in1.template shaped<Tin, 2>(bcast.y_reshape()),
+          BCast::ToIndexArray<2>(bcast.y_bcast()), error_ptr);
+    } else if (ndims == 3) {
+      functor::BinaryFunctor<Device, Functor, 3>().BCast(
+          eigen_device, out->shaped<Tout, 3>(bcast.result_shape()),
+          in0.template shaped<Tin, 3>(bcast.x_reshape()),
+          BCast::ToIndexArray<3>(bcast.x_bcast()),
+          in1.template shaped<Tin, 3>(bcast.y_reshape()),
+          BCast::ToIndexArray<3>(bcast.y_bcast()), error_ptr);
+    } else if (ndims == 4) {
+      functor::BinaryFunctor<Device, Functor, 4>().BCast(
+          eigen_device, out->shaped<Tout, 4>(bcast.result_shape()),
+          in0.template shaped<Tin, 4>(bcast.x_reshape()),
+          BCast::ToIndexArray<4>(bcast.x_bcast()),
+          in1.template shaped<Tin, 4>(bcast.y_reshape()),
+          BCast::ToIndexArray<4>(bcast.y_bcast()), error_ptr);
+    } else if (ndims == 5) {
+      functor::BinaryFunctor<Device, Functor, 5>().BCast(
+          eigen_device, out->shaped<Tout, 5>(bcast.result_shape()),
+          in0.template shaped<Tin, 5>(bcast.x_reshape()),
+          BCast::ToIndexArray<5>(bcast.x_bcast()),
+          in1.template shaped<Tin, 5>(bcast.y_reshape()),
+          BCast::ToIndexArray<5>(bcast.y_bcast()), error_ptr);
+    } else {
+      SetUnimplementedError(ctx);
+    }
+    if (Functor::has_errors && error) {
+      SetComputeError(ctx);
+    }
+  }
+};
+
+template <typename Device, typename T>
+class ApproximateEqualOp : public OpKernel {
+ public:
+  explicit ApproximateEqualOp(OpKernelConstruction* context)
+      : OpKernel(context) {
+    float tolerance;
+    OP_REQUIRES_OK(context, context->GetAttr("tolerance", &tolerance));
+    tolerance_ = T(tolerance);
+  }
+  void Compute(OpKernelContext* context) override {
+    const Tensor& x_input = context->input(0);
+    const Tensor& y_input = context->input(1);
+    OP_REQUIRES(
+        context, x_input.shape() == y_input.shape(),
+        errors::InvalidArgument("x and y must be of the same shape. ",
+                                "x shape: ", x_input.shape().DebugString(),
+                                ". y shape: ", y_input.shape().DebugString()));
+    Tensor* z_output = nullptr;
+    OP_REQUIRES_OK(context,
+                   context->allocate_output(0, x_input.shape(), &z_output));
+    const Device& d = context->eigen_device<Device>();
+    typename TTypes<T>::ConstFlat x(x_input.flat<T>());
+    typename TTypes<T>::ConstFlat y(y_input.flat<T>());
+    typename TTypes<bool>::Flat z(z_output->flat<bool>());
+    functor::ApproximateEqual<Device, T>()(d, x, y, tolerance_, z);
+  }
+
+ private:
+  T tolerance_;
+};
+
+// Basic coefficient-wise binary operations that are known to not require
+// any broadcasting. This is the case for example of the gradients of
+// unary operations.
+//   Device: E.g., CPUDevice, GPUDevice.
+//   Functor: defined above. E.g., functor::tanh_grad.
+template <typename Device, typename Functor>
+class SimpleBinaryOp : public OpKernel {
+ public:
+  typedef typename Functor::in_type Tin;    // Input scalar data type.
+  typedef typename Functor::out_type Tout;  // Output scalar data type.
+
+  explicit SimpleBinaryOp(OpKernelConstruction* ctx) : OpKernel(ctx) {}
+
+  void Compute(OpKernelContext* ctx) override {
+    const Tensor& in0 = ctx->input(0);
+    const Tensor& in1 = ctx->input(1);
+    OP_REQUIRES(
+        ctx, in0.NumElements() == in1.NumElements(),
+        errors::InvalidArgument("The two arguments to a cwise op must have "
+                                "same number of elements, got ",
+                                in0.NumElements(), " and ", in1.NumElements()));
+    auto in0_flat = in0.flat<Tin>();
+    auto in1_flat = in1.flat<Tin>();
+    const Device& eigen_device = ctx->eigen_device<Device>();
+
+    Tensor* out = nullptr;
+    if (std::is_same<Tin, Tout>::value) {
+      OP_REQUIRES_OK(ctx, ctx->forward_input_or_allocate_output(
+                              {0, 1}, 0, in0.shape(), &out));
+    } else {
+      OP_REQUIRES_OK(ctx, ctx->allocate_output(0, in0.shape(), &out));
+    }
+    auto out_flat = out->flat<Tout>();
+    functor::SimpleBinaryFunctor<Device, Functor>()(eigen_device, out_flat,
+                                                    in0_flat, in1_flat);
+  }
+};
+
+// Coefficient-wise unary operations:
+//   Device: E.g., CPUDevice, GPUDevice.
+//   Functor: defined in cwise_ops.h. E.g., functor::sqrt.
+template <typename Device, typename Functor>
+class UnaryOp : public OpKernel {
+ public:
+  typedef typename Functor::in_type Tin;    // Input scalar data type.
+  typedef typename Functor::out_type Tout;  // Output scalar data type.
+  // Tin may be different from Tout. E.g., abs: complex64 -> float
+
+  explicit UnaryOp(OpKernelConstruction* ctx) : OpKernel(ctx) {
+    auto in = DataTypeToEnum<Tin>::v();
+    auto out = DataTypeToEnum<Tout>::v();
+    OP_REQUIRES_OK(ctx, ctx->MatchSignature({in}, {out}));
+  }
+
+  void Compute(OpKernelContext* ctx) override {
+    const Tensor& inp = ctx->input(0);
+    Tensor* out = nullptr;
+    if (std::is_same<Tin, Tout>::value) {
+      OP_REQUIRES_OK(ctx, ctx->forward_input_or_allocate_output(
+                              {0}, 0, inp.shape(), &out));
+    } else {
+      OP_REQUIRES_OK(ctx, ctx->allocate_output(0, inp.shape(), &out));
+    }
+    functor::UnaryFunctor<Device, Functor>()(
+        ctx->eigen_device<Device>(), out->flat<Tout>(), inp.flat<Tin>());
+  }
+};
+
+template <typename Device, VariantUnaryOp OpEnum>
+class UnaryVariantOp : public OpKernel {
+ public:
+  explicit UnaryVariantOp(OpKernelConstruction* ctx) : OpKernel(ctx) {}
+
+  void Compute(OpKernelContext* ctx) override {
+    const Tensor& inp = ctx->input(0);
+    OP_REQUIRES(
+        ctx, TensorShapeUtils::IsScalar(inp.shape()),
+        errors::InvalidArgument("Non-scalar variants are not supported."));
+    const Variant& v = inp.scalar<Variant>()();
+    Variant v_out;
+    OP_REQUIRES_OK(ctx, UnaryOpVariant<Device>(ctx, OpEnum, v, &v_out));
+    int numa_node = ctx->device()->NumaNode();
+    Tensor out(cpu_allocator(numa_node), DT_VARIANT, TensorShape());
+    out.scalar<Variant>()() = std::move(v_out);
+    ctx->set_output(0, std::move(out));
+  }
+};
+
+namespace functor {
+
+template <typename D, typename Out, typename Rhs>
+void Assign(const D& d, Out out, Rhs rhs) {
+  out.device(d) = rhs;
+}
+
+// Partial specialization of BinaryFunctor<Device=CPUDevice, Functor, NDIMS>
+// for functors with no error checking.
+template <typename Functor, int NDIMS>
+struct BinaryFunctor<CPUDevice, Functor, NDIMS, false> {
+  void operator()(const CPUDevice& d, typename Functor::tout_type out,
+                  typename Functor::tin_type in0,
+                  typename Functor::tin_type in1, bool* error) {
+    Assign(d, out, in0.binaryExpr(in1, typename Functor::func()));
+  }
+
+  void Left(const CPUDevice& d, typename Functor::tout_type out,
+            typename Functor::tscalar_type scalar,
+            typename Functor::tin_type in, bool* error) {
+    typedef typename Functor::out_type Tout;
+    typedef typename Functor::in_type Tin;
+    typedef typename Functor::func Binary;
+    typedef typename Eigen::internal::scalar_left<Tout, Tin, Binary> Unary;
+    Assign(d, out, in.unaryExpr(Unary(scalar.data())));
+  }
+
+  void Right(const CPUDevice& d, typename Functor::tout_type out,
+             typename Functor::tin_type in,
+             typename Functor::tscalar_type scalar, bool* error) {
+    typedef typename Functor::out_type Tout;
+    typedef typename Functor::in_type Tin;
+    typedef typename Functor::func Binary;
+    typedef typename Eigen::internal::scalar_right<Tout, Tin, Binary> Unary;
+    Assign(d, out, in.unaryExpr(Unary(scalar.data())));
+  }
+
+  void BCast(const CPUDevice& dev,
+             typename TTypes<typename Functor::out_type, NDIMS>::Tensor out,
+             typename TTypes<typename Functor::in_type, NDIMS>::ConstTensor in0,
+             typename Eigen::array<Eigen::DenseIndex, NDIMS> bcast0,
+             typename TTypes<typename Functor::in_type, NDIMS>::ConstTensor in1,
+             typename Eigen::array<Eigen::DenseIndex, NDIMS> bcast1,
+             bool* error) {
+    typename Functor::func func;
+    if (AllOne<NDIMS>(bcast0) && AllOne<NDIMS>(bcast1)) {
+      Assign(dev, out, in0.binaryExpr(in1, func));
+    } else if (AllOne<NDIMS>(bcast0)) {
+      auto rhs = in1.broadcast(bcast1);
+      Assign(dev, out, in0.binaryExpr(rhs, func));
+    } else if (AllOne<NDIMS>(bcast1)) {
+      auto lhs = in0.broadcast(bcast0);
+      Assign(dev, out, lhs.binaryExpr(in1, func));
+    } else {
+      auto lhs = in0.broadcast(bcast0);
+      auto rhs = in1.broadcast(bcast1);
+      Assign(dev, out, lhs.binaryExpr(rhs, func));
+    }
+  }
+};
+
+// Partial specialization of BinaryFunctor<Device=CPUDevice, Functor, 2>
+// for functors with no error checking.
+template <typename Functor>
+struct BinaryFunctor<CPUDevice, Functor, 2, false> {
+  enum { NDIMS = 2 };
+
+  void operator()(const CPUDevice& d, typename Functor::tout_type out,
+                  typename Functor::tin_type in0,
+                  typename Functor::tin_type in1, bool* error) {
+    Assign(d, out, in0.binaryExpr(in1, typename Functor::func()));
+  }
+
+  void Left(const CPUDevice& d, typename Functor::tout_type out,
+            typename Functor::tscalar_type scalar,
+            typename Functor::tin_type in, bool* error) {
+    typedef typename Functor::out_type Tout;
+    typedef typename Functor::in_type Tin;
+    typedef typename Functor::func Binary;
+    typedef typename Eigen::internal::scalar_left<Tout, Tin, Binary> Unary;
+    Assign(d, out, in.unaryExpr(Unary(scalar.data())));
+  }
+
+  void Right(const CPUDevice& d, typename Functor::tout_type out,
+             typename Functor::tin_type in,
+             typename Functor::tscalar_type scalar, bool* error) {
+    typedef typename Functor::out_type Tout;
+    typedef typename Functor::in_type Tin;
+    typedef typename Functor::func Binary;
+    typedef typename Eigen::internal::scalar_right<Tout, Tin, Binary> Unary;
+    Assign(d, out, in.unaryExpr(Unary(scalar.data())));
+  }
+
+  inline Eigen::IndexList<Eigen::DenseIndex, Eigen::type2index<1>> NByOne(
+      Eigen::DenseIndex n) {
+    Eigen::IndexList<Eigen::DenseIndex, Eigen::type2index<1>> ret;
+    ret.set(0, n);
+    return ret;
+  }
+  inline Eigen::IndexList<Eigen::type2index<1>, Eigen::DenseIndex> OneByM(
+      Eigen::DenseIndex m) {
+    Eigen::IndexList<Eigen::type2index<1>, Eigen::DenseIndex> ret;
+    ret.set(1, m);
+    return ret;
+  }
+
+  void BCast(const CPUDevice& dev,
+             typename TTypes<typename Functor::out_type, NDIMS>::Tensor out,
+             typename TTypes<typename Functor::in_type, NDIMS>::ConstTensor in0,
+             typename Eigen::array<Eigen::DenseIndex, NDIMS> bcast0,
+             typename TTypes<typename Functor::in_type, NDIMS>::ConstTensor in1,
+             typename Eigen::array<Eigen::DenseIndex, NDIMS> bcast1,
+             bool* error) {
+    typedef typename Functor::in_type T;
+    typename Functor::func func;
+    if (Functor::use_bcast_optimization && use_bcast_optimization<T>::value) {
+      // Optimize for speed by using Eigen::type2index and avoid
+      // .broadcast() when we know it's a no-op.
+      //
+      // Here, we need to handle 6 cases depending on how many "1"
+      // exist in in0 and in1's shapes (4 numbers in total). It's not
+      // possible that two shapes have more than 2 1s because those
+      // are simplified to NDIMS==1 case.
+      //
+      // Because this optimization increases the binary size for each
+      // Functor (+, -, *, /, <, <=, etc.), type and ndim combination.
+      // we only apply such optimization for selected ops/types/ndims.
+      //
+      // Because NDIMS, Functor::use_broadcast_optimization and
+      // use_broadcast_optimization<T> are compile-time constant, gcc
+      // does a decent job avoiding generating code when conditions
+      // are not met.
+      const Eigen::DenseIndex a = in0.dimension(0);  // in0 is shape [a, b]
+      const Eigen::DenseIndex b = in0.dimension(1);
+      const Eigen::DenseIndex c = in1.dimension(0);  // in1 is shape [c, d]
+      const Eigen::DenseIndex d = in1.dimension(1);
+      if ((a == 1) && (d == 1)) {
+        auto lhs = in0.reshape(OneByM(b)).broadcast(NByOne(c));
+        auto rhs = in1.reshape(NByOne(c)).broadcast(OneByM(b));
+        Assign(dev, out, lhs.binaryExpr(rhs, func));
+        return;
+      }
+      if ((b == 1) && (c == 1)) {
+        auto lhs = in0.reshape(NByOne(a)).broadcast(OneByM(d));
+        auto rhs = in1.reshape(OneByM(d)).broadcast(NByOne(a));
+        Assign(dev, out, lhs.binaryExpr(rhs, func));
+        return;
+      }
+      if (a == 1) {
+        auto lhs = in0.reshape(OneByM(b)).broadcast(NByOne(c));
+        auto rhs = in1;
+        Assign(dev, out, lhs.binaryExpr(rhs, func));
+        return;
+      }
+      if (b == 1) {
+        auto lhs = in0.reshape(NByOne(a)).broadcast(OneByM(d));
+        auto rhs = in1;
+        Assign(dev, out, lhs.binaryExpr(rhs, func));
+        return;
+      }
+      if (c == 1) {
+        auto lhs = in0;
+        auto rhs = in1.reshape(OneByM(d)).broadcast(NByOne(a));
+        Assign(dev, out, lhs.binaryExpr(rhs, func));
+        return;
+      }
+      if (d == 1) {
+        auto lhs = in0;
+        auto rhs = in1.reshape(NByOne(c)).broadcast(OneByM(b));
+        Assign(dev, out, lhs.binaryExpr(rhs, func));
+        return;
+      }
+
+      const bool bcast0_all_one = AllOne<NDIMS>(bcast0);
+      const bool bcast1_all_one = AllOne<NDIMS>(bcast1);
+      if (bcast0_all_one && !bcast1_all_one) {
+        auto lhs = in0;  // No need to do broadcast for in0
+        auto rhs = in1.broadcast(bcast1);
+        Assign(dev, out, lhs.binaryExpr(rhs, func));
+        return;
+      }
+
+      if (!bcast0_all_one && bcast1_all_one) {
+        auto lhs = in0.broadcast(bcast0);
+        auto rhs = in1;  // No need to do broadcast for in1
+        Assign(dev, out, lhs.binaryExpr(rhs, func));
+        return;
+      }
+    }
+
+    // Fallback path. Always works and probably slower.
+    auto lhs = in0.broadcast(bcast0);
+    auto rhs = in1.broadcast(bcast1);
+    Assign(dev, out, lhs.binaryExpr(rhs, func));
+  }
+};
+
+// Version of BinaryFunctor with error handling.
+template <typename Functor, int NDIMS>
+struct BinaryFunctor<CPUDevice, Functor, NDIMS, true> {
+  void operator()(const CPUDevice& d, typename Functor::tout_type out,
+                  typename Functor::tin_type in0,
+                  typename Functor::tin_type in1, bool* error) {
+    Assign(d, out, in0.binaryExpr(in1, typename Functor::func(error)));
+  }
+
+  void Left(const CPUDevice& d, typename Functor::tout_type out,
+            typename Functor::tscalar_type scalar,
+            typename Functor::tin_type in, bool* error) {
+    typedef typename Functor::out_type Tout;
+    typedef typename Functor::in_type Tin;
+    typedef typename Functor::func Binary;
+    typedef typename Eigen::internal::scalar_left<Tout, Tin, Binary> Unary;
+    Assign(d, out, in.unaryExpr(Unary(scalar.data(), error)));
+  }
+
+  void Right(const CPUDevice& d, typename Functor::tout_type out,
+             typename Functor::tin_type in,
+             typename Functor::tscalar_type scalar, bool* error) {
+    typedef typename Functor::out_type Tout;
+    typedef typename Functor::in_type Tin;
+    typedef typename Functor::func Binary;
+    typedef typename Eigen::internal::scalar_right<Tout, Tin, Binary> Unary;
+    Assign(d, out, in.unaryExpr(Unary(scalar.data(), error)));
+  }
+
+  void BCast(const CPUDevice& dev,
+             typename TTypes<typename Functor::out_type, NDIMS>::Tensor out,
+             typename TTypes<typename Functor::in_type, NDIMS>::ConstTensor in0,
+             typename Eigen::array<Eigen::DenseIndex, NDIMS> bcast0,
+             typename TTypes<typename Functor::in_type, NDIMS>::ConstTensor in1,
+             typename Eigen::array<Eigen::DenseIndex, NDIMS> bcast1,
+             bool* error) {
+    typename Functor::func func(error);
+    auto lhs = in0.broadcast(bcast0);
+    auto rhs = in1.broadcast(bcast1);
+    Assign(dev, out, lhs.binaryExpr(rhs, func));
+  }
+};
+
+// Partial specialization of UnaryFunctor<Device=CPUDevice, Functor>.
+template <typename Functor>
+struct UnaryFunctor<CPUDevice, Functor> {
+  void operator()(const CPUDevice& d, typename Functor::tout_type out,
+                  typename Functor::tin_type in) {
+    Assign(d, out, in.unaryExpr(typename Functor::func()));
+  }
+};
+
+template <typename Functor, typename Targ>
+struct UnaryFunctorWithArg<CPUDevice, Functor, Targ> {
+  void operator()(const CPUDevice& d, typename Functor::tout_type out,
+                  typename Functor::tin_type in, Targ val) {
+    Assign(d, out, in.unaryExpr(typename Functor::func(val)));
+  }
+};
+
+// Partial specialization of ApproximateEqual<Device=CPUDevice, T>.
+template <typename T>
+struct ApproximateEqual<CPUDevice, T> {
+  void operator()(const CPUDevice& d, typename TTypes<T>::ConstFlat x,
+                  typename TTypes<T>::ConstFlat y, T tolerance,
+                  typename TTypes<bool>::Flat z) {
+    auto diff = x - y;
+    z.device(d) = diff.abs() <= tolerance;
+  }
+};
+
+}  // end namespace functor
+
+#define REGISTER(OP, D, N, F, T)                                             \
+  REGISTER_KERNEL_BUILDER(Name(N).Device(DEVICE_##D).TypeConstraint<T>("T"), \
+                          OP<D##Device, F<T>>);
+
+#define REGISTER_VARIANT(OP, D, N, ENUM)                       \
+  REGISTER_KERNEL_BUILDER(                                     \
+      Name(N).Device(DEVICE_##D).TypeConstraint<Variant>("T"), \
+      OP<D##Device, ENUM>);
+
+// Macros to register kernels for multiple types (T0, T1, etc.)  on
+// device type "D" (CPU or GPU) for operation "N" (e.g., sqrt) using
+// the functor "F" (e.g., functor::sqrt).
+
+#if defined(__ANDROID_TYPES_SLIM__)
+// Note that __ANDROID_TYPES_SLIM__ is also checked in the cwise_ops*.cc files.
+// Normally Android TensorFlow is built with a reduced number of types (float).
+// Override on the command-line using "--copt=-D__ANDROID_TYPES_FULL__"
+// to generate a library with full type support with a consequent increase in
+// code size.
+#define REGISTER2(OP, D, N, F, T0, T1) REGISTER(OP, D, N, F, T0)
+#define REGISTER3(OP, D, N, F, T0, T1, T2) REGISTER(OP, D, N, F, T0)
+#define REGISTER4(OP, D, N, F, T0, T1, T2, T3) REGISTER(OP, D, N, F, T0)
+#define REGISTER5(OP, D, N, F, T0, T1, T2, T3, T4) REGISTER(OP, D, N, F, T0)
+#define REGISTER6(OP, D, N, F, T0, T1, T2, T3, T4, T5) REGISTER(OP, D, N, F, T0)
+#define REGISTER7(OP, D, N, F, T0, T1, T2, T3, T4, T5, T6) \
+  REGISTER(OP, D, N, F, T0)
+#define REGISTER8(OP, D, N, F, T0, T1, T2, T3, T4, T5, T6, T7) \
+  REGISTER(OP, D, N, F, T0)
+#define REGISTER9(OP, D, N, F, T0, T1, T2, T3, T4, T5, T6, T7, T8) \
+  REGISTER(OP, D, N, F, T0)
+#else  // !defined(__ANDROID_TYPES_SLIM__)
+#define REGISTER2(OP, D, N, F, T0, T1) \
+  REGISTER(OP, D, N, F, T0)            \
+  REGISTER(OP, D, N, F, T1)
+#define REGISTER3(OP, D, N, F, T0, T1, T2) \
+  REGISTER2(OP, D, N, F, T0, T1)           \
+  REGISTER(OP, D, N, F, T2)
+#define REGISTER4(OP, D, N, F, T0, T1, T2, T3) \
+  REGISTER2(OP, D, N, F, T0, T1)               \
+  REGISTER2(OP, D, N, F, T2, T3)
+#define REGISTER5(OP, D, N, F, T0, T1, T2, T3, T4) \
+  REGISTER3(OP, D, N, F, T0, T1, T2)               \
+  REGISTER2(OP, D, N, F, T3, T4)
+#define REGISTER6(OP, D, N, F, T0, T1, T2, T3, T4, T5) \
+  REGISTER3(OP, D, N, F, T0, T1, T2)                   \
+  REGISTER3(OP, D, N, F, T3, T4, T5)
+#define REGISTER7(OP, D, N, F, T0, T1, T2, T3, T4, T5, T6) \
+  REGISTER4(OP, D, N, F, T0, T1, T2, T3)                   \
+  REGISTER3(OP, D, N, F, T4, T5, T6)
+#define REGISTER8(OP, D, N, F, T0, T1, T2, T3, T4, T5, T6, T7) \
+  REGISTER4(OP, D, N, F, T0, T1, T2, T3)                       \
+  REGISTER4(OP, D, N, F, T4, T5, T6, T7)
+#define REGISTER9(OP, D, N, F, T0, T1, T2, T3, T4, T5, T6, T7, T8) \
+  REGISTER5(OP, D, N, F, T0, T1, T2, T3, T4)                       \
+  REGISTER4(OP, D, N, F, T5, T6, T7, T8)
+
+// Instead of adding REGISTER10, etc., shard the .cc files - see
+// cwise_op_equal_to_*.cc for an example.
+
+#endif  // defined(__ANDROID_TYPES_SLIM__)
+
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_CWISE_OPS_COMMON_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/cwise_ops_gpu_common.cu.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/cwise_ops_gpu_common.cu.h
new file mode 100644
index 0000000000000000000000000000000000000000..fdd61d03c88c93f4755f2d7ebd44ff9516e05b8a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/cwise_ops_gpu_common.cu.h
@@ -0,0 +1,218 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#if !GOOGLE_CUDA && !TENSORFLOW_USE_ROCM
+#error This file must only be included when building with Cuda or ROCm support
+#endif
+
+#ifndef TENSORFLOW_CORE_KERNELS_CWISE_OPS_GPU_COMMON_CU_H_
+#define TENSORFLOW_CORE_KERNELS_CWISE_OPS_GPU_COMMON_CU_H_
+
+#define _USE_MATH_DEFINES
+#include <cmath>
+#include <complex>
+
+#define EIGEN_USE_GPU
+#include "tensorflow/core/framework/tensor_types.h"
+#include "tensorflow/core/kernels/cwise_ops.h"
+#include "tensorflow/core/platform/logging.h"
+#include "tensorflow/core/platform/types.h"
+namespace tensorflow {
+namespace functor {
+
+typedef Eigen::GpuDevice GPUDevice;
+typedef std::complex<float> complex64;
+typedef std::complex<double> complex128;
+
+// Partial specialization of UnaryFunctor<Device=GPUDevice, Functor>.
+template <typename Functor>
+struct UnaryFunctor<GPUDevice, Functor> {
+  void operator()(const GPUDevice& d, typename Functor::tout_type out,
+                  typename Functor::tin_type in) {
+    MaybeWith32BitIndexing<GPUDevice>(
+        [&](auto out32, auto in32) {
+          out32.device(d) = in32.unaryExpr(typename Functor::func());
+        },
+        out, in);
+  }
+};
+
+// Partial specialization of BinaryFunctor<Device=GPUDevice, Functor>.
+template <typename Functor, int NDIMS, bool has_errors>
+struct BinaryFunctor<GPUDevice, Functor, NDIMS, has_errors> {
+  void operator()(const GPUDevice& d, typename Functor::tout_type out,
+                  typename Functor::tin_type in0,
+                  typename Functor::tin_type in1, bool* error) {
+    MaybeWith32BitIndexing<GPUDevice>(
+        [&](auto out32, auto in0_32, auto in1_32) {
+          out32.device(d) = in0_32.binaryExpr(in1_32, typename Functor::func());
+        },
+        out, in0, in1);
+  }
+
+  void Left(const GPUDevice& d, typename Functor::tout_type out,
+            typename Functor::tscalar_type scalar,
+            typename Functor::tin_type in, bool* error) {
+    typedef typename Functor::out_type Tout;
+    typedef typename Functor::in_type Tin;
+    typedef typename Functor::func Binary;
+    typedef typename Eigen::internal::scalar_left<Tout, Tin, Binary> Unary;
+    MaybeWith32BitIndexing<GPUDevice>(
+        [&](auto out32, auto in32) {
+          out32.device(d) = in32.unaryExpr(Unary(scalar.data()));
+        },
+        out, in);
+  }
+
+  void Right(const GPUDevice& d, typename Functor::tout_type out,
+             typename Functor::tin_type in,
+             typename Functor::tscalar_type scalar, bool* error) {
+    typedef typename Functor::out_type Tout;
+    typedef typename Functor::in_type Tin;
+    typedef typename Functor::func Binary;
+    typedef typename Eigen::internal::scalar_right<Tout, Tin, Binary> Unary;
+    MaybeWith32BitIndexing<GPUDevice>(
+        [&](auto out32, auto in32) {
+          out32.device(d) = in32.unaryExpr(Unary(scalar.data()));
+        },
+        out, in);
+  }
+
+  void BCast(const GPUDevice& d,
+             typename TTypes<typename Functor::out_type, NDIMS>::Tensor out,
+             typename TTypes<typename Functor::in_type, NDIMS>::ConstTensor in0,
+             typename Eigen::array<Eigen::DenseIndex, NDIMS> bcast0,
+             typename TTypes<typename Functor::in_type, NDIMS>::ConstTensor in1,
+             typename Eigen::array<Eigen::DenseIndex, NDIMS> bcast1,
+             bool* error) {
+    typedef typename Functor::in_type T;
+    typename Functor::func func;
+    if ((NDIMS == 2) && Functor::use_bcast_optimization &&
+        use_bcast_optimization<T>::value) {
+      const bool bcast0_all_one = AllOne<NDIMS>(bcast0);
+      const bool bcast1_all_one = AllOne<NDIMS>(bcast1);
+      if (bcast0_all_one && !bcast1_all_one) {
+        MaybeWith32BitIndexing<GPUDevice>(
+            [&](auto out32, auto in0_32, auto in1_32) {
+              out32.device(d) =
+                  in0_32.binaryExpr(in1_32.broadcast(bcast1), func);
+            },
+            out, in0, in1);
+        return;
+      }
+      if (!bcast0_all_one && bcast1_all_one) {
+        MaybeWith32BitIndexing<GPUDevice>(
+            [&](auto out32, auto in0_32, auto in1_32) {
+              out32.device(d) =
+                  in0_32.broadcast(bcast0).binaryExpr(in1_32, func);
+            },
+            out, in0, in1);
+        return;
+      }
+    }
+    MaybeWith32BitIndexing<GPUDevice>(
+        [&](auto out32, auto in0_32, auto in1_32) {
+          out32.device(d) = in0_32.broadcast(bcast0).binaryExpr(
+              in1_32.broadcast(bcast1), func);
+        },
+        out, in0, in1);
+  }
+};
+
+// Partial specialization of ApproximateEqual<Device=GPUDevice, T>.
+template <typename T>
+struct ApproximateEqual<GPUDevice, T> {
+  void operator()(const GPUDevice& d, typename TTypes<T>::ConstFlat x,
+                  typename TTypes<T>::ConstFlat y, T tolerance,
+                  typename TTypes<bool>::Flat z) {
+    auto diff = x - y;
+    z.device(d) = diff.abs() <= tolerance;
+  }
+};
+
+// Macros to explicitly instantiate kernels on GPU for multiple types
+// (T0, T1, etc.) for UnaryFunctor (e.g., functor::sqrt).
+#define DEFINE_UNARY1(F, T) template struct UnaryFunctor<GPUDevice, F<T> >
+#define DEFINE_UNARY2(F, T0, T1) \
+  DEFINE_UNARY1(F, T0);          \
+  DEFINE_UNARY1(F, T1)
+#define DEFINE_UNARY3(F, T0, T1, T2) \
+  DEFINE_UNARY2(F, T0, T1);          \
+  DEFINE_UNARY1(F, T2)
+#define DEFINE_UNARY4(F, T0, T1, T2, T3) \
+  DEFINE_UNARY2(F, T0, T1);              \
+  DEFINE_UNARY2(F, T2, T3)
+#define DEFINE_UNARY5(F, T0, T1, T2, T3, T4) \
+  DEFINE_UNARY2(F, T0, T1);                  \
+  DEFINE_UNARY3(F, T2, T3, T4)
+#define DEFINE_UNARY6(F, T0, T1, T2, T3, T4, T5) \
+  DEFINE_UNARY2(F, T0, T1);                      \
+  DEFINE_UNARY4(F, T2, T3, T4, T5)
+#define DEFINE_UNARY7(F, T0, T1, T2, T3, T4, T5, T6) \
+  DEFINE_UNARY2(F, T0, T1);                          \
+  DEFINE_UNARY5(F, T2, T3, T4, T5, T6)
+#define DEFINE_UNARY8(F, T0, T1, T2, T3, T4, T5, T6, T7) \
+  DEFINE_UNARY4(F, T0, T1, T2, T3);                      \
+  DEFINE_UNARY4(F, T4, T5, T6, T7)
+
+// Macros to explicitly instantiate kernels on GPU for multiple types
+// (T0, T1, etc.) for BinaryFunctor.
+#define DEFINE_BINARY1(F, T)                         \
+  template struct BinaryFunctor<GPUDevice, F<T>, 1>; \
+  template struct BinaryFunctor<GPUDevice, F<T>, 2>; \
+  template struct BinaryFunctor<GPUDevice, F<T>, 3>; \
+  template struct BinaryFunctor<GPUDevice, F<T>, 4>; \
+  template struct BinaryFunctor<GPUDevice, F<T>, 5>
+#define DEFINE_BINARY2(F, T0, T1) \
+  DEFINE_BINARY1(F, T0);          \
+  DEFINE_BINARY1(F, T1)
+#define DEFINE_BINARY3(F, T0, T1, T2) \
+  DEFINE_BINARY2(F, T0, T1);          \
+  DEFINE_BINARY1(F, T2)
+#define DEFINE_BINARY4(F, T0, T1, T2, T3) \
+  DEFINE_BINARY2(F, T0, T1);              \
+  DEFINE_BINARY2(F, T2, T3)
+#define DEFINE_BINARY5(F, T0, T1, T2, T3, T4) \
+  DEFINE_BINARY2(F, T0, T1);                  \
+  DEFINE_BINARY3(F, T2, T3, T4)
+#define DEFINE_BINARY6(F, T0, T1, T2, T3, T4, T5) \
+  DEFINE_BINARY3(F, T0, T1, T2);                  \
+  DEFINE_BINARY3(F, T3, T4, T5)
+#define DEFINE_BINARY7(F, T0, T1, T2, T3, T4, T5, T6) \
+  DEFINE_BINARY3(F, T0, T1, T2);                      \
+  DEFINE_BINARY4(F, T3, T4, T5, T6)
+#define DEFINE_BINARY8(F, T0, T1, T2, T3, T4, T5, T6, T7) \
+  DEFINE_BINARY4(F, T0, T1, T2, T3);                      \
+  DEFINE_BINARY4(F, T4, T5, T6, T7)
+#define DEFINE_BINARY9(F, T0, T1, T2, T3, T4, T5, T6, T7, T8) \
+  DEFINE_BINARY4(F, T0, T1, T2, T3);                          \
+  DEFINE_BINARY5(F, T4, T5, T6, T7, T8)
+#define DEFINE_BINARY10(F, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) \
+  DEFINE_BINARY5(F, T0, T1, T2, T3, T4);                           \
+  DEFINE_BINARY5(F, T5, T6, T7, T8, T9)
+#define DEFINE_BINARY11(F, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) \
+  DEFINE_BINARY5(F, T0, T1, T2, T3, T4);                                \
+  DEFINE_BINARY6(F, T5, T6, T7, T8, T9, T10)
+
+#define DEFINE_APPROXIMATE_EQUAL1(T) \
+  template struct ApproximateEqual<GPUDevice, T>;
+#define DEFINE_APPROXIMATE_EQUAL2(T0, T1) \
+  DEFINE_APPROXIMATE_EQUAL1(T0);          \
+  DEFINE_APPROXIMATE_EQUAL1(T1);
+
+}  // end namespace functor
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_CWISE_OPS_GPU_COMMON_CU_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/cwise_ops_gpu_gradients.cu.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/cwise_ops_gpu_gradients.cu.h
new file mode 100644
index 0000000000000000000000000000000000000000..dddce612488ff83321c99b2673012f626299bf1e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/cwise_ops_gpu_gradients.cu.h
@@ -0,0 +1,74 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#if !GOOGLE_CUDA && !TENSORFLOW_USE_ROCM
+#error This file must only be included when building with Cuda or ROCm support
+#endif
+
+#ifndef TENSORFLOW_CORE_KERNELS_CWISE_OPS_GPU_GRADIENTS_CU_H_
+#define TENSORFLOW_CORE_KERNELS_CWISE_OPS_GPU_GRADIENTS_CU_H_
+
+#define EIGEN_USE_GPU
+
+#include <complex>
+
+#include "tensorflow/core/framework/tensor_types.h"
+#include "tensorflow/core/kernels/cwise_ops.h"
+#include "tensorflow/core/kernels/cwise_ops_gradients.h"
+#include "tensorflow/core/platform/types.h"
+
+#include "tensorflow/core/platform/logging.h"
+namespace tensorflow {
+namespace functor {
+
+typedef Eigen::GpuDevice GPUDevice;
+typedef std::complex<float> complex64;
+typedef std::complex<double> complex128;
+
+// Partial specialization of SimpleBinaryFunctor<Device=GPUDevice, Functor>.
+template <typename Functor>
+struct SimpleBinaryFunctor<GPUDevice, Functor> {
+  void operator()(const GPUDevice& d, typename Functor::tout_type out,
+                  typename Functor::tin_type in1,
+                  typename Functor::tin_type in2) {
+    MaybeWith32BitIndexing<GPUDevice>(
+        [&](auto out32, auto in1_32) {
+          out32.device(d) = in1_32.binaryExpr(in2, typename Functor::func());
+        },
+        out, in1);
+  }
+};
+
+// Macros to explicitly instantiate kernels on GPU for multiple types
+// (T0, T1, etc.) for SimpleBinaryFunctor (e.g., functor::tanh_grad).
+#define DEFINE_SIMPLE_BINARY1(F, T) \
+  template struct SimpleBinaryFunctor<GPUDevice, F<T> >
+#define DEFINE_SIMPLE_BINARY2(F, T0, T1) \
+  DEFINE_SIMPLE_BINARY1(F, T0);          \
+  DEFINE_SIMPLE_BINARY1(F, T1)
+#define DEFINE_SIMPLE_BINARY3(F, T0, T1, T2) \
+  DEFINE_SIMPLE_BINARY2(F, T0, T1);          \
+  DEFINE_SIMPLE_BINARY1(F, T2)
+#define DEFINE_SIMPLE_BINARY4(F, T0, T1, T2, T3) \
+  DEFINE_SIMPLE_BINARY2(F, T0, T1);              \
+  DEFINE_SIMPLE_BINARY2(F, T2, T3)
+#define DEFINE_SIMPLE_BINARY5(F, T0, T1, T2, T3, T4) \
+  DEFINE_SIMPLE_BINARY2(F, T0, T1);                  \
+  DEFINE_SIMPLE_BINARY3(F, T2, T3, T4)
+
+}  // end namespace functor
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_CWISE_OPS_GPU_GRADIENTS_CU_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/cwise_ops_gradients.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/cwise_ops_gradients.h
new file mode 100644
index 0000000000000000000000000000000000000000..0be3f78857449313d14951bb7a113aea81410114
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/cwise_ops_gradients.h
@@ -0,0 +1,210 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_CWISE_OPS_GRADIENTS_H_
+#define TENSORFLOW_CORE_KERNELS_CWISE_OPS_GRADIENTS_H_
+
+#define EIGEN_USE_THREADS
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/kernels/cwise_ops.h"
+
+namespace Eigen {
+namespace internal {
+
+// Gradient for the tanh function
+template <typename T>
+struct scalar_tanh_gradient_op {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const T
+  operator()(const T& output, const T& output_gradient) const {
+    return output_gradient * (T(1) - output * output);
+  }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet
+  packetOp(const Packet& output, const Packet& output_gradient) const {
+    return pmul(output_gradient,
+                psub(pset1<Packet>(T(1)), pmul(output, output)));
+  }
+};
+template <typename T>
+struct functor_traits<scalar_tanh_gradient_op<T>> {
+  enum {
+    Cost = NumTraits<T>::AddCost + 2 * NumTraits<T>::MulCost,
+    PacketAccess = packet_traits<T>::HasSub && packet_traits<T>::HasMul,
+  };
+};
+
+// Gradient for the sigmoid function
+template <typename T>
+struct scalar_sigmoid_gradient_op {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const T
+  operator()(const T& output, const T& output_gradient) const {
+    return output_gradient * output * (T(1) - output);
+  }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet
+  packetOp(const Packet& output, const Packet& output_gradient) const {
+    return pmul(output_gradient,
+                pmul(output, psub(pset1<Packet>(T(1)), output)));
+  }
+};
+template <typename T>
+struct functor_traits<scalar_sigmoid_gradient_op<T>> {
+  enum {
+    Cost = NumTraits<T>::AddCost + 2 * NumTraits<T>::MulCost,
+    PacketAccess = packet_traits<T>::HasSub && packet_traits<T>::HasMul,
+  };
+};
+
+// Gradient for the inverse function
+template <typename T>
+struct scalar_inverse_gradient_op {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const T
+  operator()(const T& output, const T& output_gradient) const {
+    if (output_gradient == T(0)) {
+      return T(0);
+    } else {
+      const T out_conj = numext::conj(output);
+      return -out_conj * out_conj * output_gradient;
+    }
+  }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet
+  packetOp(const Packet& output, const Packet& output_gradient) const {
+    const Packet out_conj = pconj(output);
+    return mul_no_nan_op<T>().packetOp(pnegate(pmul(out_conj, out_conj)),
+                                       output_gradient);
+  }
+};
+template <typename T>
+struct functor_traits<scalar_inverse_gradient_op<T>> {
+  enum {
+    Cost = NumTraits<T>::AddCost + 2 * NumTraits<T>::MulCost,
+    PacketAccess = packet_traits<T>::HasMul,
+  };
+};
+
+// Gradient for the sqrt function
+template <typename T>
+struct scalar_sqrt_gradient_op {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const T
+  operator()(const T& output, const T& output_gradient) const {
+    if (output_gradient == T(0)) {
+      return T(0);
+    } else {
+      const T out_conj = numext::conj(output);
+      return (static_cast<T>(0.5) * output_gradient) / out_conj;
+    }
+  }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet
+  packetOp(const Packet& output, const Packet& output_gradient) const {
+    const Packet const_half = pset1<Packet>(static_cast<T>(0.5));
+    const Packet out_conj = pconj(output);
+    return mul_no_nan_op<T>().packetOp(pdiv(const_half, out_conj),
+                                       output_gradient);
+  }
+};
+template <typename T>
+struct functor_traits<scalar_sqrt_gradient_op<T>> {
+  enum {
+    PacketAccess = packet_traits<T>::HasMul & packet_traits<T>::HasDiv,
+    Cost = NumTraits<T>::MulCost + scalar_div_cost<T, PacketAccess>::value,
+  };
+};
+
+// Gradient for the rsqrt function
+template <typename T>
+struct scalar_rsqrt_gradient_op {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const T
+  operator()(const T& output, const T& output_gradient) const {
+    if (output_gradient == T(0)) {
+      return T(0);
+    } else {
+      const T out_conj = numext::conj(output);
+      return static_cast<T>(-0.5) * (output_gradient * out_conj) *
+             (out_conj * out_conj);
+    }
+  }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet
+  packetOp(const Packet& output, const Packet& output_gradient) const {
+    const Packet const_half = pset1<Packet>(static_cast<T>(-0.5));
+    const Packet out_conj = pconj(output);
+    auto safe_pmul = [](const Packet& a, const Packet& b) {
+      return mul_no_nan_op<T>().packetOp(a, b);
+    };
+    return safe_pmul(pmul(const_half, pmul(out_conj, out_conj)),
+                     safe_pmul(out_conj, output_gradient));
+  }
+};
+template <typename T>
+struct functor_traits<scalar_rsqrt_gradient_op<T>> {
+  enum {
+    Cost = 4 * NumTraits<T>::MulCost,
+    PacketAccess = packet_traits<T>::HasMul,
+  };
+};
+
+}  // end namespace internal
+}  // end namespace Eigen
+
+namespace tensorflow {
+
+namespace functor {
+
+template <typename Device, typename Functor>
+struct SimpleBinaryFunctor {
+  void operator()(const Device& d, typename Functor::tout_type out,
+                  typename Functor::tin_type in0,
+                  typename Functor::tin_type in1);
+};
+
+// Partial specialization of BinaryFunctor for CPU devices
+typedef Eigen::ThreadPoolDevice CPUDevice;
+
+template <typename Functor>
+struct SimpleBinaryFunctor<CPUDevice, Functor> {
+  void operator()(const CPUDevice& d, typename Functor::tout_type out,
+                  typename Functor::tin_type in0,
+                  typename Functor::tin_type in1) {
+    out.device(d) = in0.binaryExpr(in1, typename Functor::func());
+  }
+};
+
+
+template <typename T>
+struct tanh_grad : base<T, Eigen::internal::scalar_tanh_gradient_op<T>> {};
+
+template <typename T>
+struct sigmoid_grad : base<T, Eigen::internal::scalar_sigmoid_gradient_op<T>> {
+};
+
+template <typename T>
+struct inverse_grad : base<T, Eigen::internal::scalar_inverse_gradient_op<T>> {
+};
+
+template <typename T>
+struct sqrt_grad : base<T, Eigen::internal::scalar_sqrt_gradient_op<T>> {};
+
+template <typename T>
+struct rsqrt_grad : base<T, Eigen::internal::scalar_rsqrt_gradient_op<T>> {};
+
+template <typename T>
+struct igamma_grad_a : base<T, Eigen::internal::scalar_igamma_der_a_op<T>> {};
+
+}  // end namespace functor
+
+}  // end namespace tensorflow
+#endif  // TENSORFLOW_CORE_KERNELS_CWISE_OPS_GRADIENTS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/data_format_ops.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/data_format_ops.h
new file mode 100644
index 0000000000000000000000000000000000000000..3d4568d523524330633557e7cb8b14a952145953
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/data_format_ops.h
@@ -0,0 +1,113 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_DATA_FORMAT_OPS_H_
+#define TENSORFLOW_CORE_KERNELS_DATA_FORMAT_OPS_H_
+// Functor definition for data format dim mapping ops, must be compilable
+// by nvcc.
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/framework/tensor_types.h"
+
+namespace tensorflow {
+namespace functor {
+
+// Functor used by DataFormatDimMapOP to do the computations.
+template <typename Device, typename T>
+struct DataFormatDimMap {
+  void operator()(const Device& d, typename TTypes<T>::ConstFlat x,
+                  typename TTypes<T>::Flat y, const TTypes<int>::Vec dst) {
+    if (dst.size() == 4) {
+      auto zero = x.constant(0);
+      auto one = x.constant(1);
+      auto two = x.constant(2);
+
+      auto f_zero = x.constant(dst(0));
+      auto f_one = x.constant(dst(1));
+      auto f_two = x.constant(dst(2));
+      auto f_three = x.constant(dst(3));
+
+      auto four = x.constant(4);
+      auto x_mod = (x + four) % 4;
+
+      auto is_zero = (x_mod == zero);
+      auto is_one = (x_mod == one);
+      auto is_two = (x_mod == two);
+
+      y.device(d) = is_zero.select(
+          f_zero, is_one.select(f_one, is_two.select(f_two, f_three)));
+    } else {
+      auto zero = x.constant(0);
+      auto one = x.constant(1);
+      auto two = x.constant(2);
+      auto three = x.constant(3);
+
+      auto f_zero = x.constant(dst(0));
+      auto f_one = x.constant(dst(1));
+      auto f_two = x.constant(dst(2));
+      auto f_three = x.constant(dst(3));
+      auto f_four = x.constant(dst(4));
+
+      auto five = x.constant(5);
+      auto x_mod = (x + five) % 5;
+
+      auto is_zero = (x_mod == zero);
+      auto is_one = (x_mod == one);
+      auto is_two = (x_mod == two);
+      auto is_three = (x_mod == three);
+
+      y.device(d) = is_zero.select(
+          f_zero,
+          is_one.select(
+              f_one, is_two.select(f_two, is_three.select(f_three, f_four))));
+    }
+  }
+};
+
+template <typename T>
+struct VecPermute {
+  explicit VecPermute(const Eigen::DSizes<Eigen::DenseIndex, 10>& dst)
+      : dst(dst) {}
+  Eigen::DSizes<Eigen::DenseIndex, 1> dimensions(
+      typename TTypes<T>::ConstFlat input) const {
+    Eigen::DSizes<Eigen::DenseIndex, 1> result;
+    result[0] = input.dimension(0);
+    return result;
+  }
+  template <typename Output, typename Device>
+  void eval(typename TTypes<T>::ConstFlat input, Output& output,
+            const Device& d) const {
+    for (int i = 0; i < input.size(); ++i) {
+      output.template chip<0>(dst[i]).device(d) = input.template chip<0>(i);
+    }
+  }
+
+ private:
+  Eigen::DSizes<Eigen::DenseIndex, 10> dst;
+};
+
+// Functor used by DataFormatVecPermuteOp to do the computations.
+template <typename Device, typename T>
+struct DataFormatVecPermute {
+  void operator()(const Device& d, typename TTypes<T>::ConstFlat x,
+                  typename TTypes<T>::Flat y,
+                  const Eigen::DSizes<Eigen::DenseIndex, 10>& dst) {
+    y.device(d) = x.customOp(VecPermute<T>(dst));
+  }
+};
+
+}  // namespace functor
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_DATA_FORMAT_OPS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/debug_ops.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/debug_ops.h
new file mode 100644
index 0000000000000000000000000000000000000000..eb1d2db77a7f2e31f91be990449c4e19d5064af1
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/debug_ops.h
@@ -0,0 +1,950 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_DEBUG_OPS_H_
+#define TENSORFLOW_CORE_KERNELS_DEBUG_OPS_H_
+
+#include <cstdint>
+#include <memory>
+#include <numeric>
+
+#include "tensorflow/core/platform/bfloat16.h"
+
+#if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+#include "tensorflow/core/common_runtime/gpu/gpu_event_mgr.h"
+#include "tensorflow/core/common_runtime/gpu/gpu_util.h"
+#include "tensorflow/core/util/determinism.h"
+#endif
+
+#if GOOGLE_CUDA
+#include "tensorflow/core/platform/cuda.h"
+#elif TENSORFLOW_USE_ROCM
+#include "tensorflow/core/platform/rocm.h"
+#endif
+
+#include "tensorflow/core/debug/debug_io_utils.h"
+#include "tensorflow/core/framework/device_base.h"
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/tensor_util.h"
+#include "tensorflow/core/lib/core/notification.h"
+#include "tensorflow/core/lib/strings/stringprintf.h"
+#include "tensorflow/core/util/debug_events_writer.h"
+
+namespace tensorflow {
+
+// Copy op for debugging.
+// Performs CPU-to-CPU or GPU-to-GPU deep-copying of tensor, depending on the
+// device on which the tensor is allocated.
+class CopyOp : public OpKernel {
+ public:
+  explicit CopyOp(OpKernelConstruction* context) : OpKernel(context) {
+    OP_REQUIRES_OK(context, context->GetAttr("tensor_name", &tensor_name_));
+
+    std::vector<string> debug_ops_spec;
+    OP_REQUIRES_OK(context,
+                   context->GetAttr("debug_ops_spec", &debug_ops_spec));
+    for (const string& debug_op_spec : debug_ops_spec) {
+      // Assume debug_op_spec has the format
+      // <debug_op>;<debug_url>;<gated_grpc>, e.g.,
+      // DebugIdentity;grpc://localhost:3333;1
+      const std::vector<string> items = str_util::Split(debug_op_spec, ";");
+      OP_REQUIRES(
+          context, items.size() == 3,
+          errors::Internal(
+              "Unexpected number of semicolons in debug_ops_spec element: ",
+              debug_op_spec));
+      debug_op_and_url_specs_.push_back(
+          DebugWatchAndURLSpec(strings::StrCat(tensor_name_, ":", items[0]),
+                               items[1], items[2] == "1"));
+    }
+  }
+
+  void Compute(OpKernelContext* context) override {
+    const Tensor& src_tensor = context->input(0);
+
+    if (src_tensor.IsInitialized() &&
+        DataTypeCanUseMemcpy(src_tensor.dtype()) &&
+        DebugIO::IsCopyNodeGateOpen(debug_op_and_url_specs_)) {
+      // Source tensor is initialized and is mem-copyable. Make a copy.
+      Tensor* copied_tensor;
+      OP_REQUIRES_OK(context, context->allocate_output(0, src_tensor.shape(),
+                                                       &copied_tensor));
+
+#if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+      Device* device = static_cast<Device*>(context->device());
+      // Determine if the input tensor is not on CPU (e.g., on GPU).
+      bool off_host_input = device->device_type() == DEVICE_GPU &&
+                            !context->input_alloc_attr(0).on_host();
+
+      if (off_host_input) {
+        DeviceContext* device_ctxt = context->op_device_context();
+        // Input is not on host: deep-copy it from GPU to the same GPU.
+        Notification done_copy;
+        GPUUtil::CopyGPUTensorToSameGPU(
+            device, device_ctxt, &src_tensor, copied_tensor,
+            [&done_copy](const Status& s) { done_copy.Notify(); });
+        done_copy.WaitForNotification();
+      } else {
+        // The input tensor is on the host (CPU): deep-copy from CPU to CPU.
+        *copied_tensor = tensor::DeepCopy(src_tensor);
+      }
+#else
+      *copied_tensor = tensor::DeepCopy(src_tensor);
+#endif
+    } else {
+      // Source tensor is NOT initialized and/or is not mem-copyable: Forward
+      // the Tensor object.
+      context->set_output(0, src_tensor);
+    }
+  }
+
+  bool IsExpensive() override { return false; }
+
+ private:
+  string tensor_name_;
+  std::vector<DebugWatchAndURLSpec> debug_op_and_url_specs_;
+};
+
+// Base class of all debug ops.
+class BaseDebugOp : public OpKernel {
+ public:
+  explicit BaseDebugOp(const string& debug_op_name,
+                       OpKernelConstruction* context)
+      : OpKernel(context), debug_op_name_(debug_op_name) {
+    OP_REQUIRES_OK(context, context->GetAttr("debug_urls", &debug_urls_));
+    OP_REQUIRES_OK(context, context->GetAttr("gated_grpc", &gated_grpc_));
+
+    string device_name;
+    string tensor_name;
+    OP_REQUIRES_OK(context, context->GetAttr("device_name", &device_name));
+    OP_REQUIRES_OK(context, context->GetAttr("tensor_name", &tensor_name));
+
+    std::vector<string> name_items = str_util::Split(tensor_name, ':');
+    string node_name;
+    int32_t output_slot = 0;
+    OP_REQUIRES(context, name_items.size() == 1 || name_items.size() == 2,
+                errors::InvalidArgument("Failed to parse tensor name: \"",
+                                        tensor_name, "\""));
+    if (name_items.size() == 2) {
+      node_name = name_items[0];
+      OP_REQUIRES(
+          context, strings::safe_strto32(name_items[1], &output_slot),
+          errors::InvalidArgument("Invalid string value for output_slot: \"",
+                                  name_items[1], "\""));
+    } else if (name_items.size() == 1) {
+      node_name = name_items[0];
+    }
+
+    debug_watch_key_.reset(
+        new DebugNodeKey(device_name, node_name, output_slot, debug_op_name_));
+  }
+
+  bool IsExpensive() override { return false; }
+
+ protected:
+  // Apply gRPC gating (if gated_grpc_ attribute is true).
+  //
+  // Returns false if and only if all grpc:// debug URLs of the debug op are
+  // disabled currently (i.e., gated off), in which case the debug op will emit
+  // an empty (size {0}) tensor of undefined data type.
+  bool ApplyGrpcGating(OpKernelContext* context) {
+    if (gated_grpc_ && !DebugIO::IsDebugNodeGateOpen(
+                           debug_watch_key_->debug_node_name, debug_urls_)) {
+      // The entire node is gated off: Output an empty tensor and avoid
+      // expensive computation.
+      Tensor* output_tensor;
+      TensorShape shape({0});
+      if (!context->allocate_output(0, shape, &output_tensor).ok()) {
+        LOG(ERROR) << "Debug node of watch key "
+                   << debug_watch_key_->debug_node_name
+                   << " failed to allocate empty tensor under gated-off state.";
+      }
+      return false;
+    } else {
+      return true;
+    }
+  }
+
+  // Publish a tensor to all debug URLs of the debug op.
+  // Log an error if the publishing failed.
+  Status PublishTensor(const Tensor& tensor, int64_t step_id = -1) {
+    if (debug_urls_.empty()) {
+      return OkStatus();
+    } else {
+      Status status = DebugIO::PublishDebugTensor(
+          *debug_watch_key_, tensor, Env::Default()->NowMicros(), debug_urls_,
+          gated_grpc_, step_id);
+      if (!status.ok()) {
+        LOG(ERROR) << "Debug node of watch key "
+                   << debug_watch_key_->debug_node_name
+                   << " failed to publish debug tensor data to all URLs "
+                   << str_util::Join(debug_urls_, ", ")
+                   << ", due to: " << status.message();
+      }
+      return status;
+    }
+  }
+
+  void CompleteDebugNodeKey(const string& io_of_node, bool is_input,
+                            int io_index) {
+    debug_watch_key_ = std::make_unique<DebugNodeKey>(
+        debug_watch_key_->device_name, debug_watch_key_->node_name,
+        debug_watch_key_->output_slot, debug_op_name_, io_of_node, is_input,
+        io_index);
+  }
+
+ private:
+  const string debug_op_name_;
+  std::unique_ptr<DebugNodeKey> debug_watch_key_;
+  std::vector<string> debug_urls_;
+  bool gated_grpc_;
+};
+
+// Identity op for debugging.
+//   Output slot 0 carries the debug signal and is always allocated on the
+//   host (CPU) as a non-Ref tensor. In the case of DebugIdentityOp,
+//   the debug signal is equal to the input tensor.
+class DebugIdentityOp : public BaseDebugOp {
+ public:
+  explicit DebugIdentityOp(OpKernelConstruction* context)
+      : BaseDebugOp("DebugIdentity", context) {}
+
+  void Compute(OpKernelContext* context) override {
+    if (!ApplyGrpcGating(context)) {
+      return;
+    }
+
+    OP_REQUIRES_OK(context, PublishTensor(context->input(0)));
+    context->set_output(0, context->input(0));
+  }
+};
+
+// Identity op for debugging.
+//   Output slot 0 carries the debug signal and is always allocated on the
+//   host (CPU) as a non-Ref tensor. In the case of DebugIdentityOp,
+//   the debug signal is equal to the input tensor.
+class DebugIdentityV3Op : public BaseDebugOp {
+ public:
+  explicit DebugIdentityV3Op(OpKernelConstruction* context)
+      : BaseDebugOp("DebugIdentityV3", context) {
+    string io_of_node;
+    bool is_input;
+    int io_index;
+    OP_REQUIRES_OK(context, context->GetAttr("io_of_node", &io_of_node));
+    OP_REQUIRES_OK(context, context->GetAttr("is_input", &is_input));
+    OP_REQUIRES_OK(context, context->GetAttr("io_index", &io_index));
+    if (!io_of_node.empty()) {
+      CompleteDebugNodeKey(io_of_node, is_input, io_index);
+    }
+  }
+
+  void Compute(OpKernelContext* context) override {
+    if (!ApplyGrpcGating(context)) {
+      return;
+    }
+
+    OP_REQUIRES_OK(context,
+                   PublishTensor(context->input(0), context->step_id()));
+    context->set_output(0, context->input(0));
+  }
+};
+
+// NaN-counter op for debugging.
+template <typename T>
+class DebugNanCountOp : public BaseDebugOp {
+ public:
+  explicit DebugNanCountOp(OpKernelConstruction* context)
+      : BaseDebugOp("DebugNanCount", context) {}
+
+  void Compute(OpKernelContext* context) override {
+    if (!ApplyGrpcGating(context)) {
+      return;
+    }
+
+    Tensor* output_tensor;
+    const Tensor& input = context->input(0);
+
+    // Use DT_INT64/int64 to be consistent with TensorShape::num_elements().
+    int64_t nan_count = 0;
+
+    // If the input is an uninitialized tensor, let nan_count be 0.
+    if (input.IsInitialized()) {
+      // Count NaNs.
+      const TensorShape& input_shape = input.shape();
+      const T* input_flat = input.template flat<T>().data();
+
+      for (int64_t i = 0; i < input_shape.num_elements(); ++i) {
+        if (Eigen::numext::isnan(static_cast<double>(input_flat[i]))) {
+          nan_count++;
+        }
+      }
+    }
+
+    TensorShape shape({1});
+    OP_REQUIRES_OK(context, context->allocate_output(0, shape, &output_tensor));
+    output_tensor->vec<int64_t>()(0) = nan_count;
+    OP_REQUIRES_OK(context, PublishTensor(*output_tensor));
+  }
+};
+
+// Numeric summary op for debugging.
+template <typename T>
+class DebugNumericSummaryOp : public BaseDebugOp {
+ public:
+  explicit DebugNumericSummaryOp(OpKernelConstruction* context)
+      : BaseDebugOp("DebugNumericSummary", context) {
+    OP_REQUIRES_OK(context, context->GetAttr("lower_bound", &lower_bound_));
+    OP_REQUIRES_OK(context, context->GetAttr("upper_bound", &upper_bound_));
+    OP_REQUIRES_OK(context,
+                   context->GetAttr("mute_if_healthy", &mute_if_healthy_));
+  }
+
+  void Compute(OpKernelContext* context) override {
+    if (!ApplyGrpcGating(context)) {
+      return;
+    }
+
+    Tensor* output_tensor;
+    const Tensor& input = context->input(0);
+
+    int64_t is_initialized = 0;
+    int64_t element_count = 0;
+    int64_t negative_inf_count = 0;
+    int64_t negative_count = 0;
+    int64_t zero_count = 0;
+    int64_t positive_count = 0;
+    int64_t positive_inf_count = 0;
+    int64_t nan_count = 0;
+    double min = std::numeric_limits<double>::infinity();
+    double max = -std::numeric_limits<double>::infinity();
+    double sum = 0.0;
+    double mean = std::numeric_limits<double>::quiet_NaN();
+    double variance = std::numeric_limits<double>::quiet_NaN();
+
+    // Equal to negative_count + zero_count + positive_count.
+    int64_t non_inf_nan_count = 0;
+
+    const TensorShape& input_shape = input.shape();
+    if (input.IsInitialized()) {
+      is_initialized = 1;
+      const T* input_flat = input.template flat<T>().data();
+
+      element_count = input_shape.num_elements();
+      const bool is_lower_bound_custom = !Eigen::numext::isinf(lower_bound_);
+      const bool is_upper_bound_custom = !Eigen::numext::isinf(upper_bound_);
+
+      for (int64_t i = 0; i < element_count; ++i) {
+        const double x = static_cast<double>(input_flat[i]);
+        if (Eigen::numext::isnan(x)) {
+          nan_count++;
+        } else if (Eigen::numext::isinf(x)) {
+          if (x < 0.0) {
+            negative_inf_count++;
+          } else {
+            positive_inf_count++;
+          }
+        } else {
+          if (is_lower_bound_custom && x <= lower_bound_) {
+            negative_inf_count++;
+          } else if (is_upper_bound_custom && x >= upper_bound_) {
+            positive_inf_count++;
+          } else if (x < 0.0) {
+            negative_count++;
+          } else if (x > 0.0) {
+            positive_count++;
+          } else {
+            zero_count++;
+          }
+
+          if (x < min) {
+            min = x;
+          }
+          if (x > max) {
+            max = x;
+          }
+
+          non_inf_nan_count++;
+          sum += x;
+        }
+      }
+
+      if (non_inf_nan_count > 0) {
+        mean = sum / non_inf_nan_count;
+
+        // Do a second pass to compute variance.
+        variance = 0.0;
+        for (int64_t i = 0; i < element_count; ++i) {
+          const double x = static_cast<double>(input_flat[i]);
+          if (!Eigen::numext::isnan(x) && !Eigen::numext::isinf(x)) {
+            variance += (x - mean) * (x - mean);
+          }
+        }
+        variance /= non_inf_nan_count;
+      }
+    }
+
+    TensorShape shape({14 + input_shape.dims()});
+    OP_REQUIRES_OK(context, context->allocate_output(0, shape, &output_tensor));
+    output_tensor->vec<double>()(0) = static_cast<double>(is_initialized);
+    output_tensor->vec<double>()(1) = static_cast<double>(element_count);
+    output_tensor->vec<double>()(2) = static_cast<double>(nan_count);
+    output_tensor->vec<double>()(3) = static_cast<double>(negative_inf_count);
+    output_tensor->vec<double>()(4) = static_cast<double>(negative_count);
+    output_tensor->vec<double>()(5) = static_cast<double>(zero_count);
+    output_tensor->vec<double>()(6) = static_cast<double>(positive_count);
+    output_tensor->vec<double>()(7) = static_cast<double>(positive_inf_count);
+    output_tensor->vec<double>()(8) = min;
+    output_tensor->vec<double>()(9) = max;
+    output_tensor->vec<double>()(10) = mean;
+    output_tensor->vec<double>()(11) = variance;
+
+    output_tensor->vec<double>()(12) = static_cast<double>(input.dtype());
+    output_tensor->vec<double>()(13) = static_cast<double>(input_shape.dims());
+    for (size_t d = 0; d < input_shape.dims(); ++d) {
+      output_tensor->vec<double>()(14 + d) =
+          static_cast<double>(input_shape.dim_sizes()[d]);
+    }
+
+    bool mute = mute_if_healthy_ && nan_count == 0 && negative_inf_count == 0 &&
+                positive_inf_count == 0;
+    if (!mute) {
+      OP_REQUIRES_OK(context, PublishTensor(*output_tensor));
+    }
+  }
+
+ private:
+  float lower_bound_;
+  float upper_bound_;
+  bool mute_if_healthy_;
+};
+
+// Identity op for tfdbg v2: Writes debug data using DebugEventsWriter.
+class DebugIdentityV2Op : public OpKernel {
+ public:
+  explicit DebugIdentityV2Op(OpKernelConstruction* context)
+      : OpKernel(context),
+        device_name_(context->device()->name()),
+        output_slot_(-1),
+        tensor_debug_mode_(0),
+        tfdbg_run_id_() {
+    std::vector<string> debug_urls;
+    OP_REQUIRES_OK(context, context->GetAttr("debug_urls", &debug_urls));
+    for (const string& debug_url : debug_urls) {
+      if (absl::StartsWith(debug_url, DebugIO::kFileURLScheme)) {
+        dump_roots_.emplace_back(
+            debug_url.substr(strlen(DebugIO::kFileURLScheme)));
+      } else {
+        context->SetStatus(
+            errors::Internal("Unsupported debug URL schema in: ", debug_url));
+      }
+    }
+    OP_REQUIRES_OK(context,
+                   context->GetAttr("tfdbg_context_id", &tfdbg_context_id_));
+    OP_REQUIRES_OK(context, context->GetAttr("op_name", &op_name_));
+    OP_REQUIRES_OK(context, context->GetAttr("output_slot", &output_slot_));
+    OP_REQUIRES_OK(context,
+                   context->GetAttr("tensor_debug_mode", &tensor_debug_mode_));
+    if (context->HasAttr("circular_buffer_size")) {
+      OP_REQUIRES_OK(context, context->GetAttr("circular_buffer_size",
+                                               &circular_buffer_size_));
+    } else {
+      circular_buffer_size_ =
+          tfdbg::DebugEventsWriter::kDefaultCyclicBufferSize;
+    }
+    if (context->HasAttr("tfdbg_run_id")) {
+      OP_REQUIRES_OK(context, context->GetAttr("tfdbg_run_id", &tfdbg_run_id_));
+    }
+  }
+
+  void Compute(OpKernelContext* context) override {
+    const Tensor& tensor = context->input(0);
+    for (const string& dump_root : dump_roots_) {
+      tfdbg::DebugEventsWriter* debug_events_writer =
+          tfdbg::DebugEventsWriter::GetDebugEventsWriter(
+              dump_root, tfdbg_run_id_, circular_buffer_size_);
+      OP_REQUIRES_OK(context, debug_events_writer->WriteGraphExecutionTrace(
+                                  tfdbg_context_id_, device_name_, op_name_,
+                                  output_slot_, tensor_debug_mode_, tensor));
+    }
+    context->set_output(0, tensor);
+  }
+
+ private:
+  std::vector<string> dump_roots_;
+  string tfdbg_context_id_;
+  string device_name_;
+  string op_name_;
+  int32 output_slot_;
+  int32 tensor_debug_mode_;
+  int64_t circular_buffer_size_;
+  string tfdbg_run_id_;
+};
+
+typedef Eigen::ThreadPoolDevice CPUDevice;
+typedef Eigen::GpuDevice GPUDevice;
+
+#if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+template <typename Tin, typename Tout>
+struct CurtHealthLaunch {
+  void Run(const GPUDevice& d, const Tin* data, int size, Tout output[1]);
+};
+
+extern template struct CurtHealthLaunch<Eigen::half, float>;
+extern template struct CurtHealthLaunch<float, float>;
+extern template struct CurtHealthLaunch<double, float>;
+extern template struct CurtHealthLaunch<Eigen::half, double>;
+extern template struct CurtHealthLaunch<float, double>;
+extern template struct CurtHealthLaunch<double, double>;
+
+template <typename Tin, typename Tout>
+struct ConciseHealthLaunch {
+  void Run(const GPUDevice& d, const Tin* data, int size, Tout output[3]);
+};
+
+extern template struct ConciseHealthLaunch<Eigen::half, float>;
+extern template struct ConciseHealthLaunch<float, float>;
+extern template struct ConciseHealthLaunch<double, float>;
+extern template struct ConciseHealthLaunch<Eigen::half, double>;
+extern template struct ConciseHealthLaunch<float, double>;
+extern template struct ConciseHealthLaunch<double, double>;
+
+template <typename Tin, typename Tout>
+struct FullHealthLaunch {
+  void Run(const GPUDevice& d, const Tin* data, int size, Tout output[6]);
+};
+
+extern template struct FullHealthLaunch<Eigen::half, float>;
+extern template struct FullHealthLaunch<float, float>;
+extern template struct FullHealthLaunch<double, float>;
+extern template struct FullHealthLaunch<Eigen::half, double>;
+extern template struct FullHealthLaunch<float, double>;
+extern template struct FullHealthLaunch<double, double>;
+
+template <typename Tin, typename Tout>
+struct ReduceInfNanThreeSlotsLaunch {
+  void Run(const GPUDevice& d, const Tin* data, int size, Tout output[3]);
+};
+
+extern template struct ReduceInfNanThreeSlotsLaunch<Eigen::half, float>;
+extern template struct ReduceInfNanThreeSlotsLaunch<float, float>;
+extern template struct ReduceInfNanThreeSlotsLaunch<double, float>;
+extern template struct ReduceInfNanThreeSlotsLaunch<Eigen::half, double>;
+extern template struct ReduceInfNanThreeSlotsLaunch<float, double>;
+extern template struct ReduceInfNanThreeSlotsLaunch<double, double>;
+
+#endif
+
+template <typename Device, typename Tin, typename Tout>
+class DebugNumericSummaryV2Op;
+
+// Numeric summary op for tfdbg v2: CPU Kernel.
+template <typename Tin, typename Tout>
+class DebugNumericSummaryV2Op<CPUDevice, Tin, Tout> : public OpKernel {
+ public:
+  explicit DebugNumericSummaryV2Op(OpKernelConstruction* context)
+      : OpKernel(context) {
+    OP_REQUIRES_OK(context,
+                   context->GetAttr("tensor_debug_mode", &tensor_debug_mode_));
+    OP_REQUIRES_OK(context, context->GetAttr("tensor_id", &tensor_id_));
+  }
+
+  void Compute(OpKernelContext* context) override {
+    const Tensor& tensor = context->input(0);
+    auto in = tensor.flat<Tin>();
+    const Tin* data = in.data();
+    const int64_t size = in.size();
+    Tensor* output_tensor;
+    Tout tensor_id = static_cast<Tout>(tensor_id_);
+    const Tout num_elem = static_cast<Tout>(context->input(0).NumElements());
+    // Disregard lossy cast if mode is REDUCE_INF_NAN_THREE_SLOTS because
+    // that mode does not make use of tensor_id.
+    if (tensor_debug_mode_ != 8) {
+      OP_REQUIRES(
+          context, tensor_id_ <= kMaxTensorId,
+          errors::InvalidArgument("DebugNumericSummaryV2Op requires "
+                                  "tensor_id to be less than or equal to "
+                                  "(2^",
+                                  std::numeric_limits<Tout>::digits,
+                                  "). Given tensor_id:", tensor_id_));
+    }
+
+    if (tensor_debug_mode_ == 2) {  // CURT_HEALTH
+      TensorShape shape({2});
+      OP_REQUIRES_OK(context,
+                     context->allocate_output(0, shape, &output_tensor));
+      output_tensor->flat<Tout>()(0) = tensor_id;  // Slot tensor id
+      output_tensor->flat<Tout>()(1) = 0.0;        // Has inf or nan
+      int fp_props =
+          std::accumulate(data, data + size, 0, [](const int x, const Tin& y) {
+            return Eigen::numext::isfinite(y) ? x : 1;
+          });
+      if (fp_props) {
+        output_tensor->flat<Tout>()(1) = 1.0;
+      }
+    } else if (tensor_debug_mode_ == 3) {  // CONCISE_HEALTH
+      TensorShape shape({5});
+      OP_REQUIRES_OK(context,
+                     context->allocate_output(0, shape, &output_tensor));
+      output_tensor->flat<Tout>()(0) = tensor_id;
+      output_tensor->flat<Tout>()(1) = num_elem;
+
+      // Accumulator value [neg_inf_count, pos_inf_count, nan_count]
+      Tout fp_props[3] = {0.0, 0.0, 0.0};
+      std::for_each(data, data + size, [&fp_props](const Tin& y) {
+        if (TF_PREDICT_TRUE(Eigen::numext::isfinite(y))) {
+          // Do nothing: common case.
+        } else if (Eigen::numext::isinf(y)) {
+          if (y < static_cast<Tin>(0.f)) {
+            ++fp_props[0];
+          } else {
+            ++fp_props[1];
+          }
+        } else if (Eigen::numext::isnan(y)) {
+          ++fp_props[2];
+        }
+      });
+      output_tensor->flat<Tout>()(2) = fp_props[0];  // Slot for -inf count
+      output_tensor->flat<Tout>()(3) = fp_props[1];  // Slot for inf count
+      output_tensor->flat<Tout>()(4) = fp_props[2];  // Slot for nan count
+    } else if (tensor_debug_mode_ == 4) {            // FULL HEALTH
+      TensorShape shape({11});
+      OP_REQUIRES_OK(context,
+                     context->allocate_output(0, shape, &output_tensor));
+      int num_dims = tensor.dims();
+      output_tensor->flat<Tout>()(0) = tensor_id;
+      output_tensor->flat<Tout>()(1) = -1.0;  // TODO(144919262): Device ID
+      output_tensor->flat<Tout>()(2) = static_cast<Tout>(tensor.dtype());
+      output_tensor->flat<Tout>()(3) = static_cast<Tout>(num_dims);
+      output_tensor->flat<Tout>()(4) = num_elem;
+
+      // Accumulator value [neg_inf_count, pos_inf_count, nan_count, neg_count,
+      //                   zero_count, pos_count]
+      Tout fp_props[6] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
+      std::for_each(data, data + size, [&fp_props](const Tin& y) {
+        if (TF_PREDICT_TRUE(Eigen::numext::isfinite(y))) {
+          if (y < static_cast<Tin>(0.f)) {
+            ++fp_props[3];
+          } else if (y == static_cast<Tin>(0.f)) {
+            ++fp_props[4];
+          } else {
+            ++fp_props[5];
+          }
+        } else if (Eigen::numext::isinf(y)) {
+          if (y < static_cast<Tin>(0.f)) {
+            ++fp_props[0];
+          } else {
+            ++fp_props[1];
+          }
+        } else if (Eigen::numext::isnan(y)) {
+          ++fp_props[2];
+        }
+      });
+      output_tensor->flat<Tout>()(5) = fp_props[0];   // Slot for -inf count
+      output_tensor->flat<Tout>()(6) = fp_props[1];   // Slot for inf count
+      output_tensor->flat<Tout>()(7) = fp_props[2];   // Slot for nan count.
+      output_tensor->flat<Tout>()(8) = fp_props[3];   // Slot for neg count.
+      output_tensor->flat<Tout>()(9) = fp_props[4];   // Slot for zero count.
+      output_tensor->flat<Tout>()(10) = fp_props[5];  // Slot for pos count.
+    } else if (tensor_debug_mode_ == 5) {             // SHAPE
+      TensorShape shape({10});
+      OP_REQUIRES_OK(context,
+                     context->allocate_output(0, shape, &output_tensor));
+
+      int num_dims = tensor.dims();
+      output_tensor->flat<Tout>()(0) = tensor_id;
+      output_tensor->flat<Tout>()(1) = static_cast<Tout>(tensor.dtype());
+      output_tensor->flat<Tout>()(2) = static_cast<Tout>(num_dims);
+      output_tensor->flat<Tout>()(3) = num_elem;
+
+      // Tensor shape - stored as (6 columns)
+      // if num_dim is less than 6, we right pad the shape with zeros
+      // if num_dim is greater than 6, we truncate the head (left most) of the
+      // dimensions as they are more predictable than the last few (e.g. batch
+      // size as first dimension)
+      int dim_idx = 4;
+      for (int i = std::max(0, num_dims - kShapeDims);
+           i < std::max(6, num_dims); ++i) {
+        if (i < num_dims) {
+          output_tensor->flat<Tout>()(dim_idx++) =
+              static_cast<Tout>(tensor.dim_size(i));
+        } else {
+          output_tensor->flat<Tout>()(dim_idx++) = 0.0;
+        }
+      }
+    } else if (tensor_debug_mode_ == 8) {  // REDUCE_INF_NAN_THREE_SLOTS.
+      TensorShape shape({3});
+      OP_REQUIRES_OK(context,
+                     context->allocate_output(0, shape, &output_tensor));
+      output_tensor->flat<Tout>()(0) = 0.0;  // Slot for -inf.
+      output_tensor->flat<Tout>()(1) = 0.0;  // Slot for inf.
+      output_tensor->flat<Tout>()(2) = 0.0;  // Slot for nan.
+
+      int fp_props =
+          std::accumulate(data, data + size, 0, [](const int x, const Tin& y) {
+            int result = x;
+            if (TF_PREDICT_TRUE(Eigen::numext::isfinite(y))) {
+              // Do nothing: common case.
+            } else if (Eigen::numext::isinf(y)) {
+              result |= y < static_cast<Tin>(0.f) ? kNegInfBit : kPosInfBit;
+            } else if (Eigen::numext::isnan(y)) {
+              result |= kNaNBit;
+            }
+            return result;
+          });
+
+      if (fp_props & kNegInfBit) {
+        output_tensor->flat<Tout>()(0) = -std::numeric_limits<Tout>::infinity();
+      }
+      if (fp_props & kPosInfBit) {
+        output_tensor->flat<Tout>()(1) = std::numeric_limits<Tout>::infinity();
+      }
+      if (fp_props & kNaNBit) {
+        output_tensor->flat<Tout>()(2) = std::numeric_limits<Tout>::quiet_NaN();
+      }
+    } else {
+      // TODO(cais): Implement other tensor debug modes in debug_event.proto.
+      context->SetStatus(errors::Unimplemented(
+          "Unimplemented tensor debug mode: ", tensor_debug_mode_));
+    }
+  }
+
+ private:
+  int tensor_debug_mode_;
+  int64_t tensor_id_;
+  static constexpr int kShapeDims = 6;
+  static constexpr int kNegInfBit = 0x01;
+  static constexpr int kPosInfBit = 0x02;
+  static constexpr int kNaNBit = 0x04;
+  static constexpr int64_t kMaxTensorId = 1LL
+                                          << std::numeric_limits<Tout>::digits;
+};
+
+#if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+
+template <typename Tin, typename Tout>
+class DebugNumericSummaryV2Op<GPUDevice, Tin, Tout> : public AsyncOpKernel {
+ public:
+  typedef GPUDevice Device;
+
+  explicit DebugNumericSummaryV2Op(OpKernelConstruction* context)
+      : AsyncOpKernel(context) {
+    OP_REQUIRES_OK(context,
+                   context->GetAttr("tensor_debug_mode", &tensor_debug_mode_));
+    OP_REQUIRES_OK(context, context->GetAttr("tensor_id", &tensor_id_));
+  }
+
+  void ComputeAsync(OpKernelContext* context, DoneCallback done) override {
+    Tensor* output_tensor;
+    Tout tensor_id = static_cast<Tout>(tensor_id_);
+    const Tensor& tensor = context->input(0);
+    const Tout num_elem = static_cast<Tout>(tensor.NumElements());
+    const Device& d = context->eigen_device<Device>();
+    auto input = tensor.flat<Tin>();
+    auto check_cb = [this, done]() { done(); };
+    // Disregard lossy cast if mode is REDUCE_INF_NAN_THREE_SLOTS because
+    // that mode does not make use of tensor_id.
+    if (tensor_debug_mode_ != 8) {
+      OP_REQUIRES_ASYNC(
+          context, tensor_id_ <= kMaxTensorId,
+          errors::InvalidArgument("DebugNumericSummaryV2Op requires "
+                                  "tensor_id to be less than or equal to "
+                                  "(2^",
+                                  std::numeric_limits<Tout>::digits,
+                                  "). Given tensor_id:", tensor_id_),
+          done);
+    }
+
+    if (tensor_debug_mode_ == 2) {  // CURT_HEALTH.
+      TensorShape shape({2});
+      OP_REQUIRES_OK(context,
+                     context->allocate_output(0, shape, &output_tensor));
+
+      auto* stream = context->op_device_context()->stream();
+      OP_REQUIRES_ASYNC(context, stream != nullptr,
+                        errors::Internal("No GPU stream available."), done);
+
+      se::DeviceMemoryBase output_tensor_ptr(
+          output_tensor->flat<Tout>().data(),
+          output_tensor->flat<Tout>().size());
+      stream->ThenMemZero(&output_tensor_ptr, 2 * sizeof(Tout));
+      // Copy tensor_id to slot zero
+      stream->ThenMemcpy(&output_tensor_ptr, &tensor_id, sizeof(Tout));
+      if (num_elem == 0) {
+        done();
+        return;
+      }
+
+      // Call the GPU kernels for the numerical (inf/nan) checks.
+      auto input = context->input(0).flat<Tin>();
+      CurtHealthLaunch<Tin, Tout>().Run(d, input.data(), input.size(),
+                                        output_tensor->flat<Tout>().data() + 1);
+
+      context->device()
+          ->tensorflow_accelerator_device_info()
+          ->event_mgr->ThenExecute(stream, std::move(check_cb));
+    } else if (tensor_debug_mode_ == 3) {  // CONCISE_HEALTH.
+      TensorShape shape({5});
+      OP_REQUIRES_OK(context,
+                     context->allocate_output(0, shape, &output_tensor));
+      OP_REQUIRES_ASYNC(context, !tensorflow::OpDeterminismRequired(),
+                        errors::Unimplemented(
+                            "Determinism is not yet supported for "
+                            "DebugNumericSummaryV2 when tensor_debug_mode is "
+                            "CONCISE_HEALTH."),
+                        done);
+
+      auto* stream = context->op_device_context()->stream();
+      OP_REQUIRES_ASYNC(context, stream != nullptr,
+                        errors::Internal("No GPU stream available."), done);
+
+      se::DeviceMemoryBase output_tensor_ptr(
+          output_tensor->flat<Tout>().data(),
+          output_tensor->flat<Tout>().size());
+      stream->ThenMemset32(&output_tensor_ptr, 0, 5 * sizeof(Tout));
+      const Tout static_output[] = {tensor_id, num_elem};
+      stream->ThenMemcpy(&output_tensor_ptr, &static_output, 2 * sizeof(Tout));
+      if (num_elem == 0) {
+        done();
+        return;
+      }
+
+      // Call the GPU kernels for the numerical (inf/nan) checks.
+      ConciseHealthLaunch<Tin, Tout>().Run(
+          d, input.data(), input.size(),
+          output_tensor->flat<Tout>().data() + 2);
+
+      context->device()
+          ->tensorflow_accelerator_device_info()
+          ->event_mgr->ThenExecute(stream, std::move(check_cb));
+    } else if (tensor_debug_mode_ == 4) {  // FULL HEALTH
+      TensorShape shape({11});
+      OP_REQUIRES_OK(context,
+                     context->allocate_output(0, shape, &output_tensor));
+
+      auto* stream = context->op_device_context()->stream();
+      OP_REQUIRES_ASYNC(context, stream != nullptr,
+                        errors::Internal("No GPU stream available."), done);
+      OP_REQUIRES_ASYNC(context, !tensorflow::OpDeterminismRequired(),
+                        errors::Unimplemented(
+                            "Determinism is not yet supported for "
+                            "DebugNumericSummaryV2 when tensor_debug_mode is "
+                            "FULL_HEALTH."),
+                        done);
+
+      se::DeviceMemoryBase output_tensor_ptr(
+          output_tensor->flat<Tout>().data(),
+          output_tensor->flat<Tout>().size());
+      stream->ThenMemset32(&output_tensor_ptr, 0, 11 * sizeof(Tout));
+
+      int num_dims = tensor.dims();
+      const Tout static_output[] = {tensor_id,
+                                    -1.0,  // TODO(144919262): Device ID
+                                    static_cast<Tout>(tensor.dtype()),
+                                    static_cast<Tout>(num_dims), num_elem};
+      stream->ThenMemcpy(&output_tensor_ptr, &static_output, 5 * sizeof(Tout));
+      if (num_elem == 0) {
+        done();
+        return;
+      }
+
+      // Call the GPU kernels for the numerical (inf/nan) checks and
+      // pos/neg/zero counts.
+      FullHealthLaunch<Tin, Tout>().Run(d, input.data(), input.size(),
+                                        output_tensor->flat<Tout>().data() + 5);
+
+      context->device()
+          ->tensorflow_accelerator_device_info()
+          ->event_mgr->ThenExecute(stream, std::move(check_cb));
+    } else if (tensor_debug_mode_ == 5) {  // SHAPE
+      TensorShape shape({10});
+      OP_REQUIRES_OK(context,
+                     context->allocate_output(0, shape, &output_tensor));
+
+      auto* stream = context->op_device_context()->stream();
+      OP_REQUIRES_ASYNC(context, stream != nullptr,
+                        errors::Internal("No GPU stream available."), done);
+
+      se::DeviceMemoryBase output_tensor_ptr(
+          output_tensor->flat<Tout>().data(),
+          output_tensor->flat<Tout>().size());
+
+      int num_dims = tensor.dims();
+      Tout static_output[10] = {tensor_id,
+                                static_cast<Tout>(tensor.dtype()),
+                                static_cast<Tout>(num_dims),
+                                num_elem,
+                                0.0,
+                                0.0,
+                                0.0,
+                                0.0,
+                                0.0,
+                                0.0};
+      // Tensor shape: right pad zeros, truncate head
+      int dim_idx = 4;
+      for (int i = std::max(0, num_dims - 6); i < num_dims; ++i) {
+        static_output[dim_idx++] = static_cast<Tout>(tensor.dim_size(i));
+      }
+      // Write to device stream
+      stream->ThenMemcpy(&output_tensor_ptr, &static_output, sizeof(Tout) * 10);
+      context->device()
+          ->tensorflow_accelerator_device_info()
+          ->event_mgr->ThenExecute(stream, std::move(check_cb));
+    } else if (tensor_debug_mode_ == 8) {  // REDUCE_INF_NAN_THREE_SLOTS.
+      TensorShape shape({3});
+      OP_REQUIRES_OK(context,
+                     context->allocate_output(0, shape, &output_tensor));
+
+      auto* stream = context->op_device_context()->stream();
+      OP_REQUIRES_ASYNC(context, stream != nullptr,
+                        errors::Internal("No GPU stream available."), done);
+
+      se::DeviceMemoryBase output_tensor_ptr(
+          output_tensor->flat<Tout>().data(),
+          output_tensor->flat<Tout>().size());
+      stream->ThenMemset32(&output_tensor_ptr, 0,
+                           output_tensor->flat<Tout>().size() * sizeof(Tout));
+      if (num_elem == 0) {
+        done();
+        return;
+      }
+
+      // Call the GPU kernels for the numerical (inf/nan) checks.
+      auto input = context->input(0).flat<Tin>();
+      ReduceInfNanThreeSlotsLaunch<Tin, Tout>().Run(
+          d, input.data(), input.size(), output_tensor->flat<Tout>().data());
+
+      context->device()
+          ->tensorflow_accelerator_device_info()
+          ->event_mgr->ThenExecute(stream, std::move(check_cb));
+    } else {
+      // TODO(cais): Implement other tensor debug modes in debug_event.proto.
+      context->SetStatus(errors::Unimplemented(
+          "Unimplemented tensor debug mode: ", tensor_debug_mode_));
+      done();
+    }
+  }
+
+ private:
+  int tensor_debug_mode_;
+  int64_t tensor_id_;
+  static constexpr int64_t kMaxTensorId = 1L
+                                          << std::numeric_limits<Tout>::digits;
+};
+
+#endif  // GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_DEBUG_OPS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/deep_conv2d.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/deep_conv2d.h
new file mode 100644
index 0000000000000000000000000000000000000000..c484db38dbd9543e5be3b07c8eccdba89eeb3121
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/deep_conv2d.h
@@ -0,0 +1,117 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_DEEP_CONV2D_H_
+#define TENSORFLOW_CORE_KERNELS_DEEP_CONV2D_H_
+
+#include "tensorflow/core/framework/types.h"
+
+namespace tensorflow {
+
+class OpKernelContext;
+
+// DeepConv2D is a Conv2D implementation specialized for deep (i.e. large
+// in_depth * out_depth product) convolutions (see deep_conv2d.cc for details).
+
+// DeepConv2DTransform is an interface for implementing transforms for
+// DeepConv2D. Implementations must specify transform matrices and
+// input/output/filter shapes. DeepConv2d computes:
+//
+//   y = C[Ad * Bg]
+//
+//   C: output transform matrix
+//   A: input data transform matrix
+//   B: filter transform matrix
+//   d: vectorized 2D data tile
+//   g: vectorized 2D filter tile
+//   y: vectorized 2D output tile
+
+template <typename T>
+class DeepConv2DTransform {
+ public:
+  virtual ~DeepConv2DTransform() {}
+
+  virtual void GetFilterTransformMatrix(const int64_t rows, const int64_t cols,
+                                        T* transform_matrix) const = 0;
+
+  virtual void GetInputTransformMatrix(const int64_t rows, const int64_t cols,
+                                       T* transform_matrix) const = 0;
+
+  virtual void GetOutputTransformMatrix(const int64_t rows, const int64_t cols,
+                                        T* transform_matrix) const = 0;
+
+  struct Shape {
+    Shape(int64_t r, int64_t c) : rows(r), cols(c) {}
+    int64_t rows;
+    int64_t cols;
+  };
+
+  virtual const Shape& filter_shape() const = 0;
+  virtual const Shape& input_shape() const = 0;
+  virtual const Shape& output_shape() const = 0;
+};
+
+// Conv2D arguments used by DeepConv2D implementation.
+struct Conv2DArgs {
+  // Input layer dimensions
+  int batch;
+  int in_rows;
+  int in_cols;
+  int in_depth;
+  int filter_rows;
+  int filter_cols;
+  int pad_rows;
+  int pad_cols;
+
+  // Output layer dimensions
+  int out_rows;
+  int out_cols;
+  int out_depth;
+
+  Conv2DArgs()
+      : batch(0),
+        in_rows(0),
+        in_cols(0),
+        in_depth(0),
+        filter_rows(0),
+        filter_cols(0),
+        pad_rows(0),
+        pad_cols(0),
+        out_rows(0),
+        out_cols(0),
+        out_depth(0) {}
+};
+
+// Returns true if convolution operation specified by function arguments
+// can use DeepConv2D implementation, and false otherwise.
+// May return false based on parameters, cost, or whether feature is disabled.
+bool CanUseDeepConv2D(int stride_rows, int stride_cols, int filter_rows,
+                      int filter_cols, int in_depth, int out_depth,
+                      int out_rows, int out_cols);
+
+namespace functor {
+
+// Calls DeepConv2D implementation (see deep_conv2d.cc for details).
+template <typename Device, typename T>
+struct DeepConv2D {
+  void operator()(OpKernelContext* ctx, const Conv2DArgs& args, const T* input,
+                  const T* filter, T* output);
+};
+
+}  // namespace functor
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_DEEP_CONV2D_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/dense_update_functor.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/dense_update_functor.h
new file mode 100644
index 0000000000000000000000000000000000000000..77087957cbecf16c5a31879dc0ef18b1484db53c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/dense_update_functor.h
@@ -0,0 +1,80 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_DENSE_UPDATE_FUNCTOR_H_
+#define TENSORFLOW_CORE_KERNELS_DENSE_UPDATE_FUNCTOR_H_
+
+#define EIGEN_USE_THREADS
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/tensor_types.h"
+
+namespace tensorflow {
+
+typedef Eigen::ThreadPoolDevice CPUDevice;
+typedef Eigen::GpuDevice GPUDevice;
+
+
+enum DenseUpdateType { ADD, SUB, ASSIGN };
+
+namespace functor {
+
+template <typename Device, typename T, DenseUpdateType OP>
+struct DenseUpdate {
+  void operator()(const Device& d, typename TTypes<T>::Flat params,
+                  typename TTypes<T>::ConstFlat update);
+};
+
+template <typename T>
+struct DenseUpdate<CPUDevice, T, ADD> {
+  void operator()(const CPUDevice& d, typename TTypes<T>::Flat params,
+                  typename TTypes<T>::ConstFlat update) {
+    params.device(d) += update;
+  }
+};
+
+template <typename T>
+struct DenseUpdate<CPUDevice, T, SUB> {
+  void operator()(const CPUDevice& d, typename TTypes<T>::Flat params,
+                  typename TTypes<T>::ConstFlat update) {
+    params.device(d) -= update;
+  }
+};
+
+template <typename T>
+struct DenseUpdate<CPUDevice, T, ASSIGN> {
+  void operator()(const CPUDevice& d, typename TTypes<T>::Flat params,
+                  typename TTypes<T>::ConstFlat update) {
+    params.device(d) = update;
+  }
+};
+
+
+}  // end namespace functor
+
+template <typename Device>
+Status VariantCopyFn(OpKernelContext* context, const Tensor& from, Tensor* to);
+
+template <>
+Status VariantCopyFn<CPUDevice>(OpKernelContext* context, const Tensor& from,
+                                Tensor* to);
+template <>
+Status VariantCopyFn<GPUDevice>(OpKernelContext* context, const Tensor& from,
+                                Tensor* to);
+
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_DENSE_UPDATE_FUNCTOR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/depthtospace_op.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/depthtospace_op.h
new file mode 100644
index 0000000000000000000000000000000000000000..63dba5d0d5fc7c4f14c39c2fdeab70d86b3dd60f
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/depthtospace_op.h
@@ -0,0 +1,56 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_DEPTHTOSPACE_OP_H_
+#define TENSORFLOW_CORE_KERNELS_DEPTHTOSPACE_OP_H_
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/framework/tensor_types.h"
+#include "tensorflow/core/util/tensor_format.h"
+
+namespace tensorflow {
+namespace functor {
+
+// Functor used by DepthToSpaceOp to do the computations.
+// Implements a family of Depth to Space transforms for a 4D 'input' tensor
+// to a 4D 'output' tensor, both tensors use type 'T' and layout 'data_format'.
+// These transforms multiply the vertical and horizontal image sizes by
+// 'block_size', and divide the depth dimension by (block_size * block_size)
+// which must divide evenly.
+// Each pixel in the input image is converted to a square block of pixels in
+// the output image. The Y, X coordinates within each block comes from the
+// high component of the input depth (channel) index.
+// e.g. for data_format = NHWC:
+//      Each element in the input tensor can be specified via 6 coordinates,
+//      ordered by decreasing memory layout significance as:
+//      n,iY,iX,bY,bX,oC  (where n=batch index, iX, iY means X or Y coordinates
+//                         within the input image, bX, bY means coordinates
+//                         within the output block, oC means output channel).
+//      The output would be a transpose to the following layout:
+//      n,iY,bY,iX,bX,oC
+template <typename Device, typename T, TensorFormat data_format>
+struct DepthToSpaceOpFunctor {
+  void operator()(const Device& d, typename TTypes<T, 4>::ConstTensor input,
+                  int block_size, typename TTypes<T, 4>::Tensor output);
+
+  // This 5-D version is to support NCHW_VECT_C.
+  void operator()(const Device& d, typename TTypes<T, 5>::ConstTensor input,
+                  int block_size, typename TTypes<T, 5>::Tensor output);
+};
+
+}  // namespace functor
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_DEPTHTOSPACE_OP_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/depthwise_conv_op.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/depthwise_conv_op.h
new file mode 100644
index 0000000000000000000000000000000000000000..1114caab7b99bb69d40ede5a1fde8ac3007aecad
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/depthwise_conv_op.h
@@ -0,0 +1,352 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_DEPTHWISE_CONV_OP_H_
+#define TENSORFLOW_CORE_KERNELS_DEPTHWISE_CONV_OP_H_
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/util/tensor_format.h"
+
+#if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+#include "tensorflow/core/platform/stream_executor.h"
+#endif  // GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+
+namespace tensorflow {
+
+struct DepthwiseArgs {
+  // Input layer dimensions
+  int batch;
+  int in_rows;
+  int in_cols;
+  int in_depth;
+  int filter_rows;
+  int filter_cols;
+  int depth_multiplier;
+  int stride;
+  int pad_rows;  // Amount of padding to the top of the input
+  int pad_cols;  // Amount of padding to the left of the input
+
+  // Output layer dimensions
+  int out_rows;
+  int out_cols;
+  int out_depth;
+
+  DepthwiseArgs()
+      : batch(0),
+        in_rows(0),
+        in_cols(0),
+        in_depth(0),
+        filter_rows(0),
+        filter_cols(0),
+        depth_multiplier(0),
+        stride(0),
+        pad_rows(0),
+        pad_cols(0),
+        out_rows(0),
+        out_cols(0),
+        out_depth(0) {}
+};
+
+// Forward declaration.
+class OpKernelContext;
+
+template <typename Device, typename T>
+struct LaunchDepthwiseConvOp {
+  void operator()(OpKernelContext* ctx, const DepthwiseArgs& args,
+                  const T* input, const T* filter, T* output,
+                  TensorFormat data_format);
+};
+
+template <typename Device, typename T>
+struct LaunchDepthwiseConvBackpropInputOp {
+  void operator()(OpKernelContext* ctx, const DepthwiseArgs& args,
+                  const T* out_backprop, const T* filter, T* in_backprop,
+                  TensorFormat data_format);
+};
+
+template <typename Device, typename T>
+struct LaunchDepthwiseConvBackpropFilterOp {
+  void operator()(OpKernelContext* ctx, const DepthwiseArgs& args,
+                  const T* out_backprop, const T* input, T* filter_backprop,
+                  TensorFormat data_format);
+};
+
+bool UseCudnnWith16BitFloat(OpKernelContext* ctx, DataType dtype);
+
+#if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+template <typename T>
+struct LaunchDepthwiseConvOp<Eigen::GpuDevice, T> {
+  void operator()(OpKernelContext* ctx, const DepthwiseArgs& args,
+                  const T* input, const T* filter, T* output,
+                  TensorFormat data_format);
+};
+
+template <typename T>
+struct LaunchDepthwiseConvBackpropInputOp<Eigen::GpuDevice, T> {
+  void operator()(class OpKernelContext* ctx, const DepthwiseArgs& args,
+                  const T* out_backprop, const T* filter, T* in_backprop,
+                  TensorFormat data_format);
+};
+
+template <typename T>
+struct LaunchDepthwiseConvBackpropFilterOp<Eigen::GpuDevice, T> {
+  void operator()(class OpKernelContext* ctx, const DepthwiseArgs& args,
+                  const T* out_backprop, const T* input, T* filter_backprop,
+                  TensorFormat data_format);
+};
+#endif  // GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+
+}  // namespace tensorflow
+
+namespace tensorflow {
+namespace functor {
+
+// Pads 'filter' to vector-register boundary along its inner dimension:
+//   filter_inner_dim_size = in_depth * depth_multiplier
+// Requires 'filter' to have the following storage order:
+//   [filter_rows, filter_cols, in_depth, depth_multiplier]
+// Returns zero-padded filter in 'padded_filter'.
+//
+// EX:
+//   in_depth = 3, depth_multiplier = 2, filter [2, 2], register_width = 4
+//   So we have a total of 3 * 2 = 6 filters, each of spatial size 2 x 2.
+//
+//   filter [rows, cols, in_depth, depth_multiplier]
+//     [u0, v0, w0, x0] [y0, z0, u1, v1] [w1, x1, y1, z1]
+//     [u2, v2, w2, x2] [y2, z2, u3, v3] [w3, x3, y3, z3]
+//
+//   padded_filter [rows, cols, in_depth, depth_multiplier]
+//     [u0, v0, w0, x0] [y0, z0, 0, 0] [u1, v1, w1, x1] [y1, z1, 0, 0]
+//     [u2, v2, w2, x2] [y2, z2, 0, 0] [u3, v3, w3, x3] [y3, z3, 0, 0]
+
+template <typename T>
+struct DepthwiseFilterPadOp {
+  void operator()(const DepthwiseArgs& args, const T* filter,
+                  T* padded_filter) {
+    typedef typename Eigen::internal::packet_traits<T>::type Packet;
+    static const int64_t kPacketSize = (sizeof(Packet) / sizeof(T));
+
+    // Calculate vectorized and scalar lengths of filter's inner dimension.
+    const int64_t filter_inner_dim_size = args.out_depth;
+    const int64_t vectorized_size =
+        (filter_inner_dim_size / kPacketSize) * kPacketSize;
+    const int64_t scalar_size = filter_inner_dim_size - vectorized_size;
+    // Calculate required padding and padded output buffer stride.
+    const int64_t pad_size = scalar_size > 0 ? kPacketSize - scalar_size : 0;
+    const int64_t padded_filter_stride = vectorized_size + kPacketSize;
+
+    const int64_t filter_spatial_size = args.filter_rows * args.filter_cols;
+    for (int64_t i = 0; i < filter_spatial_size; ++i) {
+      const int64_t input_base = i * filter_inner_dim_size;
+      const int64_t output_base = i * padded_filter_stride;
+      // Write vectorized length of filter's inner dimension to output.
+      for (int64_t j = 0; j < vectorized_size; j += kPacketSize) {
+        const auto v = Eigen::internal::ploadu<Packet>(filter + input_base + j);
+        Eigen::internal::pstoreu<T>(padded_filter + output_base + j, v);
+      }
+      // Write scalar length of filter's inner dimension to output.
+      for (int64_t j = 0; j < scalar_size; ++j) {
+        padded_filter[output_base + vectorized_size + j] =
+            filter[input_base + vectorized_size + j];
+      }
+      // Pad the remainder of output to vector-register boundary.
+      for (int64_t j = 0; j < pad_size; ++j) {
+        padded_filter[output_base + vectorized_size + scalar_size + j] =
+            static_cast<T>(0);
+      }
+    }
+  }
+};
+
+// Copies data from local region in 'input' specified by 'out_r' and 'out_'c'
+// to 'input_buffer'. The copied data is replicated by factor
+// 'args.depth_multiplier', and padded to vector register-width boundaries so
+// that it is aligned for efficient traversal and vector multiply-add by the
+// depthwise kernel.
+//
+// EX:
+//   in_depth = 3, depth_multiplier = 2, filter [2, 2], register_width = 4
+//
+//   input: [batch, in_rows, in_cols, in_depth]
+//
+//     [a0, a1, a2, b0, b1, b2, ..., e0, e1, e2, f0, f1, f2, ...]
+//
+//   input_buffer (register boundaries shown):
+//     [a0, a0, a1, a1] [a2, a2, 0, 0]   in_row = 0, in_col = 0
+//     [b0, b0, b1, b1] [b2, b2, 0, 0]   in_row = 0, in_col = 1
+//     [e0, e0, e1, e1] [e2, e2, 0, 0]   in_row = 1, in_col = 0
+//     [f0, f0, f1, f1] [f2, f2, 0, 0]   in_row = 1, in_col = 1
+//
+// Returns replicated and padded data from specified input region in
+// 'input_buffer'.
+
+template <typename T>
+struct DepthwiseInputCopyOp {
+  void operator()(const DepthwiseArgs& args,
+                  const int64_t padded_filter_inner_dim_size,
+                  const int64_t out_r, const int64_t out_c, const T* input,
+                  T* input_buffer) {
+    typedef typename Eigen::internal::packet_traits<T>::type Packet;
+    static const int64_t kPacketSize = Eigen::internal::packet_traits<T>::size;
+
+    const int64_t kDepth = args.depth_multiplier;
+    // Calculate vectorized and scalar (residual) lengths for 'in_depth'.
+    const int64_t input_vectorized_size =
+        (args.in_depth / kPacketSize) * kPacketSize;
+    const int64_t input_scalar_size = args.in_depth - input_vectorized_size;
+
+    // Calculate output padding length.
+    const int64_t output_scalar_size = args.out_depth % kPacketSize;
+    const int64_t output_pad_size =
+        output_scalar_size > 0 ? kPacketSize - output_scalar_size : 0;
+
+    // Iterate through all rows x cols reading 'in_depth' from 'input' and
+    // replicating by 'depth_multiplier' into 'input_buffer' (otherwise
+    // zero-padding input buffer as needed).
+    auto* in_buf = input_buffer;
+    const int64_t in_r_start = out_r * args.stride - args.pad_rows;
+    const int64_t in_c_start = out_c * args.stride - args.pad_cols;
+
+    // TODO: add a ploaddup variant for depth == 2 if needed.
+    if (kDepth > 1 && kDepth <= kPacketSize) {
+      for (int64_t f_r = 0; f_r < args.filter_rows; ++f_r) {
+        const int64_t in_r = in_r_start + f_r;
+
+        for (int64_t f_c = 0; f_c < args.filter_cols; ++f_c) {
+          const int64_t in_c = in_c_start + f_c;
+
+          if (in_r >= 0 && in_r < args.in_rows && in_c >= 0 &&
+              in_c < args.in_cols) {
+            const auto* in =
+                input + (in_r * args.in_cols + in_c) * args.in_depth;
+            int64_t limit = args.in_depth;
+            // This will overwrite up to kPacketSize next elements,
+            // this is ok on all iterations except the last one, since
+            // we will write correct values on a next iteration.
+            if (f_c == args.filter_cols - 1) {
+              limit -= (kPacketSize - kDepth) / kDepth + 1;
+              if (limit < 0) {
+                limit = 0;
+              }
+            }
+            // Copy vectorized portion of inner dimension.
+            for (int64_t d = 0; d < limit; d++) {
+              const auto p = Eigen::internal::pset1<Packet>(in[d]);
+              Eigen::internal::pstoreu<T>(in_buf, p);
+              in_buf += kDepth;
+            }
+
+            // Copy the scalar portion.
+            for (int64_t d = limit; d < args.in_depth; d++) {
+              const auto value = in[d];
+              for (int64_t dm = 0; dm < kDepth; dm++) {
+                in_buf[dm] = value;
+              }
+              in_buf += kDepth;
+            }
+
+            // Pad the remainder of the output to vector register boundary.
+            for (int64_t d = 0; d < output_pad_size; ++d) {
+              in_buf[d] = static_cast<T>(0);
+            }
+            in_buf += output_pad_size;
+          } else {
+            // Zero pad.
+            memset(in_buf, 0, sizeof(T) * padded_filter_inner_dim_size);
+            in_buf += padded_filter_inner_dim_size;
+          }
+        }
+      }
+    } else if (kDepth > kPacketSize) {
+      // Calculate vectorized and scalar (residual) lengths for
+      // 'depth_multiplier'. This is used to efficiently replicate data for
+      // when 'depth_multiplier' > kPacketSize.
+      const int64_t dm_vectorized_size = (kDepth / kPacketSize) * kPacketSize;
+
+      for (int64_t f_r = 0; f_r < args.filter_rows; ++f_r) {
+        const int64_t in_r = in_r_start + f_r;
+
+        for (int64_t f_c = 0; f_c < args.filter_cols; ++f_c) {
+          const int64_t in_c = in_c_start + f_c;
+
+          if (in_r >= 0 && in_r < args.in_rows && in_c >= 0 &&
+              in_c < args.in_cols) {
+            const auto* in =
+                input + (in_r * args.in_cols + in_c) * args.in_depth;
+            // Copy vectorized portion of inner dimension.
+            for (int64_t d = 0; d < args.in_depth; d++) {
+              const auto p = Eigen::internal::pset1<Packet>(in[d]);
+              for (int64_t dm = 0; dm < dm_vectorized_size; dm += kPacketSize) {
+                Eigen::internal::pstoreu<T>(in_buf + dm, p);
+              }
+              // Overlapping store for the remainder.
+              Eigen::internal::pstoreu<T>(in_buf + kDepth - kPacketSize, p);
+              in_buf += kDepth;
+            }
+            // Pad the remainder of the output to vector register boundary.
+            for (int64_t d = 0; d < output_pad_size; ++d) {
+              in_buf[d] = static_cast<T>(0);
+            }
+            in_buf += output_pad_size;
+          } else {
+            // Zero pad.
+            memset(in_buf, 0, sizeof(T) * padded_filter_inner_dim_size);
+            in_buf += padded_filter_inner_dim_size;
+          }
+        }
+      }
+    } else if (kDepth == 1) {
+      for (int64_t f_r = 0; f_r < args.filter_rows; ++f_r) {
+        const int64_t in_r = in_r_start + f_r;
+
+        for (int64_t f_c = 0; f_c < args.filter_cols; ++f_c) {
+          const int64_t in_c = in_c_start + f_c;
+
+          if (in_r >= 0 && in_r < args.in_rows && in_c >= 0 &&
+              in_c < args.in_cols) {
+            const auto* in =
+                input + (in_r * args.in_cols + in_c) * args.in_depth;
+            for (int64_t d = 0; d < input_vectorized_size; d += kPacketSize) {
+              const auto p = Eigen::internal::ploadu<Packet>(in + d);
+              Eigen::internal::pstoreu<T>(in_buf, p);
+              in_buf += kPacketSize;
+            }
+            for (int64_t d = 0; d < input_scalar_size; ++d) {
+              T v = in[input_vectorized_size + d];
+              in_buf[d] = v;
+            }
+            in_buf += input_scalar_size;
+
+            // Pad the remainder of the output to vector register boundary.
+            for (int64_t d = 0; d < output_pad_size; ++d) {
+              in_buf[d] = static_cast<T>(0);
+            }
+            in_buf += output_pad_size;
+          } else {
+            // Zero pad.
+            memset(in_buf, 0, sizeof(T) * padded_filter_inner_dim_size);
+            in_buf += padded_filter_inner_dim_size;
+          }
+        }
+      }
+    }
+  }
+};
+
+}  // namespace functor
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_DEPTHWISE_CONV_OP_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/depthwise_conv_op_gpu.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/depthwise_conv_op_gpu.h
new file mode 100644
index 0000000000000000000000000000000000000000..a4c5a178016ba346ffbe09f8809a57fe9759edd8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/depthwise_conv_op_gpu.h
@@ -0,0 +1,1758 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_DEPTHWISE_CONV_OP_GPU_H_
+#define TENSORFLOW_CORE_KERNELS_DEPTHWISE_CONV_OP_GPU_H_
+
+#if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+#define EIGEN_USE_GPU
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/kernels/depthwise_conv_op.h"
+#include "tensorflow/core/kernels/gpu_prim.h"
+#include "tensorflow/core/platform/types.h"
+#include "tensorflow/core/util/determinism.h"
+#include "tensorflow/core/util/gpu_kernel_helper.h"
+#include "tensorflow/core/util/tensor_format.h"
+
+#if defined(_MSC_VER) && !defined(__clang__)
+#define UNROLL
+#define NOUNROLL
+#else
+#define UNROLL _Pragma("unroll")
+#define NOUNROLL _Pragma("nounroll")
+#endif
+
+namespace tensorflow {
+
+namespace detail {
+template <typename T>
+struct PseudoHalfType {
+  using Type = T;
+};
+template <>
+struct PseudoHalfType<Eigen::half> {
+  using Type = float;
+};
+template <>
+struct PseudoHalfType<Eigen::bfloat16> {
+  using Type = float;
+};
+}  // namespace detail
+
+using Eigen::GpuDevice;
+
+// Returns whether depthwise convolution forward or backward input pass can be
+// performed using the faster ('Small') variant of the kernel.
+inline EIGEN_DEVICE_FUNC bool CanLaunchDepthwiseConv2dGPUSmall(
+    const DepthwiseArgs& args) {
+  return args.depth_multiplier == 1 && args.stride == 1 && args.in_rows <= 32 &&
+         args.in_cols <= 32 && args.in_rows == args.out_rows &&
+         args.in_cols == args.out_cols && args.pad_rows >= 0 &&
+         args.pad_rows < args.filter_rows && args.pad_cols >= 0 &&
+         args.pad_cols < args.filter_cols &&
+         args.filter_rows * args.filter_cols <=
+             (args.in_rows + 1) / 2 * args.in_cols;
+}
+
+// Returns whether depthwise convolution backward filter pass can be performed
+// using the faster ('Small') variant of the kernel.
+inline EIGEN_DEVICE_FUNC bool CanLaunchDepthwiseConv2dBackpropFilterGPUSmall(
+    const DepthwiseArgs& args, const int block_height) {
+  return args.depth_multiplier == 1 && args.stride == 1 && args.in_rows <= 32 &&
+         args.in_cols <= 32 && args.in_rows == args.out_rows &&
+         args.in_cols == args.out_cols && args.pad_rows >= 0 &&
+         args.pad_rows < args.filter_rows && args.pad_cols >= 0 &&
+         args.pad_cols < args.filter_cols && block_height <= args.in_rows &&
+         args.filter_rows * args.filter_cols <= args.in_cols * block_height;
+}
+
+// The DepthwiseConv2dGPUKernels perform either forward or backprop input
+// convolution depending on a template argument of this enum.
+enum DepthwiseConv2dDirection { DIRECTION_FORWARD, DIRECTION_BACKWARD };
+
+// A GPU kernel to compute the depthwise convolution forward pass
+// in NHWC format.
+template <typename T, int kKnownFilterWidth, int kKnownFilterHeight,
+          int kKnownDepthMultiplier>
+__global__ void __launch_bounds__(1024, 2)
+    DepthwiseConv2dGPUKernelNHWC(const DepthwiseArgs args,
+                                 const T* __restrict__ input,
+                                 const T* __restrict__ filter,
+                                 T* __restrict__ output, int num_outputs) {
+  typedef typename detail::PseudoHalfType<T>::Type S;
+  const int in_height = args.in_rows;
+  const int in_width = args.in_cols;
+  const int in_depth = args.in_depth;
+  const int filter_height =
+      kKnownFilterHeight < 0 ? args.filter_rows : kKnownFilterHeight;
+  const int filter_width =
+      kKnownFilterWidth < 0 ? args.filter_cols : kKnownFilterWidth;
+  const int depth_multiplier =
+      kKnownDepthMultiplier < 0 ? args.depth_multiplier : kKnownDepthMultiplier;
+  const int stride = args.stride;
+  const int pad_height = args.pad_rows;
+  const int pad_width = args.pad_cols;
+  const int out_height = args.out_rows;
+  const int out_width = args.out_cols;
+  const int out_depth = args.out_depth;
+
+  GPU_1D_KERNEL_LOOP(thread_id, num_outputs) {
+    // Compute the indexes of this thread in the output.
+    const int out_channel = thread_id % out_depth;
+    const int out_col = (thread_id / out_depth) % out_width;
+    const int out_row = (thread_id / out_depth / out_width) % out_height;
+    const int batch = thread_id / out_depth / out_width / out_height;
+    // Compute the input depth and the index of depth multiplier.
+    const int in_channel = out_channel / depth_multiplier;
+    const int multiplier = out_channel % depth_multiplier;
+
+    // Decide if all input is valid, if yes, we can skip the boundary checks
+    // for each input.
+    const int input_row_start = out_row * stride - pad_height;
+    const int input_col_start = out_col * stride - pad_width;
+    const int input_row_end = input_row_start + filter_height;
+    const int input_col_end = input_col_start + filter_width;
+
+    S sum = static_cast<S>(0);
+
+    const int input_offset_temp = in_height * batch;
+    if (input_row_start >= 0 && input_col_start >= 0 &&
+        input_row_end < in_height && input_col_end < in_width) {
+      UNROLL for (int filter_row = 0; filter_row < filter_height;
+                  ++filter_row) {
+        const int in_row = input_row_start + filter_row;
+        const int filter_offset_temp = filter_width * filter_row;
+        UNROLL for (int filter_col = 0; filter_col < filter_width;
+                    ++filter_col) {
+          const int in_col = input_col_start + filter_col;
+
+          const int input_offset =
+              in_channel +
+              in_depth * (in_col + in_width * (in_row + input_offset_temp));
+          const int filter_offset =
+              multiplier +
+              depth_multiplier *
+                  (in_channel + in_depth * (filter_col + filter_offset_temp));
+          sum += static_cast<S>(ldg(input + input_offset)) *
+                 static_cast<S>(ldg(filter + filter_offset));
+        }
+      }
+    } else {
+      UNROLL for (int filter_row = 0; filter_row < filter_height;
+                  ++filter_row) {
+        const int in_row = input_row_start + filter_row;
+        const int filter_offset_temp = filter_width * filter_row;
+        UNROLL for (int filter_col = 0; filter_col < filter_width;
+                    ++filter_col) {
+          const int in_col = input_col_start + filter_col;
+          if (in_row >= 0 && in_row < in_height && in_col >= 0 &&
+              in_col < in_width) {
+            const int in_col = input_col_start + filter_col;
+
+            const int input_offset =
+                in_channel +
+                in_depth * (in_col + in_width * (in_row + input_offset_temp));
+            const int filter_offset =
+                multiplier +
+                depth_multiplier *
+                    (in_channel + in_depth * (filter_col + filter_offset_temp));
+            sum += static_cast<S>(ldg(input + input_offset)) *
+                   static_cast<S>(ldg(filter + filter_offset));
+          }
+        }
+      }
+    }
+    output[thread_id] = static_cast<T>(sum);
+  }
+}
+
+// CUDA kernel to compute the depthwise convolution forward pass in NHWC format,
+// tailored for small images up to 32x32. Stride and depth multiplier must be 1.
+// Padding must be 'SAME', which allows to reuse the index computation. Only
+// use this kernel if CanLaunchDepthwiseConv2dGPUSmall(args) returns true.
+// Tiles of the input and filter tensors are loaded into shared memory before
+// performing the convolution. Each thread handles two elements per iteration,
+// one each in the lower and upper half of a tile.
+// Backprop input direction is the same as forward direction with the filter
+// rotated by 180°.
+// T is the tensors' data type. S is the math type the kernel uses. This is the
+// same as T for all cases but pseudo half (which has T=Eigen::half, S=float).
+template <typename T, DepthwiseConv2dDirection kDirection,
+          int kKnownFilterWidth, int kKnownFilterHeight, int kBlockDepth,
+          bool kKnownEvenHeight>
+__global__ __launch_bounds__(1024, 2) void DepthwiseConv2dGPUKernelNHWCSmall(
+    const DepthwiseArgs args, const T* __restrict__ input,
+    const T* __restrict__ filter, T* __restrict__ output) {
+  typedef typename detail::PseudoHalfType<T>::Type S;
+  assert(CanLaunchDepthwiseConv2dGPUSmall(args));
+  // Holds block plus halo and filter data for blockDim.x depths.
+  GPU_DYNAMIC_SHARED_MEM_DECL(8, unsigned char, shared_memory);
+  static_assert(sizeof(S) <= 8, "Insufficient alignment detected");
+  S* const shared_data = reinterpret_cast<S*>(shared_memory);
+
+  const int num_batches = args.batch;
+  const int in_height = args.in_rows;
+  const int in_width = args.in_cols;
+  const int in_depth = args.in_depth;
+  const int filter_height =
+      kKnownFilterHeight < 0 ? args.filter_rows : kKnownFilterHeight;
+  const int filter_width =
+      kKnownFilterWidth < 0 ? args.filter_cols : kKnownFilterWidth;
+  const int pad_height = args.pad_rows;
+  const int pad_width = args.pad_cols;
+
+  assert(blockDim.x == kBlockDepth);
+  assert(blockDim.y == args.in_cols);
+  const int block_height = blockDim.z;
+
+  // These values are the same for all threads and could
+  // be precomputed on the CPU.
+  const int block_size = block_height * in_width * kBlockDepth;
+  const int in_row_size = in_width * in_depth;
+  const int in_size = in_height * in_row_size;
+  const int in_increment = (in_width - 1) * kBlockDepth;
+  const int filter_pixels = filter_height * filter_width;
+  const int tile_width = in_width + filter_width - 1;
+  const int even_height = kKnownEvenHeight || (1 & ~in_height);
+  const int tile_height = in_height + filter_height - even_height;
+  const int tile_row_size = tile_width * kBlockDepth;
+  const int tile_size = tile_height * tile_row_size;
+  const int tile_offset = block_height * tile_row_size;
+  const int pad_offset = pad_height * tile_width + pad_width;
+  const int batch_blocks = (in_depth + kBlockDepth - 1) / kBlockDepth;
+  const int in_blocks = batch_blocks * num_batches;
+  const int tensor_offset =
+      kKnownEvenHeight ? in_size / 2 : block_height * in_row_size;
+
+  const int thread_depth = threadIdx.x;
+  const int thread_col = threadIdx.y;
+  const int thread_row = threadIdx.z;
+
+  // Position in block.
+  const int thread_pix = thread_row * in_width + thread_col;
+  const int thread_idx = thread_pix * kBlockDepth + thread_depth;
+
+  // Initialize tile, in particular the padding.
+  for (int i = thread_idx; i < tile_size; i += block_size) {
+    shared_data[i] = S();
+  }
+  __syncthreads();
+
+  // Position in tensors.
+  const int tensor_idx = thread_pix * in_depth + thread_depth;
+
+  // Position in (padded) shared memory.
+  const int data_pix = thread_row * tile_width + thread_col;
+  const int data_idx = data_pix * kBlockDepth + thread_depth;
+
+  // Position in shared memory, offset by pad_height / pad_width.
+  const int tile_pix = data_pix + pad_offset;
+  const int tile_idx = tile_pix * kBlockDepth + thread_depth;
+
+  const int max_channel = in_depth - thread_depth;
+  const int filter_write_offset =
+      thread_pix < filter_pixels ? tile_size + thread_idx : 0;
+  const int filter_read_offset =
+      tile_size + thread_depth +
+      (kDirection == DIRECTION_FORWARD ? 0 : filter_pixels * kBlockDepth);
+  const bool skip_second =
+      !kKnownEvenHeight && thread_row + (in_height & 1) == block_height;
+
+  for (int b = blockIdx.x; b < in_blocks; b += gridDim.x) {
+    const int batch = b / batch_blocks;
+    const int block = b - batch * batch_blocks;
+
+    const int start_channel = block * kBlockDepth;
+    const int filter_offset = tensor_idx + start_channel;
+    const int inout_offset = batch * in_size + filter_offset;
+    const bool channel_in_range = start_channel < max_channel;
+
+    if (channel_in_range) {
+      const T* const in_ptr = inout_offset + input;
+      S* const tile_ptr = tile_idx + shared_data;
+      tile_ptr[0] = static_cast<S>(ldg(in_ptr));
+      if (!skip_second) {
+        tile_ptr[tile_offset] = static_cast<S>(ldg(tensor_offset + in_ptr));
+      }
+
+      if (filter_write_offset != 0) {
+        shared_data[filter_write_offset] =
+            static_cast<S>(ldg(filter_offset + filter));
+      }
+    }
+
+    // Note: the condition to reach this is uniform across the entire block.
+    __syncthreads();
+
+    if (channel_in_range) {
+      S sum1 = S();
+      S sum2 = S();
+      int shared_offset = data_idx;
+      const S* filter_ptr = filter_read_offset + shared_data;
+      UNROLL for (int r = 0; r < filter_height; ++r) {
+        UNROLL for (int c = 0; c < filter_width; ++c) {
+          if (kDirection == DIRECTION_BACKWARD) {
+            filter_ptr -= kBlockDepth;
+          }
+          const S filter_value = *filter_ptr;
+          const S* const tile_ptr = shared_offset + shared_data;
+          sum1 += filter_value * tile_ptr[0];
+          sum2 += filter_value * tile_ptr[tile_offset];
+          shared_offset += kBlockDepth;
+          if (kDirection == DIRECTION_FORWARD) {
+            filter_ptr += kBlockDepth;
+          }
+        }
+        shared_offset += in_increment;
+      }
+      T* const out_ptr = inout_offset + output;
+      out_ptr[0] = static_cast<T>(sum1);
+      if (!skip_second) {
+        out_ptr[tensor_offset] = static_cast<T>(sum2);
+      }
+    }
+
+    // Note: the condition to reach this is uniform across the entire block.
+    __syncthreads();
+  }
+}
+
+// A GPU kernel to compute the depthwise convolution forward pass
+// in NCHW format.
+template <typename T, int kKnownFilterWidth, int kKnownFilterHeight,
+          int kKnownDepthMultiplier>
+__global__ void __launch_bounds__(1024, 2)
+    DepthwiseConv2dGPUKernelNCHW(const DepthwiseArgs args,
+                                 const T* __restrict__ input,
+                                 const T* __restrict__ filter,
+                                 T* __restrict__ output, int num_outputs) {
+  typedef typename detail::PseudoHalfType<T>::Type S;
+  const int in_height = args.in_rows;
+  const int in_width = args.in_cols;
+  const int in_depth = args.in_depth;
+  const int filter_height =
+      kKnownFilterHeight < 0 ? args.filter_rows : kKnownFilterHeight;
+  const int filter_width =
+      kKnownFilterWidth < 0 ? args.filter_cols : kKnownFilterWidth;
+  const FastDividerUint32 depth_multiplier =
+      kKnownDepthMultiplier < 0 ? args.depth_multiplier : kKnownDepthMultiplier;
+  const int stride = args.stride;
+  const int pad_height = args.pad_rows;
+  const int pad_width = args.pad_cols;
+  const int out_width = args.out_cols;
+  const FastDividerUint32 out_height = args.out_rows;
+  const FastDividerUint32 out_depth = args.out_depth;
+
+  GPU_1D_KERNEL_LOOP(thread_id, num_outputs) {
+    // Compute the indexes of this thread in the output.
+    //
+    // We want coalesced reads so we make sure that each warp reads
+    // a contiguous chunk of memory.
+    //
+    // THIS IS PROBABLY WRONG, we are not doing coalesced reads
+    // into the input, because of the depth multiplier division...
+    const int out_col = thread_id % out_width;
+    const int out_row = (thread_id / out_width) % out_height;
+    const int out_channel = (thread_id / out_width / out_height) % out_depth;
+    const int batch = thread_id / out_width / out_height / out_depth;
+
+    // Compute the input depth and the index of depth multiplier
+    // based off the output depth index that this thread is
+    // computing n.
+    const int in_channel = out_channel / depth_multiplier;
+    const int multiplier = out_channel % depth_multiplier;
+
+    // Data is stored in the following format (let's assume we
+    // flatten the height and width into one contiguous dimension
+    // called "P".
+    //
+    // B1C1P1 B1C1P2 ..... B1C2P1 B1C2P2 ....
+    // B2C1P1 B2C1P2 ..... B2C2P1 B2C2P2 ....
+    //
+    // Each row contains in_depth * in_height * in_width values
+    // for each sample in the batch.
+    //
+    // We can further flatten it into:
+    //
+    // B1C1P1 B1C1P2 .....
+    // B1C2P1 B1C2P2 ....
+    // B2C1P1 B2C1P2 .....
+    // B2C2P1 B2C2P2 ....
+    //
+    // where each row is a contiguous array of all of the spatial
+    // pixels for a given batch and input depth.  The following
+    // loop unrolls across the filter dimensions for a given thread,
+    // indexing into the filter value and the corresponding input
+    // patch.
+    //
+    // We can compute the index into the patch once right here.
+    const int input_offset_temp =
+        (batch * in_depth + in_channel) * (in_height * in_width);
+
+    // Finally, we can iterate over the spatial dimensions and perform the
+    // convolution, writing into the output at the end.
+    //
+    // We perform an additional optimization, where we can determine
+    // whether the patch fits within the image indices statically, and
+    // avoid boundary checking within the loop.
+    const int input_row_start = out_row * stride - pad_height;
+    const int input_col_start = out_col * stride - pad_width;
+    const int input_row_end = input_row_start + filter_height;
+    const int input_col_end = input_col_start + filter_width;
+
+    S sum = static_cast<S>(0);
+    if (input_row_start >= 0 && input_col_start >= 0 &&
+        input_row_end < in_height && input_col_end < in_width) {
+      // Loop that doesn't need to check for boundary conditions.
+      UNROLL for (int filter_row = 0; filter_row < filter_height;
+                  ++filter_row) {
+        const int in_row = input_row_start + filter_row;
+        const int filter_offset_temp = filter_width * filter_row;
+        UNROLL for (int filter_col = 0; filter_col < filter_width;
+                    ++filter_col) {
+          const int in_col = input_col_start + filter_col;
+
+          const int input_offset =
+              (input_offset_temp) + (in_row * in_width) + in_col;
+          const int filter_offset =
+              multiplier +
+              depth_multiplier *
+                  (in_channel + in_depth * (filter_col + filter_offset_temp));
+          sum += static_cast<S>(ldg(input + input_offset)) *
+                 static_cast<S>(ldg(filter + filter_offset));
+        }
+      }
+    } else {
+      // Loop that needs to check for boundary conditions.
+      UNROLL for (int filter_row = 0; filter_row < filter_height;
+                  ++filter_row) {
+        const int in_row = input_row_start + filter_row;
+        const int filter_offset_temp = filter_width * filter_row;
+        UNROLL for (int filter_col = 0; filter_col < filter_width;
+                    ++filter_col) {
+          const int in_col = input_col_start + filter_col;
+          // TODO(vrv): the in_row check can be done outside of this loop;
+          // benchmark both methods to determine the better decision.
+          if (in_row >= 0 && in_row < in_height && in_col >= 0 &&
+              in_col < in_width) {
+            const int in_col = input_col_start + filter_col;
+
+            // input_offset_temp indexes into the start of memory
+            // where the spatial data starts.
+            const int input_offset =
+                (input_offset_temp) + (in_row * in_width) + in_col;
+
+            const int filter_offset =
+                multiplier +
+                depth_multiplier *
+                    (in_channel + in_depth * (filter_col + filter_offset_temp));
+            sum += static_cast<S>(ldg(input + input_offset)) *
+                   static_cast<S>(ldg(filter + filter_offset));
+          }
+        }
+      }
+    }
+
+    output[thread_id] = static_cast<T>(sum);
+  }
+}
+
+// CUDA kernel to compute the depthwise convolution forward pass in NCHW format,
+// tailored for small images up to 32x32. Stride and depth multiplier must be 1.
+// Padding must be 'SAME', which allows to reuse the index computation. Only
+// use this kernel if CanLaunchDepthwiseConv2dGPUSmall(args) returns true.
+// Tiles of the input and filter tensors are loaded into shared memory before
+// performing the convolution. Each thread handles two elements per iteration,
+// one each in the lower and upper half of a tile.
+// Backprop input direction is the same as forward direction with the filter
+// rotated by 180°.
+// T is the tensors' data type. S is the math type the kernel uses. This is the
+// same as T for all cases but pseudo half (which has T=Eigen::half, S=float).
+template <typename T, DepthwiseConv2dDirection kDirection,
+          int kKnownFilterWidth, int kKnownFilterHeight, int kBlockDepth,
+          bool kKnownEvenHeight>
+__global__ __launch_bounds__(1024, 2) void DepthwiseConv2dGPUKernelNCHWSmall(
+    const DepthwiseArgs args, const T* __restrict__ input,
+    const T* __restrict__ filter, T* __restrict__ output) {
+  typedef typename detail::PseudoHalfType<T>::Type S;
+  assert(CanLaunchDepthwiseConv2dGPUSmall(args));
+  // Holds block plus halo and filter data for blockDim.z depths.
+  GPU_DYNAMIC_SHARED_MEM_DECL(8, unsigned char, shared_memory);
+  static_assert(sizeof(S) <= 8, "Insufficient alignment detected");
+  S* const shared_data = reinterpret_cast<S*>(shared_memory);
+
+  const int num_batches = args.batch;
+  const int in_height = args.in_rows;
+  const int in_width = args.in_cols;
+  const int in_depth = args.in_depth;
+  const int filter_height =
+      kKnownFilterHeight < 0 ? args.filter_rows : kKnownFilterHeight;
+  const int filter_width =
+      kKnownFilterWidth < 0 ? args.filter_cols : kKnownFilterWidth;
+  const int pad_height = args.pad_rows;
+  const int pad_width = args.pad_cols;
+
+  // Fixed blockDim.z, tailored for maximum grid size for images of size 16x16.
+  assert(blockDim.x == args.in_cols);
+  assert(blockDim.z == kBlockDepth);
+  const int block_height = blockDim.y;
+
+  // These values are the same for all threads and could
+  // be precomputed on the CPU.
+  const int block_pixels = in_width * block_height;
+  const int block_size = block_pixels * kBlockDepth;
+  const int in_pixels = in_width * in_height;
+  const int in_increment = in_width - 1;
+  const int filter_pixels = filter_height * filter_width;
+  const int tile_width = in_width + filter_width - 1;
+  const int even_height = kKnownEvenHeight || (1 & ~in_height);
+  const int tile_height = in_height + filter_height - even_height;
+  const int tile_pixels = tile_width * tile_height;
+  const int tile_size = tile_pixels * kBlockDepth;
+  const int tile_offset = block_height * tile_width;
+  const int pad_offset = pad_height * tile_width + pad_width;
+  const int in_total_depth = in_depth * num_batches;
+  const int in_blocks = (in_total_depth + kBlockDepth - 1) / kBlockDepth;
+
+  const int thread_col = threadIdx.x;
+  const int thread_row = threadIdx.y;
+  const int thread_depth = threadIdx.z;
+
+  // Position in block.
+  const int thread_pix = thread_row * in_width + thread_col;
+  const int thread_idx = thread_depth * block_pixels + thread_pix;
+
+  // Initialize tile, in particular the padding.
+  for (int i = thread_idx; i < tile_size; i += block_size) {
+    shared_data[i] = S();
+  }
+  __syncthreads();
+
+  // Position in tensors.
+  const int tensor_idx = thread_depth * in_pixels + thread_pix;
+
+  // Position in (padded) shared memory.
+  const int data_pix = thread_row * tile_width + thread_col;
+  const int data_idx = thread_depth * tile_pixels + data_pix;
+
+  // Position in shared memory, offset by pad_height / pad_width.
+  const int tile_idx = data_idx + pad_offset;
+
+  // Filter is always in HWCK format, irrespective of the input/output format.
+  const int filter_pix = thread_idx / kBlockDepth;
+  const int filter_channel = thread_idx % kBlockDepth;
+  const int filter_idx = filter_pix * in_depth;
+
+  const int max_channel = in_total_depth - thread_depth;
+  const int filter_write_offset =
+      filter_pix < filter_pixels ? tile_size + thread_idx : 0;
+  const int filter_read_offset =
+      tile_size + thread_depth +
+      (kDirection == DIRECTION_FORWARD ? 0 : filter_pixels * kBlockDepth);
+  const bool skip_second =
+      !kKnownEvenHeight && thread_row + (in_height & 1) == block_height;
+
+  for (int b = blockIdx.x; b < in_blocks; b += gridDim.x) {
+    const int channel = b * kBlockDepth;
+
+    const int inout_offset = channel * in_pixels + tensor_idx;
+    const bool channel_in_range = channel < max_channel;
+
+    if (channel_in_range) {
+      const T* const in_ptr = inout_offset + input;
+      S* const tile_ptr = tile_idx + shared_data;
+      tile_ptr[0] = static_cast<S>(ldg(in_ptr));
+      if (!skip_second) {
+        tile_ptr[tile_offset] = static_cast<S>(ldg(block_pixels + in_ptr));
+      }
+    }
+
+    if (filter_write_offset != 0) {
+      const int filter_offset =
+          filter_idx + (channel + filter_channel) % in_depth;
+      shared_data[filter_write_offset] =
+          static_cast<S>(ldg(filter_offset + filter));
+    }
+
+    // Note: the condition to reach this is uniform across the entire block.
+    __syncthreads();
+
+    if (channel_in_range) {
+      S sum1 = S();
+      S sum2 = S();
+      int shared_offset = data_idx;
+      const S* filter_ptr = filter_read_offset + shared_data;
+      UNROLL for (int r = 0; r < filter_height; ++r) {
+        UNROLL for (int c = 0; c < filter_width; ++c) {
+          if (kDirection == DIRECTION_BACKWARD) {
+            filter_ptr -= kBlockDepth;
+          }
+          const S filter_value = *filter_ptr;
+          const S* const tile_ptr = shared_offset + shared_data;
+          sum1 += filter_value * tile_ptr[0];
+          sum2 += filter_value * tile_ptr[tile_offset];
+          ++shared_offset;
+          if (kDirection == DIRECTION_FORWARD) {
+            filter_ptr += kBlockDepth;
+          }
+        }
+        shared_offset += in_increment;
+      }
+      T* const out_ptr = inout_offset + output;
+      out_ptr[0] = static_cast<T>(sum1);
+      if (!skip_second) {
+        out_ptr[block_pixels] = static_cast<T>(sum2);
+      }
+    }
+
+    // Note: the condition to reach this is uniform across the entire block.
+    __syncthreads();
+  }
+}
+
+template <typename T, DepthwiseConv2dDirection kDirection,
+          int kKnownFilterWidth, int kKnownFilterHeight, int kBlockDepth,
+          bool kKnownEvenHeight>
+Status LaunchDepthwiseConv2dGPUSmall(OpKernelContext* ctx,
+                                     const DepthwiseArgs& args, const T* input,
+                                     const T* filter, T* output,
+                                     TensorFormat data_format) {
+  typedef typename detail::PseudoHalfType<T>::Type S;
+  const int block_height = (args.in_rows + 1) / 2;
+  dim3 block_dim;
+  int block_count;
+  void (*kernel)(const DepthwiseArgs, const T*, const T*, T*);
+  switch (data_format) {
+    case FORMAT_NHWC:
+      block_dim = dim3(kBlockDepth, args.in_cols, block_height);
+      block_count =
+          args.batch * DivUp(args.out_depth, kBlockDepth) * kBlockDepth;
+      kernel =
+          DepthwiseConv2dGPUKernelNHWCSmall<T, kDirection, kKnownFilterWidth,
+                                            kKnownFilterHeight, kBlockDepth,
+                                            kKnownEvenHeight>;
+      break;
+    case FORMAT_NCHW:
+      block_dim = dim3(args.in_cols, block_height, kBlockDepth);
+      block_count =
+          DivUp(args.batch * args.out_depth, kBlockDepth) * kBlockDepth;
+      kernel =
+          DepthwiseConv2dGPUKernelNCHWSmall<T, kDirection, kKnownFilterWidth,
+                                            kKnownFilterHeight, kBlockDepth,
+                                            kKnownEvenHeight>;
+      break;
+    default:
+      return errors::InvalidArgument("FORMAT_", ToString(data_format),
+                                     " is not supported");
+  }
+  const int tile_width = args.in_cols + args.filter_cols - 1;
+  const int tile_height = block_height * 2 + args.filter_rows - 1;
+  const int tile_pixels = tile_height * tile_width;
+  const int filter_pixels = args.filter_rows * args.filter_cols;
+  const int shared_memory_size =
+      kBlockDepth * (tile_pixels + filter_pixels) * sizeof(S);
+  const int num_outputs = args.out_rows * args.out_cols * block_count;
+  auto device = ctx->eigen_gpu_device();
+  GpuLaunchConfig config = GetGpuLaunchConfigFixedBlockSize(
+      num_outputs, device, kernel, shared_memory_size,
+      block_dim.x * block_dim.y * block_dim.z);
+  TF_CHECK_OK(GpuLaunchKernel(kernel, config.block_count, block_dim,
+                              shared_memory_size, device.stream(), args, input,
+                              filter, output));
+  return OkStatus();
+}
+
+// Returns whether the context's GPU supports efficient fp16 math.
+inline bool HasFastHalfMath(OpKernelContext* ctx) {
+  se::CudaComputeCapability compute_capability =
+      ctx->op_device_context()->stream()->GetCudaComputeCapability();
+  // GPUs before sm_53 don't support fp16 math, and sm_61's fp16 math is slow.
+  return compute_capability.IsAtLeast(5, 3) &&
+         compute_capability != se::CudaComputeCapability{6, 1};
+}
+
+template <typename T, DepthwiseConv2dDirection kDirection,
+          int kKnownFilterWidth, int kKnownFilterHeight, int kBlockDepth>
+Status LaunchDepthwiseConv2dGPUSmall(OpKernelContext* ctx,
+                                     const DepthwiseArgs& args, const T* input,
+                                     const T* filter, T* output,
+                                     TensorFormat data_format) {
+  if (args.in_rows & 1) {
+    return LaunchDepthwiseConv2dGPUSmall<T, kDirection, kKnownFilterWidth,
+                                         kKnownFilterHeight, kBlockDepth,
+                                         false>(ctx, args, input, filter,
+                                                output, data_format);
+  } else {
+    return LaunchDepthwiseConv2dGPUSmall<T, kDirection, kKnownFilterWidth,
+                                         kKnownFilterHeight, kBlockDepth, true>(
+        ctx, args, input, filter, output, data_format);
+  }
+}
+
+template <typename T, DepthwiseConv2dDirection kDirection,
+          int kKnownFilterWidth, int kKnownFilterHeight>
+Status LaunchDepthwiseConv2dGPUSmall(OpKernelContext* ctx,
+                                     const DepthwiseArgs& args, const T* input,
+                                     const T* filter, T* output,
+                                     TensorFormat data_format) {
+  // Maximize (power of two) kBlockDepth while keeping a block within 1024
+  // threads (2 pixels per thread).
+  const int block_pixels = (args.in_rows + 1) / 2 * args.in_cols;
+  if (block_pixels > 256) {
+    return LaunchDepthwiseConv2dGPUSmall<T, kDirection, kKnownFilterWidth,
+                                         kKnownFilterHeight, 2>(
+        ctx, args, input, filter, output, data_format);
+  } else if (block_pixels > 128) {
+    return LaunchDepthwiseConv2dGPUSmall<T, kDirection, kKnownFilterWidth,
+                                         kKnownFilterHeight, 4>(
+        ctx, args, input, filter, output, data_format);
+  } else {
+    return LaunchDepthwiseConv2dGPUSmall<T, kDirection, kKnownFilterWidth,
+                                         kKnownFilterHeight, 8>(
+        ctx, args, input, filter, output, data_format);
+  }
+}
+
+template <typename T, int kKnownFilterWidth, int kKnownFilterHeight,
+          int kKnownDepthMultiplier>
+Status LaunchDepthwiseConv2dGPU(OpKernelContext* ctx, const DepthwiseArgs& args,
+                                const T* input, const T* filter, T* output,
+                                TensorFormat data_format) {
+  void (*kernel)(const DepthwiseArgs, const T*, const T*, T*, int);
+  switch (data_format) {
+    case FORMAT_NHWC:
+      kernel =
+          DepthwiseConv2dGPUKernelNHWC<T, kKnownFilterWidth, kKnownFilterHeight,
+                                       kKnownDepthMultiplier>;
+      break;
+    case FORMAT_NCHW:
+      kernel =
+          DepthwiseConv2dGPUKernelNCHW<T, kKnownFilterWidth, kKnownFilterHeight,
+                                       kKnownDepthMultiplier>;
+      break;
+    default:
+      return errors::InvalidArgument("FORMAT_", ToString(data_format),
+                                     " is not supported");
+  }
+  const int num_outputs =
+      args.batch * args.out_rows * args.out_cols * args.out_depth;
+  auto device = ctx->eigen_gpu_device();
+  GpuLaunchConfig config =
+      GetGpuLaunchConfig(num_outputs, device, kernel, 0, 0);
+  // The compile-time constant version runs faster with a single block.
+  const int max_block_count = kKnownFilterWidth < 0 || kKnownFilterHeight < 0 ||
+                                      kKnownDepthMultiplier < 0
+                                  ? std::numeric_limits<int>::max()
+                                  : device.getNumGpuMultiProcessors();
+  TF_CHECK_OK(GpuLaunchKernel(kernel,
+                              std::min(max_block_count, config.block_count),
+                              config.thread_per_block, 0, device.stream(), args,
+                              input, filter, output, num_outputs));
+  return OkStatus();
+}
+
+template <typename T, int kKnownFilterWidth, int kKnownFilterHeight>
+Status LaunchDepthwiseConv2dGPU(OpKernelContext* ctx, const DepthwiseArgs& args,
+                                const T* input, const T* filter, T* output,
+                                TensorFormat data_format) {
+  if (args.depth_multiplier == 1) {
+    if (CanLaunchDepthwiseConv2dGPUSmall(args)) {
+      return LaunchDepthwiseConv2dGPUSmall<
+          T, DIRECTION_FORWARD, kKnownFilterWidth, kKnownFilterHeight>(
+          ctx, args, input, filter, output, data_format);
+    }
+
+    return LaunchDepthwiseConv2dGPU<T, kKnownFilterWidth, kKnownFilterHeight,
+                                    1>(ctx, args, input, filter, output,
+                                       data_format);
+  } else {
+    return LaunchDepthwiseConv2dGPU<T, kKnownFilterWidth, kKnownFilterHeight,
+                                    -1>(ctx, args, input, filter, output,
+                                        data_format);
+  }
+}
+
+// A simple launch pad to launch the GPU kernel for depthwise convolution.
+template <typename T>
+void LaunchDepthwiseConvOp<GpuDevice, T>::operator()(OpKernelContext* ctx,
+                                                     const DepthwiseArgs& args,
+                                                     const T* input,
+                                                     const T* filter, T* output,
+                                                     TensorFormat data_format) {
+  if (args.filter_rows == 3 && args.filter_cols == 3) {
+    OP_REQUIRES_OK(ctx, LaunchDepthwiseConv2dGPU<T, 3, 3>(
+                            ctx, args, input, filter, output, data_format));
+  } else {
+    OP_REQUIRES_OK(ctx, LaunchDepthwiseConv2dGPU<T, -1, -1>(
+                            ctx, args, input, filter, output, data_format));
+  }
+}
+
+// A GPU kernel to compute the depthwise convolution backprop w.r.t. input.
+template <typename T, int kKnownFilterWidth, int kKnownFilterHeight,
+          int kKnownDepthMultiplier>
+__global__ void __launch_bounds__(640, 2)
+    DepthwiseConv2dBackpropInputGPUKernelNHWC(
+        const DepthwiseArgs args, const T* __restrict__ out_backprop,
+        const T* __restrict__ filter, T* __restrict__ in_backprop,
+        int num_in_backprop) {
+  const int in_height = args.in_rows;
+  const int in_width = args.in_cols;
+  const int in_depth = args.in_depth;
+  const int filter_height =
+      kKnownFilterHeight < 0 ? args.filter_rows : kKnownFilterHeight;
+  const int filter_width =
+      kKnownFilterWidth < 0 ? args.filter_cols : kKnownFilterWidth;
+  const int depth_multiplier =
+      kKnownDepthMultiplier < 0 ? args.depth_multiplier : kKnownDepthMultiplier;
+  const int stride = args.stride;
+  const int pad_height = args.pad_rows;
+  const int pad_width = args.pad_cols;
+  const int out_height = args.out_rows;
+  const int out_width = args.out_cols;
+  const int out_depth = args.out_depth;
+
+  GPU_1D_KERNEL_LOOP(thread_id, num_in_backprop) {
+    // Compute the indexes of this thread in the output.
+    const int in_channel = thread_id % in_depth;
+    const int in_col = (thread_id / in_depth) % in_width;
+    const int in_row = (thread_id / in_depth / in_width) % in_height;
+    const int batch = thread_id / in_depth / in_width / in_height;
+
+    T sum = static_cast<T>(0);
+
+    const int out_row_start =
+        tf_max<int>(0, (in_row - filter_height + pad_height + stride) / stride);
+    const int out_row_end =
+        tf_min(out_height - 1, (in_row + pad_height) / stride);
+    const int out_col_start =
+        tf_max(0, (in_col - filter_width + pad_width + stride) / stride);
+    const int out_col_end =
+        tf_min(out_width - 1, (in_col + pad_width) / stride);
+
+    NOUNROLL for (int out_row = out_row_start; out_row <= out_row_end;
+                  ++out_row) {
+      const int filter_row = in_row + pad_height - out_row * stride;
+      const int temp_out_backprop_offset =
+          out_depth * out_width * (out_row + out_height * batch);
+      const int temp_filter_offset = filter_width * filter_row;
+      NOUNROLL for (int out_col = out_col_start; out_col <= out_col_end;
+                    ++out_col) {
+        const int filter_col = in_col + pad_width - out_col * stride;
+        int filter_offset =
+            depth_multiplier *
+            (in_channel + in_depth * (filter_col + temp_filter_offset));
+        const int out_backprop_offset =
+            out_depth * out_col + temp_out_backprop_offset;
+#pragma unroll 6
+        for (int i = 0; i < depth_multiplier; ++i) {
+          sum += ldg(out_backprop + out_backprop_offset +
+                     in_channel * depth_multiplier + i) *
+                 ldg(filter + filter_offset + i);
+        }
+      }
+    }
+    const int in_backprop_offset =
+        in_channel +
+        in_depth * (in_col + in_width * (in_row + in_height * batch));
+    in_backprop[in_backprop_offset] = sum;
+  }
+}
+
+template <typename T, int kKnownFilterWidth, int kKnownFilterHeight,
+          int kKnownDepthMultiplier>
+__global__ void __launch_bounds__(640, 2)
+    DepthwiseConv2dBackpropInputGPUKernelNCHW(
+        const DepthwiseArgs args, const T* __restrict__ out_backprop,
+        const T* __restrict__ filter, T* __restrict__ in_backprop,
+        int num_in_backprop) {
+  const FastDividerUint32 in_height = args.in_rows;
+  const FastDividerUint32 in_width = args.in_cols;
+  const FastDividerUint32 in_depth = args.in_depth;
+  const int filter_height =
+      kKnownFilterHeight < 0 ? args.filter_rows : kKnownFilterHeight;
+  const int filter_width =
+      kKnownFilterWidth < 0 ? args.filter_cols : kKnownFilterWidth;
+  const int depth_multiplier =
+      kKnownDepthMultiplier < 0 ? args.depth_multiplier : kKnownDepthMultiplier;
+  const int stride = args.stride;
+  const int pad_height = args.pad_rows;
+  const int pad_width = args.pad_cols;
+  const int out_height = args.out_rows;
+  const int out_width = args.out_cols;
+  const int out_depth = args.out_depth;
+
+  // TODO(vrv): Consider assigning threads to output and using
+  // atomics for accumulation, similar to the filter case.
+  GPU_1D_KERNEL_LOOP(thread_id, num_in_backprop) {
+    // Compute the indexes of this thread in the input.
+    const int in_col = thread_id % in_width;
+    const int in_row = (thread_id / in_width) % in_height;
+    const int in_channel = (thread_id / in_width / in_height) % in_depth;
+    const int batch = thread_id / in_depth / in_width / in_height;
+
+    T sum = static_cast<T>(0);
+    const int out_channel_start = in_channel * depth_multiplier;
+    const int out_channel_end = out_channel_start + depth_multiplier;
+
+    const int out_row_start =
+        tf_max<int>(0, (in_row - filter_height + pad_height + stride) / stride);
+    const int out_row_end =
+        tf_min<int>(out_height - 1, (in_row + pad_height) / stride);
+    const int out_col_start =
+        tf_max<int>(0, (in_col - filter_width + pad_width + stride) / stride);
+    const int out_col_end =
+        tf_min<int>(out_width - 1, (in_col + pad_width) / stride);
+
+    UNROLL for (int out_channel = out_channel_start;
+                out_channel < out_channel_end; ++out_channel) {
+      UNROLL for (int out_row = out_row_start; out_row <= out_row_end;
+                  ++out_row) {
+        const int filter_row = in_row + pad_height - out_row * stride;
+        const int filter_dm = out_channel - out_channel_start;
+
+        const int temp_filter_offset = filter_width * filter_row;
+        for (int out_col = out_col_start; out_col <= out_col_end; ++out_col) {
+          const int filter_col = in_col + pad_width - out_col * stride;
+          const int filter_offset =
+              filter_dm +
+              args.depth_multiplier *
+                  (in_channel + in_depth * (filter_col + temp_filter_offset));
+
+          const int out_backprop_offset =
+              (batch * out_depth * out_height * out_width) +
+              (out_channel * out_height * out_width) + (out_row * out_width) +
+              (out_col);
+
+          sum += ldg(out_backprop + out_backprop_offset) *
+                 ldg(filter + filter_offset);
+        }
+      }
+    }
+    const int in_backprop_offset = (batch * in_height * in_width * in_depth) +
+                                   (in_channel * in_height * in_width) +
+                                   (in_row * in_width) + (in_col);
+    in_backprop[in_backprop_offset] = sum;
+  }
+}
+
+template <typename T, int kKnownFilterWidth, int kKnownFilterHeight,
+          int kKnownDepthMultiplier>
+Status LaunchDepthwiseConv2dBackpropInputGPU(OpKernelContext* ctx,
+                                             const DepthwiseArgs& args,
+                                             const T* out_backprop,
+                                             const T* filter, T* in_backprop,
+                                             TensorFormat data_format) {
+  void (*kernel)(const DepthwiseArgs, const T*, const T*, T*, int);
+  switch (data_format) {
+    case FORMAT_NHWC:
+      kernel = DepthwiseConv2dBackpropInputGPUKernelNHWC<
+          T, kKnownFilterWidth, kKnownFilterHeight, kKnownDepthMultiplier>;
+      break;
+    case FORMAT_NCHW:
+      kernel = DepthwiseConv2dBackpropInputGPUKernelNCHW<
+          T, kKnownFilterWidth, kKnownFilterHeight, kKnownDepthMultiplier>;
+      break;
+    default:
+      return errors::InvalidArgument("FORMAT_", ToString(data_format),
+                                     " is not supported");
+  }
+  const int num_in_backprop =
+      args.batch * args.in_rows * args.in_cols * args.in_depth;
+  auto device = ctx->eigen_gpu_device();
+  int launch_bounds_value = 640;
+  GpuLaunchConfig config = GetGpuLaunchConfig(num_in_backprop, device, kernel,
+                                              0, launch_bounds_value);
+  TF_CHECK_OK(GpuLaunchKernel(
+      kernel, config.block_count, config.thread_per_block, 0, device.stream(),
+      args, out_backprop, filter, in_backprop, num_in_backprop));
+  return OkStatus();
+}
+
+template <typename T, int kKnownFilterWidth, int kKnownFilterHeight>
+Status LaunchDepthwiseConv2dBackpropInputGPU(OpKernelContext* ctx,
+                                             const DepthwiseArgs& args,
+                                             const T* out_backprop,
+                                             const T* filter, T* in_backprop,
+                                             TensorFormat data_format) {
+  if (args.depth_multiplier == 1) {
+    // This kernel doesn't currently work in all cases so it is disabled.
+    // TODO(b/150988950): Fix and reenable this kernel.
+    if (/* CanLaunchDepthwiseConv2dGPUSmall(args) */ false) {
+      return LaunchDepthwiseConv2dGPUSmall<
+          T, DIRECTION_BACKWARD, kKnownFilterWidth, kKnownFilterHeight>(
+          ctx, args, out_backprop, filter, in_backprop, data_format);
+    }
+
+    return LaunchDepthwiseConv2dBackpropInputGPU<T, kKnownFilterWidth,
+                                                 kKnownFilterHeight, 1>(
+        ctx, args, out_backprop, filter, in_backprop, data_format);
+  } else {
+    return LaunchDepthwiseConv2dBackpropInputGPU<T, kKnownFilterWidth,
+                                                 kKnownFilterHeight, -1>(
+        ctx, args, out_backprop, filter, in_backprop, data_format);
+  }
+}
+
+// A simple launch pad to launch the GPU kernel for depthwise convolution.
+template <typename T>
+void LaunchDepthwiseConvBackpropInputOp<GpuDevice, T>::operator()(
+    OpKernelContext* ctx, const DepthwiseArgs& args, const T* out_backprop,
+    const T* filter, T* in_backprop, TensorFormat data_format) {
+  if (args.filter_rows == 3 && args.filter_cols == 3) {
+    OP_REQUIRES_OK(
+        ctx, LaunchDepthwiseConv2dBackpropInputGPU<T, 3, 3>(
+                 ctx, args, out_backprop, filter, in_backprop, data_format));
+  } else {
+    OP_REQUIRES_OK(
+        ctx, LaunchDepthwiseConv2dBackpropInputGPU<T, -1, -1>(
+                 ctx, args, out_backprop, filter, in_backprop, data_format));
+  }
+}
+
+// A GPU kernel to compute the depthwise convolution backprop w.r.t. filter.
+// TODO: Add fp32 accumulation to half calls of this function. This addition
+// is non-trivial as the partial sums are added directly to the output
+template <typename T, int kKnownFilterWidth, int kKnownFilterHeight,
+          int kKnownDepthMultiplier>
+__global__ void __launch_bounds__(640, 2)
+    DepthwiseConv2dBackpropFilterGPUKernelNHWC(
+        const DepthwiseArgs args, const T* __restrict__ out_backprop,
+        const T* __restrict__ input, T* __restrict__ filter_backprop,
+        int num_out_backprop) {
+  const int in_height = args.in_rows;
+  const int in_width = args.in_cols;
+  const int in_depth = args.in_depth;
+  const int filter_height =
+      kKnownFilterHeight < 0 ? args.filter_rows : kKnownFilterHeight;
+  const int filter_width =
+      kKnownFilterWidth < 0 ? args.filter_cols : kKnownFilterWidth;
+  const int depth_multiplier =
+      kKnownDepthMultiplier < 0 ? args.depth_multiplier : kKnownDepthMultiplier;
+  const int stride = args.stride;
+  const int pad_height = args.pad_rows;
+  const int pad_width = args.pad_cols;
+  const int out_height = args.out_rows;
+  const int out_width = args.out_cols;
+  const int out_depth = args.out_depth;
+
+  GPU_1D_KERNEL_LOOP(thread_id, num_out_backprop) {
+    // Compute the indexes of this thread in the output.
+    const int out_channel = thread_id % out_depth;
+    const int out_col = (thread_id / out_depth) % out_width;
+    const int out_row = (thread_id / out_depth / out_width) % out_height;
+    const int batch = thread_id / out_depth / out_width / out_height;
+    // Compute the input depth and the index of depth multiplier.
+    const int in_channel = out_channel / depth_multiplier;
+    const int dm = out_channel % depth_multiplier;
+
+    // Decide if all input is valid, if yes, we can skip the boundary checks
+    // for each input.
+    const int in_row_start = out_row * stride - pad_height;
+    const int in_col_start = out_col * stride - pad_width;
+    const int in_row_end = in_row_start + filter_height;
+    const int in_col_end = in_col_start + filter_width;
+
+    const int out_backprop_offset =
+        out_channel +
+        out_depth * (out_col + out_width * (out_row + out_height * batch));
+    const T out_bp = ldg(out_backprop + out_backprop_offset);
+    if (in_row_start >= 0 && in_col_start >= 0 && in_row_end < in_height &&
+        in_col_end < in_width) {
+      UNROLL for (int filter_row = 0; filter_row < filter_height;
+                  ++filter_row) {
+        const int in_row = in_row_start + filter_row;
+        // Avoid repeated computation.
+        const int input_offset_temp = in_width * (in_row + in_height * batch);
+        UNROLL for (int filter_col = 0; filter_col < filter_width;
+                    ++filter_col) {
+          const int in_col = in_col_start + filter_col;
+
+          const int input_offset =
+              in_channel + in_depth * (in_col + input_offset_temp);
+          T partial_sum = ldg(input + input_offset) * out_bp;
+          T* addr =
+              filter_backprop +
+              (dm + depth_multiplier *
+                        (in_channel +
+                         in_depth * (filter_col + filter_width * filter_row)));
+          GpuAtomicAdd(addr, partial_sum);
+        }
+      }
+    } else {
+      UNROLL for (int filter_row = 0; filter_row < filter_height;
+                  ++filter_row) {
+        const int in_row = in_row_start + filter_row;
+        // Avoid repeated computation.
+        const int input_offset_temp = in_width * (in_row + in_height * batch);
+        UNROLL for (int filter_col = 0; filter_col < filter_width;
+                    ++filter_col) {
+          const int in_col = in_col_start + filter_col;
+          const int addr_temp = filter_width * filter_row;
+
+          if (in_row >= 0 && in_row < in_height && in_col >= 0 &&
+              in_col < in_width) {
+            const int input_offset =
+                in_channel + in_depth * (in_col + input_offset_temp);
+            T partial_sum = ldg(input + input_offset) * out_bp;
+            T* addr =
+                filter_backprop +
+                (dm + depth_multiplier *
+                          (in_channel + in_depth * (filter_col + addr_temp)));
+            // Potentially many threads can add to the same address so we have
+            // to use atomic add here.
+            // TODO(jmchen): If atomic add turns out to be slow, we can:
+            // 1. allocate multiple buffers for the gradients (one for each
+            // example in a batch, for example). This can reduce the
+            // contention on the destination; 2. Have each thread compute one
+            // gradient for an element in the filters. This should work well
+            // when the input depth is big and filter size is not too small.
+            GpuAtomicAdd(addr, partial_sum);
+          }
+        }
+      }
+    }
+  }
+}
+
+// Device function to compute sub-warp sum reduction for a power-of-two group of
+// neighboring threads.
+template <int kWidth, typename T>
+__device__ __forceinline__ T WarpSumReduce(T val) {
+  // support only power-of-two widths.
+  assert(__popc(kWidth) == 1);
+  int sub_warp = GpuLaneId() / kWidth;
+  int zeros = sub_warp * kWidth;
+  unsigned mask = ((1UL << kWidth) - 1) << zeros;
+  for (int delta = kWidth / 2; delta > 0; delta /= 2) {
+    val += GpuShuffleXorSync(mask, val, delta);
+  }
+  return val;
+}
+
+// CUDA kernel to compute the depthwise convolution backward w.r.t. filter in
+// NHWC format, tailored for small images up to 32x32. Stride and depth
+// multiplier must be 1. Padding must be 'SAME'. Only use this kernel if
+// CanLaunchDepthwiseConv2dGPUSmall(args) returns true.
+// Tiles of the input tensor are loaded into shared memory before performing the
+// convolution. Per iteration and filter element, each thread first performs
+// a partial convolution for two elements, one each in the lower and upper half
+// of a tile. The intermediate result of all pixels of a warp are then
+// accumulated and written to shared memory. Finally, the values in shared
+// memory are warp-accumulated (in chunks of kAccumPixels elements) and summed
+// up in global memory using atomics.
+// Requirements: threads per block must be multiple of 32 and <= launch_bounds,
+// kAccumPixels * 64 >= args.in_rows * args.in_cols * kBlockDepth.
+// T is the tensors' data type. S is the math type the kernel uses. This is the
+// same as T for all cases but pseudo half (which has T=Eigen::half, S=float).
+template <typename T, int kKnownFilterWidth, int kKnownFilterHeight,
+          int kBlockDepth, int kAccumPixels>
+__global__
+__launch_bounds__(1024, 2) void DepthwiseConv2dBackpropFilterGPUKernelNHWCSmall(
+    const DepthwiseArgs args, const T* __restrict__ output,
+    const T* __restrict__ input, T* __restrict__ filter) {
+  typedef typename detail::PseudoHalfType<T>::Type S;
+  assert(CanLaunchDepthwiseConv2dBackpropFilterGPUSmall(args, blockDim.z));
+  // Holds block plus halo and filter data for blockDim.x depths.
+  GPU_DYNAMIC_SHARED_MEM_DECL(8, unsigned char, shared_memory);
+  static_assert(sizeof(S) <= 8, "Insufficient alignment detected");
+  S* const shared_data = reinterpret_cast<S*>(shared_memory);
+
+  const int num_batches = args.batch;
+  const int in_height = args.in_rows;
+  const int in_width = blockDim.y;  // slower (see b/62280718): args.in_cols;
+  const int in_depth = args.in_depth;
+  const int filter_height =
+      kKnownFilterHeight < 0 ? args.filter_rows : kKnownFilterHeight;
+  const int filter_width =
+      kKnownFilterWidth < 0 ? args.filter_cols : kKnownFilterWidth;
+  const int pad_height = args.pad_rows;
+  const int pad_width = args.pad_cols;
+
+  assert(blockDim.x == kBlockDepth);
+  assert(blockDim.y == args.in_cols);
+  const int block_height = blockDim.z;
+
+  // These values are the same for all threads and could
+  // be precomputed on the CPU.
+  const int block_size = block_height * in_width * kBlockDepth;
+  assert((block_size & 31) == 0);
+  const int in_row_size = in_width * in_depth;
+  const int in_size = in_height * in_row_size;
+  const int in_increment = (in_width - 1) * kBlockDepth;
+  const int filter_pixels = filter_height * filter_width;
+  const int tile_width = in_width + filter_width - 1;
+  const int tile_height = 2 * block_height + filter_height - 1;
+  const int tile_row_size = tile_width * kBlockDepth;
+  const int tile_size = tile_height * tile_row_size;
+  const int tile_offset = block_height * tile_row_size;
+  const int pad_offset = pad_height * tile_width + pad_width;
+  const int batch_blocks = (in_depth + kBlockDepth - 1) / kBlockDepth;
+  const int in_blocks = batch_blocks * num_batches;
+  const int tensor_offset = block_height * in_row_size;
+  // The accumulator has a fixed number of pixels that can be reduced by one
+  // warp. Pixels beyond ceil(in_pixels * kBlockDepth / 64) are never written.
+  assert(kAccumPixels * 64 >= in_height * in_width * kBlockDepth);
+  const int accum_increment = kAccumPixels * kBlockDepth;
+  const int accum_size = filter_pixels * accum_increment;
+
+  const int thread_depth = threadIdx.x;
+  const int thread_col = threadIdx.y;
+  const int thread_row = threadIdx.z;
+
+  // Position in block.
+  const int thread_pix = thread_row * in_width + thread_col;
+  const int thread_idx = thread_pix * kBlockDepth + thread_depth;
+
+  // Initialize tile, in particular the padding and accumulator.
+  for (int i = thread_idx; i < tile_size + accum_size; i += block_size) {
+    shared_data[i] = S();
+  }
+  __syncthreads();
+
+  // Position in tensors.
+  const int tensor_idx = thread_pix * in_depth + thread_depth;
+
+  // Position in (padded) shared memory.
+  const int data_pix = thread_row * tile_width + thread_col;
+  const int data_idx = data_pix * kBlockDepth + thread_depth;
+
+  // Position in shared memory, offset by pad_height / pad_width.
+  const int tile_pix = data_pix + pad_offset;
+  const int tile_idx = tile_pix * kBlockDepth + thread_depth;
+
+  // Position in accumulator (kBlockDepth per warp, depth major).
+  const int accum_pix = thread_pix / (32 / kBlockDepth);
+  const int accum_idx = thread_depth * kAccumPixels + accum_pix;
+
+  const int max_channel = in_depth - thread_depth;
+  const int accum_offset = tile_size + accum_idx;
+  const bool skip_second = block_height + thread_row >= in_height;
+
+  for (int b = blockIdx.x; b < in_blocks; b += gridDim.x) {
+    const int batch = b / batch_blocks;
+    const int block = b - batch * batch_blocks;
+
+    const int start_channel = block * kBlockDepth;
+    const int filter_offset = tensor_idx + start_channel;
+    const int inout_offset = batch * in_size + filter_offset;
+    const bool channel_in_range = start_channel < max_channel;
+
+    if (channel_in_range) {
+      const T* const in_ptr = inout_offset + input;
+      S* const tile_ptr = tile_idx + shared_data;
+      tile_ptr[0] = static_cast<S>(ldg(in_ptr));
+      if (!skip_second) {
+        tile_ptr[tile_offset] = static_cast<S>(ldg(tensor_offset + in_ptr));
+      }
+    }
+
+    // Note: the condition to reach this is uniform across the entire block.
+    __syncthreads();
+    unsigned active_threads = GpuBallotSync(kCudaWarpAll, channel_in_range);
+
+    if (channel_in_range) {
+      const T* const out_ptr = inout_offset + output;
+      const S out1 = static_cast<S>(ldg(out_ptr));
+      const S out2 =
+          skip_second ? S() : static_cast<S>(ldg(tensor_offset + out_ptr));
+      int shared_offset = data_idx;
+      S* accum_ptr = accum_offset + shared_data;
+      UNROLL for (int r = 0; r < filter_height; ++r) {
+        UNROLL for (int c = 0; c < filter_width; ++c) {
+          const S* const tile_ptr = shared_offset + shared_data;
+          S val = out1 * tile_ptr[0] + out2 * tile_ptr[tile_offset];
+          // Warp-accumulate pixels of the same depth and write to accumulator.
+          for (int delta = 16; delta >= kBlockDepth; delta /= 2) {
+            val += GpuShuffleXorSync(active_threads, val, delta);
+          }
+          if (!(thread_idx & 32 - kBlockDepth) /* lane_idx < kBlockDepth */) {
+            *accum_ptr = val;
+          }
+          shared_offset += kBlockDepth;
+          accum_ptr += accum_increment;
+        }
+        shared_offset += in_increment;
+      }
+    }
+
+    // Note: the condition to reach this is uniform across the entire block.
+    __syncthreads();
+
+    const S* const accum_data = tile_size + shared_data;
+    for (int i = thread_idx; i < accum_size; i += block_size) {
+      const int filter_idx = i / kAccumPixels;
+      const int filter_pix = filter_idx / kBlockDepth;
+      const int filter_channel = filter_idx % kBlockDepth + start_channel;
+      const int filter_offset = filter_pix * in_depth + filter_channel;
+      if (filter_channel < in_depth) {
+        S val = accum_data[i];
+        // Warp-accumulate the pixels of the same depth from the accumulator.
+        val = WarpSumReduce<kAccumPixels>(val);
+        if (!(thread_idx & kAccumPixels - 1)) {
+          GpuAtomicAdd(filter_offset + filter, static_cast<T>(val));
+        }
+      }
+    }
+  }
+}
+
+// A GPU kernel to compute the depthwise convolution backprop w.r.t. filter.
+template <typename T>
+__global__ void __launch_bounds__(512, 2)
+    DepthwiseConv2dBackpropFilterGPUKernelNCHW(
+        const DepthwiseArgs args, const T* __restrict__ out_backprop,
+        const T* __restrict__ input, T* __restrict__ filter_backprop) {
+  const int batch_num = args.batch;
+  const int in_depth = args.in_depth;
+  const int in_height = args.in_rows;
+  const int in_width = args.in_cols;
+  const int filter_width = args.filter_cols;
+  const int stride_height = args.stride;
+  const int stride_width = args.stride;
+  const int pad_height = args.pad_rows;
+  const int pad_width = args.pad_cols;
+  const int out_depth = args.out_depth;
+  const int out_height = args.out_rows;
+  const FastDividerUint32 out_width = args.out_cols;
+  const FastDividerUint32 depth_multiplier = args.depth_multiplier;
+  assert(gridDim.x == filter_width);
+  assert(gridDim.z == out_depth);
+
+  typedef gpuprim::WarpReduce<T> WarpReduce;
+  typename WarpReduce::TempStorage temp_storage;
+
+  const int filter_w = blockIdx.x;
+  const int filter_h = blockIdx.y;
+  const int out_c = blockIdx.z;
+
+  const int in_c = out_c / depth_multiplier;
+  const int dm = out_c % depth_multiplier;
+  const int filter_backprop_offset =
+      (((filter_h * filter_width) + filter_w) * in_depth + in_c) *
+          depth_multiplier +
+      dm;
+  const int out_spatial_size = out_height * out_width;
+
+  T partial_sum = static_cast<T>(0.f);
+  for (int batch = 0; batch < batch_num; batch++) {
+    const int input_offset_temp = (batch * in_depth + in_c) * in_height;
+    const int output_backprop_offset_temp =
+        (batch * out_depth + out_c) * out_height;
+    for (int i = threadIdx.x; i < out_spatial_size; i += blockDim.x) {
+      const int out_col = i % out_width;
+      const int out_row = i / out_width;
+      // We use the formula: `(in_row - filter_w + pad_left ) / stride =
+      // out_row` to compute corresponding in_row and out_row positions. Similar
+      // for in_col and out_col.
+      const int in_row = out_row * stride_height + filter_h - pad_height;
+      const int in_col = out_col * stride_width + filter_w - pad_width;
+
+      if (in_row < 0 || in_col < 0 || in_row >= in_height ||
+          in_col >= in_width) {
+        continue;
+      }
+
+      int input_offset = (input_offset_temp + in_row) * in_width + in_col;
+      int output_backprop_offset =
+          (output_backprop_offset_temp + out_row) * out_width + out_col;
+      partial_sum += out_backprop[output_backprop_offset] * input[input_offset];
+    }
+  }
+
+  T val = WarpReduce(temp_storage).Sum(partial_sum);
+  if (gpuprim::LaneId() == 0) {
+    T* addr = filter_backprop + filter_backprop_offset;
+    GpuAtomicAdd(addr, val);
+  }
+}
+
+// CUDA kernel to compute the depthwise convolution backward w.r.t. filter in
+// NCHW format, tailored for small images up to 32x32. Stride and depth
+// multiplier must be 1. Padding must be 'SAME'. Only use this kernel if
+// CanLaunchDepthwiseConv2dGPUSmall(args) returns true.
+// Tiles of the input tensor are loaded into shared memory before performing the
+// convolution. Per iteration and filter element, each thread first performs
+// a partial convolution for two elements, one each in the lower and upper half
+// of a tile. The intermediate result of all pixels of a warp are then
+// accumulated and written to shared memory. Finally, the values in shared
+// memory are warp-accumulated (in chunks of kAccumPixels elements) and summed
+// up in global memory using atomics.
+// Requirements: threads per block must be multiple of 32 and <= launch_bounds,
+// kAccumPixels * 64 >= args.in_rows * args.in_cols * kBlockDepth.
+template <typename T, int kKnownFilterWidth, int kKnownFilterHeight,
+          int kBlockDepth, int kAccumPixels>
+__global__
+__launch_bounds__(1024, 2) void DepthwiseConv2dBackpropFilterGPUKernelNCHWSmall(
+    const DepthwiseArgs args, const T* __restrict__ output,
+    const T* __restrict__ input, T* __restrict__ filter) {
+  typedef typename detail::PseudoHalfType<T>::Type S;
+  assert(CanLaunchDepthwiseConv2dBackpropFilterGPUSmall(args, blockDim.x));
+  // Holds block plus halo and filter data for blockDim.z depths.
+  GPU_DYNAMIC_SHARED_MEM_DECL(8, unsigned char, shared_memory);
+  static_assert(sizeof(S) <= 8, "Insufficient alignment detected");
+  S* const shared_data = reinterpret_cast<S*>(shared_memory);
+
+  const int num_batches = args.batch;
+  const int in_height = args.in_rows;
+  const int in_width = blockDim.x;  // slower (see b/62280718): args.in_cols;
+  const int in_depth = args.in_depth;
+  const int filter_height =
+      kKnownFilterHeight < 0 ? args.filter_rows : kKnownFilterHeight;
+  const int filter_width =
+      kKnownFilterWidth < 0 ? args.filter_cols : kKnownFilterWidth;
+  const int pad_height = args.pad_rows;
+  const int pad_width = args.pad_cols;
+
+  assert(blockDim.x == args.in_cols);
+  assert(blockDim.z == kBlockDepth);
+  const int block_height = blockDim.y;
+
+  // These values are the same for all threads and could
+  // be precomputed on the CPU.
+  const int block_pixels = in_width * block_height;
+  const int block_size = block_pixels * kBlockDepth;
+  assert((block_size & 31) == 0);
+  const int in_pixels = in_width * in_height;
+  const int in_increment = in_width - 1;
+  const int filter_pixels = filter_height * filter_width;
+  const int tile_width = in_width + filter_width - 1;
+  const int tile_height = 2 * block_height + filter_height - 1;
+  const int tile_pixels = tile_width * tile_height;
+  const int tile_size = tile_pixels * kBlockDepth;
+  const int tile_offset = block_height * tile_width;
+  const int pad_offset = pad_height * tile_width + pad_width;
+  const int in_total_depth = in_depth * num_batches;
+  const int in_blocks = (in_total_depth + kBlockDepth - 1) / kBlockDepth;
+  // The accumulator has a fixed number of pixels that can be reduced by one
+  // warp. Pixels beyond ceil(in_pixels * kBlockDepth / 64) are never written.
+  assert(kAccumPixels * 64 >= in_height * in_width * kBlockDepth);
+  const int accum_increment = kAccumPixels * kBlockDepth;
+  const int accum_size = filter_pixels * accum_increment;
+
+  const int thread_col = threadIdx.x;
+  const int thread_row = threadIdx.y;
+  const int thread_depth = threadIdx.z;
+
+  // Position in block.
+  const int thread_pix = thread_row * in_width + thread_col;
+  const int thread_idx = thread_depth * block_pixels + thread_pix;
+
+  // Initialize tile, in particular the padding and accumulator.
+  for (int i = thread_idx; i < tile_size + accum_size; i += block_size) {
+    shared_data[i] = S();
+  }
+  __syncthreads();
+
+  // Position in tensors.
+  const int tensor_idx = thread_depth * in_pixels + thread_pix;
+
+  // Position in (padded) shared memory.
+  const int data_pix = thread_row * tile_width + thread_col;
+  const int data_idx = thread_depth * tile_pixels + data_pix;
+
+  // Position in shared memory, offset by pad_height / pad_width.
+  const int tile_idx = data_idx + pad_offset;
+
+  // Position in accumulator (kBlockDepth per warp, depth major).
+  const int accum_pix = thread_pix / (32 / kBlockDepth);
+  const int accum_idx = thread_depth * kAccumPixels + accum_pix;
+
+  const int max_channel = in_total_depth - thread_depth;
+  const int accum_offset = tile_size + accum_idx;
+  const bool skip_second = block_height + thread_row >= in_height;
+
+  for (int b = blockIdx.x; b < in_blocks; b += gridDim.x) {
+    const int channel = b * kBlockDepth;
+
+    const int inout_offset = channel * in_pixels + tensor_idx;
+    const bool channel_in_range = channel < max_channel;
+
+    if (channel_in_range) {
+      const T* const in_ptr = inout_offset + input;
+      S* const tile_ptr = tile_idx + shared_data;
+      tile_ptr[0] = static_cast<S>(ldg(in_ptr));
+      if (!skip_second) {
+        tile_ptr[tile_offset] = static_cast<S>(ldg(block_pixels + in_ptr));
+      }
+    }
+
+    // Note: the condition to reach this is uniform across the entire block.
+    __syncthreads();
+    unsigned active_threads = GpuBallotSync(kCudaWarpAll, channel_in_range);
+
+    if (channel_in_range) {
+      const T* const out_ptr = inout_offset + output;
+      const S out1 = static_cast<S>(ldg(out_ptr));
+      const S out2 =
+          skip_second ? S() : static_cast<S>(ldg(block_pixels + out_ptr));
+      int shared_offset = data_idx;
+      S* accum_ptr = accum_offset + shared_data;
+      UNROLL for (int r = 0; r < filter_height; ++r) {
+        UNROLL for (int c = 0; c < filter_width; ++c) {
+          const S* const tile_ptr = shared_offset + shared_data;
+          S val = out1 * tile_ptr[0] + out2 * tile_ptr[tile_offset];
+          // Warp-accumulate pixels of the same depth and write to accumulator.
+          for (int delta = 16 / kBlockDepth; delta > 0; delta /= 2) {
+            val += GpuShuffleXorSync(active_threads, val, delta);
+          }
+          if (!(thread_idx & 32 / kBlockDepth - 1)) {
+            *accum_ptr = val;  // kBlockDepth threads per warp.
+          }
+          ++shared_offset;
+          accum_ptr += accum_increment;
+        }
+        shared_offset += in_increment;
+      }
+    }
+
+    // Note: the condition to reach this is uniform across the entire block.
+    __syncthreads();
+
+    const S* const accum_data = tile_size + shared_data;
+    for (int i = thread_idx; i < accum_size; i += block_size) {
+      const int filter_idx = i / kAccumPixels;
+      const int filter_pix = filter_idx / kBlockDepth;
+      const int filter_channel =
+          (channel + filter_idx % kBlockDepth) % in_depth;
+      const int filter_offset = filter_pix * in_depth + filter_channel;
+      if (filter_channel < in_depth) {
+        S val = accum_data[i];
+        // Warp-accumulate pixels of the same depth from the accumulator.
+        val = WarpSumReduce<kAccumPixels>(val);
+        if (!(thread_idx & kAccumPixels - 1)) {
+          GpuAtomicAdd(filter_offset + filter, static_cast<T>(val));
+        }
+      }
+    }
+  }
+}
+
+template <typename T, int kKnownFilterWidth, int kKnownFilterHeight,
+          int kBlockDepth, int kAccumPixels>
+Status TryLaunchDepthwiseConv2dBackpropFilterGPUSmall(
+    OpKernelContext* ctx, const DepthwiseArgs& args, const int block_height,
+    const T* out_backprop, const T* input, T* filter_backprop,
+    TensorFormat data_format) {
+  typedef typename detail::PseudoHalfType<T>::Type S;
+  auto device = ctx->eigen_gpu_device();
+  const int tile_width = args.in_cols + args.filter_cols - 1;
+  const int tile_height = block_height * 2 + args.filter_rows - 1;
+  const int tile_pixels = tile_height * tile_width;
+  const int filter_pixels = args.filter_rows * args.filter_cols;
+  const int shared_memory_size =
+      kBlockDepth * (tile_pixels + filter_pixels * kAccumPixels) * sizeof(S);
+  if (shared_memory_size > device.sharedMemPerBlock()) {
+    return errors::FailedPrecondition("Not enough shared memory");
+  }
+
+  dim3 block_dim;
+  int block_count;
+  void (*kernel)(const DepthwiseArgs, const T*, const T*, T*);
+  switch (data_format) {
+    case FORMAT_NHWC:
+      block_dim = dim3(kBlockDepth, args.in_cols, block_height);
+      block_count =
+          args.batch * DivUp(args.out_depth, kBlockDepth) * kBlockDepth;
+      kernel = DepthwiseConv2dBackpropFilterGPUKernelNHWCSmall<
+          T, kKnownFilterWidth, kKnownFilterHeight, kBlockDepth, kAccumPixels>;
+      break;
+    case FORMAT_NCHW:
+      block_dim = dim3(args.in_cols, block_height, kBlockDepth);
+      block_count =
+          DivUp(args.batch * args.out_depth, kBlockDepth) * kBlockDepth;
+      kernel = DepthwiseConv2dBackpropFilterGPUKernelNCHWSmall<
+          T, kKnownFilterWidth, kKnownFilterHeight, kBlockDepth, kAccumPixels>;
+      break;
+    default:
+      return errors::InvalidArgument("FORMAT_", ToString(data_format),
+                                     " is not supported");
+  }
+  const int num_out_backprop = args.out_rows * args.out_cols * block_count;
+  GpuLaunchConfig config = GetGpuLaunchConfigFixedBlockSize(
+      num_out_backprop, device, kernel, shared_memory_size,
+      block_dim.x * block_dim.y * block_dim.z);
+  TF_CHECK_OK(GpuLaunchKernel(kernel, config.block_count, block_dim,
+                              shared_memory_size, device.stream(), args,
+                              out_backprop, input, filter_backprop));
+  return OkStatus();
+}
+
+template <typename T, int kKnownFilterWidth, int kKnownFilterHeight,
+          int kBlockDepth>
+Status TryLaunchDepthwiseConv2dBackpropFilterGPUSmall(
+    OpKernelContext* ctx, const DepthwiseArgs& args, const int block_height,
+    const T* out_backprop, const T* input, T* filter_backprop,
+    TensorFormat data_format) {
+  // Minimize (power of two) kAccumPixels, while satisfying
+  // kAccumPixels * 32 >= block_height * in_width * kBlockDepth.
+  const int block_pixels = block_height * args.in_cols * kBlockDepth;
+  if (block_pixels > 512) {
+    return TryLaunchDepthwiseConv2dBackpropFilterGPUSmall<
+        T, kKnownFilterWidth, kKnownFilterHeight, kBlockDepth, 32>(
+        ctx, args, block_height, out_backprop, input, filter_backprop,
+        data_format);
+  } else if (block_pixels > 256) {
+    return TryLaunchDepthwiseConv2dBackpropFilterGPUSmall<
+        T, kKnownFilterWidth, kKnownFilterHeight, kBlockDepth, 16>(
+        ctx, args, block_height, out_backprop, input, filter_backprop,
+        data_format);
+  } else {
+    return TryLaunchDepthwiseConv2dBackpropFilterGPUSmall<
+        T, kKnownFilterWidth, kKnownFilterHeight, kBlockDepth, 8>(
+        ctx, args, block_height, out_backprop, input, filter_backprop,
+        data_format);
+  }
+}
+
+template <typename T, int kKnownFilterWidth, int kKnownFilterHeight>
+Status TryLaunchDepthwiseConv2dBackpropFilterGPUSmall(
+    OpKernelContext* ctx, const DepthwiseArgs& args, const T* out_backprop,
+    const T* input, T* filter_backprop, TensorFormat data_format) {
+  // Maximize (power of two) kBlockDepth while keeping a block within 1024
+  // threads (2 pixels per thread).
+  int block_depth = 8;
+  int block_height = (args.in_rows + 1) / 2;
+  int round_mask = 1;
+  for (; block_depth > 1; block_depth /= 2) {
+    // args.in_cols * block_height * kBlockDepth must be multiple of 32.
+    for (; block_height * args.in_cols * block_depth & 31;
+         round_mask = round_mask * 2 + 1) {
+      block_height = block_height + round_mask & ~round_mask;
+    }
+    int block_size = block_height * args.in_cols * block_depth;
+    if (block_size <= 1024) {
+      break;
+    }
+  }
+
+  if (!CanLaunchDepthwiseConv2dBackpropFilterGPUSmall(args, block_height)) {
+    return errors::FailedPrecondition("Cannot launch this configuration");
+  }
+
+  switch (block_depth) {
+    case 8:
+      return TryLaunchDepthwiseConv2dBackpropFilterGPUSmall<
+          T, kKnownFilterWidth, kKnownFilterHeight, 8>(
+          ctx, args, block_height, out_backprop, input, filter_backprop,
+          data_format);
+    case 4:
+      return TryLaunchDepthwiseConv2dBackpropFilterGPUSmall<
+          T, kKnownFilterWidth, kKnownFilterHeight, 4>(
+          ctx, args, block_height, out_backprop, input, filter_backprop,
+          data_format);
+    case 2:
+      return TryLaunchDepthwiseConv2dBackpropFilterGPUSmall<
+          T, kKnownFilterWidth, kKnownFilterHeight, 2>(
+          ctx, args, block_height, out_backprop, input, filter_backprop,
+          data_format);
+    default:
+      return errors::InvalidArgument("Unexpected block depth");
+  }
+}
+
+template <typename T, int kKnownFilterWidth, int kKnownFilterHeight,
+          int kKnownDepthMultiplier>
+Status LaunchDepthwiseConv2dBackpropFilterGPU(
+    OpKernelContext* ctx, const DepthwiseArgs& args, const T* out_backprop,
+    const T* input, T* filter_backprop, TensorFormat data_format) {
+  auto device = ctx->eigen_gpu_device();
+  const int num_out_backprop =
+      args.batch * args.out_rows * args.out_cols * args.out_depth;
+  if (data_format == FORMAT_NHWC) {
+    auto kernel = DepthwiseConv2dBackpropFilterGPUKernelNHWC<
+        T, kKnownFilterWidth, kKnownFilterHeight, kKnownDepthMultiplier>;
+
+    int launch_bounds_value = 640;
+    GpuLaunchConfig config = GetGpuLaunchConfig(num_out_backprop, device,
+                                                kernel, 0, launch_bounds_value);
+    TF_CHECK_OK(GpuLaunchKernel(
+        kernel, config.block_count, config.thread_per_block, 0, device.stream(),
+        args, out_backprop, input, filter_backprop, num_out_backprop));
+  } else if (data_format == FORMAT_NCHW) {
+    auto kernel = DepthwiseConv2dBackpropFilterGPUKernelNCHW<T>;
+    dim3 blocks = dim3(args.filter_cols, args.filter_rows, args.out_depth);
+    dim3 threads = dim3(512, 1, 1);
+
+    TF_CHECK_OK(GpuLaunchKernel(kernel, blocks, threads, 0, device.stream(),
+                                args, out_backprop, input, filter_backprop));
+  } else {
+    return errors::InvalidArgument("FORMAT_", ToString(data_format),
+                                   " is not supported");
+  }
+
+  return OkStatus();
+}
+
+template <typename T, int kKnownFilterWidth, int kKnownFilterHeight>
+Status LaunchDepthwiseConv2dBackpropFilterGPU(
+    OpKernelContext* ctx, const DepthwiseArgs& args, const T* out_backprop,
+    const T* input, T* filter_backprop, TensorFormat data_format) {
+  if (args.depth_multiplier == 1) {
+    if (TryLaunchDepthwiseConv2dBackpropFilterGPUSmall<T, kKnownFilterWidth,
+                                                       kKnownFilterHeight>(
+            ctx, args, out_backprop, input, filter_backprop, data_format)
+            .ok()) {
+      return OkStatus();
+    }
+
+    return LaunchDepthwiseConv2dBackpropFilterGPU<T, kKnownFilterWidth,
+                                                  kKnownFilterHeight, 1>(
+        ctx, args, out_backprop, input, filter_backprop, data_format);
+  } else {
+    return LaunchDepthwiseConv2dBackpropFilterGPU<T, kKnownFilterWidth,
+                                                  kKnownFilterHeight, -1>(
+        ctx, args, out_backprop, input, filter_backprop, data_format);
+  }
+}
+
+// A simple launch pad to launch the GPU kernel for depthwise convolution.
+template <typename T>
+void LaunchDepthwiseConvBackpropFilterOp<GpuDevice, T>::operator()(
+    OpKernelContext* ctx, const DepthwiseArgs& args, const T* out_backprop,
+    const T* input, T* filter_backprop, TensorFormat data_format) {
+  auto stream = ctx->op_device_context()->stream();
+
+  // It's simpler to catch this here than in
+  // DepthwiseConv2dNativeBackpropFilterOp
+  OP_REQUIRES(
+      ctx, !OpDeterminismRequired(),
+      errors::Unimplemented(
+          "A deterministic GPU implementation of DepthwiseConvBackpropFilter is"
+          " not available with this version of cuDNN. Please build with cuDNN"
+          " version 7.6.3 or later."));
+
+  // Initialize the results to 0.
+  int num_filter_backprop =
+      args.filter_rows * args.filter_cols * args.out_depth;
+  se::DeviceMemoryBase filter_bp_ptr(filter_backprop, num_filter_backprop);
+  stream->ThenMemZero(&filter_bp_ptr, num_filter_backprop * sizeof(T));
+
+  if (args.filter_rows == 3 && args.filter_cols == 3) {
+    OP_REQUIRES_OK(
+        ctx, LaunchDepthwiseConv2dBackpropFilterGPU<T, 3, 3>(
+                 ctx, args, out_backprop, input, filter_backprop, data_format));
+  } else {
+    OP_REQUIRES_OK(
+        ctx, LaunchDepthwiseConv2dBackpropFilterGPU<T, -1, -1>(
+                 ctx, args, out_backprop, input, filter_backprop, data_format));
+  }
+}
+}  // namespace tensorflow
+#endif  // GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+
+#endif  // TENSORFLOW_CORE_KERNELS_DEPTHWISE_CONV_OP_GPU_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/diag_op.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/diag_op.h
new file mode 100644
index 0000000000000000000000000000000000000000..e00857da530d3f6e08e46971f09569f989fa6282
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/diag_op.h
@@ -0,0 +1,43 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_DIAG_OP_H_
+#define TENSORFLOW_CORE_KERNELS_DIAG_OP_H_
+
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/tensor_types.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+
+namespace functor {
+
+template <typename Device, typename T>
+struct DiagFunctor {
+  Status operator()(OpKernelContext* context, const int64_t size, const T* in,
+                    T* out);
+};
+
+template <typename Device, typename T>
+struct DiagPartFunctor {
+  Status operator()(OpKernelContext* context, const int64_t size, const T* in,
+                    T* out);
+};
+
+}  // namespace functor
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_DIAG_OP_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/dilation_ops.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/dilation_ops.h
new file mode 100644
index 0000000000000000000000000000000000000000..4f0b944a22620d3c1a640dfe6e863549059972a5
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/dilation_ops.h
@@ -0,0 +1,66 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_DILATION_OPS_H_
+#define TENSORFLOW_CORE_KERNELS_DILATION_OPS_H_
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/framework/tensor_types.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+namespace functor {
+
+template <typename Device, typename T>
+struct Dilation {
+  // We assume that the tensor sizes are correct.
+  void operator()(const Device& d, typename TTypes<T, 4>::ConstTensor input,
+                  typename TTypes<T, 3>::ConstTensor filter, int stride_rows,
+                  int stride_cols, int rate_rows, int rate_cols, int pad_top,
+                  int pad_left, typename TTypes<T, 4>::Tensor output);
+};
+
+template <typename Device, typename T>
+struct DilationBackpropInput {
+  // We assume that the tensor sizes are correct.
+  // To avoid storing the argmax values during forward computation, we recompute
+  // the argmax during backward computation, which is the reason why we provide
+  // filter as argument to the backward computation routine.
+  void operator()(const Device& d, typename TTypes<T, 4>::ConstTensor input,
+                  typename TTypes<T, 3>::ConstTensor filter,
+                  typename TTypes<T, 4>::ConstTensor out_backprop,
+                  int stride_rows, int stride_cols, int rate_rows,
+                  int rate_cols, int pad_top, int pad_left,
+                  typename TTypes<T, 4>::Tensor in_backprop);
+};
+
+template <typename Device, typename T>
+struct DilationBackpropFilter {
+  // We assume that the tensor sizes are correct.
+  // To avoid storing the argmax values during forward computation, we recompute
+  // the argmax during backward computation, which is the reason why we provide
+  // filter as argument to the backward computation routine.
+  void operator()(const Device& d, typename TTypes<T, 4>::ConstTensor input,
+                  typename TTypes<T, 3>::ConstTensor filter,
+                  typename TTypes<T, 4>::ConstTensor out_backprop,
+                  int stride_rows, int stride_cols, int rate_rows,
+                  int rate_cols, int pad_top, int pad_left,
+                  typename TTypes<T, 3>::Tensor filter_backprop);
+};
+
+}  // namespace functor
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_DILATION_OPS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/eigen_activations.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/eigen_activations.h
new file mode 100644
index 0000000000000000000000000000000000000000..8224627f844d846d032c7ad6ae0e0d72ab1ce11f
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/eigen_activations.h
@@ -0,0 +1,122 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_EIGEN_ACTIVATIONS_H_
+#define TENSORFLOW_CORE_KERNELS_EIGEN_ACTIVATIONS_H_
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+
+namespace Eigen {
+
+/** scalar_sigmoid_fast_derivative_op
+ * \ingroup CXX11_NeuralNetworks_Module
+ * \brief Template functor to compute the fast derivative of a sigmoid
+ *
+ * Input should be the backpropagated gradient.
+ *
+ * \sa class CwiseUnaryOp, Cwise::sigmoid_fast_derivative()
+ */
+template <typename T>
+struct scalar_sigmoid_fast_derivative_op {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T operator()(const T& y) const {
+    const T one = T(1);
+    return (one - y) * y;
+  }
+
+  template <typename Packet>
+  inline Packet packetOp(const Packet& y) const {
+    const Packet one = internal::pset1<Packet>(1);
+    return internal::pmul(internal::psub(one, y), y);
+  }
+};
+
+namespace internal {
+template <typename T>
+struct functor_traits<scalar_sigmoid_fast_derivative_op<T> > {
+  enum {
+    Cost = NumTraits<T>::AddCost * 2 + NumTraits<T>::MulCost,
+    PacketAccess = packet_traits<T>::HasAdd && packet_traits<T>::HasMul &&
+                   packet_traits<T>::HasNegate
+  };
+};
+}  // namespace internal
+
+/** scalar_tanh_fast_derivative_op
+ * \ingroup CXX11_NeuralNetworks_Module
+ * \brief Template functor to compute the fast derivative of a tanh
+ *
+ * Input should be the backpropagated gradient.
+ *
+ * \sa class CwiseUnaryOp, Cwise::tanh_fast_derivative()
+ */
+template <typename T>
+struct scalar_tanh_fast_derivative_op {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T operator()(const T& y) const {
+    const T one = T(1);
+    return one - (y * y);
+  }
+
+  template <typename Packet>
+  inline Packet packetOp(const Packet& y) const {
+    const Packet one = internal::pset1<Packet>(1);
+    return internal::psub(one, internal::pmul(y, y));
+  }
+};
+
+namespace internal {
+template <typename T>
+struct functor_traits<scalar_tanh_fast_derivative_op<T> > {
+  enum {
+    Cost = NumTraits<T>::AddCost * 2 + NumTraits<T>::MulCost * 1,
+    PacketAccess = packet_traits<T>::HasAdd && packet_traits<T>::HasMul &&
+                   packet_traits<T>::HasNegate
+  };
+};
+}  // namespace internal
+
+/**
+ * \ingroup CXX11_NeuralNetworks_Module
+ * \brief Template functor to clip the magnitude of the first scalar.
+ *
+ * \sa class CwiseBinaryOp, MatrixBase::Clip
+ */
+template <typename Scalar>
+struct scalar_clip_op {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar
+  operator()(const Scalar& a, const Scalar& b) const {
+    return numext::mini(numext::maxi(a, -b), b);
+  }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet
+  packetOp(const Packet& a, const Packet& b) const {
+    return internal::pmin(internal::pmax(a, internal::pnegate(b)), b);
+  }
+};
+
+namespace internal {
+template <typename Scalar>
+struct functor_traits<scalar_clip_op<Scalar> > {
+  enum {
+    Cost = NumTraits<Scalar>::AddCost * 3,
+    PacketAccess = packet_traits<Scalar>::HasMax &&
+                   packet_traits<Scalar>::HasMin &&
+                   packet_traits<Scalar>::HasNegate
+  };
+};
+}  // namespace internal
+
+}  // end namespace Eigen
+
+#endif  // TENSORFLOW_CORE_KERNELS_EIGEN_ACTIVATIONS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/eigen_attention.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/eigen_attention.h
new file mode 100644
index 0000000000000000000000000000000000000000..7eec12bf1bbf163a675dae7499a8300bdda72c2f
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/eigen_attention.h
@@ -0,0 +1,300 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_EIGEN_ATTENTION_H_
+#define TENSORFLOW_CORE_KERNELS_EIGEN_ATTENTION_H_
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+
+namespace Eigen {
+
+// Noise mode used when padding.
+enum ExtractGlimpsesNoiseMode {
+  UNIFORM = 0,
+  GAUSSIAN = 1,
+  ZERO = 2,
+};
+
+/** ExtractGlimpses
+ * \ingroup CXX11_NeuralNetworks_Module
+ *
+ * \brief Extract glimpses from an input tensor.
+ *
+ * The input parameter is expected to be a col-major tensor with a rank of 4
+ * (depth, x, y, and batch). The width and height parameters specify the
+ * extension of the returned glimpses. The offsets parameter specifies the x, y
+ * locations of the center of the glimpses relative to the center of the input
+ * image. The vector is expected to contain one IndexPair for each image in the
+ * batch dimension. The normalized boolean indicates if incoming coordinates are
+ * normalized so that 0.0 and 1.0 correspond to the minimum and maximum of each
+ * height and width dimension. The centered boolean indicates if incoming
+ * coordinates are centered relative to the image, in which case -1.0 and 1.0
+ * correspond to minimum and maximum of each dimension while 0.0 corresponds to
+ * the center.
+ *
+ * The result can be assigned to a tensor of rank equal to that of the input.
+ * The result will be laid out in col-major order (depth, x, y, batch). The
+ * dimensions of the result will be equal to the dimensions of the input except
+ * for width and height which will be equal to the requested glimpse size.
+ */
+namespace {
+
+template <typename Index>
+struct GlimpseExtractionOp {
+  GlimpseExtractionOp(const Index width, const Index height,
+                      const std::vector<IndexPair<float> >& offsets,
+                      const bool normalized, const bool centered,
+                      const ExtractGlimpsesNoiseMode noise, const int version)
+      : width_(width),
+        height_(height),
+        offsets_(offsets),
+        normalized_(normalized),
+        centered_(centered),
+        noise_(noise),
+        version_(version) {}
+
+  template <typename Input>
+  DSizes<Index, 4> dimensions(const Input& input) const {
+    typedef typename internal::traits<Input>::Index IndexType;
+    typedef TensorRef<Tensor<typename internal::traits<Input>::Scalar, 4,
+                             internal::traits<Input>::Layout, IndexType> >
+        Ref;
+    Ref in(input);
+
+    DSizes<Index, 4> dims = in.dimensions();
+
+    dims[0] = in.dimension(0);
+    dims[1] = width_;
+    dims[2] = height_;
+    dims[3] = in.dimension(3);
+    return dims;
+  }
+
+  template <typename Input, typename Output, typename Device>
+  EIGEN_DEVICE_FUNC void eval(const Input& input, Output& output,
+                              const Device& device) const {
+    typedef typename internal::traits<Input>::Index IndexType;
+    typedef TensorRef<Tensor<typename internal::traits<Input>::Scalar, 4,
+                             internal::traits<Input>::Layout, IndexType> >
+        Ref;
+    Ref in(input);
+    const Index num_channels = in.dimension(0);
+    const Index input_width = in.dimension(1);
+    const Index input_height = in.dimension(2);
+    const Index batch_size = in.dimension(3);
+    eigen_assert(input_width > 0);
+    eigen_assert(input_height > 0);
+    internal::NormalRandomGenerator<float> gen;
+    internal::UniformRandomGenerator<float> unigen;
+
+    for (Index i = 0; i < batch_size; ++i) {
+      float x = offsets_[i].first, y = offsets_[i].second;
+
+      if (version_ == 1) {
+        // Un-normalize coordinates back to pixel space if normalized.
+        if (normalized_) {
+          x *= input_width;
+          y *= input_height;
+        }
+        // Un-center if coordinates are centered on the image center.
+        if (centered_) {
+          x /= 2.0f;
+          y /= 2.0f;
+          x += input_width / 2.0f;
+          y += input_height / 2.0f;
+        }
+        // Remove half of the glimpse window.
+        x -= width_ / 2.0f;
+        y -= height_ / 2.0f;
+      } else {
+        if (normalized_) {
+          // Un-normalize coordinates back to pixel space if normalized.
+          x *= input_width;
+          y *= input_height;
+          if (centered_) {
+            // Un-center if coordinates are centered on the image center.
+            x /= 2.0f;
+            y /= 2.0f;
+            x += input_width / 2.0f;
+            y += input_height / 2.0f;
+            // Remove half of the glimpse window.
+            x -= width_ / 2.0f;
+            y -= height_ / 2.0f;
+          }
+        } else {
+          if (centered_) {
+            x += input_width / 2.0f;
+            y += input_height / 2.0f;
+          }
+        }
+      }
+
+      const Index offset_x = (Index)x;
+      const Index offset_y = (Index)y;
+      Index glimpse_width = width_;
+      Index glimpse_height = height_;
+      bool partial_overlap = false;
+      DSizes<Index, 3> slice_offset(0, offset_x, offset_y);
+      DSizes<Index, 3> slice_extent(num_channels, width_, height_);
+      DSizes<Index, 3> base_offset(0, 0, 0);
+
+      if (offset_x < 0) {
+        slice_offset[1] = 0;
+        glimpse_width = (std::max<Index>)(0, width_ + offset_x);
+        slice_extent[1] = glimpse_width;
+        base_offset[1] = width_ - glimpse_width;
+        partial_overlap = true;
+      } else if (offset_x + width_ >= input_width) {
+        glimpse_width = (std::max<Index>)(0, input_width - offset_x);
+        slice_extent[1] = glimpse_width;
+        partial_overlap = true;
+      }
+      if (offset_y < 0) {
+        slice_offset[2] = 0;
+        glimpse_height = (std::max<Index>)(0, height_ + offset_y);
+        slice_extent[2] = glimpse_height;
+        base_offset[2] = height_ - glimpse_height;
+        partial_overlap = true;
+      } else if (offset_y + height_ >= input_height) {
+        glimpse_height = (std::max<Index>)(0, input_height - offset_y);
+        slice_extent[2] = glimpse_height;
+        partial_overlap = true;
+      }
+      slice_extent[1] = std::min<Index>(input_width, slice_extent[1]);
+      slice_extent[2] = std::min<Index>(input_height, slice_extent[2]);
+
+      if (partial_overlap) {
+        switch (noise_) {
+          case ZERO: {
+            // Initialize the glimpse with zero noise.
+            output.template chip<3>(i).device(device) =
+                output.template chip<3>(i).constant(0);
+          } break;
+          case UNIFORM: {
+            // Initialize the glimpse with uniform noise.
+            typedef std::remove_const_t<
+                typename internal::traits<Input>::Scalar>
+                Scalar;
+            TensorFixedSize<Scalar, Sizes<> > mini;
+            mini.device(device) = input.template chip<3>(i).minimum();
+            TensorFixedSize<float, Sizes<> > range;
+            range.device(device) = (input.template chip<3>(i).maximum() - mini)
+                                       .template cast<float>();
+
+            DSizes<Index, 3> glimpse_size(num_channels, width_, height_);
+            TensorMap<Tensor<float, 3> > tmp(nullptr, glimpse_size);
+            output.template chip<3>(i).device(device) =
+                mini.reshape(Sizes<1, 1, 1>()).broadcast(glimpse_size) +
+                (tmp.random(unigen) *
+                 range.reshape(Sizes<1, 1, 1>()).broadcast(glimpse_size))
+                    .template cast<Scalar>();
+          } break;
+          case GAUSSIAN: {
+            // Initialize the glimpse with white noise: compute the mean and
+            // sigma
+            // of each channel, and use them to shape the gaussian.
+            DSizes<Index, 2> glimpse_size(width_, height_);
+            DSizes<Index, 2> input_size(input_width, input_height);
+            typedef std::remove_const_t<
+                typename internal::traits<Input>::Scalar>
+                Scalar;
+
+            for (int j = 0; j < num_channels; ++j) {
+              TensorFixedSize<Scalar, Sizes<> > mean;
+              mean.device(device) = input.template chip<3>(i)
+                                        .template chip<0>(j)
+                                        .template cast<float>()
+                                        .mean();
+              TensorFixedSize<float, Sizes<> > sigma;
+              sigma.device(device) =
+                  (input.template chip<3>(i)
+                       .template chip<0>(j)
+                       .template cast<float>() -
+                   mean.reshape(Sizes<1, 1>()).broadcast(input_size))
+                      .square()
+                      .mean()
+                      .sqrt();
+              TensorFixedSize<Scalar, Sizes<> > mini;
+              mini.device(device) =
+                  input.template chip<3>(i).template chip<0>(j).minimum();
+              TensorFixedSize<float, Sizes<> > maxi;
+              maxi.device(device) =
+                  input.template chip<3>(i).template chip<0>(j).maximum();
+
+              TensorMap<Tensor<float, 2> > tmp(nullptr, glimpse_size);
+              output.template chip<3>(i).template chip<0>(j).device(device) =
+                  (mean.reshape(Sizes<1, 1>()).broadcast(glimpse_size) +
+                   (tmp.random(gen) *
+                    sigma.reshape(Sizes<1, 1>()).broadcast(glimpse_size))
+                       .template cast<Scalar>())
+                      .cwiseMin(
+                          maxi.reshape(Sizes<1, 1>()).broadcast(glimpse_size))
+                      .cwiseMax(
+                          mini.reshape(Sizes<1, 1>()).broadcast(glimpse_size));
+            }
+          } break;
+        }
+
+        // Copy the part of the glimpse that cover the input image if any.
+        if (glimpse_width == 0 || glimpse_height == 0) {
+          continue;
+        }
+        output.template chip<3>(i)
+            .slice(base_offset, slice_extent)
+            .device(device) =
+            input.template chip<3>(i).slice(slice_offset, slice_extent);
+      } else {
+        output.template chip<3>(i).device(device) =
+            input.template chip<3>(i).slice(slice_offset, slice_extent);
+      }
+    }
+  }
+
+ private:
+  const Index width_;
+  const Index height_;
+  const std::vector<IndexPair<float> > offsets_;
+  const bool normalized_;
+  const bool centered_;
+  const ExtractGlimpsesNoiseMode noise_;
+  const int version_;
+};
+}  // namespace
+
+template <typename Input>
+EIGEN_ALWAYS_INLINE static const TensorCustomUnaryOp<
+    const GlimpseExtractionOp<typename internal::traits<Input>::Index>,
+    const Input>
+ExtractGlimpses(
+    const Input& input, const typename internal::traits<Input>::Index width,
+    const typename internal::traits<Input>::Index height,
+    const std::vector<IndexPair<float> >& offsets, const bool normalized = true,
+    const bool centered = true,
+    const ExtractGlimpsesNoiseMode noise = ExtractGlimpsesNoiseMode::UNIFORM,
+    const int version = 2) {
+  EIGEN_STATIC_ASSERT(internal::traits<Input>::Layout == ColMajor,
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT(internal::traits<Input>::NumDimensions == 4,
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+
+  typedef typename internal::traits<Input>::Index Index;
+  const GlimpseExtractionOp<Index> op(width, height, offsets, normalized,
+                                      centered, noise, version);
+  return input.customOp(op);
+}
+
+}  // end namespace Eigen
+
+#endif  // TENSORFLOW_CORE_KERNELS_EIGEN_ATTENTION_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/eigen_backward_cuboid_convolutions.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/eigen_backward_cuboid_convolutions.h
new file mode 100644
index 0000000000000000000000000000000000000000..4ef1b924881f9c87f86fe53e6ad50945bb2dd80b
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/eigen_backward_cuboid_convolutions.h
@@ -0,0 +1,610 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_EIGEN_BACKWARD_CUBOID_CONVOLUTIONS_H_
+#define TENSORFLOW_CORE_KERNELS_EIGEN_BACKWARD_CUBOID_CONVOLUTIONS_H_
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/kernels/eigen_cuboid_convolution.h"
+
+namespace Eigen {
+
+/** CuboidConvolutionBackwardInput
+ * \ingroup CXX11_NeuralNetworks_Module
+ *
+ * \brief Computes the backprop for the input of a 3D convolution.
+ *
+ * The output_backward parameter is expected to be a tensor with a rank of 4 or
+ * more (channels, depth, height, width, and optionally others)
+ * The kernel parameter is expected to be a 5D tensor (filters, channels,
+ * kernel_depth, kernel_height, kernel_width)
+ * output_backward and kernel have to be in the same layout.
+ *
+ * The dimensions of the result will be filters, depth, height, width (and
+ * others if applicable).
+ *
+ * It is possible to swap the order of the depth, width and height dimensions
+ * provided that the same order is used in the input, the kernel, and the
+ * output.
+ *
+ * All dimension orders above are given for col-major, and should be reversed
+ * for row-major.
+ */
+
+template <typename OutputBackward, typename Kernel>
+EIGEN_ALWAYS_INLINE static const std::conditional_t<
+    internal::traits<OutputBackward>::Layout == ColMajor,
+    TensorReshapingOp<
+        const DSizes<typename internal::traits<OutputBackward>::Index,
+                     internal::traits<OutputBackward>::NumDimensions>,
+        const TensorContractionOp<
+            const array<
+                IndexPair<typename internal::traits<OutputBackward>::Index>, 1>,
+            const Eigen::TensorForcedEvalOp<const TensorReshapingOp<
+                const DSizes<typename internal::traits<OutputBackward>::Index,
+                             2>,
+                const TensorShufflingOp<
+                    const array<
+                        typename internal::traits<OutputBackward>::Index, 5>,
+                    const TensorReverseOp<const Eigen::array<bool, 5>,
+                                          const Kernel>>>>,
+            const TensorReshapingOp<
+                const DSizes<typename internal::traits<OutputBackward>::Index,
+                             2>,
+                const TensorVolumePatchOp<Dynamic, Dynamic, Dynamic,
+                                          const OutputBackward>>>>,
+    TensorReshapingOp<
+        const DSizes<typename internal::traits<OutputBackward>::Index,
+                     internal::traits<OutputBackward>::NumDimensions>,
+        const TensorContractionOp<
+            const array<
+                IndexPair<typename internal::traits<OutputBackward>::Index>, 1>,
+            const TensorReshapingOp<
+                const DSizes<typename internal::traits<OutputBackward>::Index,
+                             2>,
+                const TensorVolumePatchOp<Dynamic, Dynamic, Dynamic,
+                                          const OutputBackward>>,
+            const Eigen::TensorForcedEvalOp<const TensorReshapingOp<
+                const DSizes<typename internal::traits<OutputBackward>::Index,
+                             2>,
+                const TensorShufflingOp<
+                    const array<
+                        typename internal::traits<OutputBackward>::Index, 5>,
+                    const TensorReverseOp<const Eigen::array<bool, 5>,
+                                          const Kernel>>>>>>>
+CuboidConvolutionBackwardInput(
+    const Kernel& kernel, const OutputBackward& output_backward,
+    typename internal::traits<OutputBackward>::Index inputPlanes,
+    typename internal::traits<OutputBackward>::Index inputRows,
+    typename internal::traits<OutputBackward>::Index inputCols,
+    const DenseIndex plane_stride = 1, const DenseIndex row_stride = 1,
+    const DenseIndex col_stride = 1) {
+  typedef typename internal::traits<OutputBackward>::Index TensorIndex;
+  const TensorRef<const Tensor<typename internal::traits<Kernel>::Scalar,
+                               internal::traits<Kernel>::NumDimensions,
+                               internal::traits<Kernel>::Layout, TensorIndex>>
+      kern(kernel);
+  const TensorRef<
+      const Tensor<typename internal::traits<OutputBackward>::Scalar,
+                   internal::traits<OutputBackward>::NumDimensions,
+                   internal::traits<OutputBackward>::Layout, TensorIndex>>
+      out(output_backward);
+
+  EIGEN_STATIC_ASSERT(internal::traits<Kernel>::Layout ==
+                          internal::traits<OutputBackward>::Layout,
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+
+  static const bool isColMajor =
+      (internal::traits<OutputBackward>::Layout == ColMajor);
+
+  static const int NumDims = internal::traits<OutputBackward>::NumDimensions;
+
+  // Number of filters to apply. This is the same as the output depth of the
+  // result
+  const TensorIndex kernelFilters =
+      isColMajor ? kern.dimensions()[0] : kern.dimensions()[4];
+  // Number of channels. This is the same as the input depth.
+  const TensorIndex kernelChannels =
+      isColMajor ? kern.dimensions()[1] : kern.dimensions()[3];
+  const TensorIndex kernelPlanes =
+      isColMajor ? kern.dimensions()[2] : kern.dimensions()[2];
+  const TensorIndex kernelRows =
+      isColMajor ? kern.dimensions()[3] : kern.dimensions()[1];
+  const TensorIndex kernelCols =
+      isColMajor ? kern.dimensions()[4] : kern.dimensions()[0];
+
+  const TensorIndex outputPlanes =
+      isColMajor ? out.dimensions()[1] : out.dimensions()[NumDims - 2];
+  const TensorIndex outputRows =
+      isColMajor ? out.dimensions()[2] : out.dimensions()[NumDims - 3];
+  const TensorIndex outputCols =
+      isColMajor ? out.dimensions()[3] : out.dimensions()[NumDims - 4];
+
+  // TODO(ezhulenev): Add support for inflated strides. Without inflated strides
+  // effective kernel planes/rows/cols are always the same as the kernel itself
+  // (see eigen_spatial_convolutions for details).
+  const TensorIndex kernelPlanesEff = kernelPlanes;
+  const TensorIndex kernelRowsEff = kernelRows;
+  const TensorIndex kernelColsEff = kernelCols;
+
+  // Computing the forward padding.
+  const TensorIndex forward_pad_top_z = numext::maxi<Index>(
+      0,
+      ((outputPlanes - 1) * plane_stride + kernelPlanesEff - inputPlanes) / 2);
+  const TensorIndex forward_pad_top = numext::maxi<Index>(
+      0, ((outputRows - 1) * row_stride + kernelRowsEff - inputRows) / 2);
+  const TensorIndex forward_pad_left = numext::maxi<Index>(
+      0, ((outputCols - 1) * col_stride + kernelColsEff - inputCols) / 2);
+
+  const TensorIndex padding_top_z = kernelPlanesEff - 1 - forward_pad_top_z;
+  const TensorIndex padding_top = kernelRowsEff - 1 - forward_pad_top;
+  const TensorIndex padding_left = kernelColsEff - 1 - forward_pad_left;
+
+  const TensorIndex padding_bottom_z = inputPlanes -
+                                       (outputPlanes - 1) * plane_stride - 2 -
+                                       padding_top_z + kernelPlanesEff;
+  const TensorIndex padding_bottom = inputRows - (outputRows - 1) * row_stride -
+                                     2 - padding_top + kernelRowsEff;
+  const TensorIndex padding_right = inputCols - (outputCols - 1) * col_stride -
+                                    2 - padding_left + kernelColsEff;
+
+  eigen_assert(padding_top_z >= 0);
+  eigen_assert(padding_top >= 0);
+  eigen_assert(padding_left >= 0);
+  eigen_assert(padding_bottom_z >= 0);
+  eigen_assert(padding_bottom >= 0);
+  eigen_assert(padding_right >= 0);
+
+  // The kernel has dimensions :
+  //   filters x channels x patch_planes x patch_rows x patch_cols.
+  // We need to reverse the kernel along the spatial dimensions.
+  Eigen::array<bool, 5> kernel_reverse;
+  if (isColMajor) {
+    kernel_reverse[0] = false;
+    kernel_reverse[1] = false;
+    kernel_reverse[2] = true;
+    kernel_reverse[3] = true;
+    kernel_reverse[4] = true;
+  } else {
+    kernel_reverse[0] = true;
+    kernel_reverse[1] = true;
+    kernel_reverse[2] = true;
+    kernel_reverse[3] = false;
+    kernel_reverse[4] = false;
+  }
+
+  // Reorder the dimensions to:
+  //   filters x patch_planes x patch_rows x patch_cols x channels
+  array<TensorIndex, 5> kernel_shuffle;
+  if (isColMajor) {
+    //  From: filters x channels x planes x rows x cols
+    //  To:   filters x planes x rows x cols x channels
+    kernel_shuffle[0] = 0;
+    kernel_shuffle[1] = 2;
+    kernel_shuffle[2] = 3;
+    kernel_shuffle[3] = 4;
+    kernel_shuffle[4] = 1;
+  } else {
+    //  From: cols x rows x planes x channels x filters
+    //  To:   channels x cols x rows x planes x filters
+    kernel_shuffle[0] = 3;
+    kernel_shuffle[1] = 0;
+    kernel_shuffle[2] = 1;
+    kernel_shuffle[3] = 2;
+    kernel_shuffle[4] = 4;
+  }
+
+  // Collapse the dims
+  DSizes<TensorIndex, 2> kernel_dims;
+  if (isColMajor) {
+    kernel_dims[0] = kernelFilters * kernelPlanes * kernelRows * kernelCols;
+    kernel_dims[1] = kernelChannels;
+  } else {
+    kernel_dims[1] = kernelFilters * kernelPlanes * kernelRows * kernelCols;
+    kernel_dims[0] = kernelChannels;
+  }
+
+  // The output_backward has dimensions out_depth X out_planes X out_rows X
+  // out_cols X OTHERS
+  // When we extract the image patches from output_backward, it will have
+  // dimensions:
+  //   out_depth X (patch_planes * patch_rows * patch_cols) X (input_planes *
+  //   input_rows * input_cols * OTHERS)
+  DSizes<TensorIndex, 2> pre_contract_dims;
+  if (isColMajor) {
+    pre_contract_dims[0] =
+        kernelFilters * kernelPlanes * kernelRows * kernelCols;
+    pre_contract_dims[1] = inputPlanes * inputRows * inputCols;
+    for (int i = 4; i < NumDims; ++i) {
+      pre_contract_dims[1] *= out.dimension(i);
+    }
+  } else {
+    pre_contract_dims[1] =
+        kernelFilters * kernelPlanes * kernelRows * kernelCols;
+    pre_contract_dims[0] = inputPlanes * inputRows * inputCols;
+    for (int i = 0; i < NumDims - 4; ++i) {
+      pre_contract_dims[0] *= out.dimension(i);
+    }
+  }
+
+  // We will contract along the collapsed dimension that contains the
+  // kernelFilters, kernelPlanes, kernelRows and kernelCols.
+  array<IndexPair<TensorIndex>, 1> contract_dims;
+  if (isColMajor) {
+    // col-major: kernel.contract(output.patches)
+    contract_dims[0] = IndexPair<TensorIndex>(0, 0);
+  } else {
+    // row-major: output.patches.contract(kernel)
+    contract_dims[0] = IndexPair<TensorIndex>(1, 1);
+  }
+
+  // Post contraction, the dimensions of the input_backprop is
+  //  channels X input_planes X input_rows X input_cols X OTHERS
+  DSizes<TensorIndex, NumDims> post_contract_dims;
+  if (isColMajor) {
+    post_contract_dims[0] = kernelChannels;
+    post_contract_dims[1] = inputPlanes;
+    post_contract_dims[2] = inputRows;
+    post_contract_dims[3] = inputCols;
+    for (int i = 4; i < NumDims; ++i) {
+      post_contract_dims[i] = out.dimension(i);
+    }
+  } else {
+    post_contract_dims[NumDims - 1] = kernelChannels;
+    post_contract_dims[NumDims - 2] = inputPlanes;
+    post_contract_dims[NumDims - 3] = inputRows;
+    post_contract_dims[NumDims - 4] = inputCols;
+    for (int i = 0; i < NumDims - 4; ++i) {
+      post_contract_dims[i] = out.dimension(i);
+    }
+  }
+
+  return choose(
+      Cond<internal::traits<OutputBackward>::Layout == ColMajor>(),
+      kernel.reverse(kernel_reverse)
+          .shuffle(kernel_shuffle)
+          .reshape(kernel_dims)
+          .eval()
+          .contract(output_backward
+                        .extract_volume_patches(
+                            kernelPlanes, kernelRows, kernelCols, 1, 1, 1,
+                            plane_stride, row_stride, col_stride, padding_top_z,
+                            padding_bottom_z, padding_top, padding_bottom,
+                            padding_left, padding_right)
+                        .reshape(pre_contract_dims),
+                    contract_dims)
+          .reshape(post_contract_dims),
+      output_backward
+          .extract_volume_patches(kernelPlanes, kernelRows, kernelCols, 1, 1, 1,
+                                  plane_stride, row_stride, col_stride,
+                                  padding_top_z, padding_bottom_z, padding_top,
+                                  padding_bottom, padding_left, padding_right)
+          .reshape(pre_contract_dims)
+          .contract(kernel.reverse(kernel_reverse)
+                        .shuffle(kernel_shuffle)
+                        .reshape(kernel_dims)
+                        .eval(),
+                    contract_dims)
+          .reshape(post_contract_dims));
+}
+
+/** CuboidConvolutionBackwardKernel
+ * \ingroup CXX11_NeuralNetworks_Module
+ *
+ * \brief Computes the backprop for the filter of a 3D convolution.
+ *
+ * The output_backward parameter is expected to be a tensor with a rank of 4 or
+ * more (channels, depth, height, width, and optionally others)
+ * The kernel parameter is expected to be a 4D tensor (filters, channels,
+ * kernel_depth, kernel_height, kernel_width)
+ * output_backward and kernel have to be in the same layout.
+ *
+ * The dimensions of the result will be filters, depth, height, width (and
+ * others if applicable).
+ *
+ * It is possible to swap the order of the depth, width and height dimensions
+ * provided that the same order is used in the input, the kernel, and the
+ * output.
+ *
+ * All dimension orders above are given for col-major, and should be reversed
+ * for row-major.
+ */
+template <typename OutputBackward, typename Input>
+EIGEN_ALWAYS_INLINE static const std::conditional_t<
+    internal::traits<Input>::Layout == ColMajor,
+    const TensorReverseOp<
+        const Eigen::array<typename internal::traits<Input>::Index,
+                           internal::traits<Input>::NumDimensions>,
+        const Eigen::TensorShufflingOp<
+            const Eigen::array<typename internal::traits<Input>::Index,
+                               internal::traits<Input>::NumDimensions>,
+            const Eigen::TensorReshapingOp<
+                const Eigen::DSizes<typename internal::traits<Input>::Index,
+                                    internal::traits<Input>::NumDimensions>,
+                const TensorContractionOp<
+                    const array<
+                        IndexPair<typename internal::traits<Input>::Index>, 1>,
+                    const Eigen::TensorForcedEvalOp<const TensorReshapingOp<
+                        const DSizes<typename internal::traits<Input>::Index,
+                                     2>,
+                        const Eigen::TensorShufflingOp<
+                            const Eigen::array<
+                                typename internal::traits<Input>::Index,
+                                internal::traits<Input>::NumDimensions>,
+                            const OutputBackward>>>,
+                    const TensorReshapingOp<
+                        const DSizes<typename internal::traits<Input>::Index,
+                                     2>,
+                        const TensorVolumePatchOp<
+                            Dynamic, Dynamic, Dynamic,
+                            const Eigen::TensorForcedEvalOp<
+                                const Eigen::TensorShufflingOp<
+                                    const Eigen::array<
+                                        typename internal::traits<Input>::Index,
+                                        internal::traits<Input>::NumDimensions>,
+                                    const Input>>>>>>>>,
+    const TensorReverseOp<
+        const Eigen::array<typename internal::traits<Input>::Index,
+                           internal::traits<Input>::NumDimensions>,
+        const Eigen::TensorShufflingOp<
+            const Eigen::array<typename internal::traits<Input>::Index,
+                               internal::traits<Input>::NumDimensions>,
+            const Eigen::TensorReshapingOp<
+                const Eigen::DSizes<typename internal::traits<Input>::Index,
+                                    internal::traits<Input>::NumDimensions>,
+                const TensorContractionOp<
+                    const array<
+                        IndexPair<typename internal::traits<Input>::Index>, 1>,
+                    const TensorReshapingOp<
+                        const DSizes<typename internal::traits<Input>::Index,
+                                     2>,
+                        const TensorVolumePatchOp<
+                            Dynamic, Dynamic, Dynamic,
+                            const Eigen::TensorForcedEvalOp<
+                                const Eigen::TensorShufflingOp<
+                                    const Eigen::array<
+                                        typename internal::traits<Input>::Index,
+                                        internal::traits<Input>::NumDimensions>,
+                                    const Input>>>>,
+                    const Eigen::TensorForcedEvalOp<const TensorReshapingOp<
+                        const DSizes<typename internal::traits<Input>::Index,
+                                     2>,
+                        const Eigen::TensorShufflingOp<
+                            const Eigen::array<
+                                typename internal::traits<Input>::Index,
+                                internal::traits<Input>::NumDimensions>,
+                            const OutputBackward>>>>>>>>
+CuboidConvolutionBackwardKernel(
+    const Input& input, const OutputBackward& output_backward,
+    typename internal::traits<Input>::Index kernelPlanes,
+    typename internal::traits<Input>::Index kernelRows,
+    typename internal::traits<Input>::Index kernelCols,
+    const DenseIndex stridePlanes = 1, const DenseIndex strideRows = 1,
+    const DenseIndex strideCols = 1) {
+  typedef typename internal::traits<Input>::Index TensorIndex;
+  TensorRef<Tensor<typename internal::traits<Input>::Scalar,
+                   internal::traits<Input>::NumDimensions,
+                   internal::traits<Input>::Layout, TensorIndex>>
+      in(input);
+  TensorRef<Tensor<typename internal::traits<OutputBackward>::Scalar,
+                   internal::traits<OutputBackward>::NumDimensions,
+                   internal::traits<OutputBackward>::Layout, TensorIndex>>
+      out(output_backward);
+
+  EIGEN_STATIC_ASSERT(internal::traits<Input>::Layout ==
+                          internal::traits<OutputBackward>::Layout,
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+
+  static const bool isColMajor = (internal::traits<Input>::Layout == ColMajor);
+
+  static const int NumDims = internal::traits<Input>::NumDimensions;
+  EIGEN_STATIC_ASSERT(internal::traits<Input>::NumDimensions ==
+                          internal::traits<OutputBackward>::NumDimensions,
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+
+  // We do not support higher dimensional backward convolutions, or convolutions
+  // without batch dimension.
+  // TODO(ezhulenev): Relax this constraint, and turn on tests without batch
+  // dimension in eigen_backward_cuboid_convolutions_test.cc.
+  EIGEN_STATIC_ASSERT(internal::traits<Input>::NumDimensions == 5,
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+
+  const TensorIndex inputPlanes =
+      isColMajor ? in.dimension(1) : in.dimension(NumDims - 2);
+  const TensorIndex inputRows =
+      isColMajor ? in.dimension(2) : in.dimension(NumDims - 3);
+  const TensorIndex inputCols =
+      isColMajor ? in.dimension(3) : in.dimension(NumDims - 4);
+
+  const TensorIndex outputPlanes =
+      isColMajor ? out.dimension(1) : out.dimension(NumDims - 2);
+  const TensorIndex outputRows =
+      isColMajor ? out.dimension(2) : out.dimension(NumDims - 3);
+  const TensorIndex outputCols =
+      isColMajor ? out.dimension(3) : out.dimension(NumDims - 4);
+
+  // Number of filters. This is the same as the output depth.
+  const TensorIndex kernelFilters =
+      isColMajor ? out.dimension(0) : out.dimension(NumDims - 1);
+  // Number of channels. This is the same as the input depth.
+  const TensorIndex kernelChannels =
+      isColMajor ? in.dimension(0) : in.dimension(NumDims - 1);
+
+  // Number of batches in the input tensor.
+  const TensorIndex batch =
+      isColMajor ? in.dimension(4) : in.dimension(NumDims - 5);
+
+  // TODO(ezhulenev): Add support for inflated strides. Without inflated strides
+  // effective kernel planes/rows/cols are always the same as the kernel itself
+  // (see eigen_spatial_convolutions for details).
+  const TensorIndex kernelPlanesEff = kernelPlanes;
+  const TensorIndex kernelRowsEff = kernelRows;
+  const TensorIndex kernelColsEff = kernelCols;
+
+  // Compute forward padding from input and output_backward dimensions.
+  const TensorIndex padPlanes = numext::maxi<Index>(
+      0, (outputPlanes - 1) * stridePlanes + kernelPlanesEff - inputPlanes);
+  const TensorIndex padRows = numext::maxi<Index>(
+      0, (outputRows - 1) * strideRows + kernelRowsEff - inputRows);
+  const TensorIndex padCols = numext::maxi<Index>(
+      0, (outputCols - 1) * strideCols + kernelColsEff - inputCols);
+
+  const TensorIndex padding_top_z = padPlanes / 2;
+  const TensorIndex padding_top = padRows / 2;
+  const TensorIndex padding_left = padCols / 2;
+
+  // Compute paddings for output_backward before extracting patches.
+  const auto expanded_out_planes = (outputPlanes - 1) * stridePlanes + 1;
+  const auto expanded_out_rows = (outputRows - 1) * strideRows + 1;
+  const auto expanded_out_cols = (outputCols - 1) * strideCols + 1;
+  const auto padded_out_planes = inputPlanes + kernelPlanes - 1;
+  const auto padded_out_rows = inputRows + kernelRows - 1;
+  const auto padded_out_cols = inputCols + kernelCols - 1;
+  const auto top_pad_planes = kernelPlanes - 1 - padding_top_z;
+  const auto top_pad_rows = kernelRows - 1 - padding_top;
+  const auto left_pad_cols = kernelCols - 1 - padding_left;
+  const auto bottom_pad_planes =
+      padded_out_planes - expanded_out_planes - top_pad_planes;
+  const auto bottom_pad_rows =
+      padded_out_rows - expanded_out_rows - top_pad_rows;
+  const auto right_pad_cols =
+      padded_out_cols - expanded_out_cols - left_pad_cols;
+
+  // Reorder output_backward dimensions.
+  array<TensorIndex, 5> output_backward_shuffle;
+  if (isColMajor) {
+    // From: [out_depth, out_planes, out_rows, out_cols, batch]
+    // To:   [batch, out_planes, out_rows, out_cols, out_depth]
+    output_backward_shuffle = {4, 1, 2, 3, 0};
+  } else {
+    // From: [batch, out_cols, out_rows, out_planes, out_depth]
+    // To:   [out_depth, out_cols, out_rows, out_planes, batch]
+    output_backward_shuffle = {4, 1, 2, 3, 0};
+  }
+
+  // Reorder input dimensions.
+  array<TensorIndex, 5> input_shuffle;
+  if (isColMajor) {
+    // From: [in_depth, in_planes, in_rows, in_cols, batch]
+    // To:   [in_depth, batch, in_planes, in_rows, in_cols]
+    input_shuffle = {0, 4, 1, 2, 3};
+  } else {
+    // From: [batch, in_cols, in_rows, in_planes, in_depth]
+    // To:   [in_cols, in_rows, in_planes, batch, in_depth]
+    input_shuffle = {1, 2, 3, 0, 4};
+  }
+
+  // Input is playing the role of a "kernel" in this convolution.
+  DSizes<TensorIndex, 2> input_dims;
+  if (isColMajor) {
+    input_dims[0] = kernelChannels;
+    input_dims[1] = batch * inputPlanes * inputRows * inputCols;
+  } else {
+    input_dims[1] = kernelChannels;
+    input_dims[0] = inputCols * inputRows * inputPlanes * batch;
+  }
+
+  // Molds the output of the patch extraction result into a 2D tensor:
+  // - the first dimension (dims[0]): the patch values to be multiplied with the
+  // kernels
+  // - the second dimension (dims[1]): everything else
+  DSizes<TensorIndex, 2> pre_contract_dims;
+  if (isColMajor) {
+    pre_contract_dims[0] = batch * inputPlanes * inputRows * inputCols;
+    pre_contract_dims[1] =
+        kernelPlanes * kernelRows * kernelCols * kernelFilters;
+  } else {
+    pre_contract_dims[1] = inputCols * inputRows * inputPlanes * batch;
+    pre_contract_dims[0] =
+        kernelFilters * kernelCols * kernelRows * kernelPlanes;
+  }
+
+  // We will contract along the collapsed dimension that contains the
+  // batch, inputPlanes, inputRows and inputCols.
+  array<IndexPair<TensorIndex>, 1> contract_dims;
+  contract_dims[0] = IndexPair<TensorIndex>(1, 0);
+
+  // Dimensions after contraction.
+  DSizes<TensorIndex, NumDims> post_contract_dims;
+  if (isColMajor) {
+    post_contract_dims[0] = kernelChannels;
+    post_contract_dims[1] = kernelPlanes;
+    post_contract_dims[2] = kernelRows;
+    post_contract_dims[3] = kernelCols;
+    post_contract_dims[4] = kernelFilters;
+  } else {
+    post_contract_dims[0] = kernelFilters;
+    post_contract_dims[1] = kernelCols;
+    post_contract_dims[2] = kernelRows;
+    post_contract_dims[3] = kernelPlanes;
+    post_contract_dims[4] = kernelChannels;
+  }
+
+  // Reorder output of contraction to valid filter shape.
+  array<TensorIndex, 5> kernel_shuffle;
+  if (isColMajor) {
+    // From: [in_depth, kernel_planes, kernel_rows, kernel_cols, out_depth]
+    // To:   [out_depth, in_depth, kernel_planes, kernel_rows, kernel_cols]
+    kernel_shuffle = {4, 0, 1, 2, 3};
+  } else {
+    // From: [out_depth, kernel_cols, kernel_rows, kernel_planes, in_depth]
+    // To:   [kernel_cols, kernel_rows, kernel_planes, in_depth, out_depth]
+    kernel_shuffle = {1, 2, 3, 4, 0};
+  }
+
+  // Reverse kernel backprop dimensions.
+  array<TensorIndex, 5> kernel_reverse;
+  if (isColMajor) {
+    kernel_reverse = {false, false, true, true, true};
+  } else {
+    kernel_reverse = {true, true, true, false, false};
+  }
+
+  // Create convolution input (aka source of patches) from output backward
+  // tensor by shuffling dimensions.
+  const auto the_input =
+      output_backward.shuffle(output_backward_shuffle).eval();
+
+  // Create convolution kernel (aka filter) from input by shuffling and
+  // reshaping.
+  const auto the_kernel =
+      input.shuffle(input_shuffle).reshape(input_dims).eval();
+
+  return choose(Cond<internal::traits<Input>::Layout == ColMajor>(),
+                the_kernel.contract(
+                    the_input
+                        .extract_volume_patches(
+                            inputPlanes, inputRows, inputCols, 1, 1, 1,
+                            stridePlanes, strideRows, strideCols,
+                            top_pad_planes, bottom_pad_planes, top_pad_rows,
+                            bottom_pad_rows, left_pad_cols, right_pad_cols)
+                        .reshape(pre_contract_dims),
+                    contract_dims),
+                the_input
+                    .extract_volume_patches(
+                        inputPlanes, inputRows, inputCols, 1, 1, 1,
+                        stridePlanes, strideRows, strideCols, top_pad_planes,
+                        bottom_pad_planes, top_pad_rows, bottom_pad_rows,
+                        left_pad_cols, right_pad_cols)
+                    .reshape(pre_contract_dims)
+                    .contract(the_kernel, contract_dims))
+      .reshape(post_contract_dims)
+      .shuffle(kernel_shuffle)
+      .reverse(kernel_reverse);
+}
+
+}  // end namespace Eigen
+
+#endif  // TENSORFLOW_CORE_KERNELS_EIGEN_BACKWARD_CUBOID_CONVOLUTIONS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/eigen_backward_spatial_convolutions.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/eigen_backward_spatial_convolutions.h
new file mode 100644
index 0000000000000000000000000000000000000000..6bb389fd57ae272b62a3ad3b65fc078599f84c26
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/eigen_backward_spatial_convolutions.h
@@ -0,0 +1,593 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_EIGEN_BACKWARD_SPATIAL_CONVOLUTIONS_H_
+#define TENSORFLOW_CORE_KERNELS_EIGEN_BACKWARD_SPATIAL_CONVOLUTIONS_H_
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tsl/framework/convolution/eigen_spatial_convolutions.h"
+
+namespace Eigen {
+
+/** SpatialConvolutionBackwardInput
+ * \ingroup CXX11_NeuralNetworks_Module
+ *
+ * \brief Computes the backprop for the input of a 2D convolution.
+ *
+ * The output_backward parameter is expected to be a tensor with a rank of 3 or
+ * more (channels, height, width, and optionally others)
+ * The kernel parameter is expected to be a 4D tensor (filters, channels,
+ * kernel_height, kernel_width)
+ * The output_backward and the kernel must both be in col-major layout. The
+ * result will also be in col-major layout.
+ *
+ * If row_in_stride, col_in_stride > 1, then applies convolution with holes
+ * (aka atrous convolution), sampling every row_in_stride, col_in_stride input
+ * pixels.
+ *
+ * The result can be assigned to a tensor of rank equal to the rank of the
+ * output_backward. The dimensions of the result will be filters, height, width
+ * (and others if applicable).
+ *
+ * It is possible to swap the order of the width and height dimensions provided
+ * that the same order is used in the input, the kernel, and the output.
+ *
+ */
+typedef IndexList<type2index<0>, type2index<0>, type2index<1>, type2index<1>>
+    ReverseColMajor;
+typedef IndexList<type2index<1>, type2index<1>, type2index<0>, type2index<0>>
+    ReverseRowMajor;
+
+template <typename OutputBackward, typename Kernel>
+EIGEN_ALWAYS_INLINE static const std::conditional_t<
+    internal::traits<OutputBackward>::Layout == ColMajor,
+    TensorReshapingOp<
+        const DSizes<typename internal::traits<OutputBackward>::Index,
+                     internal::traits<OutputBackward>::NumDimensions>,
+        const TensorContractionOp<
+            const array<
+                IndexPair<typename internal::traits<OutputBackward>::Index>, 1>,
+            const TensorReshapingOp<
+                const DSizes<typename internal::traits<OutputBackward>::Index,
+                             2>,
+                const Eigen::TensorForcedEvalOp<const TensorShufflingOp<
+                    const array<
+                        typename internal::traits<OutputBackward>::Index, 4>,
+                    const Eigen::TensorForcedEvalOp<const TensorReverseOp<
+                        const ReverseColMajor, const Kernel>>>>>,
+            const TensorReshapingOp<
+                const DSizes<typename internal::traits<OutputBackward>::Index,
+                             2>,
+                const TensorImagePatchOp<Dynamic, Dynamic,
+                                         const OutputBackward>>>>,
+    TensorReshapingOp<
+
+        const DSizes<typename internal::traits<OutputBackward>::Index,
+                     internal::traits<OutputBackward>::NumDimensions>,
+        const TensorContractionOp<
+            const array<
+                IndexPair<typename internal::traits<OutputBackward>::Index>, 1>,
+            const TensorReshapingOp<
+                const DSizes<typename internal::traits<OutputBackward>::Index,
+                             2>,
+                const TensorImagePatchOp<Dynamic, Dynamic,
+                                         const OutputBackward>>,
+            const TensorReshapingOp<
+                const DSizes<typename internal::traits<OutputBackward>::Index,
+                             2>,
+                const Eigen::TensorForcedEvalOp<const TensorShufflingOp<
+                    const array<
+                        typename internal::traits<OutputBackward>::Index, 4>,
+                    const Eigen::TensorForcedEvalOp<const TensorReverseOp<
+                        const ReverseRowMajor, const Kernel>>>>>>>>
+SpatialConvolutionBackwardInput(
+    const Kernel& kernel, const OutputBackward& output_backward,
+    typename internal::traits<OutputBackward>::Index inputRows,
+    typename internal::traits<OutputBackward>::Index inputCols,
+    const DenseIndex row_stride = 1, const DenseIndex col_stride = 1,
+    const DenseIndex row_in_stride = 1, const DenseIndex col_in_stride = 1) {
+  typedef typename internal::traits<OutputBackward>::Index TensorIndex;
+  typedef typename internal::traits<OutputBackward>::Scalar OutScalar;
+  TensorRef<Tensor<typename internal::traits<Kernel>::Scalar,
+                   internal::traits<Kernel>::NumDimensions,
+                   internal::traits<Kernel>::Layout, TensorIndex>>
+      kern(kernel);
+  TensorRef<Tensor<OutScalar, internal::traits<OutputBackward>::NumDimensions,
+                   internal::traits<OutputBackward>::Layout, TensorIndex>>
+      out(output_backward);
+
+  EIGEN_STATIC_ASSERT(internal::traits<Kernel>::Layout ==
+                          internal::traits<OutputBackward>::Layout,
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+
+  static const bool isColMajor =
+      (internal::traits<OutputBackward>::Layout == ColMajor);
+
+  static const int NumDims = internal::traits<OutputBackward>::NumDimensions;
+
+  // Number of filters to apply. This is the same as the output depth of the
+  // result
+  const TensorIndex kernelFilters =
+      isColMajor ? kern.dimensions()[0] : kern.dimensions()[3];
+  // Number of channels. This is the same as the input depth.
+  const TensorIndex kernelChannels =
+      isColMajor ? kern.dimensions()[1] : kern.dimensions()[2];
+  const TensorIndex kernelRows =
+      isColMajor ? kern.dimensions()[2] : kern.dimensions()[1];
+  const TensorIndex kernelCols =
+      isColMajor ? kern.dimensions()[3] : kern.dimensions()[0];
+
+  // This is the effective kernel size, taking into account the (*_in_stride -
+  // 1) zero-values
+  // inserted between consecutive kernel elements in atrous convolution
+  const TensorIndex kernelRowsEff =
+      kernelRows + (kernelRows - 1) * (row_in_stride - 1);
+  const TensorIndex kernelColsEff =
+      kernelCols + (kernelCols - 1) * (col_in_stride - 1);
+
+  const TensorIndex outputRows = isColMajor
+                                     ? output_backward.dimension(1)
+                                     : output_backward.dimension(NumDims - 2);
+  const TensorIndex outputCols = isColMajor
+                                     ? output_backward.dimension(2)
+                                     : output_backward.dimension(NumDims - 3);
+
+  // Computing the forward padding
+  const TensorIndex forward_pad_top = numext::maxi<Index>(
+      0, ((outputRows - 1) * row_stride + kernelRowsEff - inputRows) / 2);
+  const TensorIndex forward_pad_left = numext::maxi<Index>(
+      0, ((outputCols - 1) * col_stride + kernelColsEff - inputCols) / 2);
+  const TensorIndex padding_top = kernelRowsEff - 1 - forward_pad_top;
+  const TensorIndex padding_left = kernelColsEff - 1 - forward_pad_left;
+
+  const TensorIndex padding_bottom = inputRows - (outputRows - 1) * row_stride -
+                                     2 - padding_top + kernelRowsEff;
+  const TensorIndex padding_right = inputCols - (outputCols - 1) * col_stride -
+                                    2 - padding_left + kernelColsEff;
+
+  eigen_assert(padding_top >= 0);
+  eigen_assert(padding_left >= 0);
+  eigen_assert(padding_bottom >= 0);
+  eigen_assert(padding_right >= 0);
+
+  // The kernel has dimensions filters X channels X patch_rows X patch_cols
+  // We need to reverse the kernel along dimensions corresponding to rows and
+  // cols.
+  // TODO(yangke): we can make things slightly faster by collapsing the
+  // dimensions
+  // where we don't reverse. Try that once we have a faster compiler.
+  typedef std::conditional_t<isColMajor, ReverseColMajor, ReverseRowMajor>
+      Reverse;
+  Reverse kernel_reverse;
+  // Reorder the dimensions to:
+  //   filters x patch_rows x patch_cols x channels
+  array<TensorIndex, 4> kernel_shuffle;
+  if (isColMajor) {
+    //  From: filters x channels x rows x cols
+    //  To:   filters x rows x cols x channels
+    kernel_shuffle[0] = 0;
+    kernel_shuffle[1] = 2;
+    kernel_shuffle[2] = 3;
+    kernel_shuffle[3] = 1;
+  } else {
+    //  From: cols x rows x channels x filters
+    //  To:   channels x cols x rows x filters
+    kernel_shuffle[0] = 2;
+    kernel_shuffle[1] = 0;
+    kernel_shuffle[2] = 1;
+    kernel_shuffle[3] = 3;
+  }
+
+  // Collapse the dims
+  DSizes<TensorIndex, 2> kernel_dims;
+  if (isColMajor) {
+    kernel_dims[0] = kernelFilters * kernelRows * kernelCols;
+    kernel_dims[1] = kernelChannels;
+  } else {
+    kernel_dims[1] = kernelFilters * kernelRows * kernelCols;
+    kernel_dims[0] = kernelChannels;
+  }
+
+  // The output_backward has dimensions out_depth X out_rows X out_cols X OTHERS
+  // When we extract the image patches from output_backward, it will have
+  // dimensions
+  //   out_depth X (patch_rows * patch_cols) X (input_rows * input_cols *
+  //   OTHERS)
+  DSizes<TensorIndex, 2> pre_contract_dims;
+  if (isColMajor) {
+    pre_contract_dims[0] = kernelFilters * kernelRows * kernelCols;
+    pre_contract_dims[1] = inputRows * inputCols;
+    for (int i = 3; i < NumDims; ++i) {
+      pre_contract_dims[1] *= out.dimension(i);
+    }
+  } else {
+    pre_contract_dims[1] = kernelFilters * kernelRows * kernelCols;
+    pre_contract_dims[0] = inputRows * inputCols;
+    for (int i = 0; i < NumDims - 3; ++i) {
+      pre_contract_dims[0] *= out.dimension(i);
+    }
+  }
+
+  // We will contract along the collapsed dimension that contains the
+  // kernelFilters, the kernelRows and the kernelCols.
+  array<IndexPair<TensorIndex>, 1> contract_dims;
+  if (isColMajor) {
+    // col-major: kernel.contract(output.patches)
+    contract_dims[0] = IndexPair<TensorIndex>(0, 0);
+  } else {
+    // row-major: output.patches.contract(kernel)
+    contract_dims[0] = IndexPair<TensorIndex>(1, 1);
+  }
+
+  // Post contraction, the dimensions of the input_backprop is
+  //  channels X input_rows X input_cols X OTHERS
+  DSizes<TensorIndex, NumDims> post_contract_dims;
+  if (isColMajor) {
+    post_contract_dims[0] = kernelChannels;
+    post_contract_dims[1] = inputRows;
+    post_contract_dims[2] = inputCols;
+    for (int i = 3; i < NumDims; ++i) {
+      post_contract_dims[i] = out.dimension(i);
+    }
+  } else {
+    post_contract_dims[NumDims - 1] = kernelChannels;
+    post_contract_dims[NumDims - 2] = inputRows;
+    post_contract_dims[NumDims - 3] = inputCols;
+    for (int i = 0; i < NumDims - 3; ++i) {
+      post_contract_dims[i] = out.dimension(i);
+    }
+  }
+
+  // NOTE(ezhulenev): We do eval after reverse and shuffle, because tiled
+  // evaluation of these ops does not compose. Doing explicit eval is ~8x
+  // faster in micro benchmarks.
+
+  return choose(
+      Cond<internal::traits<OutputBackward>::Layout == ColMajor>(),
+      kernel.reverse(kernel_reverse)
+          .eval()
+          .shuffle(kernel_shuffle)
+          .eval()
+          .reshape(kernel_dims)
+          .contract(
+              output_backward
+                  .extract_image_patches(
+                      kernelRows, kernelCols, 1, 1, row_in_stride,
+                      col_in_stride, row_stride, col_stride, padding_top,
+                      padding_bottom, padding_left, padding_right, OutScalar(0))
+                  .reshape(pre_contract_dims),
+              contract_dims)
+          .reshape(post_contract_dims),
+      output_backward
+          .extract_image_patches(kernelRows, kernelCols, 1, 1, row_in_stride,
+                                 col_in_stride, row_stride, col_stride,
+                                 padding_top, padding_bottom, padding_left,
+                                 padding_right, OutScalar(0))
+          .reshape(pre_contract_dims)
+          .contract(kernel.reverse(kernel_reverse)
+                        .eval()
+                        .shuffle(kernel_shuffle)
+                        .eval()
+                        .reshape(kernel_dims),
+                    contract_dims)
+          .reshape(post_contract_dims));
+}
+
+/** SpatialConvolutionBackwardKernel
+ * \ingroup CXX11_NeuralNetworks_Module
+ *
+ * \brief Computes the backprop for the filter of a 2D convolution.
+ *
+ * The output_backward parameter is expected to be a tensor with a rank of 3 or
+ * more (channels, height, width, and optionally others)
+ * The kernel parameter is expected to be a 4D tensor (filters, channels,
+ * kernel_height, kernel_width)
+ * The output_backward and the kernel must both be in col-major layout. The
+ * result will also be in col-major layout.
+ *
+ * If row_in_stride, col_stride > 1, then applies convolution with holes (aka
+ * atrous convolution), sampling every row_in_stride, col_in_stride input
+ * pixels.
+ *
+ * The result can be assigned to a tensor of rank equal to the rank of the
+ * output_backward. The dimensions of the result will be filters, height, width
+ * (and others if applicable).
+ *
+ * It is possible to swap the order of the width and height dimensions provided
+ * that the same order is used in the input, the kernel, and the output.
+ *
+ */
+
+template <typename OutputBackward, typename Input>
+EIGEN_ALWAYS_INLINE static const std::conditional_t<
+    internal::traits<Input>::Layout == ColMajor,
+    const TensorReverseOp<
+        const Eigen::array<typename internal::traits<Input>::Index,
+                           internal::traits<Input>::NumDimensions>,
+        const Eigen::TensorForcedEvalOp<const Eigen::TensorShufflingOp<
+            const Eigen::array<typename internal::traits<Input>::Index,
+                               internal::traits<Input>::NumDimensions>,
+            const Eigen::TensorReshapingOp<
+                const Eigen::DSizes<typename internal::traits<Input>::Index,
+                                    internal::traits<Input>::NumDimensions>,
+                const TensorContractionOp<
+                    const array<
+                        IndexPair<typename internal::traits<Input>::Index>, 1>,
+                    const TensorReshapingOp<
+                        const DSizes<typename internal::traits<Input>::Index,
+                                     2>,
+                        const Eigen::TensorForcedEvalOp<
+                            const Eigen::TensorShufflingOp<
+                                const Eigen::array<
+                                    typename internal::traits<Input>::Index,
+                                    internal::traits<Input>::NumDimensions>,
+                                const Input>>>,
+                    const TensorReshapingOp<
+                        const DSizes<typename internal::traits<Input>::Index,
+                                     2>,
+                        const TensorImagePatchOp<
+                            Dynamic, Dynamic,
+                            const Eigen::TensorForcedEvalOp<
+                                const Eigen::TensorShufflingOp<
+                                    const Eigen::array<
+                                        typename internal::traits<Input>::Index,
+                                        internal::traits<Input>::NumDimensions>,
+                                    const OutputBackward>>>>>>>>>,
+    const TensorReverseOp<
+        const Eigen::array<typename internal::traits<Input>::Index,
+                           internal::traits<Input>::NumDimensions>,
+        const Eigen::TensorForcedEvalOp<const Eigen::TensorShufflingOp<
+            const Eigen::array<typename internal::traits<Input>::Index,
+                               internal::traits<Input>::NumDimensions>,
+            const Eigen::TensorReshapingOp<
+                const Eigen::DSizes<typename internal::traits<Input>::Index,
+                                    internal::traits<Input>::NumDimensions>,
+                const TensorContractionOp<
+                    const array<
+                        IndexPair<typename internal::traits<Input>::Index>, 1>,
+                    const TensorReshapingOp<
+                        const DSizes<typename internal::traits<Input>::Index,
+                                     2>,
+                        const TensorImagePatchOp<
+                            Dynamic, Dynamic,
+                            const Eigen::TensorForcedEvalOp<
+                                const Eigen::TensorShufflingOp<
+                                    const Eigen::array<
+                                        typename internal::traits<Input>::Index,
+                                        internal::traits<Input>::NumDimensions>,
+                                    const OutputBackward>>>>,
+                    const TensorReshapingOp<
+                        const DSizes<typename internal::traits<Input>::Index,
+                                     2>,
+                        const Eigen::TensorForcedEvalOp<
+                            const Eigen::TensorShufflingOp<
+                                const Eigen::array<
+                                    typename internal::traits<Input>::Index,
+                                    internal::traits<Input>::NumDimensions>,
+                                const Input>>>>>>>>>
+SpatialConvolutionBackwardKernel(
+    const Input& input, const OutputBackward& output_backward,
+    typename internal::traits<Input>::Index kernelRows,
+    typename internal::traits<Input>::Index kernelCols,
+    const DenseIndex row_stride = 1, const DenseIndex col_stride = 1,
+    const DenseIndex row_in_stride = 1, const DenseIndex col_in_stride = 1) {
+  typedef typename internal::traits<Input>::Index TensorIndex;
+  typedef typename internal::traits<OutputBackward>::Scalar OutScalar;
+  TensorRef<Tensor<typename internal::traits<Input>::Scalar,
+                   internal::traits<Input>::NumDimensions,
+                   internal::traits<Input>::Layout, TensorIndex>>
+      in(input);
+  TensorRef<Tensor<OutScalar, internal::traits<OutputBackward>::NumDimensions,
+                   internal::traits<OutputBackward>::Layout, TensorIndex>>
+      out(output_backward);
+
+  EIGEN_STATIC_ASSERT(internal::traits<Input>::Layout ==
+                          internal::traits<OutputBackward>::Layout,
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+
+  // stride and in_stride cannot both be larger than 1
+  eigen_assert(!(row_stride > 1 && row_in_stride > 1));
+  eigen_assert(!(col_stride > 1 && col_in_stride > 1));
+
+  static const bool isColMajor = (internal::traits<Input>::Layout == ColMajor);
+
+  static const int NumDims = internal::traits<Input>::NumDimensions;
+  EIGEN_STATIC_ASSERT(internal::traits<Input>::NumDimensions ==
+                          internal::traits<OutputBackward>::NumDimensions,
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT(NumDims == 4, YOU_MADE_A_PROGRAMMING_MISTAKE);
+
+  const TensorIndex inputRows =
+      isColMajor ? in.dimension(1) : in.dimension(NumDims - 2);
+  const TensorIndex inputCols =
+      isColMajor ? in.dimension(2) : in.dimension(NumDims - 3);
+
+  const TensorIndex outputRows = isColMajor
+                                     ? output_backward.dimension(1)
+                                     : output_backward.dimension(NumDims - 2);
+  const TensorIndex outputCols = isColMajor
+                                     ? output_backward.dimension(2)
+                                     : output_backward.dimension(NumDims - 3);
+
+  // Number of filters to apply. This is the same as the output depth of the
+  // result
+  const TensorIndex kernelFilters =
+      isColMajor ? out.dimensions()[0] : out.dimensions()[NumDims - 1];
+
+  // Number of channels. This is the same as the input depth.
+  const TensorIndex kernelChannels =
+      isColMajor ? in.dimensions()[0] : in.dimensions()[NumDims - 1];
+
+  // This is the effective kernel size, taking into account the
+  // (*_in_stride - 1) zero-values inserted between consecutive kernel
+  // elements in atrous convolution
+  const TensorIndex kernelRowsEff =
+      kernelRows + (kernelRows - 1) * (row_in_stride - 1);
+  const TensorIndex kernelColsEff =
+      kernelCols + (kernelCols - 1) * (col_in_stride - 1);
+
+  // Number of batches (and other dimensions) in the input tensor.
+  TensorIndex batch = 1;
+  for (int d = 3; d < NumDims; ++d) {
+    batch *= isColMajor ? in.dimension(d) : in.dimension(NumDims - d - 1);
+  }
+
+  // Computing the forward padding
+  const TensorIndex padRows = numext::maxi<Index>(
+      0, (outputRows - 1) * row_stride + kernelRowsEff - inputRows);
+  const TensorIndex padCols = numext::maxi<Index>(
+      0, (outputCols - 1) * col_stride + kernelColsEff - inputCols);
+
+  TensorIndex padding_top = padRows / 2;
+  TensorIndex padding_left = padCols / 2;
+
+  // Compute paddings for output_backward before extracting patches.
+  const TensorIndex expanded_out_rows = (outputRows - 1) * row_stride + 1;
+  const TensorIndex expanded_out_cols = (outputCols - 1) * col_stride + 1;
+
+  const TensorIndex padded_out_rows = inputRows + kernelRowsEff - 1;
+  const TensorIndex padded_out_cols = inputCols + kernelColsEff - 1;
+
+  const TensorIndex top_pad_rows = kernelRowsEff - 1 - padding_top;
+  const TensorIndex left_pad_cols = kernelColsEff - 1 - padding_left;
+
+  const TensorIndex bottom_pad_rows =
+      padded_out_rows - expanded_out_rows - top_pad_rows;
+  const TensorIndex right_pad_cols =
+      padded_out_cols - expanded_out_cols - left_pad_cols;
+
+  // Reorder output_backward dimensions.
+  array<TensorIndex, 4> output_backward_shuffle;
+  if (isColMajor) {
+    // From: [out_depth, out_rows, out_cols, batch]
+    // To:   [batch, out_rows, out_cols, out_depth]
+    output_backward_shuffle = {3, 1, 2, 0};
+  } else {
+    // From: [batch, out_cols, out_rows, out_depth]
+    // To:   [out_depth, out_cols, out_rows, batch]
+    output_backward_shuffle = {3, 1, 2, 0};
+  }
+
+  // Reorder input dimensions.
+  array<TensorIndex, 4> input_shuffle;
+  if (isColMajor) {
+    // From: [in_depth, in_rows, in_cols, batch]
+    // To:   [in_depth, batch, in_rows, in_cols]
+    input_shuffle = {0, 3, 1, 2};
+  } else {
+    // From: [batch, in_cols, in_rows, in_depth]
+    // To:   [in_cols, in_rows, batch, in_depth]
+    input_shuffle = {1, 2, 0, 3};
+  }
+
+  // Input is playing the role of a "kernel" in this convolution.
+  DSizes<TensorIndex, 2> input_dims;
+  if (isColMajor) {
+    input_dims[0] = kernelChannels;
+    input_dims[1] = batch * inputRows * inputCols;
+  } else {
+    input_dims[1] = kernelChannels;
+    input_dims[0] = inputCols * inputRows * batch;
+  }
+
+  // Molds the output of the patch extraction result into a 2D tensor:
+  // - the first dimension (dims[0]): the patch values to be multiplied with the
+  // kernels
+  // - the second dimension (dims[1]): everything else
+  DSizes<TensorIndex, 2> pre_contract_dims;
+  if (isColMajor) {
+    pre_contract_dims[0] = batch * inputRows * inputCols;
+    pre_contract_dims[1] = kernelRows * kernelCols * kernelFilters;
+  } else {
+    pre_contract_dims[1] = inputCols * inputRows * batch;
+    pre_contract_dims[0] = kernelFilters * kernelCols * kernelRows;
+  }
+
+  // We will contract along the collapsed dimension that contains the
+  // batch, inputRows and inputCols.
+  array<IndexPair<TensorIndex>, 1> contract_dims;
+  contract_dims[0] = IndexPair<TensorIndex>(1, 0);
+
+  // Dimensions after contraction.
+  DSizes<TensorIndex, NumDims> post_contract_dims;
+  if (isColMajor) {
+    post_contract_dims[0] = kernelChannels;
+    post_contract_dims[1] = kernelRows;
+    post_contract_dims[2] = kernelCols;
+    post_contract_dims[3] = kernelFilters;
+  } else {
+    post_contract_dims[0] = kernelFilters;
+    post_contract_dims[1] = kernelCols;
+    post_contract_dims[2] = kernelRows;
+    post_contract_dims[3] = kernelChannels;
+  }
+
+  // Reorder output of contraction to a valid filter shape.
+  array<TensorIndex, 4> kernel_shuffle;
+  if (isColMajor) {
+    // From: [in_depth, kernel_rows, kernel_cols, out_depth]
+    // To:   [out_depth, in_depth, kernel_rows, kernel_cols]
+    kernel_shuffle = {3, 0, 1, 2};
+  } else {
+    // From: [out_depth, kernel_cols, kernel_rows, in_depth]
+    // To:   [kernel_cols, kernel_rows, in_depth, out_depth]
+    kernel_shuffle = {1, 2, 3, 0};
+  }
+
+  // Reverse kernel backprop dimensions.
+  array<TensorIndex, 4> kernel_reverse;
+  if (isColMajor) {
+    kernel_reverse = {false, false, true, true};
+  } else {
+    kernel_reverse = {true, true, false, false};
+  }
+
+  // Create convolution input (aka source of patches) from output backward
+  // tensor by shuffling dimensions.
+  const auto output_backward_shuffled =
+      output_backward.shuffle(output_backward_shuffle).eval();
+
+  // Create convolution kernel (aka filter) from input by shuffling and
+  // reshaping.
+  const auto input_shuffled =
+      input.shuffle(input_shuffle).eval().reshape(input_dims);
+
+  return choose(
+             Cond<internal::traits<OutputBackward>::Layout == ColMajor>(),
+             input_shuffled.contract(
+                 output_backward_shuffled
+                     .extract_image_patches(inputRows, inputCols, row_in_stride,
+                                            col_in_stride, 1, 1, row_stride,
+                                            col_stride, top_pad_rows,
+                                            bottom_pad_rows, left_pad_cols,
+                                            right_pad_cols, OutScalar(0))
+                     .reshape(pre_contract_dims),
+                 contract_dims),
+             output_backward_shuffled
+                 .extract_image_patches(
+                     inputRows, inputCols, row_in_stride, col_in_stride, 1, 1,
+                     row_stride, col_stride, top_pad_rows, bottom_pad_rows,
+                     left_pad_cols, right_pad_cols, OutScalar(0))
+                 .reshape(pre_contract_dims)
+                 .contract(input_shuffled, contract_dims))
+      .reshape(post_contract_dims)
+      .shuffle(kernel_shuffle)
+      .eval()
+      .reverse(kernel_reverse);
+}
+
+}  // end namespace Eigen
+
+#endif  // TENSORFLOW_CORE_KERNELS_EIGEN_BACKWARD_SPATIAL_CONVOLUTIONS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/eigen_benchmark.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/eigen_benchmark.h
new file mode 100644
index 0000000000000000000000000000000000000000..816dde55d5c5f5fa75ea8accc6e6d58f27ab41de
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/eigen_benchmark.h
@@ -0,0 +1,295 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_EIGEN_BENCHMARK_H_
+#define TENSORFLOW_CORE_KERNELS_EIGEN_BENCHMARK_H_
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/framework/tensor_types.h"
+#include "tensorflow/core/kernels/eigen_backward_cuboid_convolutions.h"
+#include "tensorflow/core/kernels/eigen_backward_spatial_convolutions.h"
+#include "tensorflow/core/kernels/eigen_cuboid_convolution.h"
+#include "tensorflow/core/platform/test_benchmark.h"
+#include "tsl/framework/convolution/eigen_spatial_convolutions.h"
+
+using ::tensorflow::TTypes;
+
+template <typename Scalar, typename Device>
+class SpatialConvolutionBenchmarksSuite {
+ public:
+  using Input = TTypes<float, 4>::ConstTensor;
+  using Filter = TTypes<float, 4>::ConstTensor;
+  using Output = TTypes<float, 4>::Tensor;
+
+  using Dimensions = Eigen::DSizes<Eigen::Index, 4>;
+
+  SpatialConvolutionBenchmarksSuite(::testing::benchmark::State& state,
+                                    Device& device)
+      : state_(state), device_(device) {}
+
+  Eigen::Index BufferSize(const Dimensions& dims) {
+    return dims.TotalSize() * sizeof(Scalar);
+  }
+
+  void SpatialConvolution(Dimensions input_dims, Dimensions filter_dims) {
+    Dimensions output_dims(input_dims[0],    // batch
+                           input_dims[1],    // input_height
+                           input_dims[2],    // input_width
+                           filter_dims[3]);  // filter_count
+
+    Scalar* input_data =
+        static_cast<Scalar*>(device_.allocate(BufferSize(input_dims)));
+    Scalar* filter_data =
+        static_cast<Scalar*>(device_.allocate(BufferSize(filter_dims)));
+    Scalar* output_data =
+        static_cast<Scalar*>(device_.allocate(BufferSize(output_dims)));
+
+    device_.memset(input_data, 123, BufferSize(input_dims));
+    device_.memset(filter_data, 123, BufferSize(filter_dims));
+
+    Input input(input_data, input_dims);
+    Filter filter(filter_data, filter_dims);
+    Output output(output_data, output_dims);
+
+    for (auto s : state_) {
+      output.device(device_) = Eigen::SpatialConvolution(input, filter);
+      tensorflow::testing::DoNotOptimize(output);
+    }
+
+    device_.deallocate(input_data);
+    device_.deallocate(filter_data);
+    device_.deallocate(output_data);
+  }
+
+  void SpatialConvolutionBackwardInput(Dimensions input_dims,
+                                       Dimensions filter_dims) {
+    using OutputBackward = TTypes<float, 4>::ConstTensor;
+    using InputBackward = TTypes<float, 4>::Tensor;
+
+    Dimensions output_dims(input_dims[0],    // batch
+                           input_dims[1],    // input_height
+                           input_dims[2],    // input_width
+                           filter_dims[3]);  // filter_count
+
+    // Assuming that the convolution had SAME padding.
+    Eigen::Index input_rows = input_dims[1];
+    Eigen::Index input_cols = input_dims[2];
+
+    Scalar* filter_data =
+        static_cast<Scalar*>(device_.allocate(BufferSize(filter_dims)));
+    Scalar* output_backward_data =
+        static_cast<Scalar*>(device_.allocate(BufferSize(output_dims)));
+    Scalar* input_backward_data =
+        static_cast<Scalar*>(device_.allocate(BufferSize(input_dims)));
+
+    device_.memset(filter_data, 123, BufferSize(filter_dims));
+    device_.memset(output_backward_data, 123, BufferSize(output_dims));
+
+    Filter filter(filter_data, filter_dims);
+    OutputBackward output_backward(output_backward_data, output_dims);
+    InputBackward input_backward(input_backward_data, input_dims);
+
+    for (auto s : state_) {
+      input_backward.device(device_) = Eigen::SpatialConvolutionBackwardInput(
+          filter, output_backward, input_rows, input_cols);
+      tensorflow::testing::DoNotOptimize(input_backward);
+    }
+
+    device_.deallocate(filter_data);
+    device_.deallocate(output_backward_data);
+    device_.deallocate(input_backward_data);
+  }
+
+  void SpatialConvolutionBackwardKernel(Dimensions input_dims,
+                                        Dimensions filter_dims) {
+    using OutputBackward = TTypes<float, 4>::ConstTensor;
+    using FilterBackward = TTypes<float, 4>::Tensor;
+
+    Dimensions output_dims(input_dims[0],    // batch
+                           input_dims[1],    // input_height
+                           input_dims[2],    // input_width
+                           filter_dims[3]);  // filter_count
+
+    // Assuming that the convolution had SAME padding.
+    Eigen::Index filter_rows = filter_dims[0];
+    Eigen::Index filter_cols = filter_dims[1];
+
+    Scalar* input_data =
+        static_cast<Scalar*>(device_.allocate(BufferSize(input_dims)));
+    Scalar* output_backward_data =
+        static_cast<Scalar*>(device_.allocate(BufferSize(output_dims)));
+    Scalar* filter_backward_data =
+        static_cast<Scalar*>(device_.allocate(BufferSize(filter_dims)));
+
+    device_.memset(input_data, 123, BufferSize(input_dims));
+    device_.memset(output_backward_data, 123, BufferSize(output_dims));
+
+    Input input(input_data, input_dims);
+    OutputBackward output_backward(output_backward_data, input_dims);
+    FilterBackward filter_backward(filter_backward_data, filter_dims);
+
+    for (auto s : state_) {
+      filter_backward.device(device_) = Eigen::SpatialConvolutionBackwardKernel(
+          input, output_backward, filter_rows, filter_cols);
+      tensorflow::testing::DoNotOptimize(filter_backward);
+    }
+
+    device_.deallocate(input_data);
+    device_.deallocate(output_backward_data);
+    device_.deallocate(filter_backward_data);
+  }
+
+ private:
+  ::testing::benchmark::State& state_;
+
+  Device& device_;
+};
+
+template <typename Scalar, typename Device>
+class CuboidConvolutionBenchmarksSuite {
+ public:
+  using Input = TTypes<float, 5>::ConstTensor;
+  using Filter = TTypes<float, 5>::ConstTensor;
+  using Output = TTypes<float, 5>::Tensor;
+
+  using Dimensions = Eigen::DSizes<Eigen::Index, 5>;
+
+  CuboidConvolutionBenchmarksSuite(::testing::benchmark::State& state,
+                                   Device& device)
+      : state_(state), device_(device) {}
+
+  Eigen::Index BufferSize(const Dimensions& dims) {
+    return dims.TotalSize() * sizeof(Scalar);
+  }
+
+  void CuboidConvolution(Dimensions input_dims, Dimensions filter_dims) {
+    Dimensions output_dims(input_dims[0],    // batch
+                           input_dims[1],    // input_height
+                           input_dims[2],    // input_width
+                           input_dims[3],    // input_planes
+                           filter_dims[4]);  // filter_count
+
+    Scalar* input_data =
+        static_cast<Scalar*>(device_.allocate(BufferSize(input_dims)));
+    Scalar* filter_data =
+        static_cast<Scalar*>(device_.allocate(BufferSize(filter_dims)));
+    Scalar* output_data =
+        static_cast<Scalar*>(device_.allocate(BufferSize(output_dims)));
+
+    device_.memset(input_data, 123, BufferSize(input_dims));
+    device_.memset(filter_data, 123, BufferSize(filter_dims));
+
+    Input input(input_data, input_dims);
+    Filter filter(filter_data, filter_dims);
+    Output output(output_data, output_dims);
+
+    for (auto s : state_) {
+      output.device(device_) = Eigen::CuboidConvolution(input, filter);
+      tensorflow::testing::DoNotOptimize(output);
+    }
+
+    device_.deallocate(input_data);
+    device_.deallocate(filter_data);
+    device_.deallocate(output_data);
+  }
+
+  void CuboidConvolutionBackwardInput(Dimensions input_dims,
+                                      Dimensions filter_dims) {
+    Dimensions output_dims(input_dims[0],    // batch
+                           input_dims[1],    // input_height
+                           input_dims[2],    // input_width
+                           input_dims[3],    // input_planes
+                           filter_dims[4]);  // filter_count
+
+    using OutputBackward = TTypes<float, 5>::ConstTensor;
+    using InputBackward = TTypes<float, 5>::Tensor;
+
+    // Assuming that the convolution had SAME padding.
+    Eigen::Index input_rows = input_dims[1];
+    Eigen::Index input_cols = input_dims[2];
+    Eigen::Index input_planes = input_dims[3];
+
+    Scalar* filter_data =
+        static_cast<Scalar*>(device_.allocate(BufferSize(filter_dims)));
+    Scalar* output_backward_data =
+        static_cast<Scalar*>(device_.allocate(BufferSize(output_dims)));
+    Scalar* input_backward_data =
+        static_cast<Scalar*>(device_.allocate(BufferSize(input_dims)));
+
+    device_.memset(filter_data, 123, BufferSize(filter_dims));
+    device_.memset(output_backward_data, 123, BufferSize(output_dims));
+
+    Filter filter(filter_data, filter_dims);
+    OutputBackward output_backward(output_backward_data, output_dims);
+    InputBackward input_backward(input_backward_data, input_dims);
+
+    for (auto s : state_) {
+      input_backward.device(device_) = Eigen::CuboidConvolutionBackwardInput(
+          filter, output_backward, input_planes, input_rows, input_cols);
+      tensorflow::testing::DoNotOptimize(input_backward);
+    }
+
+    device_.deallocate(filter_data);
+    device_.deallocate(output_backward_data);
+    device_.deallocate(input_backward_data);
+  }
+
+  void CuboidConvolutionBackwardKernel(Dimensions input_dims,
+                                       Dimensions filter_dims) {
+    using OutputBackward = TTypes<float, 5>::ConstTensor;
+    using FilterBackward = TTypes<float, 5>::Tensor;
+
+    Dimensions output_dims(input_dims[0],    // batch
+                           input_dims[1],    // input_height
+                           input_dims[2],    // input_width
+                           input_dims[3],    // input_planes
+                           filter_dims[4]);  // filter_count
+
+    // Assuming that the convolution had SAME padding.
+    Eigen::Index filter_rows = filter_dims[0];
+    Eigen::Index filter_cols = filter_dims[1];
+    Eigen::Index filter_planes = filter_dims[2];
+
+    Scalar* input_data =
+        static_cast<Scalar*>(device_.allocate(BufferSize(input_dims)));
+    Scalar* output_backward_data =
+        static_cast<Scalar*>(device_.allocate(BufferSize(output_dims)));
+    Scalar* filter_backward_data =
+        static_cast<Scalar*>(device_.allocate(BufferSize(filter_dims)));
+
+    device_.memset(input_data, 123, BufferSize(input_dims));
+    device_.memset(output_backward_data, 123, BufferSize(output_dims));
+
+    Input input(input_data, input_dims);
+    OutputBackward output_backward(output_backward_data, output_dims);
+    FilterBackward filter_backward(filter_backward_data, filter_dims);
+
+    for (auto s : state_) {
+      filter_backward.device(device_) = Eigen::CuboidConvolutionBackwardKernel(
+          input, output_backward, filter_planes, filter_rows, filter_cols);
+      tensorflow::testing::DoNotOptimize(filter_backward);
+    }
+
+    device_.deallocate(input_data);
+    device_.deallocate(output_backward_data);
+    device_.deallocate(filter_backward_data);
+  }
+
+ private:
+  ::testing::benchmark::State& state_;
+  Device& device_;
+};
+
+#endif  // TENSORFLOW_CORE_KERNELS_EIGEN_BENCHMARK_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/eigen_cuboid_convolution.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/eigen_cuboid_convolution.h
new file mode 100644
index 0000000000000000000000000000000000000000..a5f8f7976d8c2ecf2ac7acfef4c92bc2adb93e17
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/eigen_cuboid_convolution.h
@@ -0,0 +1,1995 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_EIGEN_CUBOID_CONVOLUTION_H_
+#define TENSORFLOW_CORE_KERNELS_EIGEN_CUBOID_CONVOLUTION_H_
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+
+#if defined(TENSORFLOW_USE_CUSTOM_CONTRACTION_KERNEL)
+#include "tsl/framework/contraction/eigen_contraction_kernel.h"
+#endif
+
+#include "tsl/framework/convolution/eigen_convolution_helpers.h"
+
+namespace Eigen {
+
+namespace internal {
+
+#if !EIGEN_ALTIVEC_USE_CUSTOM_PACK
+// WARNING: Most of the code here implicitly assumes that the matrix is in
+// ColMajor layout. This is guaranteed by the tensor contraction (see
+// TensorContraction.h).
+//
+// Inside Eigen a tensor contraction is represented by a matrix multiplication.
+// We don't want to actually extract volume patches and reshape the result into
+// a matrix (this involves allocating huge extra memory), so the patch
+// extraction and reshape operations are implicit.
+//
+// TensorContractionInputMapper takes a matrix index and returns the coefficient
+// (or the packet) of the "virtual tensor", that would be at that index if we
+// were to actually reshape the result of patch extraction.
+//
+// TensorContractionSubMapper provides a similar view into the "virtual matrix"
+// at the given vertical and horizontal offsets.
+//
+// "Virtual matrix" dimensions:
+//   *0: kernelChannels * kernelPlanes * kernelRows * kernelCols
+//    1: out_planes * out_height * out_width * OTHERS (e.g batches, etc...)
+//
+// *) extracted patches are continuous in memory (innermost dimension assuming
+//    col major layout)
+//
+// With this dimensions:
+//   row - offset within a single patch (in code: patchId)
+//   col - index of the extracted patch (in code: patchIndex)
+//         patchIndex ∈ [0..num_patches * OTHERS] (batch and other dimensions)
+//
+template <typename NewDimension, Index Planes, Index Rows, Index Cols,
+          typename ArgType, typename Device, typename Scalar_, typename Index,
+          typename nocontract_t, typename contract_t, int Side, int packet_size,
+          bool inner_dim_contiguous, bool inner_dim_reordered, int Alignment>
+class TensorContractionInputMapper<
+    Scalar_, Index, Side,
+    TensorEvaluator<const TensorReshapingOp<NewDimension,
+                                            const TensorVolumePatchOp<
+                                                Planes, Rows, Cols, ArgType> >,
+                    Device>,
+    nocontract_t, contract_t, packet_size, inner_dim_contiguous,
+    inner_dim_reordered, Alignment> {
+ public:
+  typedef Scalar_ Scalar;
+  typedef TensorContractionInputMapper<
+      Scalar, Index, Side,
+      TensorEvaluator<const TensorReshapingOp<
+                          NewDimension, const TensorVolumePatchOp<
+                                            Planes, Rows, Cols, ArgType> >,
+                      Device>,
+      nocontract_t, contract_t, packet_size, inner_dim_contiguous,
+      inner_dim_reordered, Alignment>
+      Self;
+  typedef TensorContractionSubMapper<
+      Scalar, Index, Side,
+      TensorEvaluator<const TensorReshapingOp<
+                          NewDimension, const TensorVolumePatchOp<
+                                            Planes, Rows, Cols, ArgType> >,
+                      Device>,
+      nocontract_t, contract_t, packet_size, inner_dim_contiguous,
+      inner_dim_reordered, Alignment>
+      SubMapper;
+  typedef SubMapper VectorMapper;
+  typedef SubMapper LinearMapper;
+  typedef typename packet_traits<Scalar>::type Packet;
+
+  EIGEN_DEVICE_FUNC
+  TensorContractionInputMapper(
+      const TensorEvaluator<
+          const TensorReshapingOp<
+              NewDimension,
+              const TensorVolumePatchOp<Planes, Rows, Cols, ArgType> >,
+          Device>& tensor,
+      const nocontract_t&, const nocontract_t&, const contract_t&,
+      const contract_t&)
+      : m_impl(tensor.impl().impl()) {
+    if (internal::traits<ArgType>::Layout == ColMajor) {
+      m_patch_depth = tensor.impl().dimensions()[0];
+      m_patch_planes = tensor.impl().dimensions()[1];
+      m_patch_rows = tensor.impl().dimensions()[2];
+      m_patch_cols = tensor.impl().dimensions()[3];
+      m_num_patches = tensor.impl().dimensions()[4];
+    } else {
+      const int NumDims = tensor.impl().dimensions().size();
+      m_patch_depth = tensor.impl().dimensions()[NumDims - 1];
+      m_patch_planes = tensor.impl().dimensions()[NumDims - 2];
+      m_patch_rows = tensor.impl().dimensions()[NumDims - 3];
+      m_patch_cols = tensor.impl().dimensions()[NumDims - 4];
+      m_num_patches = tensor.impl().dimensions()[NumDims - 5];
+    }
+
+    // Strides for navigating through the single patch.
+    m_patch_plane_stride = m_patch_depth;
+    m_patch_row_stride = m_patch_planes * m_patch_plane_stride;
+    m_patch_col_stride = m_patch_rows * m_patch_row_stride;
+
+    // Strides for the output tensor.
+    // IMPORTANT: These strides are used to locate an element in a patch at a
+    // depth zero (channel), which is not quite the same as "traditional"
+    // stride.
+    m_rowStride = m_patch_planes;
+    m_colStride = m_patch_rows * m_rowStride;
+    m_patchStride = m_colStride * m_patch_cols * m_patch_depth;
+    m_otherStride = m_patchStride * m_num_patches;
+
+    m_outputPlanes = tensor.impl().outputPlanes();
+    m_outputRows = tensor.impl().outputRows();
+    m_outputCols = tensor.impl().outputCols();
+
+    m_outputPlanesRows = m_outputPlanes * m_outputRows;
+
+    m_plane_strides = tensor.impl().userPlaneStride();
+    m_row_strides = tensor.impl().userRowStride();
+    m_col_strides = tensor.impl().userColStride();
+
+    m_in_plane_strides = tensor.impl().userInPlaneStride();
+    m_in_row_strides = tensor.impl().userInRowStride();
+    m_in_col_strides = tensor.impl().userInColStride();
+
+    m_patch_plane_inflate_strides = tensor.impl().planeInflateStride();
+    m_patch_row_inflate_strides = tensor.impl().rowInflateStride();
+    m_patch_col_inflate_strides = tensor.impl().colInflateStride();
+
+    if (internal::traits<ArgType>::Layout == ColMajor) {
+      m_inputDepth = tensor.impl().impl().dimensions()[0];
+      m_inputPlanes = tensor.impl().impl().dimensions()[1];
+      m_inputRows = tensor.impl().impl().dimensions()[2];
+      m_inputCols = tensor.impl().impl().dimensions()[3];
+    } else {
+      const int NumDims = tensor.impl().impl().dimensions().size();
+      m_inputDepth = tensor.impl().impl().dimensions()[NumDims - 1];
+      m_inputPlanes = tensor.impl().impl().dimensions()[NumDims - 2];
+      m_inputRows = tensor.impl().impl().dimensions()[NumDims - 3];
+      m_inputCols = tensor.impl().impl().dimensions()[NumDims - 4];
+    }
+
+    // Strides for navigating through the input tensor.
+    m_planeInputStride = m_inputDepth;
+    m_rowInputStride = m_inputDepth * m_inputPlanes;
+    m_colInputStride = m_inputDepth * m_inputRows * m_inputPlanes;
+    m_patchInputStride =
+        m_inputDepth * m_inputRows * m_inputCols * m_inputPlanes;
+
+    m_planePaddingTop = tensor.impl().planePaddingTop();
+    m_rowPaddingTop = tensor.impl().rowPaddingTop();
+    m_colPaddingLeft = tensor.impl().colPaddingLeft();
+
+    m_fastNumPatches = internal::TensorIntDivisor<Index>(m_num_patches);
+
+    m_fastPatchPlaneStride =
+        internal::TensorIntDivisor<Index>(m_patch_plane_stride);
+    m_fastPatchRowStride =
+        internal::TensorIntDivisor<Index>(m_patch_row_stride);
+    m_fastPatchColStride =
+        internal::TensorIntDivisor<Index>(m_patch_col_stride);
+
+    m_fastInputPlaneStride =
+        internal::TensorIntDivisor<Index>(m_patch_plane_inflate_strides);
+    m_fastInputRowStride =
+        internal::TensorIntDivisor<Index>(m_patch_row_inflate_strides);
+    m_fastInputColStride =
+        internal::TensorIntDivisor<Index>(m_patch_col_inflate_strides);
+
+    m_fastRowStride = internal::TensorIntDivisor<Index>(m_rowStride);
+    m_fastColStride = internal::TensorIntDivisor<Index>(m_colStride);
+
+    m_fastDimZero = internal::TensorIntDivisor<Index>(m_patch_depth);
+    m_fastOutputRows = internal::TensorIntDivisor<Index>(m_outputRows);
+    m_fastOutputPlanes = internal::TensorIntDivisor<Index>(m_outputPlanes);
+    m_fastOutputRows = internal::TensorIntDivisor<Index>(m_outputRows);
+    m_fastOutputCols = internal::TensorIntDivisor<Index>(m_outputCols);
+
+    m_fastOutputPlanesRows =
+        internal::TensorIntDivisor<Index>(m_outputPlanesRows);
+  }
+
+  EIGEN_DEVICE_FUNC
+  TensorContractionInputMapper(const TensorContractionInputMapper& base_mapper)
+      : m_impl(base_mapper.m_impl) {
+    m_patch_depth = base_mapper.m_patch_depth;
+    m_patch_planes = base_mapper.m_patch_planes;
+    m_patch_rows = base_mapper.m_patch_rows;
+    m_patch_cols = base_mapper.m_patch_cols;
+    m_num_patches = base_mapper.m_num_patches;
+
+    m_patch_plane_stride = base_mapper.m_patch_plane_stride;
+    m_patch_row_stride = base_mapper.m_patch_row_stride;
+    m_patch_col_stride = base_mapper.m_patch_col_stride;
+
+    m_rowStride = base_mapper.m_rowStride;
+    m_colStride = base_mapper.m_colStride;
+    m_patchStride = base_mapper.m_patchStride;
+    m_otherStride = base_mapper.m_otherStride;
+
+    m_planeInputStride = base_mapper.m_planeInputStride;
+    m_rowInputStride = base_mapper.m_rowInputStride;
+    m_colInputStride = base_mapper.m_colInputStride;
+    m_patchInputStride = base_mapper.m_patchInputStride;
+    m_otherInputStride = base_mapper.m_otherInputStride;
+
+    m_inputDepth = base_mapper.m_inputDepth;
+    m_inputPlanes = base_mapper.m_inputPlanes;
+    m_inputRows = base_mapper.m_inputRows;
+    m_inputCols = base_mapper.m_inputCols;
+
+    m_outputPlanes = base_mapper.m_outputPlanes;
+    m_outputRows = base_mapper.m_outputRows;
+    m_outputCols = base_mapper.m_outputCols;
+
+    m_plane_strides = base_mapper.m_plane_strides;
+    m_row_strides = base_mapper.m_row_strides;
+    m_col_strides = base_mapper.m_col_strides;
+
+    m_in_plane_strides = base_mapper.m_in_plane_strides;
+    m_in_row_strides = base_mapper.m_in_row_strides;
+    m_in_col_strides = base_mapper.m_in_col_strides;
+
+    m_patch_plane_inflate_strides = base_mapper.m_patch_plane_inflate_strides;
+    m_patch_row_inflate_strides = base_mapper.m_patch_row_inflate_strides;
+    m_patch_col_inflate_strides = base_mapper.m_patch_col_inflate_strides;
+
+    m_planePaddingTop = base_mapper.m_planePaddingTop;
+    m_rowPaddingTop = base_mapper.m_rowPaddingTop;
+    m_colPaddingLeft = base_mapper.m_colPaddingLeft;
+
+    m_outputPlanesRows = base_mapper.m_outputPlanesRows;
+
+    m_fastNumPatches = base_mapper.m_fastNumPatches;
+    m_fastPatchPlaneStride = base_mapper.m_fastPatchPlaneStride;
+    m_fastPatchRowStride = base_mapper.m_fastPatchRowStride;
+    m_fastPatchColStride = base_mapper.m_fastPatchColStride;
+    m_fastInputPlaneStride = base_mapper.m_fastInputPlaneStride;
+    m_fastInputRowStride = base_mapper.m_fastInputRowStride;
+    m_fastInputColStride = base_mapper.m_fastInputColStride;
+    m_fastRowStride = base_mapper.m_fastRowStride;
+    m_fastColStride = base_mapper.m_fastColStride;
+    m_fastOutputPlanes = base_mapper.m_fastOutputPlanes;
+    m_fastOutputRows = base_mapper.m_fastOutputRows;
+    m_fastOutputCols = base_mapper.m_fastOutputCols;
+    m_fastDimZero = base_mapper.m_fastDimZero;
+    m_fastOutputPlanesRows = base_mapper.m_fastOutputPlanesRows;
+  }
+
+  // If true, turns off some optimizations for loading packets since the image
+  // patches are "non-standard" such as there are non-trivial strides or
+  // inflations in the input.
+  EIGEN_DEVICE_FUNC
+  EIGEN_ALWAYS_INLINE bool nonStandardPatches() const {
+    return m_in_plane_strides != 1 || m_in_row_strides != 1 ||
+           m_in_col_strides != 1 || m_patch_plane_inflate_strides != 1 ||
+           m_patch_row_inflate_strides != 1 || m_patch_col_inflate_strides != 1;
+  }
+
+  EIGEN_DEVICE_FUNC
+  EIGEN_STRONG_INLINE SubMapper getSubMapper(Index i, Index j) const {
+    return SubMapper(*this, i, j);
+  }
+
+  EIGEN_DEVICE_FUNC
+  EIGEN_STRONG_INLINE LinearMapper getLinearMapper(Index i, Index j) const {
+    return LinearMapper(*this, i, j);
+  }
+
+  EIGEN_DEVICE_FUNC
+  EIGEN_ALWAYS_INLINE Scalar operator()(Index row) const {
+    Index planeIndex, rowIndex, colIndex, otherIndex;
+    computeBaseIndices(0, planeIndex, rowIndex, colIndex, otherIndex);
+    return loadCoeff(row, planeIndex, rowIndex, colIndex, otherIndex);
+  }
+
+  // Load the coefficient at the patchIndex location instead of the usual
+  // m_rowIndex, m_colIndex, m_otherIndex. This is currently only used by the
+  // gpu code.
+  EIGEN_DEVICE_FUNC
+  EIGEN_STRONG_INLINE Scalar operator()(Index row, Index patchIndex) const {
+    Index planeIndex, rowIndex, colIndex, otherIndex;
+    computeBaseIndices(patchIndex, planeIndex, rowIndex, colIndex, otherIndex);
+    return loadCoeff(row, planeIndex, rowIndex, colIndex, otherIndex);
+  }
+
+  EIGEN_DEVICE_FUNC
+  EIGEN_ALWAYS_INLINE Packet loadPacket(Index row) const {
+    Index planeIndex, rowIndex, colIndex, otherIndex;
+    computeBaseIndices(0, planeIndex, rowIndex, colIndex, otherIndex);
+    return loadPacket(row, planeIndex, rowIndex, colIndex, otherIndex);
+  }
+
+  // Load the packet at the patchIndex location instead of the usual m_rowIndex,
+  // m_colIndex, m_otherIndex. This is currently only used by the gpu code.
+  EIGEN_DEVICE_FUNC
+  EIGEN_ALWAYS_INLINE Packet loadPacket(Index row, Index patchIndex) const {
+    Index planeIndex, rowIndex, colIndex, otherIndex;
+    computeBaseIndices(patchIndex, planeIndex, rowIndex, colIndex, otherIndex);
+    return loadPacket(row, planeIndex, rowIndex, colIndex, otherIndex);
+  }
+
+  EIGEN_DEVICE_FUNC
+  EIGEN_ALWAYS_INLINE const TensorEvaluator<ArgType, Device>& impl() const {
+    return m_impl;
+  }
+
+  EIGEN_DEVICE_FUNC
+  EIGEN_ALWAYS_INLINE Index patchDepth() const { return m_planeInputStride; }
+  EIGEN_DEVICE_FUNC
+  EIGEN_ALWAYS_INLINE Index patchPlanes() const { return m_rowStride; }
+  EIGEN_DEVICE_FUNC
+  EIGEN_ALWAYS_INLINE Index patchRows() const { return m_patch_rows; }
+  EIGEN_DEVICE_FUNC
+  EIGEN_ALWAYS_INLINE Index patchCols() const { return m_patch_cols; }
+
+ private:
+  friend class TensorContractionSubMapper<
+      Scalar, Index, Side,
+      TensorEvaluator<const TensorReshapingOp<
+                          NewDimension, const TensorVolumePatchOp<
+                                            Planes, Rows, Cols, ArgType> >,
+                      Device>,
+      nocontract_t, contract_t, packet_size, inner_dim_contiguous,
+      inner_dim_reordered, Alignment>;
+
+  // Load coefficient from a patch specified by the "within patch offset"
+  // (patchId) and the precomputed indices of the first element of the patch.
+  EIGEN_DEVICE_FUNC
+  EIGEN_STRONG_INLINE Scalar loadCoeff(Index patchId, Index planeIndex,
+                                       Index rowIndex, Index colIndex,
+                                       Index otherIndex) const {
+    // Find the offset of the element wrt the location of the first element.
+    const Index patchOffset = patchId / m_fastDimZero;
+
+    const Index colOffset = patchOffset / m_fastColStride;
+    const Index inputCol = colIndex + colOffset * m_in_col_strides;
+    const Index origInputCol =
+        (m_patch_col_inflate_strides == 1)
+            ? inputCol
+            : ((inputCol >= 0) ? (inputCol / m_fastInputColStride) : 0);
+
+    const Index rowOffset =
+        (patchOffset - colOffset * m_colStride) / m_fastRowStride;
+    const Index inputRow = rowIndex + rowOffset * m_in_row_strides;
+    const Index origInputRow =
+        (m_patch_row_inflate_strides == 1)
+            ? inputRow
+            : ((inputRow >= 0) ? (inputRow / m_fastInputRowStride) : 0);
+
+    const Index planeOffset =
+        patchOffset - colOffset * m_colStride - rowOffset * m_rowStride;
+    const Index inputPlane = planeIndex + planeOffset * m_in_plane_strides;
+    const Index origInputPlane =
+        (m_patch_plane_inflate_strides == 1)
+            ? inputPlane
+            : ((inputPlane >= 0) ? (inputPlane / m_fastInputPlaneStride) : 0);
+
+    if (origInputCol < 0 || origInputRow < 0 || origInputPlane < 0 ||
+        origInputCol >= m_inputCols || origInputRow >= m_inputRows ||
+        origInputPlane >= m_inputPlanes ||
+        (inputCol != origInputCol * m_patch_col_inflate_strides) ||
+        (inputRow != origInputRow * m_patch_row_inflate_strides) ||
+        (inputPlane != origInputPlane * m_patch_plane_inflate_strides)) {
+      return Scalar(0);
+    }
+
+    const Index depth = patchId - patchOffset * patchDepth();
+    const Index inputIndex = depth + origInputPlane * m_planeInputStride +
+                             origInputRow * m_rowInputStride +
+                             origInputCol * m_colInputStride + otherIndex;
+
+    return m_impl.coeff(inputIndex);
+  }
+
+  // This is the same as loadCoeff(...), but optimized for all `inflate_strides`
+  // and `in_strides` equal to 1 (template specialization without templates).
+  EIGEN_DEVICE_FUNC
+  EIGEN_STRONG_INLINE Scalar loadCoeffStandard(Index patchId, Index planeIndex,
+                                               Index rowIndex, Index colIndex,
+                                               Index otherIndex) const {
+    eigen_assert(!nonStandardPatches());
+
+    // Find the offset of the element wrt the location of the first element.
+    const Index patchOffset = patchId / m_fastDimZero;
+
+    const Index colOffset = patchOffset / m_fastColStride;
+    const Index rowOffset =
+        (patchOffset - colOffset * m_colStride) / m_fastRowStride;
+    const Index planeOffset =
+        patchOffset - colOffset * m_colStride - rowOffset * m_rowStride;
+
+    const Index inputCol = colIndex + colOffset;
+    const Index inputRow = rowIndex + rowOffset;
+    const Index inputPlane = planeIndex + planeOffset;
+
+    if (inputCol < 0 || inputCol >= m_inputCols || inputRow < 0 ||
+        inputRow >= m_inputRows || inputPlane < 0 ||
+        inputPlane >= m_inputPlanes) {
+      return Scalar(0);
+    }
+
+    const Index depth = patchId - patchOffset * patchDepth();
+    const Index inputIndex = depth + inputPlane * m_planeInputStride +
+                             inputRow * m_rowInputStride +
+                             inputCol * m_colInputStride + otherIndex;
+
+    return m_impl.coeff(inputIndex);
+  }
+
+  // Load packet from a patch specified by the "within patch offset"
+  // (patchId) and the precomputed indices of the first element of the patch.
+  EIGEN_DEVICE_FUNC
+  EIGEN_ALWAYS_INLINE Packet loadPacket(Index patchId, Index planeIndex,
+                                        Index rowIndex, Index colIndex,
+                                        Index otherIndex) const {
+    const Index packetSize = internal::unpacket_traits<Packet>::size;
+
+    EIGEN_STATIC_ASSERT(packetSize > 1, YOU_MADE_A_PROGRAMMING_MISTAKE)
+    eigen_assert(patchId <
+                 patchDepth() * patchPlanes() * patchRows() * patchCols());
+
+    if (nonStandardPatches()) {
+      return packetWithPossibleZero(patchId, planeIndex, rowIndex, colIndex,
+                                    otherIndex);
+    }
+    typedef decltype(m_impl) TensorEvaluatorT;
+    return loadPacketStandard<Packet, TensorEvaluatorT>(
+        patchId, planeIndex, rowIndex, colIndex, otherIndex);
+  }
+
+  // Helper function to load a 'partial' packet - this is the single row part of
+  // a packet that is split across two rows (but single column). In the
+  // 'partial' packet, the elements corresponding to the row (specified through
+  // rowOffset) are loaded and the rest of the elements are zero-filled into the
+  // 'partial' packet. This function is called from
+  // loadPacketStandardFromSingleColumnTwoRows(). This code path is exercised
+  // only when the packet type supports masked load and when the partial packet
+  // load is available in the TensorEvaluator.
+  EIGEN_DEVICE_FUNC
+  EIGEN_ALWAYS_INLINE Packet loadPartialPacketStandard(
+      Index planeIndex, Index rowIndex, Index colIndex, Index otherIndex,
+      Index patchId, const Index span[], const Index patchOffsets[],
+      Index colOffset, Index rowOffset) const {
+    const Index inputCol = colIndex + colOffset;
+    const Index inputRow = rowIndex + rowOffset;
+    const Index planeOffsets[2] = {
+        patchOffsets[0] - colOffset * m_colStride - rowOffset * m_rowStride,
+        patchOffsets[1] - colOffset * m_colStride - rowOffset * m_rowStride};
+    const Index inputPlanes[2] = {planeIndex + planeOffsets[0],
+                                  planeIndex + planeOffsets[1]};
+
+    if (inputRow >= m_inputRows || inputRow < 0 || inputCol >= m_inputCols ||
+        inputCol < 0 || inputPlanes[0] >= m_inputPlanes || inputPlanes[1] < 0) {
+      // Partial packet is all zeros
+      return internal::pset1<Packet>(Scalar(0));
+    } else if (inputPlanes[0] >= 0 && inputPlanes[1] < m_inputPlanes) {
+      // From inputIndex-span[0], we need to load elements starting from index
+      // span[0] all the way upto (and including) span[1].
+      const Index depth = patchId - patchOffsets[0] * patchDepth();
+      const Index inputIndex = depth + inputPlanes[0] * m_planeInputStride +
+                               inputRow * m_rowInputStride +
+                               inputCol * m_colInputStride + otherIndex;
+      return m_impl.template partialPacket<Packet>(
+          inputIndex - span[0], mask<Packet>(span[0], span[1] + 1));
+    } else {
+      // Using slow path for this partial packet.
+      // We need to load elements starting from index span[0] all the way upto
+      // (and including) span[1]. We split this load into 3 parts:
+      // 0 : span[0]-1 - Zeros will be loaded for these indices
+      // span[0] : span[1] - Elements will be loaded here for these indices
+      // span[1]+1 : packetSize-1 - Zeross will be loaded for these indices
+      const Index packetSize = internal::unpacket_traits<Packet>::size;
+      EIGEN_ALIGN_MAX
+      std::remove_const_t<Scalar> values[packetSize];
+      for (int i = 0; i < span[0]; ++i) values[i] = Scalar(0);
+      for (int i = span[0]; i < span[1] + 1; ++i)
+        values[i] = loadCoeff(patchId - span[0] + i, planeIndex, rowIndex,
+                              colIndex, otherIndex);
+      for (int i = span[1] + 1; i < packetSize; ++i) values[i] = Scalar(0);
+      return internal::pload<Packet>(values);
+    }
+  }
+
+  // Helper function to load a packet that is split across two rows (but single
+  // column). If required, this function is called from loadPacketStandard()
+  // when the packet type supports masked load and when the partial packet load
+  // is available in the TensorEvaluator.
+  EIGEN_DEVICE_FUNC
+  EIGEN_ALWAYS_INLINE Packet loadPacketStandardFromSingleColumnTwoRows(
+      Index patchId, Index planeIndex, Index rowIndex, Index colIndex,
+      Index otherIndex, const Index patchOffsets[], const Index colOffsets[],
+      const Index rowOffsets[]) const {
+    eigen_assert(colOffsets[1] == colOffsets[0] &&
+                 rowOffsets[1] == rowOffsets[0] + 1);
+    const Index packetSize = internal::unpacket_traits<Packet>::size;
+
+    // Packet to load will be split into 2 parts where each part spans a single
+    // row and both the parts span the same column.
+    // First determine where to split.
+    const Index patchIdSplit =
+        (((rowOffsets[1] * m_rowStride) + (colOffsets[0] * m_colStride)) *
+         m_patch_depth) -
+        1;
+    const Index patchOffsetSplit = patchIdSplit / m_fastDimZero;
+
+    // patchIds[i]:          patchId corresponding to partial packet i
+    // spans[i]:             Start and end indices corresponding to the elements
+    //                       to be loaded for partial packet i
+    // patchOffsets2Cols[i]: patchOffsets corresponding to partial packet i
+    const Index patchIds[2] = {patchId, patchIdSplit + 1};
+    const Index spans[2][2] = {{0, patchIdSplit - patchId},
+                               {patchIdSplit - patchId + 1, packetSize - 1}};
+    const Index patchOffsets2Cols[2][2] = {
+        {patchOffsets[0], patchOffsetSplit},
+        {patchOffsetSplit + 1, patchOffsets[1]}};
+
+    // Load partial packets and do bit-wise OR to generate required packet
+    return internal::por<Packet>(
+        loadPartialPacketStandard(planeIndex, rowIndex, colIndex, otherIndex,
+                                  patchIds[0], spans[0], patchOffsets2Cols[0],
+                                  colOffsets[0], rowOffsets[0]),
+        loadPartialPacketStandard(planeIndex, rowIndex, colIndex, otherIndex,
+                                  patchIds[1], spans[1], patchOffsets2Cols[1],
+                                  colOffsets[1], rowOffsets[1]));
+  }
+
+  // Helper function to load a packet that is present in a single column and
+  // row. If required, this function is called from loadPacketStandard().
+  EIGEN_DEVICE_FUNC
+  EIGEN_ALWAYS_INLINE Packet loadPacketStandardFromSingleColumnSingleRow(
+      Index patchId, Index planeIndex, Index rowIndex, Index colIndex,
+      Index otherIndex, const Index patchOffsets[], const Index colOffsets[],
+      const Index rowOffsets[], const Index inputCols[],
+      const Index inputRows[]) const {
+    eigen_assert(colOffsets[1] == colOffsets[0] &&
+                 rowOffsets[1] == rowOffsets[0]);
+    const Index planeOffsets[2] = {
+        patchOffsets[0] - colOffsets[0] * m_colStride -
+            rowOffsets[0] * m_rowStride,
+        patchOffsets[1] - colOffsets[1] * m_colStride -
+            rowOffsets[1] * m_rowStride};
+    eigen_assert(planeOffsets[0] <= planeOffsets[1]);
+    const Index inputPlanes[2] = {planeIndex + planeOffsets[0],
+                                  planeIndex + planeOffsets[1]};
+
+    if (inputPlanes[0] >= m_inputPlanes || inputPlanes[1] < 0) {
+      return internal::pset1<Packet>(Scalar(0));
+    }
+    if (inputPlanes[0] >= 0 && inputPlanes[1] < m_inputPlanes) {
+      const Index depth = patchId - patchOffsets[0] * patchDepth();
+      const Index inputIndex = depth + inputPlanes[0] * m_planeInputStride +
+                               inputRows[0] * m_rowInputStride +
+                               inputCols[0] * m_colInputStride + otherIndex;
+      return m_impl.template packet<Unaligned>(inputIndex);
+    }
+    return packetWithPossibleZero(patchId, planeIndex, rowIndex, colIndex,
+                                  otherIndex);
+  }
+
+  // Load standard packet from a patch specified by the "within patch offset"
+  // (patchId) and the precomputed indices of the first element of the patch.
+  // This function will be called if partial packet loading is not available
+  // for the TensorEvaluator or if the packet type does not support masked
+  // load.
+  template <typename PacketT, typename TensorEvaluatorT>
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE typename std::enable_if<
+      !TensorEvaluatorHasPartialPacket<TensorEvaluatorT, PacketT, Index>::value,
+      PacketT>::type
+  loadPacketStandard(Index patchId, Index planeIndex, Index rowIndex,
+                     Index colIndex, Index otherIndex) const {
+    const Index packetSize = internal::unpacket_traits<Packet>::size;
+    EIGEN_STATIC_ASSERT(packetSize > 1, YOU_MADE_A_PROGRAMMING_MISTAKE)
+    eigen_assert(patchId <
+                 patchDepth() * patchPlanes() * patchRows() * patchCols());
+    eigen_assert(!nonStandardPatches());
+
+    if ((patchDepth() % packetSize) == 0) {
+      return loadPacketFast(patchId, planeIndex, rowIndex, colIndex,
+                            otherIndex);
+    } else {
+      // Offsets and input calculation here are identical to
+      // loadCoeffStandard(...), but repeated twice.
+
+      const Index patchOffsets[2] = {
+          patchId / m_fastDimZero, (patchId + packetSize - 1) / m_fastDimZero};
+
+      const Index colOffsets[2] = {patchOffsets[0] / m_fastColStride,
+                                   patchOffsets[1] / m_fastColStride};
+      eigen_assert(colOffsets[0] <= colOffsets[1]);
+
+      const Index inputCols[2] = {colIndex + colOffsets[0],
+                                  colIndex + colOffsets[1]};
+      if (inputCols[0] >= m_inputCols || inputCols[1] < 0) {
+        return internal::pset1<Packet>(Scalar(0));
+      }
+
+      if (inputCols[0] == inputCols[1]) {
+        const Index rowOffsets[2] = {
+            (patchOffsets[0] - colOffsets[0] * m_colStride) / m_fastRowStride,
+            (patchOffsets[1] - colOffsets[1] * m_colStride) / m_fastRowStride};
+        eigen_assert(rowOffsets[0] <= rowOffsets[1]);
+        const Index inputRows[2] = {rowIndex + rowOffsets[0],
+                                    rowIndex + rowOffsets[1]};
+
+        if (inputRows[0] >= m_inputRows || inputRows[1] < 0) {
+          return internal::pset1<Packet>(Scalar(0));
+        }
+
+        if (inputRows[0] == inputRows[1]) {
+          return loadPacketStandardFromSingleColumnSingleRow(
+              patchId, planeIndex, rowIndex, colIndex, otherIndex, patchOffsets,
+              colOffsets, rowOffsets, inputCols, inputRows);
+        }
+      }
+    }
+
+    return packetWithPossibleZero(patchId, planeIndex, rowIndex, colIndex,
+                                  otherIndex);
+  }
+
+  // Load standard packet from a patch specified by the "within patch offset"
+  // (patchId) and the precomputed indices of the first element of the patch.
+  // This function will be called if partial packet loading is available for
+  // the TensorEvaluator and if the packet type supports masked load.
+  // The only difference between this and the other case is that if the packet
+  // to load is split across two rows (but in same column), then in this case
+  // instead of going to the slow (element-by-element) load, we load two packets
+  // - each containing elements from one of the rows (rest of the elements of
+  // the packets are zeroes), and then combine these two packets to generate the
+  // required packet. The idea is to enable fast load (if possible) of these
+  // 'partial' packets.
+  template <typename PacketT, typename TensorEvaluatorT>
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE typename std::enable_if<
+      TensorEvaluatorHasPartialPacket<TensorEvaluatorT, PacketT, Index>::value,
+      PacketT>::type
+  loadPacketStandard(Index patchId, Index planeIndex, Index rowIndex,
+                     Index colIndex, Index otherIndex) const {
+    const Index packetSize = internal::unpacket_traits<Packet>::size;
+    EIGEN_STATIC_ASSERT(packetSize > 1, YOU_MADE_A_PROGRAMMING_MISTAKE)
+    eigen_assert(patchId <
+                 patchDepth() * patchPlanes() * patchRows() * patchCols());
+    eigen_assert(!nonStandardPatches());
+
+    if ((patchDepth() % packetSize) == 0) {
+      return loadPacketFast(patchId, planeIndex, rowIndex, colIndex,
+                            otherIndex);
+    } else {
+      // Offsets and input calculation here are identical to
+      // loadCoeffStandard(...), but repeated twice.
+
+      const Index patchOffsets[2] = {
+          patchId / m_fastDimZero, (patchId + packetSize - 1) / m_fastDimZero};
+
+      const Index colOffsets[2] = {patchOffsets[0] / m_fastColStride,
+                                   patchOffsets[1] / m_fastColStride};
+      eigen_assert(colOffsets[0] <= colOffsets[1]);
+
+      const Index inputCols[2] = {colIndex + colOffsets[0],
+                                  colIndex + colOffsets[1]};
+      if (inputCols[0] >= m_inputCols || inputCols[1] < 0) {
+        return internal::pset1<Packet>(Scalar(0));
+      }
+
+      if (inputCols[0] == inputCols[1]) {
+        const Index rowOffsets[2] = {
+            (patchOffsets[0] - colOffsets[0] * m_colStride) / m_fastRowStride,
+            (patchOffsets[1] - colOffsets[1] * m_colStride) / m_fastRowStride};
+        eigen_assert(rowOffsets[0] <= rowOffsets[1]);
+        const Index inputRows[2] = {rowIndex + rowOffsets[0],
+                                    rowIndex + rowOffsets[1]};
+
+        if (inputRows[0] >= m_inputRows || inputRows[1] < 0) {
+          return internal::pset1<Packet>(Scalar(0));
+        }
+
+        if (inputRows[0] == inputRows[1]) {
+          return loadPacketStandardFromSingleColumnSingleRow(
+              patchId, planeIndex, rowIndex, colIndex, otherIndex, patchOffsets,
+              colOffsets, rowOffsets, inputCols, inputRows);
+        }
+        if (inputRows[0] + 1 == inputRows[1]) {
+          return loadPacketStandardFromSingleColumnTwoRows(
+              patchId, planeIndex, rowIndex, colIndex, otherIndex, patchOffsets,
+              colOffsets, rowOffsets);
+        }
+      }
+    }
+
+    return packetWithPossibleZero(patchId, planeIndex, rowIndex, colIndex,
+                                  otherIndex);
+  }
+
+  EIGEN_DEVICE_FUNC
+  EIGEN_ALWAYS_INLINE Packet loadPacketFast(Index patchId, Index planeIndex,
+                                            Index rowIndex, Index colIndex,
+                                            Index otherIndex) const {
+    const Index packetSize = internal::unpacket_traits<Packet>::size;
+    EIGEN_STATIC_ASSERT(packetSize > 1, YOU_MADE_A_PROGRAMMING_MISTAKE)
+    eigen_assert(patchId <
+                 patchDepth() * patchPlanes() * patchRows() * patchCols());
+
+    eigen_assert(!nonStandardPatches());
+    eigen_assert((patchDepth() % packetSize) == 0);
+
+    // Find the offset of the element wrt the location of the first element.
+    const Index patchOffset = patchId / m_fastDimZero;
+    eigen_assert((patchId + packetSize - 1) / m_fastDimZero == patchOffset);
+
+    const Index colOffset = patchOffset / m_fastColStride;
+    const Index rowOffset =
+        (patchOffset - colOffset * m_colStride) / m_fastRowStride;
+    const Index planeOffset =
+        patchOffset - colOffset * m_colStride - rowOffset * m_rowStride;
+
+    const Index inputCol = colIndex + colOffset;
+    const Index inputRow = rowIndex + rowOffset;
+    const Index inputPlane = planeIndex + planeOffset;
+
+    if (inputCol < 0 || inputRow < 0 || inputPlane < 0 ||
+        inputCol >= m_inputCols || inputRow >= m_inputRows ||
+        inputPlane >= m_inputPlanes) {
+      return internal::pset1<Packet>(Scalar(0));
+    }
+
+    const Index depth = patchId - patchOffset * patchDepth();
+    const Index inputIndex = depth + inputPlane * m_planeInputStride +
+                             inputRow * m_rowInputStride +
+                             inputCol * m_colInputStride + otherIndex;
+    return m_impl.template packet<Unaligned>(inputIndex);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet
+  packetWithPossibleZero(Index patchId, Index planeIndex, Index rowIndex,
+                         Index colIndex, Index otherIndex) const {
+    const int packetSize = internal::unpacket_traits<Packet>::size;
+    EIGEN_ALIGN_MAX
+    std::remove_const_t<Scalar> values[packetSize];
+    for (int i = 0; i < packetSize; ++i) {
+      values[i] =
+          loadCoeff(patchId + i, planeIndex, rowIndex, colIndex, otherIndex);
+    }
+    Packet rslt = internal::pload<Packet>(values);
+    return rslt;
+  }
+
+  // Precompute the indices (plane, row, col, other) of the first element of
+  // the given patch index, within the output tensor of the TensorVolumePatchOp.
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void computeBaseIndices(
+      Index patchIndex, Index& planeIndex, Index& rowIndex, Index& colIndex,
+      Index& otherIndex) const {
+    const size_t NumInputDims = array_size<
+        typename TensorEvaluator<ArgType, Device>::Dimensions>::value;
+
+    // Check if patchIndex might contain batch and other dimensions.
+    otherIndex = (NumInputDims == 4) ? 0 : patchIndex / m_fastNumPatches;
+
+    // Compute index of the patch within the batch (and other dimensions).
+    const Index patch3DIndex = (NumInputDims == 4)
+                                   ? patchIndex
+                                   : (patchIndex - otherIndex * m_num_patches);
+
+    otherIndex *= m_patchInputStride;
+
+    colIndex = patch3DIndex / m_fastOutputPlanesRows;
+    rowIndex =
+        (patch3DIndex - colIndex * m_outputPlanesRows) / m_fastOutputPlanes;
+    planeIndex =
+        patch3DIndex - (colIndex * m_outputRows + rowIndex) * m_outputPlanes;
+
+    colIndex = colIndex * m_col_strides - m_colPaddingLeft;
+    rowIndex = rowIndex * m_row_strides - m_rowPaddingTop;
+    planeIndex = planeIndex * m_plane_strides - m_planePaddingTop;
+  }
+
+  Index m_patch_depth;   // number of channels in the patch
+  Index m_patch_planes;  // number of planes in the patch
+  Index m_patch_rows;    // number of rows in the patch
+  Index m_patch_cols;    // number of columns in the patch
+  Index m_num_patches;   // number of patches to extract
+
+  // Strides for navigating through the single patch.
+  Index m_patch_plane_stride;
+  Index m_patch_row_stride;
+  Index m_patch_col_stride;
+
+  // Strides for the output tensor (depth is not the part of the stride).
+  Index m_rowStride;
+  Index m_colStride;
+  Index m_patchStride;
+  Index m_otherStride;
+
+  Index m_planeInputStride;  // Plane stride in the input tensor
+  Index m_rowInputStride;    // Row stride in the input tensor
+  Index m_colInputStride;    // Col stride in the input tensor
+  Index m_patchInputStride;  // Patch stride in the input tensor
+  Index m_otherInputStride;
+
+  Index m_inputDepth;   // Depth of the input tensor
+  Index m_inputPlanes;  // Number of planes in the input tensor
+  Index m_inputRows;    // Number of rows in the input tensor
+  Index m_inputCols;    // Number of cols in the input tensor
+
+  Index m_outputPlanes;      // Number of output planes
+  Index m_outputRows;        // Number of output rows
+  Index m_outputCols;        // Number of output cols
+  Index m_outputPlanesRows;  // Cached outputPlanes * outputRows.
+
+  Index m_plane_strides;  // User specified plane stride
+  Index m_row_strides;    // User specified row stride
+  Index m_col_strides;    // User specified col stride
+
+  // User specified plane/row/col atrous convolution strides.
+  Index m_in_plane_strides;
+  Index m_in_row_strides;
+  Index m_in_col_strides;
+
+  // User specified plane/row/col inflation strides in the image patch.
+  Index m_patch_plane_inflate_strides;
+  Index m_patch_row_inflate_strides;
+  Index m_patch_col_inflate_strides;
+
+  Index m_planePaddingTop;  // Plane padding
+  Index m_rowPaddingTop;    // Row padding
+  Index m_colPaddingLeft;   // Column padding
+
+  // Fast representation of various divisors.
+  internal::TensorIntDivisor<Index> m_fastNumPatches;
+
+  internal::TensorIntDivisor<Index> m_fastPatchPlaneStride;
+  internal::TensorIntDivisor<Index> m_fastPatchRowStride;
+  internal::TensorIntDivisor<Index> m_fastPatchColStride;
+
+  internal::TensorIntDivisor<Index> m_fastInputPlaneStride;
+  internal::TensorIntDivisor<Index> m_fastInputRowStride;
+  internal::TensorIntDivisor<Index> m_fastInputColStride;
+
+  internal::TensorIntDivisor<Index> m_fastRowStride;
+  internal::TensorIntDivisor<Index> m_fastColStride;
+
+  internal::TensorIntDivisor<Index> m_fastDimZero;  // aka output depth
+  internal::TensorIntDivisor<Index> m_fastOutputPlanes;
+  internal::TensorIntDivisor<Index> m_fastOutputRows;
+  internal::TensorIntDivisor<Index> m_fastOutputCols;
+  internal::TensorIntDivisor<Index> m_fastOutputPlanesRows;
+
+  const TensorEvaluator<ArgType, Device> m_impl;
+};
+
+template <typename NewDimension, Index Planes, Index Rows, Index Cols,
+          typename ArgType, typename Device, typename Scalar, typename Index,
+          typename nocontract_t, typename contract_t, int Side, int packet_size,
+          bool inner_dim_contiguous, bool inner_dim_reordered, int Alignment>
+class TensorContractionSubMapper<
+    Scalar, Index, Side,
+    TensorEvaluator<const TensorReshapingOp<NewDimension,
+                                            const TensorVolumePatchOp<
+                                                Planes, Rows, Cols, ArgType> >,
+                    Device>,
+    nocontract_t, contract_t, packet_size, inner_dim_contiguous,
+    inner_dim_reordered, Alignment> {
+ public:
+  typedef typename packet_traits<Scalar>::type Packet;
+  typedef typename packet_traits<Scalar>::half HalfPacket;
+
+  typedef TensorContractionInputMapper<
+      Scalar, Index, Side,
+      TensorEvaluator<const TensorReshapingOp<
+                          NewDimension, const TensorVolumePatchOp<
+                                            Planes, Rows, Cols, ArgType> >,
+                      Device>,
+      nocontract_t, contract_t, packet_size, inner_dim_contiguous,
+      inner_dim_reordered, Alignment>
+      ParentMapper;
+  typedef TensorContractionSubMapper<
+      Scalar, Index, Side,
+      TensorEvaluator<const TensorReshapingOp<
+                          NewDimension, const TensorVolumePatchOp<
+                                            Planes, Rows, Cols, ArgType> >,
+                      Device>,
+      nocontract_t, contract_t, packet_size, inner_dim_contiguous,
+      inner_dim_reordered, Alignment>
+      Self;
+  typedef Self LinearMapper;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorContractionSubMapper(
+      const ParentMapper& base_mapper, Index vert_offset, Index horiz_offset)
+      : m_base_mapper(base_mapper),
+        m_depth_offset(vert_offset),
+        m_col_offset(horiz_offset) {
+    m_base_mapper.computeBaseIndices(m_col_offset, m_planeIndex, m_rowIndex,
+                                     m_colIndex, m_otherIndex);
+  }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorContractionSubMapper(
+      const Self& base_mapper, Index vert_offset, Index horiz_offset)
+      : m_base_mapper(base_mapper.m_base_mapper),
+        m_depth_offset(vert_offset + base_mapper.m_depth_offset),
+        m_col_offset(horiz_offset + base_mapper.m_col_offset) {
+    m_base_mapper.computeBaseIndices(m_col_offset, m_planeIndex, m_rowIndex,
+                                     m_colIndex, m_otherIndex);
+  }
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Scalar operator()(Index i) const {
+    return m_base_mapper.loadCoeff(i + m_depth_offset, m_planeIndex, m_rowIndex,
+                                   m_colIndex, m_otherIndex);
+  }
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Scalar operator()(Index i,
+                                                          Index j) const {
+    return m_base_mapper(i + m_depth_offset, j + m_col_offset);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet loadPacket(Index i) const {
+    return m_base_mapper.loadPacket(i + m_depth_offset, m_planeIndex,
+                                    m_rowIndex, m_colIndex, m_otherIndex);
+  }
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet loadPacket(Index i,
+                                                          Index j) const {
+    return m_base_mapper.template loadPacket<Alignment>(i + m_depth_offset,
+                                                        j + m_col_offset);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Scalar
+  loadCoeffStandard(Index i) const {
+    return m_base_mapper.loadCoeffStandard(
+        i + m_depth_offset, m_planeIndex, m_rowIndex, m_colIndex, m_otherIndex);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet loadPacketFast(Index i) const {
+    return m_base_mapper.loadPacketFast(i + m_depth_offset, m_planeIndex,
+                                        m_rowIndex, m_colIndex, m_otherIndex);
+  }
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet
+  loadPacketStandard(Index i) const {
+    typedef decltype(m_base_mapper.m_impl) TensorEvaluatorT;
+    return m_base_mapper.template loadPacketStandard<Packet, TensorEvaluatorT>(
+        i + m_depth_offset, m_planeIndex, m_rowIndex, m_colIndex, m_otherIndex);
+  }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC bool aligned(Index) const {
+    return false;
+  }
+
+  EIGEN_DEVICE_FUNC
+  EIGEN_ALWAYS_INLINE bool nonStandardPatches() const {
+    return m_base_mapper.nonStandardPatches();
+  }
+
+  // Max(Col|Row|Plane|Depth): compute the upper limit for the column, row,
+  // plane and depth index respectively that fits into the peeled_k elements
+  // starting at m_depth_offset.
+
+  EIGEN_DEVICE_FUNC
+  EIGEN_ALWAYS_INLINE Index maxCol(const Index peeled_k) const {
+    const Index max_col =
+        fastPatchColStride().divide(m_depth_offset + peeled_k);
+    return std::min<Index>(1 + max_col, patchCols());
+  }
+
+  EIGEN_DEVICE_FUNC
+  EIGEN_ALWAYS_INLINE Index maxRow(const Index peeled_k,
+                                   const Index col) const {
+    const Index max_row = fastPatchRowStride().divide(
+        m_depth_offset + peeled_k - col * patchColStride());
+    return std::min<Index>(1 + max_row, patchRows());
+  }
+
+  EIGEN_DEVICE_FUNC
+  EIGEN_ALWAYS_INLINE Index maxPlane(const Index peeled_k, const Index col,
+                                     const Index row) const {
+    const Index max_plane = fastPatchPlaneStride().divide(
+        m_depth_offset + peeled_k - col * patchColStride() -
+        row * patchRowStride());
+    return std::min<Index>(1 + max_plane, patchPlanes());
+  }
+
+  // MaxDepth uses only the remaining number of elements in the peeled_k.
+  EIGEN_DEVICE_FUNC
+  EIGEN_ALWAYS_INLINE Index maxDepth(const Index num_elements,
+                                     const Index start_depth) const {
+    return std::min<Index>(start_depth + num_elements, patchDepth());
+  }
+
+  // Every register matters in this code, so sometimes to prevent register
+  // spilling, instead of the variable that you would expect to see, we use
+  // another one, that is guaranteed to have the same value. E.g. patch depth is
+  // always the same as input depth, and it's also the same as input plane
+  // stride. Bunch of other parameters have similar relations.
+
+  typedef internal::TensorIntDivisor<Index> IndexDivisor;
+
+  EIGEN_DEVICE_FUNC
+  EIGEN_ALWAYS_INLINE Index patchDepth() const {
+    eigen_assert(m_base_mapper.m_patch_depth ==
+                     m_base_mapper.m_planeInputStride &&
+                 "Patch depth must be equal to plane input stride.");
+    return m_base_mapper.m_planeInputStride;
+  }
+
+  EIGEN_DEVICE_FUNC
+  EIGEN_ALWAYS_INLINE Index patchPlanes() const {
+    eigen_assert(m_base_mapper.m_patch_planes == m_base_mapper.m_rowStride &&
+                 "Patch planes must be equal to row stride.");
+    return m_base_mapper.m_rowStride;
+  }
+  EIGEN_DEVICE_FUNC
+  EIGEN_ALWAYS_INLINE Index patchRows() const {
+    return m_base_mapper.m_patch_rows;
+  }
+  EIGEN_DEVICE_FUNC
+  EIGEN_ALWAYS_INLINE Index patchCols() const {
+    return m_base_mapper.m_patch_cols;
+  }
+
+  EIGEN_DEVICE_FUNC
+  EIGEN_ALWAYS_INLINE Index patchPlaneStride() const {
+    eigen_assert(patchDepth() == m_base_mapper.m_patch_plane_stride &&
+                 "Patch depth must be equal to patch plane stride.");
+    return patchDepth();
+  }
+  EIGEN_DEVICE_FUNC
+  EIGEN_ALWAYS_INLINE Index patchRowStride() const {
+    return m_base_mapper.m_patch_row_stride;
+  }
+  EIGEN_DEVICE_FUNC
+  EIGEN_ALWAYS_INLINE Index patchColStride() const {
+    return m_base_mapper.m_patch_col_stride;
+  }
+
+  EIGEN_DEVICE_FUNC
+  EIGEN_ALWAYS_INLINE IndexDivisor fastPatchPlaneStride() const {
+    eigen_assert(patchDepth() == m_base_mapper.m_patch_plane_stride &&
+                 "Patch depth must be equal to patch plane stride.");
+    return m_base_mapper.m_fastDimZero;  // patch_depth
+  }
+  EIGEN_DEVICE_FUNC
+  EIGEN_ALWAYS_INLINE IndexDivisor fastPatchRowStride() const {
+    return m_base_mapper.m_fastPatchRowStride;
+  }
+  EIGEN_DEVICE_FUNC
+  EIGEN_ALWAYS_INLINE IndexDivisor fastPatchColStride() const {
+    return m_base_mapper.m_fastPatchColStride;
+  }
+
+  EIGEN_DEVICE_FUNC
+  EIGEN_ALWAYS_INLINE Packet packetNoPadding(const Index depth,
+                                             const Index baseIndex) const {
+    const Index inputIndex = depth + baseIndex;
+    return m_base_mapper.m_impl.template packet<Unaligned>(inputIndex);
+  }
+  EIGEN_DEVICE_FUNC
+  EIGEN_ALWAYS_INLINE Scalar coeffNoPadding(const Index depth,
+                                            const Index baseIndex) const {
+    const Index inputIndex = depth + baseIndex;
+    return m_base_mapper.m_impl.coeff(inputIndex);
+  }
+
+  EIGEN_DEVICE_FUNC
+  EIGEN_ALWAYS_INLINE bool padPlane(const Index plane) const {
+    const Index p = m_planeIndex + plane;
+    return p < 0 || p >= m_base_mapper.m_inputPlanes;
+  }
+  EIGEN_DEVICE_FUNC
+  EIGEN_ALWAYS_INLINE bool padRow(const Index row) const {
+    const Index r = m_rowIndex + row;
+    return r < 0 || r >= m_base_mapper.m_inputRows;
+  }
+  EIGEN_DEVICE_FUNC
+  EIGEN_ALWAYS_INLINE bool padCol(const Index col) const {
+    const Index c = m_colIndex + col;
+    return c < 0 || c >= m_base_mapper.m_inputCols;
+  }
+  EIGEN_DEVICE_FUNC
+  EIGEN_ALWAYS_INLINE Index baseIndex(const Index plane, const Index row,
+                                      const Index col) const {
+    const Index p = m_planeIndex + plane;
+    const Index r = m_rowIndex + row;
+    const Index c = m_colIndex + col;
+    return p * m_base_mapper.m_planeInputStride +
+           r * m_base_mapper.m_rowInputStride +
+           c * m_base_mapper.m_colInputStride + m_otherIndex;
+  }
+
+  EIGEN_DEVICE_FUNC
+  EIGEN_ALWAYS_INLINE Index planeOffset() const {
+    const Index patchOffset = m_depth_offset / m_base_mapper.m_fastDimZero;
+    const Index colOffset = patchOffset / m_base_mapper.m_fastColStride;
+    const Index rowOffset =
+        (patchOffset - colOffset * m_base_mapper.m_colStride) /
+        m_base_mapper.m_fastRowStride;
+    const Index planeOffset = patchOffset -
+                              colOffset * m_base_mapper.m_colStride -
+                              rowOffset * m_base_mapper.m_rowStride;
+    return planeOffset;
+  }
+
+  EIGEN_DEVICE_FUNC
+  EIGEN_ALWAYS_INLINE Index rowOffset() const {
+    const Index patchOffset = m_depth_offset / m_base_mapper.m_fastDimZero;
+    const Index colOffset = patchOffset / m_base_mapper.m_fastColStride;
+    const Index rowOffset =
+        (patchOffset - colOffset * m_base_mapper.m_colStride) /
+        m_base_mapper.m_fastRowStride;
+    return rowOffset;
+  }
+
+  EIGEN_DEVICE_FUNC
+  EIGEN_ALWAYS_INLINE Index colOffset() const {
+    const Index patchOffset = m_depth_offset / m_base_mapper.m_fastDimZero;
+    const Index colOffset = patchOffset / m_base_mapper.m_fastColStride;
+    return colOffset;
+  }
+
+  EIGEN_DEVICE_FUNC
+  EIGEN_ALWAYS_INLINE Index depthOffset() const {
+    return m_depth_offset % patchDepth();
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE LinearMapper
+  getLinearMapper(Index i, Index j) const {
+    return LinearMapper(m_base_mapper, i + m_depth_offset, j + m_col_offset);
+  }
+
+ private:
+  const ParentMapper m_base_mapper;  // Keeping a copy instead of a reference
+                                     // performs better in benchmarks.
+
+  Index m_depth_offset;  // First row in the input matrix
+  Index m_col_offset;    // First col in the input matrix
+
+  // Knowing that: col_offset == patchIndex * OTHERS, we keep precomputed base
+  // indices for the first element in a patch specified by col_offset
+  // (see computeBaseIndices(...) for details).
+  Index m_planeIndex;
+  Index m_rowIndex;
+  Index m_colIndex;
+  Index m_otherIndex;
+};
+
+// Arrange a block of the right input matrix (in our case it's always a "virtual
+// matrix" constructed from extracted volume patches) in contiguous memory.
+//
+// Given column major input (A0 beside A1 in memory):
+// A0 B0 C0 D0  E0 F0 G0 H0 ... Z0
+// A1 B1 C1 D1  E1 F1 G1 H1 ... Z1
+// A2 B2 C2 D2  E2 F2 G2 H2 ... Z2
+// A3 B3 C3 D3  E3 F3 G3 H3 ... Z3
+// A4 B4 C4 D4  E4 F4 G4 H4 ... Z4
+// A5 B5 C5 D5  E5 F5 G5 H5 ... Z5
+// A6 B6 C6 D6  E6 F6 G6 H6 ... Z6
+// A7 B7 C7 D7  E7 F7 G7 H7 ... Z7
+// A8 ...
+// ...
+//
+// *) A, B, C, ... - patches extracted from the original input.
+// *) A0, A1, A2 ... - values from the same patch at different offsets.
+//
+// The traversal (packed rhs memory) order (B0 besides A0 in memory):
+// A0 B0 C0 D0 A1 B1 C1 D1 ...
+// E0 F0 G0 H0 E1 F1 G1 H1 ...
+// ...
+// Z0 Z1 Z2 Z3 Z4 Z5 Z6 Z7 ... <- doesn't belong to any block (nr = 4)
+//
+// This traversal order must be the same as in default gemm_pack_rhs defined in
+// GeneralBlockPanelKernel.h.
+//
+// *) nr - number of registers along the 'n' dimension.
+//    See GeneralBlockPanelKernel.h and "Anatomy of High-Performance Matrix
+//    Multiplication" paper.
+//
+// TODO(ezhulenev): Add support for squeezing reads along two innermost
+// dimensions (see eigen_spatial_convolutions).
+template <typename NewDimension, Index Planes, Index Rows, Index Cols,
+          typename ArgType, typename Device, typename Scalar, typename Index,
+          typename nocontract_t, typename contract_t, int packet_size,
+          bool inner_dim_contiguous, bool inner_dim_reordered, int Alignment,
+          int nr>
+struct gemm_pack_rhs<
+    Scalar, Index,
+    TensorContractionSubMapper<
+        Scalar, Index, Rhs,
+        TensorEvaluator<const TensorReshapingOp<
+                            NewDimension, const TensorVolumePatchOp<
+                                              Planes, Rows, Cols, ArgType> >,
+                        Device>,
+        nocontract_t, contract_t, packet_size, inner_dim_contiguous,
+        inner_dim_reordered, Alignment>,
+    nr, ColMajor, false, false> {
+  typedef TensorContractionSubMapper<
+      Scalar, Index, Rhs,
+      TensorEvaluator<const TensorReshapingOp<
+                          NewDimension, const TensorVolumePatchOp<
+                                            Planes, Rows, Cols, ArgType> >,
+                      Device>,
+      nocontract_t, contract_t, packet_size, inner_dim_contiguous,
+      inner_dim_reordered, Alignment>
+      SubMapper;
+
+  typedef SubMapper DataMapper;
+  typedef typename packet_traits<Scalar>::type Packet;
+
+  EIGEN_STATIC_ASSERT((nr == 4), YOU_MADE_A_PROGRAMMING_MISTAKE);
+
+  EIGEN_DEVICE_FUNC
+  EIGEN_DONT_INLINE void operator()(Scalar* block, const DataMapper& rhs,
+                                    Index depth, Index cols, Index stride = 0,
+                                    Index offset = 0) const {
+    eigen_assert(stride == 0);
+    eigen_assert(offset == 0);
+
+    const Index packet_cols4 = (cols / 4) * 4;
+    const Index peeled_k = (depth / packet_size) * packet_size;
+    const bool non_standard_patches = rhs.nonStandardPatches();
+
+    for (Index j2 = 0; j2 < packet_cols4; j2 += 4) {
+      const SubMapper dm0 = rhs.getLinearMapper(0, j2 + 0);
+      const SubMapper dm1 = rhs.getLinearMapper(0, j2 + 1);
+      const SubMapper dm2 = rhs.getLinearMapper(0, j2 + 2);
+      const SubMapper dm3 = rhs.getLinearMapper(0, j2 + 3);
+
+      Index k = 0;
+      if ((packet_size % 4) == 0 && !non_standard_patches) {
+        // FAST PATH:
+        // Iterate over patch columns, rows and planes if we know that a single
+        // packet do not span across multiple planes, rows or columns.
+        if ((rhs.patchDepth() % packet_size) == 0) {
+          const Index start_col = rhs.colOffset();
+          const Index max_col = rhs.maxCol(peeled_k);
+
+          for (Index c = start_col; c < max_col; ++c) {
+            eigen_assert(k <= peeled_k);
+
+            const Index start_row = (c == start_col) ? rhs.rowOffset() : 0;
+            const Index max_row = rhs.maxRow(peeled_k, c);
+
+            const bool pad_col0 = dm0.padCol(c);
+            const bool pad_col1 = dm1.padCol(c);
+            const bool pad_col2 = dm2.padCol(c);
+            const bool pad_col3 = dm3.padCol(c);
+
+            for (Index r = start_row; r < max_row; ++r) {
+              eigen_assert(k <= peeled_k);
+
+              const Index start_plane = ((c == start_col) && (r == start_row))
+                                            ? rhs.planeOffset()
+                                            : 0;
+              const Index max_plane = rhs.maxPlane(peeled_k, c, r);
+
+              const bool pad_row0 = pad_col0 || dm0.padRow(r);
+              const bool pad_row1 = pad_col1 || dm1.padRow(r);
+              const bool pad_row2 = pad_col2 || dm2.padRow(r);
+              const bool pad_row3 = pad_col3 || dm3.padRow(r);
+
+              for (Index p = start_plane; p < max_plane; ++p) {
+                eigen_assert(k <= peeled_k);
+
+                const bool pad0 = pad_row0 || dm0.padPlane(p);
+                const bool pad1 = pad_row1 || dm1.padPlane(p);
+                const bool pad2 = pad_row2 || dm2.padPlane(p);
+                const bool pad3 = pad_row3 || dm3.padPlane(p);
+
+                const Index idx0 = dm0.baseIndex(p, r, c);
+                const Index idx1 = dm1.baseIndex(p, r, c);
+                const Index idx2 = dm2.baseIndex(p, r, c);
+                const Index idx3 = dm3.baseIndex(p, r, c);
+
+                const Index start_depth =
+                    ((c == start_col) && (r == start_row) && (p == start_plane))
+                        ? rhs.depthOffset()
+                        : 0;
+                const Index max_depth = rhs.maxDepth(peeled_k - k, start_depth);
+                eigen_assert((max_depth - start_depth) % packet_size == 0);
+
+                for (Index d = start_depth; d < max_depth; d += packet_size) {
+                  eigen_assert(k < peeled_k);
+                  PacketBlock<Packet, 4> kernel;
+                  kernel.packet[0] = pad0 ? pset1<Packet>(Scalar(0))
+                                          : rhs.packetNoPadding(d, idx0);
+                  kernel.packet[1] = pad1 ? pset1<Packet>(Scalar(0))
+                                          : rhs.packetNoPadding(d, idx1);
+                  kernel.packet[2] = pad2 ? pset1<Packet>(Scalar(0))
+                                          : rhs.packetNoPadding(d, idx2);
+                  kernel.packet[3] = pad3 ? pset1<Packet>(Scalar(0))
+                                          : rhs.packetNoPadding(d, idx3);
+                  ptranspose(kernel);
+                  pstoreu(block + 0 * packet_size, kernel.packet[0]);
+                  pstoreu(block + 1 * packet_size, kernel.packet[1]);
+                  pstoreu(block + 2 * packet_size, kernel.packet[2]);
+                  pstoreu(block + 3 * packet_size, kernel.packet[3]);
+                  block += 4 * packet_size;
+                  k += packet_size;
+                }
+              }
+            }
+          }
+
+          // The loop above should fill peeled_k elements.
+          eigen_assert(peeled_k == k);
+
+        } else {
+          // Packet can span multiple planes, rows or columns, so we have to go
+          // though the slower "standard" path.
+          for (; k < peeled_k; k += packet_size) {
+            PacketBlock<Packet, 4> kernel;
+            kernel.packet[0] = dm0.loadPacketStandard(k);
+            kernel.packet[1] = dm1.loadPacketStandard(k);
+            kernel.packet[2] = dm2.loadPacketStandard(k);
+            kernel.packet[3] = dm3.loadPacketStandard(k);
+            ptranspose(kernel);
+            pstoreu(block + 0 * packet_size, kernel.packet[0]);
+            pstoreu(block + 1 * packet_size, kernel.packet[1]);
+            pstoreu(block + 2 * packet_size, kernel.packet[2]);
+            pstoreu(block + 3 * packet_size, kernel.packet[3]);
+            block += 4 * packet_size;
+          }
+        }
+      }
+
+      // Copy the remaining coefficients of the column block after the peeled_k.
+      if (!non_standard_patches) {
+        for (; k < depth; k++) {
+          block[0] = dm0.loadCoeffStandard(k);
+          block[1] = dm1.loadCoeffStandard(k);
+          block[2] = dm2.loadCoeffStandard(k);
+          block[3] = dm3.loadCoeffStandard(k);
+          block += 4;
+        }
+      } else {
+        for (; k < depth; k++) {
+          block[0] = dm0(k);
+          block[1] = dm1(k);
+          block[2] = dm2(k);
+          block[3] = dm3(k);
+          block += 4;
+        }
+      }
+    }
+
+    // Copy the remaining columns one at a time (nr==1).
+    for (Index j2 = packet_cols4; j2 < cols; ++j2) {
+      const SubMapper dm0 = rhs.getLinearMapper(0, j2);
+      for (Index k = 0; k < depth; k++) {
+        *block = dm0(k);
+        block += 1;
+      }
+    }
+  }
+};
+
+// Template specialization for packet_size = 2. We must special-case packet
+// blocks with nr > packet_size, e.g. PacketBlock<Packet2d, 4>.
+//
+// TODO(ezhulenev): Add support for squeezing reads along two innermost
+// dimensions (see eigen_spatial_convolutions).
+template <typename NewDimension, Index Planes, Index Rows, Index Cols,
+          typename ArgType, typename Device, typename Scalar, typename Index,
+          typename nocontract_t, typename contract_t, bool inner_dim_contiguous,
+          bool inner_dim_reordered, int Alignment, int nr>
+struct gemm_pack_rhs<
+    Scalar, Index,
+    TensorContractionSubMapper<
+        Scalar, Index, Rhs,
+        TensorEvaluator<const TensorReshapingOp<
+                            NewDimension, const TensorVolumePatchOp<
+                                              Planes, Rows, Cols, ArgType> >,
+                        Device>,
+        nocontract_t, contract_t, /*packet_size*/ 2, inner_dim_contiguous,
+        inner_dim_reordered, Alignment>,
+    nr, ColMajor, false, false> {
+  typedef TensorContractionSubMapper<
+      Scalar, Index, Rhs,
+      TensorEvaluator<const TensorReshapingOp<
+                          NewDimension, const TensorVolumePatchOp<
+                                            Planes, Rows, Cols, ArgType> >,
+                      Device>,
+      nocontract_t, contract_t, /*packet_size*/ 2, inner_dim_contiguous,
+      inner_dim_reordered, Alignment>
+      SubMapper;
+  typedef SubMapper DataMapper;
+  typedef typename packet_traits<Scalar>::type Packet;
+
+  EIGEN_STATIC_ASSERT((nr == 4), YOU_MADE_A_PROGRAMMING_MISTAKE);
+
+  EIGEN_DEVICE_FUNC
+  EIGEN_DONT_INLINE void operator()(Scalar* block, const DataMapper& rhs,
+                                    Index depth, Index cols, Index stride = 0,
+                                    Index offset = 0) const {
+    eigen_assert(stride == 0);
+    eigen_assert(offset == 0);
+
+    const int packet_size = 2;
+
+    const Index packet_cols4 = (cols / 4) * 4;
+    const Index peeled_k = (depth / packet_size) * packet_size;
+    const bool non_standard_patches = rhs.nonStandardPatches();
+
+    for (Index j2 = 0; j2 < packet_cols4; j2 += 4) {
+      const SubMapper dm0 = rhs.getLinearMapper(0, j2 + 0);
+      const SubMapper dm1 = rhs.getLinearMapper(0, j2 + 1);
+      const SubMapper dm2 = rhs.getLinearMapper(0, j2 + 2);
+      const SubMapper dm3 = rhs.getLinearMapper(0, j2 + 3);
+
+      Index k = 0;
+      if (!non_standard_patches) {
+        // FAST PATH:
+        // Iterate over patch columns, rows and planes if we know that a single
+        // packet do not span across multiple planes, rows or columns.
+        if ((rhs.patchDepth() % packet_size) == 0) {
+          const Index start_col = rhs.colOffset();
+          const Index max_col = rhs.maxCol(peeled_k);
+
+          for (Index c = start_col; c < max_col; ++c) {
+            eigen_assert(k <= peeled_k);
+
+            const Index start_row = (c == start_col) ? rhs.rowOffset() : 0;
+            const Index max_row = rhs.maxRow(peeled_k, c);
+
+            const bool pad_col0 = dm0.padCol(c);
+            const bool pad_col1 = dm1.padCol(c);
+            const bool pad_col2 = dm2.padCol(c);
+            const bool pad_col3 = dm3.padCol(c);
+
+            for (Index r = start_row; r < max_row; ++r) {
+              eigen_assert(k <= peeled_k);
+
+              const Index start_plane = ((c == start_col) && (r == start_row))
+                                            ? rhs.planeOffset()
+                                            : 0;
+              const Index max_plane = rhs.maxPlane(peeled_k, c, r);
+
+              const bool pad_row0 = dm0.padRow(r);
+              const bool pad_row1 = dm1.padRow(r);
+              const bool pad_row2 = dm2.padRow(r);
+              const bool pad_row3 = dm3.padRow(r);
+
+              for (Index p = start_plane; p < max_plane; ++p) {
+                eigen_assert(k <= peeled_k);
+
+                const bool pad0 = pad_col0 || pad_row0 || dm0.padPlane(p);
+                const bool pad1 = pad_col1 || pad_row1 || dm1.padPlane(p);
+                const bool pad2 = pad_col2 || pad_row2 || dm2.padPlane(p);
+                const bool pad3 = pad_col3 || pad_row3 || dm3.padPlane(p);
+
+                const Index idx0 = dm0.baseIndex(p, r, c);
+                const Index idx1 = dm1.baseIndex(p, r, c);
+                const Index idx2 = dm2.baseIndex(p, r, c);
+                const Index idx3 = dm3.baseIndex(p, r, c);
+
+                const Index start_depth =
+                    ((c == start_col) && (r == start_row) && (p == start_plane))
+                        ? rhs.depthOffset()
+                        : 0;
+                const Index max_depth = rhs.maxDepth(peeled_k - k, start_depth);
+                eigen_assert((max_depth - start_depth) % packet_size == 0);
+
+                for (Index d = start_depth; d < max_depth; d += packet_size) {
+                  eigen_assert(k < peeled_k);
+                  PacketBlock<Packet, 2> kernel0;
+                  PacketBlock<Packet, 2> kernel1;
+                  kernel0.packet[0] = pad0 ? pset1<Packet>(Scalar(0))
+                                           : rhs.packetNoPadding(d, idx0);
+                  kernel0.packet[1] = pad1 ? pset1<Packet>(Scalar(0))
+                                           : rhs.packetNoPadding(d, idx1);
+                  kernel1.packet[0] = pad2 ? pset1<Packet>(Scalar(0))
+                                           : rhs.packetNoPadding(d, idx2);
+                  kernel1.packet[1] = pad3 ? pset1<Packet>(Scalar(0))
+                                           : rhs.packetNoPadding(d, idx3);
+                  ptranspose(kernel0);
+                  ptranspose(kernel1);
+                  pstoreu(block + 0 * packet_size, kernel0.packet[0]);
+                  pstoreu(block + 1 * packet_size, kernel1.packet[0]);
+                  pstoreu(block + 2 * packet_size, kernel0.packet[1]);
+                  pstoreu(block + 3 * packet_size, kernel1.packet[1]);
+                  block += 4 * packet_size;
+                  k += packet_size;
+                }
+              }
+            }
+          }
+
+          // The loop above should fill peeled_k elements.
+          eigen_assert(peeled_k == k);
+
+        } else {
+          for (; k < peeled_k; k += packet_size) {
+            PacketBlock<Packet, 2> kernel0;
+            PacketBlock<Packet, 2> kernel1;
+            kernel0.packet[0] = dm0.loadPacketStandard(k);
+            kernel0.packet[1] = dm1.loadPacketStandard(k);
+            kernel1.packet[0] = dm2.loadPacketStandard(k);
+            kernel1.packet[1] = dm3.loadPacketStandard(k);
+            ptranspose(kernel0);
+            ptranspose(kernel1);
+            pstoreu(block + 0 * packet_size, kernel0.packet[0]);
+            pstoreu(block + 1 * packet_size, kernel1.packet[0]);
+            pstoreu(block + 2 * packet_size, kernel0.packet[1]);
+            pstoreu(block + 3 * packet_size, kernel1.packet[1]);
+            block += 4 * packet_size;
+          }
+        }
+      }
+
+      // Copy the remaining coefficients of the column block after the peeled_k.
+      if (!rhs.nonStandardPatches()) {
+        for (; k < depth; k++) {
+          block[0] = dm0.loadCoeffStandard(k);
+          block[1] = dm1.loadCoeffStandard(k);
+          block[2] = dm2.loadCoeffStandard(k);
+          block[3] = dm3.loadCoeffStandard(k);
+          block += 4;
+        }
+      } else {
+        for (; k < depth; k++) {
+          block[0] = dm0(k);
+          block[1] = dm1(k);
+          block[2] = dm2(k);
+          block[3] = dm3(k);
+          block += 4;
+        }
+      }
+    }
+
+    // Copy the remaining columns one at a time (nr==1).
+    for (Index j2 = packet_cols4; j2 < cols; ++j2) {
+      const SubMapper dm0 = rhs.getLinearMapper(0, j2);
+      for (Index k = 0; k < depth; k++) {
+        *block = dm0(k);
+        block += 1;
+      }
+    }
+  }
+};
+
+// Special case for non-vectorized types such as float16 (packet_size = 1).
+template <typename NewDimension, Index Planes, Index Rows, Index Cols,
+          typename ArgType, typename Device, typename Scalar, typename Index,
+          typename nocontract_t, typename contract_t, bool inner_dim_contiguous,
+          bool inner_dim_reordered, int Alignment, int nr>
+struct gemm_pack_rhs<
+    Scalar, Index,
+    TensorContractionSubMapper<
+        Scalar, Index, Rhs,
+        TensorEvaluator<const TensorReshapingOp<
+                            NewDimension, const TensorVolumePatchOp<
+                                              Planes, Rows, Cols, ArgType> >,
+                        Device>,
+        nocontract_t, contract_t, /*packet_size*/ 1, inner_dim_contiguous,
+        inner_dim_reordered, Alignment>,
+    nr, ColMajor, false, false> {
+  typedef TensorContractionSubMapper<
+      Scalar, Index, Rhs,
+      TensorEvaluator<const TensorReshapingOp<
+                          NewDimension, const TensorVolumePatchOp<
+                                            Planes, Rows, Cols, ArgType> >,
+                      Device>,
+      nocontract_t, contract_t, 1, inner_dim_contiguous, inner_dim_reordered,
+      Alignment>
+      SubMapper;
+  typedef SubMapper DataMapper;
+
+  EIGEN_STATIC_ASSERT((nr == 4), YOU_MADE_A_PROGRAMMING_MISTAKE);
+
+  EIGEN_DEVICE_FUNC
+  EIGEN_DONT_INLINE void operator()(Scalar* block, const DataMapper& rhs,
+                                    Index depth, Index cols, Index stride = 0,
+                                    Index offset = 0) const {
+    eigen_assert(stride == 0);
+    eigen_assert(offset == 0);
+
+    const Index packet_cols4 = (cols / 4) * 4;
+
+    for (Index j2 = 0; j2 < packet_cols4; j2 += 4) {
+      const SubMapper dm0 = rhs.getLinearMapper(0, j2 + 0);
+      const SubMapper dm1 = rhs.getLinearMapper(0, j2 + 1);
+      const SubMapper dm2 = rhs.getLinearMapper(0, j2 + 2);
+      const SubMapper dm3 = rhs.getLinearMapper(0, j2 + 3);
+
+      if (!rhs.nonStandardPatches()) {
+        for (Index k = 0; k < depth; k++) {
+          block[0] = dm0.loadCoeffStandard(k);
+          block[1] = dm1.loadCoeffStandard(k);
+          block[2] = dm2.loadCoeffStandard(k);
+          block[3] = dm3.loadCoeffStandard(k);
+          block += 4;
+        }
+      } else {
+        for (Index k = 0; k < depth; k++) {
+          block[0] = dm0(k);
+          block[1] = dm1(k);
+          block[2] = dm2(k);
+          block[3] = dm3(k);
+          block += 4;
+        }
+      }
+    }
+
+    // Copy the remaining columns one at a time (nr==1).
+    for (Index j2 = packet_cols4; j2 < cols; ++j2) {
+      const SubMapper dm0 = rhs.getLinearMapper(0, j2);
+      for (Index k = 0; k < depth; k++) {
+        *block = dm0(k);
+        block += 1;
+      }
+    }
+  }
+};
+#endif
+
+#if defined(TENSORFLOW_USE_CUSTOM_CONTRACTION_KERNEL)
+// Pack a block of the right input matrix (in our case it's always a "virtual
+// matrix" constructed from extracted image patches) in contiguous block in
+// column-major storage order. Knowing the properties of the original patch op
+// we can do it more efficient than the default gemm_pack_colmajor_block.
+//
+// TODO(ezhulenev): gemm_pack_colmajor_block for spatial convolutions supports
+// squeezing reads along the 2 innermost dimensions, add it here if needed.
+template <typename NewDimension, Index Planes, Index Rows, Index Cols,
+          typename ArgType, typename Device, typename Scalar,
+          typename StorageIndex, typename nocontract_t, typename contract_t,
+          int packet_size, bool inner_dim_contiguous, bool inner_dim_reordered,
+          int Alignment>
+struct gemm_pack_colmajor_block<
+    Scalar, StorageIndex,
+    TensorContractionSubMapper<
+        Scalar, StorageIndex, Rhs,
+        TensorEvaluator<const TensorReshapingOp<
+                            NewDimension, const TensorVolumePatchOp<
+                                              Planes, Rows, Cols, ArgType> >,
+                        Device>,
+        nocontract_t, contract_t, packet_size, inner_dim_contiguous,
+        inner_dim_reordered, Alignment>,
+    ColMajor> {
+  typedef TensorContractionSubMapper<
+      Scalar, StorageIndex, Rhs,
+      TensorEvaluator<const TensorReshapingOp<
+                          NewDimension, const TensorVolumePatchOp<
+                                            Planes, Rows, Cols, ArgType> >,
+                      Device>,
+      nocontract_t, contract_t, packet_size, inner_dim_contiguous,
+      inner_dim_reordered, Alignment>
+      SubMapper;
+
+  typedef SubMapper DataMapper;
+  typedef typename packet_traits<Scalar>::type Packet;
+
+  EIGEN_DONT_INLINE
+  void operator()(Scalar* block, const DataMapper& rhs, StorageIndex rows,
+                  StorageIndex cols) {
+    const bool standard_patches = !rhs.nonStandardPatches();
+
+    if (standard_patches && rhs.patchDepth() % packet_size == 0) {
+      packStandardPatches<true>(block, rhs, rows, cols);
+
+    } else if (standard_patches) {
+      packStandardPatches<false>(block, rhs, rows, cols);
+
+    } else {
+      // With non-standard patches we don't do any vectorized loads.
+      // TODO(ezhulenev): It doesn't look like that we should completely give up
+      // on packets. Make this code path faster!
+      for (StorageIndex col = 0; col < cols; ++col) {
+        SubMapper lm = rhs.getLinearMapper(0, col);
+        for (StorageIndex i = 0; i < rows; ++i) {
+          *block = lm(i);
+          ++block;
+        }
+      }
+    }
+  }
+
+ private:
+  // Pack standard volume patches:
+  //
+  // - patch_depth_is_multiple_of_packet_size=true: We are guaranteed to have
+  //   depth dimension size to be a multiple of packet size, so we can skip all
+  //   non vectorized loads and checks.
+  //
+  template <bool patch_depth_is_multiple_of_packet_size>
+  EIGEN_ALWAYS_INLINE void packStandardPatches(Scalar* block,
+                                               const DataMapper& rhs,
+                                               StorageIndex rows,
+                                               StorageIndex cols) {
+    eigen_assert(!rhs.nonStandardPatches());
+
+    // Give vectorized_rows the name used in all other gemm_pack_rhs above.
+    const Index peeled_k = (rows / packet_size) * packet_size;
+
+    const Index start_col = rhs.colOffset();
+    const Index max_col = rhs.maxCol(peeled_k);
+
+    for (StorageIndex col = 0; col < cols; ++col) {
+      SubMapper lm = rhs.getLinearMapper(0, col);
+
+      Index k = 0;
+      for (Index c = start_col; c < max_col; ++c) {
+        eigen_assert(k <= peeled_k);
+
+        const Index start_row = (c == start_col) ? rhs.rowOffset() : 0;
+        const Index max_row = rhs.maxRow(peeled_k, c);
+        const bool pad_col = lm.padCol(c);
+
+        for (Index r = start_row; r < max_row; ++r) {
+          eigen_assert(k <= peeled_k);
+
+          const Index start_plane =
+              ((c == start_col) && (r == start_row)) ? rhs.planeOffset() : 0;
+          const Index max_plane = rhs.maxPlane(peeled_k, c, r);
+          const bool pad_row = pad_col || lm.padRow(r);
+
+          for (Index p = start_plane; p < max_plane; ++p) {
+            eigen_assert(k <= peeled_k);
+
+            const Index start_depth =
+                ((c == start_col) && (r == start_row) && (p == start_plane))
+                    ? rhs.depthOffset()
+                    : 0;
+            const Index max_depth = rhs.maxDepth(peeled_k - k, start_depth);
+
+            const bool pad = pad_col || pad_row || lm.padPlane(p);
+            const Index base_idx = lm.baseIndex(p, r, c);
+
+            if (patch_depth_is_multiple_of_packet_size)
+              eigen_assert((max_depth - start_depth) % packet_size == 0);
+
+            // If patch depth is a multiple of packet size, it's guaranteed that
+            // we can process all values in depth dimension with packets.
+            const Index max_vectorized_depth =
+                patch_depth_is_multiple_of_packet_size
+                    ? max_depth
+                    : max_depth - packet_size;
+
+            Index d = start_depth;
+
+            // 1. Process depth dimension with vectorized instructions.
+            for (; d < max_vectorized_depth; d += packet_size) {
+              eigen_assert(k < peeled_k);
+              const Packet packet = pad ? pset1<Packet>(Scalar(0))
+                                        : rhs.packetNoPadding(d, base_idx);
+              internal::pstoreu(block, packet);
+              block += packet_size;
+              k += packet_size;
+            }
+
+            // 2. Finish with coefficients.
+            if (!patch_depth_is_multiple_of_packet_size) {
+              for (; d < max_depth; d++) {
+                eigen_assert(k < peeled_k);
+                *block = pad ? Scalar(0) : rhs.coeffNoPadding(d, base_idx);
+                ++block;
+                ++k;
+              }
+            }
+          }
+        }
+      }
+
+      // The loop above should fill peeled_k elements.
+      eigen_assert(peeled_k == k);
+
+      // Fill remaining elements using loadCoeffStandard.
+      for (; k < rows; ++k) {
+        *block = lm.loadCoeffStandard(k);
+        ++block;
+      }
+    }
+  }
+};
+#endif  // defined(TENSORFLOW_USE_CUSTOM_CONTRACTION_KERNEL)
+
+}  // namespace internal
+
+/** CuboidConvolution
+ * \ingroup CXX11_NeuralNetworks_Module
+ *
+ * \brief Applies a 3D convolution over a multichannel input voxel block.
+ *
+ * The input parameter is expected to be a tensor with a rank of 4 or more
+ * (channels, depth, height, width, and optionally others).
+ * The kernel parameter is expected to be a 5D tensor (filters, channels,
+ * kernel_depth, kernel_height, kernel_width).
+ * The result can be assigned to a tensor of rank equal to the rank of the
+ * input. The dimensions of the result will be filters, depth, height, width
+ * (and others if applicable).
+ *
+ * The input and kernel have to be in the same layout, and both row-major and
+ * col-major are supported. The shapes given above are for col-major layout.
+ * For row-major, all dimensions should be reversed.
+ *
+ * It is possible to swap the order of the depth, width, and height dimensions
+ * provided that the same order is used in the input, the kernel, and the
+ * output.
+ */
+template <typename Input, typename Kernel>
+EIGEN_ALWAYS_INLINE static const std::conditional_t<
+    internal::traits<Input>::Layout == ColMajor,
+    TensorReshapingOp<
+        const DSizes<typename internal::traits<Input>::Index,
+                     internal::traits<Input>::NumDimensions>,
+        const TensorContractionOp<
+            const array<IndexPair<typename internal::traits<Input>::Index>, 1>,
+            const TensorReshapingOp<
+                const DSizes<typename internal::traits<Input>::Index, 2>,
+                const Kernel>,
+            const TensorReshapingOp<
+                const DSizes<typename internal::traits<Input>::Index, 2>,
+                const TensorVolumePatchOp<Dynamic, Dynamic, Dynamic,
+                                          const Input> > > >,
+    TensorReshapingOp<
+        const DSizes<typename internal::traits<Input>::Index,
+                     internal::traits<Input>::NumDimensions>,
+        const TensorContractionOp<
+            const array<IndexPair<typename internal::traits<Input>::Index>, 1>,
+            const TensorReshapingOp<
+                const DSizes<typename internal::traits<Input>::Index, 2>,
+                const TensorVolumePatchOp<Dynamic, Dynamic, Dynamic,
+                                          const Input> >,
+            const TensorReshapingOp<
+                const DSizes<typename internal::traits<Input>::Index, 2>,
+                const Kernel> > > >
+CuboidConvolution(const Input& input, const Kernel& kernel,
+                  const Index stridePlanes = 1, const Index strideRows = 1,
+                  const Index strideCols = 1,
+                  const PaddingType padding_type = PADDING_SAME) {
+  typedef typename internal::traits<Input>::Index TensorIndex;
+  TensorRef<Tensor<typename internal::traits<Input>::Scalar,
+                   internal::traits<Input>::NumDimensions,
+                   internal::traits<Input>::Layout, TensorIndex> >
+      in(input);
+  TensorRef<Tensor<typename internal::traits<Kernel>::Scalar,
+                   internal::traits<Kernel>::NumDimensions,
+                   internal::traits<Kernel>::Layout, TensorIndex> >
+      kern(kernel);
+
+  EIGEN_STATIC_ASSERT(
+      internal::traits<Input>::Layout == internal::traits<Kernel>::Layout,
+      YOU_MADE_A_PROGRAMMING_MISTAKE);
+  static const bool isColMajor = (internal::traits<Input>::Layout == ColMajor);
+  static const int NumDims = internal::traits<Input>::NumDimensions;
+
+  // Number of filters to apply. This is the same as the output depth of the
+  // result.
+  const TensorIndex kernelFilters =
+      isColMajor ? kern.dimensions()[0] : kern.dimensions()[4];
+  const TensorIndex kernelChannels =
+      isColMajor ? kern.dimensions()[1] : kern.dimensions()[3];
+
+  // Spatial size of the kernel.
+  const TensorIndex kernelPlanes =
+      isColMajor ? kern.dimensions()[2] : kern.dimensions()[2];
+  const TensorIndex kernelRows =
+      isColMajor ? kern.dimensions()[3] : kern.dimensions()[1];
+  const TensorIndex kernelCols =
+      isColMajor ? kern.dimensions()[4] : kern.dimensions()[0];
+
+  if (isColMajor) {
+    eigen_assert(kernelChannels == in.dimension(0));
+  } else {
+    eigen_assert(kernelChannels == in.dimension(NumDims - 1));
+  }
+
+  const TensorIndex inputPlanes =
+      isColMajor ? in.dimension(1) : in.dimension(NumDims - 2);
+  const TensorIndex inputRows =
+      isColMajor ? in.dimension(2) : in.dimension(NumDims - 3);
+  const TensorIndex inputCols =
+      isColMajor ? in.dimension(3) : in.dimension(NumDims - 4);
+
+  TensorIndex out_planes;
+  TensorIndex out_height;
+  TensorIndex out_width;
+  switch (padding_type) {
+    case PADDING_VALID:
+      out_planes = Eigen::divup(inputPlanes - kernelPlanes + 1,
+                                static_cast<TensorIndex>(stridePlanes));
+      out_height = Eigen::divup(inputRows - kernelRows + 1,
+                                static_cast<TensorIndex>(strideRows));
+      out_width = Eigen::divup(inputCols - kernelCols + 1,
+                               static_cast<TensorIndex>(strideCols));
+      break;
+    case PADDING_SAME:
+      out_planes =
+          Eigen::divup(inputPlanes, static_cast<TensorIndex>(stridePlanes));
+      out_height =
+          Eigen::divup(inputRows, static_cast<TensorIndex>(strideRows));
+      out_width = Eigen::divup(inputCols, static_cast<TensorIndex>(strideCols));
+      break;
+    default:
+      out_planes = 0;
+      out_height = 0;
+      out_width = 0;
+      eigen_assert(false && "unexpected padding");
+  }
+
+  DSizes<TensorIndex, 2> kernel_dims;
+  if (isColMajor) {
+    kernel_dims[0] = kernelFilters;
+    kernel_dims[1] = kernelChannels * kernelPlanes * kernelRows * kernelCols;
+  } else {
+    kernel_dims[0] = kernelChannels * kernelPlanes * kernelRows * kernelCols;
+    kernel_dims[1] = kernelFilters;
+  }
+
+  // Molds the output of the patch extraction result into a 2D tensor:
+  // - the first dimension (dims[0]): the patch values to be multiplied with the
+  // kernels
+  // - the second dimension (dims[1]): everything else
+  DSizes<TensorIndex, 2> pre_contract_dims;
+  if (isColMajor) {
+    pre_contract_dims[0] =
+        kernelChannels * kernelPlanes * kernelRows * kernelCols;
+    pre_contract_dims[1] = out_planes * out_height * out_width;
+    for (int i = 4; i < NumDims; ++i) {
+      pre_contract_dims[1] *= in.dimension(i);
+    }
+  } else {
+    pre_contract_dims[1] =
+        kernelChannels * kernelPlanes * kernelRows * kernelCols;
+    pre_contract_dims[0] = out_planes * out_height * out_width;
+    for (int i = 0; i < NumDims - 4; ++i) {
+      pre_contract_dims[0] *= in.dimension(i);
+    }
+  }
+
+  array<IndexPair<TensorIndex>, 1> contract_dims;
+  contract_dims[0] = IndexPair<TensorIndex>(1, 0);
+
+  // Molds the output of the contraction into the shape expected by the user
+  // (assuming ColMajor):
+  // - 1st dim: kernel filters
+  // - 2nd dim: output depth
+  // - 3nd dim: output height
+  // - 4rd dim: output width
+  // - 5th dim and beyond: everything else including batch size
+  DSizes<TensorIndex, NumDims> post_contract_dims;
+  if (isColMajor) {
+    post_contract_dims[0] = kernelFilters;
+    post_contract_dims[1] = out_planes;
+    post_contract_dims[2] = out_height;
+    post_contract_dims[3] = out_width;
+    for (int i = 4; i < NumDims; ++i) {
+      post_contract_dims[i] = in.dimension(i);
+    }
+  } else {
+    post_contract_dims[NumDims - 1] = kernelFilters;
+    post_contract_dims[NumDims - 2] = out_planes;
+    post_contract_dims[NumDims - 3] = out_height;
+    post_contract_dims[NumDims - 4] = out_width;
+    for (int i = 0; i < NumDims - 4; ++i) {
+      post_contract_dims[i] = in.dimension(i);
+    }
+  }
+
+  return choose(
+      Cond<internal::traits<Input>::Layout == ColMajor>(),
+      kernel.reshape(kernel_dims)
+          .contract(input
+                        .extract_volume_patches(
+                            kernelPlanes, kernelRows, kernelCols, stridePlanes,
+                            strideRows, strideCols, padding_type)
+                        .reshape(pre_contract_dims),
+                    contract_dims)
+          .reshape(post_contract_dims),
+      input
+          .extract_volume_patches(kernelPlanes, kernelRows, kernelCols,
+                                  stridePlanes, strideRows, strideCols,
+                                  padding_type)
+          .reshape(pre_contract_dims)
+          .contract(kernel.reshape(kernel_dims), contract_dims)
+          .reshape(post_contract_dims));
+}
+
+}  // end namespace Eigen
+
+#endif  // TENSORFLOW_CORE_KERNELS_EIGEN_CUBOID_CONVOLUTION_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/eigen_pooling.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/eigen_pooling.h
new file mode 100644
index 0000000000000000000000000000000000000000..ac701df0e7dc95d3523bb03345896433d7bfd96f
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/eigen_pooling.h
@@ -0,0 +1,546 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_EIGEN_POOLING_H_
+#define TENSORFLOW_CORE_KERNELS_EIGEN_POOLING_H_
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+
+namespace Eigen {
+
+/** SpatialMaxPooling
+ * \ingroup CXX11_NeuralNetworks_Module
+ *
+ * \brief Applies a max-pooling over a multichannel input image.
+ *
+ * The input parameter is expected to be a with a rank of 4 (channels, height,
+ * width, others in col-major, and the reverse of that in row-major).
+ *
+ * The result can be assigned to a tensor of rank equal to the rank of the
+ * input. The dimensions of the result will be channels, height, width, and
+ * others (in col-major, and the reverse of that if the input was row-major).
+ *
+ * The order of the width and height dimensions can be swapped if needed.
+ *
+ */
+template <typename Input>
+EIGEN_ALWAYS_INLINE static const TensorReshapingOp<
+    const Eigen::DSizes<typename internal::traits<Input>::Index,
+                        internal::traits<Input>::NumDimensions>,
+    const TensorReductionOp<
+        internal::MaxReducer<
+            std::remove_const_t<typename internal::traits<Input>::Scalar>>,
+        std::conditional_t<
+            internal::traits<Input>::Layout == ColMajor,
+            const Eigen::IndexList<Eigen::type2index<1>, Eigen::type2index<2>>,
+            const Eigen::IndexList<Eigen::type2index<2>, Eigen::type2index<3>>>,
+        const TensorImagePatchOp<Dynamic, Dynamic, const Input>>>
+SpatialMaxPooling(const Input& input, DenseIndex patchRows,
+                  DenseIndex patchCols, DenseIndex strideRows,
+                  DenseIndex strideCols, const PaddingType padding_type,
+                  DenseIndex in_strideRows = 1, DenseIndex in_strideCols = 1) {
+  EIGEN_STATIC_ASSERT(internal::traits<Input>::NumDimensions == 4,
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+
+  typedef typename internal::traits<Input>::Index TensorIndex;
+  TensorRef<Tensor<typename internal::traits<Input>::Scalar,
+                   internal::traits<Input>::NumDimensions,
+                   internal::traits<Input>::Layout, TensorIndex> >
+      in(input);
+
+  const DenseIndex patchRowsEff =
+      patchRows + (patchRows - 1) * (in_strideRows - 1);
+  const DenseIndex patchColsEff =
+      patchCols + (patchCols - 1) * (in_strideCols - 1);
+
+  static const bool isColMajor = (internal::traits<Input>::Layout == ColMajor);
+  static const int idxRows = isColMajor ? 1 : 2;
+  static const int idxCols = isColMajor ? 2 : 1;
+
+  // Molds the output of the reduction into the shape expected by the user.
+  // (assuming col-major):
+  // - 1st dim: channels
+  // - 2nd dim: output height
+  // - 3rd dim: output width
+  // - 4th dim and beyond: everything else including batch size
+  Eigen::DSizes<TensorIndex, internal::traits<Input>::NumDimensions>
+      post_reduce_dims;
+  post_reduce_dims[0] = in.dimension(0);
+  if (padding_type == PADDING_VALID) {
+    post_reduce_dims[idxRows] = Eigen::divup(
+        static_cast<DenseIndex>(in.dimension(idxRows)) - patchRowsEff + 1,
+        strideRows);
+    post_reduce_dims[idxCols] = Eigen::divup(
+        static_cast<DenseIndex>(in.dimension(idxCols)) - patchColsEff + 1,
+        strideCols);
+  } else {
+    post_reduce_dims[idxRows] = Eigen::divup(
+        static_cast<DenseIndex>(in.dimension(idxRows)), strideRows);
+    post_reduce_dims[idxCols] = Eigen::divup(
+        static_cast<DenseIndex>(in.dimension(idxCols)), strideCols);
+  }
+  post_reduce_dims[3] = in.dimension(3);
+
+  // Take advantage of cxx11 to give the compiler information it can use to
+  // optimize the code.
+  std::conditional_t<
+      internal::traits<Input>::Layout == ColMajor,
+      const Eigen::IndexList<Eigen::type2index<1>, Eigen::type2index<2>>,
+      const Eigen::IndexList<Eigen::type2index<2>, Eigen::type2index<3>>>
+      reduction_dims;
+
+  return input
+      .extract_image_patches(
+          patchRows, patchCols, strideRows, strideCols, in_strideRows,
+          in_strideCols, padding_type,
+          Eigen::NumTraits<std::remove_const_t<
+              typename internal::traits<Input>::Scalar>>::lowest())
+      .maximum(reduction_dims)
+      .reshape(post_reduce_dims);
+}
+
+/** CuboidMaxPooling
+ * \ingroup CXX11_NeuralNetworks_Module
+ *
+ * \brief Applies a max-pooling over a multichannel input volume.
+ *
+ * The input parameter is expected to be a tensor with a rank of 5 (channels,
+ * depth, height, width, others in col-major, and the reverse of that in
+ * row-major).
+ *
+ * The result can be assigned to a tensor of rank equal to the rank of the
+ * input. The dimensions of the result will be channels, depth, height, width,
+ * and others (in col-major, and the reverse of that if the input was
+ * row-major).
+ *
+ * The order of the depth, width and height dimensions can be swapped if
+ * needed.
+ *
+ */
+template <typename Input>
+EIGEN_ALWAYS_INLINE static const TensorReshapingOp<
+    const Eigen::DSizes<DenseIndex, internal::traits<Input>::NumDimensions>,
+    const TensorReductionOp<
+        internal::MaxReducer<
+            std::remove_const_t<typename internal::traits<Input>::Scalar>>,
+        const Eigen::IndexList<Eigen::type2index<1>>,
+        const TensorReshapingOp<
+            const Eigen::DSizes<DenseIndex, 3>,
+            const TensorVolumePatchOp<Dynamic, Dynamic, Dynamic, const Input>>>>
+CuboidMaxPooling(const Input& input, DenseIndex patchPlanes,
+                 DenseIndex patchRows, DenseIndex patchCols,
+                 DenseIndex stridePlanes, DenseIndex strideRows,
+                 DenseIndex strideCols, const PaddingType padding_type) {
+  EIGEN_STATIC_ASSERT(internal::traits<Input>::NumDimensions == 5,
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+  static const bool isColMajor = (internal::traits<Input>::Layout == ColMajor);
+
+  typedef typename internal::traits<Input>::Index TensorIndex;
+  TensorRef<Tensor<typename internal::traits<Input>::Scalar,
+                   internal::traits<Input>::NumDimensions,
+                   internal::traits<Input>::Layout, TensorIndex> >
+      in(input);
+
+  static const int idxPlanes = isColMajor ? 1 : 3;
+  static const int idxRows = 2;
+  static const int idxCols = isColMajor ? 3 : 1;
+
+  // Molds the output of the reduction into the shape expected by the used
+  // (assuming col-major):
+  // - 1st dim: channels
+  // - 2nd dim: output depth
+  // - 3rd dim: output height
+  // - 4th dim: output width
+  // - 5th dim and beyond: everything else including batch size
+  Eigen::DSizes<DenseIndex, internal::traits<Input>::NumDimensions>
+      post_reduce_dims;
+  post_reduce_dims[0] = in.dimension(0);
+  if (padding_type == PADDING_VALID) {
+    post_reduce_dims[idxPlanes] = Eigen::divup(
+        static_cast<DenseIndex>(in.dimension(idxPlanes)) - patchPlanes + 1,
+        stridePlanes);
+    post_reduce_dims[idxRows] = Eigen::divup(
+        static_cast<DenseIndex>(in.dimension(idxRows)) - patchRows + 1,
+        strideRows);
+    post_reduce_dims[idxCols] = Eigen::divup(
+        static_cast<DenseIndex>(in.dimension(idxCols)) - patchCols + 1,
+        strideCols);
+  } else {
+    post_reduce_dims[idxPlanes] = Eigen::divup(
+        static_cast<DenseIndex>(in.dimension(idxPlanes)), stridePlanes);
+    post_reduce_dims[idxRows] = Eigen::divup(
+        static_cast<DenseIndex>(in.dimension(idxRows)), strideRows);
+    post_reduce_dims[idxCols] = Eigen::divup(
+        static_cast<DenseIndex>(in.dimension(idxCols)), strideCols);
+  }
+  post_reduce_dims[4] = in.dimension(4);
+
+  Eigen::DSizes<DenseIndex, 3> pre_reduce_dims;
+  pre_reduce_dims[1] = patchRows * patchCols * patchPlanes;
+  if (isColMajor) {
+    pre_reduce_dims[0] = post_reduce_dims[0];
+    pre_reduce_dims[2] = post_reduce_dims[1] * post_reduce_dims[2] *
+                         post_reduce_dims[3] * post_reduce_dims[4];
+  } else {
+    pre_reduce_dims[0] = post_reduce_dims[0] * post_reduce_dims[1] *
+                         post_reduce_dims[2] * post_reduce_dims[3];
+    pre_reduce_dims[2] = post_reduce_dims[4];
+  }
+
+  typedef std::remove_const_t<typename internal::traits<Input>::Scalar>
+      CoeffReturnType;
+
+  // Take advantage of cxx11 to give the compiler information it can use to
+  // optimize the code.
+  Eigen::IndexList<Eigen::type2index<1> > reduction_dims;
+  return input
+      .extract_volume_patches(patchPlanes, patchRows, patchCols, stridePlanes,
+                              strideRows, strideCols, padding_type,
+                              -Eigen::NumTraits<CoeffReturnType>::highest())
+      .reshape(pre_reduce_dims)
+      .maximum(reduction_dims)
+      .reshape(post_reduce_dims);
+}
+
+/** SpatialAvgPooling
+ * \ingroup CXX11_NeuralNetworks_Module
+ *
+ * \brief Applies an average pooling over a multichannel input image.
+ *
+ * The input parameter is expected to be a tensor with a rank of 4 (channels,
+ * height, width, others in col-major, and the reverse of that in row-major).
+ *
+ * The result can be assigned to a tensor of rank equal to the rank of the
+ * input. The dimensions of the result will be channels, height, width, and
+ * others (in col-major, and the reverse of that if the input was row-major).
+ *
+ * The order of the width and height dimensions can be swapped if needed.
+ *
+ */
+namespace internal {
+
+template <typename T>
+struct AvgPoolMeanReducer {
+#if (EIGEN_ARCH_i386 || EIGEN_ARCH_x86_64) && !defined(__CUDACC__) && \
+    !defined(__HIPCC__)
+  // We only support packet access for floats.
+  static constexpr bool PacketAccess = internal::is_same<T, float>::value;
+#else
+  static const bool PacketAccess = false;
+#endif
+  static constexpr bool IsStateful = true;
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE AvgPoolMeanReducer() : scalarCount_(0) {
+    typedef typename packet_traits<T>::type Packet;
+#if defined(__HIPCC__)
+    packetCount_ = 0;
+#else
+    packetCount_ = pset1<Packet>(T(0.0));
+#endif
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void reduce(const T t, T* accum) {
+    if (t != -Eigen::NumTraits<T>::highest()) {
+      (*accum) = (*accum) + t;
+      scalarCount_++;
+    }
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T initialize() const {
+    return static_cast<T>(0);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T finalize(const T accum) const {
+    eigen_assert(scalarCount_ > 0);
+    return accum / T(scalarCount_);
+  }
+
+#if (EIGEN_ARCH_i386 || EIGEN_ARCH_x86_64) && !defined(__CUDACC__) && \
+    !defined(__HIPCC__)
+#ifdef EIGEN_VECTORIZE_AVX512
+#define pequal(a, b)   \
+  _mm512_castsi512_ps( \
+      _mm512_maskz_set1_epi32(_mm512_cmp_ps_mask(a, b, _CMP_EQ_UQ), -1))
+
+  // The ternarylogic function immediate determines the values in the result
+  // In the case below, 0xd8 implies (false_mask) ? (b) : (a)
+  // For details, refer to the vpternlogd instruction table at
+  // http://www.intel.com/content/dam/www/public/us/en/documents/manuals/64-ia-32-architectures-software-developer-vol-2c-manual.pdf
+
+#define psel(a, b, false_mask)                        \
+  _mm512_castsi512_ps(_mm512_ternarylogic_epi32(      \
+      _mm512_castps_si512(a), _mm512_castps_si512(b), \
+      _mm512_castps_si512(false_mask), 0xd8))
+#elif defined EIGEN_VECTORIZE_AVX
+#define pequal(a, b) _mm256_cmp_ps(a, b, _CMP_EQ_UQ)
+#define psel(a, b, false_mask) _mm256_blendv_ps(a, b, false_mask)
+#else
+#define pequal(a, b) _mm_cmpeq_ps(a, b)
+#define psel(a, b, false_mask) \
+  _mm_or_ps(_mm_andnot_ps(false_mask, a), _mm_and_ps(false_mask, b))
+#endif
+
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void reducePacket(const Packet& p,
+                                                          Packet* accum) {
+    reducePacketWithType(static_cast<T>(0), p, accum);
+  }
+
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void reducePacketWithType(
+      T, const Packet& p, Packet* accum) {
+    Packet skip_mask =
+        pequal(p, pset1<Packet>(-Eigen::NumTraits<T>::highest()));
+    (*accum) = padd<Packet>(*accum, psel(p, pset1<Packet>(0), skip_mask));
+    packetCount_ = padd<Packet>(
+        packetCount_, psel(pset1<Packet>(1), pset1<Packet>(0), skip_mask));
+  }
+
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet initializePacket() const {
+    return pset1<Packet>(0);
+  }
+
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet
+  finalizePacket(const Packet& vaccum) const {
+    return pdiv(vaccum, packetCount_);
+  }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T
+  finalizeBoth(const T saccum, const Packet& vaccum) const {
+    return (saccum + predux(vaccum)) / (scalarCount_ + predux(packetCount_));
+  }
+#endif
+
+ protected:
+  typedef typename packet_traits<T>::type Packet;
+  int scalarCount_;
+#if defined(__HIPCC__)
+  int packetCount_;
+#else
+  Packet packetCount_;
+#endif
+};
+
+template <typename Device>
+struct reducer_traits<AvgPoolMeanReducer<float>, Device> {
+  enum {
+    Cost = 1,
+#if (EIGEN_ARCH_i386 || EIGEN_ARCH_x86_64) && !defined(__CUDACC__) && \
+    !defined(__HIPCC__)
+    // We only support packet access for floats.
+    PacketAccess = true,
+#else
+    PacketAccess = false,
+#endif
+    IsStateful = true,
+    IsExactlyAssociative = false
+  };
+};
+
+template <>
+struct reducer_traits<AvgPoolMeanReducer<float>, GpuDevice> {
+  enum {
+    Cost = 1,
+    PacketAccess = false,
+    IsStateful = true,
+    IsExactlyAssociative = false
+  };
+};
+
+}  // namespace internal
+
+template <typename Input>
+EIGEN_ALWAYS_INLINE static const TensorReshapingOp<
+    const Eigen::DSizes<typename internal::traits<Input>::Index,
+                        internal::traits<Input>::NumDimensions>,
+    const TensorReductionOp<
+        internal::AvgPoolMeanReducer<
+            std::remove_const_t<typename internal::traits<Input>::Scalar>>,
+        std::conditional_t<
+            internal::traits<Input>::Layout == ColMajor,
+            const Eigen::IndexList<Eigen::type2index<1>, Eigen::type2index<2>>,
+            const Eigen::IndexList<Eigen::type2index<2>, Eigen::type2index<3>>>,
+        const TensorImagePatchOp<Dynamic, Dynamic, const Input>>>
+SpatialAvgPooling(const Input& input, DenseIndex patchRows,
+                  DenseIndex patchCols, DenseIndex strideRows,
+                  DenseIndex strideCols, const PaddingType padding_type,
+                  DenseIndex in_strideRows = 1, DenseIndex in_strideCols = 1) {
+  EIGEN_STATIC_ASSERT(internal::traits<Input>::NumDimensions == 4,
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+
+  typedef typename internal::traits<Input>::Index TensorIndex;
+  TensorRef<Tensor<typename internal::traits<Input>::Scalar,
+                   internal::traits<Input>::NumDimensions,
+                   internal::traits<Input>::Layout, TensorIndex> >
+      in(input);
+
+  const DenseIndex patchRowsEff =
+      patchRows + (patchRows - 1) * (in_strideRows - 1);
+  const DenseIndex patchColsEff =
+      patchCols + (patchCols - 1) * (in_strideCols - 1);
+
+  static const bool isColMajor = (internal::traits<Input>::Layout == ColMajor);
+  static const int idxRows = isColMajor ? 1 : 2;
+  static const int idxCols = isColMajor ? 2 : 1;
+
+  // Molds the output of the reduction into the shape expected by the user.
+  // (assuming col-major):
+  // - 1st dim: channels
+  // - 2nd dim: output height
+  // - 3rd dim: output width
+  // - 4th dim and beyond: everything else including batch size
+  Eigen::DSizes<TensorIndex, internal::traits<Input>::NumDimensions>
+      post_reduce_dims;
+  post_reduce_dims[0] = in.dimension(0);
+  if (padding_type == PADDING_VALID) {
+    post_reduce_dims[idxRows] = Eigen::divup(
+        static_cast<DenseIndex>(in.dimension(idxRows)) - patchRowsEff + 1,
+        strideRows);
+    post_reduce_dims[idxCols] = Eigen::divup(
+        static_cast<DenseIndex>(in.dimension(idxCols)) - patchColsEff + 1,
+        strideCols);
+  } else {
+    post_reduce_dims[idxRows] = Eigen::divup(
+        static_cast<DenseIndex>(in.dimension(idxRows)), strideRows);
+    post_reduce_dims[idxCols] = Eigen::divup(
+        static_cast<DenseIndex>(in.dimension(idxCols)), strideCols);
+  }
+  post_reduce_dims[3] = in.dimension(3);
+
+  typedef std::remove_const_t<typename internal::traits<Input>::Scalar>
+      CoeffReturnType;
+  internal::AvgPoolMeanReducer<CoeffReturnType> mean_with_nan;
+
+  // Take advantage of cxx11 to give the compiler information it can use to
+  // optimize the code.
+  std::conditional_t<
+      internal::traits<Input>::Layout == ColMajor,
+      const Eigen::IndexList<Eigen::type2index<1>, Eigen::type2index<2>>,
+      const Eigen::IndexList<Eigen::type2index<2>, Eigen::type2index<3>>>
+      reduction_dims;
+  return input
+      .extract_image_patches(patchRows, patchCols, strideRows, strideCols,
+                             in_strideRows, in_strideCols, padding_type,
+                             -Eigen::NumTraits<CoeffReturnType>::highest())
+      .reduce(reduction_dims, mean_with_nan)
+      .reshape(post_reduce_dims);
+}
+
+/** CuboidAvgPooling
+ * \ingroup CXX11_NeuralNetworks_Module
+ *
+ * \brief Applies an average pooling over a multichannel input volume.
+ *
+ * The input parameter is expected to be a tensor with a rank of 5 (channels,
+ * depth, height, width, others, and the reverse of that in row-major).
+ *
+ * The result can be assigned to a tensor of rank equal to the rank of the
+ * input. The dimensions of the result will be channels, depth, width, and
+ * others (in col-major, and the reverse of that if the input was row-major).
+ *
+ * The order of the depth, width and height dimensions can be swapped if
+ * needed.
+ *
+ */
+template <typename Input>
+EIGEN_ALWAYS_INLINE static const TensorReshapingOp<
+    const Eigen::DSizes<DenseIndex, internal::traits<Input>::NumDimensions>,
+    const TensorReductionOp<
+        internal::AvgPoolMeanReducer<
+            std::remove_const_t<typename internal::traits<Input>::Scalar>>,
+        const Eigen::IndexList<Eigen::type2index<1>>,
+        const TensorReshapingOp<
+            const Eigen::DSizes<DenseIndex, 3>,
+            const TensorVolumePatchOp<Dynamic, Dynamic, Dynamic, const Input>>>>
+CuboidAvgPooling(const Input& input, DenseIndex patchPlanes,
+                 DenseIndex patchRows, DenseIndex patchCols,
+                 DenseIndex stridePlanes, DenseIndex strideRows,
+                 DenseIndex strideCols, const PaddingType padding_type) {
+  EIGEN_STATIC_ASSERT(internal::traits<Input>::NumDimensions == 5,
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+  static const bool isColMajor = (internal::traits<Input>::Layout == ColMajor);
+
+  typedef typename internal::traits<Input>::Index TensorIndex;
+  TensorRef<Tensor<typename internal::traits<Input>::Scalar,
+                   internal::traits<Input>::NumDimensions,
+                   internal::traits<Input>::Layout, TensorIndex> >
+      in(input);
+
+  static const int idxPlanes = isColMajor ? 1 : 3;
+  static const int idxRows = 2;
+  static const int idxCols = isColMajor ? 3 : 1;
+  // Molds the output of the reduction into the shape expected by the used
+  // (assuming col-major):
+  // - 1st dim: channels
+  // - 2nd dim: outupt depth
+  // - 3rd dim: output height
+  // - 4th dim: output width
+  // - 5th dim and beyond: everything else including batch size
+  Eigen::DSizes<DenseIndex, internal::traits<Input>::NumDimensions>
+      post_reduce_dims;
+  post_reduce_dims[0] = in.dimension(0);
+  if (padding_type == PADDING_VALID) {
+    post_reduce_dims[idxPlanes] = Eigen::divup(
+        static_cast<DenseIndex>(in.dimension(idxPlanes)) - patchPlanes + 1,
+        stridePlanes);
+    post_reduce_dims[idxRows] = Eigen::divup(
+        static_cast<DenseIndex>(in.dimension(idxRows)) - patchRows + 1,
+        strideRows);
+    post_reduce_dims[idxCols] = Eigen::divup(
+        static_cast<DenseIndex>(in.dimension(idxCols)) - patchCols + 1,
+        strideCols);
+  } else {
+    post_reduce_dims[idxPlanes] = Eigen::divup(
+        static_cast<DenseIndex>(in.dimension(idxPlanes)), stridePlanes);
+    post_reduce_dims[idxRows] = Eigen::divup(
+        static_cast<DenseIndex>(in.dimension(idxRows)), strideRows);
+    post_reduce_dims[idxCols] = Eigen::divup(
+        static_cast<DenseIndex>(in.dimension(idxCols)), strideCols);
+  }
+  post_reduce_dims[4] = in.dimension(4);
+
+  Eigen::DSizes<DenseIndex, 3> pre_reduce_dims;
+  pre_reduce_dims[1] = patchRows * patchCols * patchPlanes;
+  if (isColMajor) {
+    pre_reduce_dims[0] = post_reduce_dims[0];
+    pre_reduce_dims[2] = post_reduce_dims[1] * post_reduce_dims[2] *
+                         post_reduce_dims[3] * post_reduce_dims[4];
+  } else {
+    pre_reduce_dims[0] = post_reduce_dims[0] * post_reduce_dims[1] *
+                         post_reduce_dims[2] * post_reduce_dims[3];
+    pre_reduce_dims[2] = post_reduce_dims[4];
+  }
+
+  typedef std::remove_const_t<typename internal::traits<Input>::Scalar>
+      CoeffReturnType;
+  internal::AvgPoolMeanReducer<CoeffReturnType> mean_with_nan;
+
+  // Take advantage of cxx11 to give the compiler information it can use to
+  // optimize the code.
+  Eigen::IndexList<Eigen::type2index<1> > reduction_dims;
+  return input
+      .extract_volume_patches(patchPlanes, patchRows, patchCols, stridePlanes,
+                              strideRows, strideCols, padding_type,
+                              -Eigen::NumTraits<CoeffReturnType>::highest())
+      .reshape(pre_reduce_dims)
+      .reduce(reduction_dims, mean_with_nan)
+      .reshape(post_reduce_dims);
+}
+
+}  // end namespace Eigen
+
+#endif  // TENSORFLOW_CORE_KERNELS_EIGEN_POOLING_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/fake_quant_ops_functor.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/fake_quant_ops_functor.h
new file mode 100644
index 0000000000000000000000000000000000000000..5053b5f6510c8ab5b28b78b9bfa271890d1bb917
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/fake_quant_ops_functor.h
@@ -0,0 +1,290 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_FAKE_QUANT_OPS_FUNCTOR_H_
+#define TENSORFLOW_CORE_KERNELS_FAKE_QUANT_OPS_FUNCTOR_H_
+
+#include <tuple>
+
+#define EIGEN_STACK_ALLOCATION_LIMIT 0
+#define EIGEN_USE_THREADS
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/framework/tensor_types.h"
+#include "tensorflow/core/platform/types.h"
+
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE float StdRound(float input) {
+// On Android, std::round() isn't present, just round().
+#if defined(__ANDROID__)
+  return round(input);
+#else
+  return std::round(input);
+#endif
+}
+
+namespace tensorflow {
+
+// Gymnastics with nudged zero point is to ensure that real zero maps to
+// an integer, which is required for e.g. zero-padding in convolutional layers.
+// Outputs nudged_min, nudged_max, nudged_scale.
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void Nudge(
+    const float min, const float max, const int quant_min, const int quant_max,
+    float* nudged_min, float* nudged_max, float* scale, float* inv_scale) {
+  const float quant_min_float = static_cast<float>(quant_min);
+  const float quant_max_float = static_cast<float>(quant_max);
+  *scale = (max - min) / (quant_max_float - quant_min_float);
+  // Re-calculate the inverse to avoid loss of precision which would result
+  // from simply taking the reciprocal of *scale
+  *inv_scale = (quant_max_float - quant_min_float) / (max - min);
+  const float zero_point_from_min = quant_min_float - min / *scale;
+  const uint16 nudged_zero_point = [zero_point_from_min, quant_min,
+                                    quant_min_float, quant_max,
+                                    quant_max_float] {
+    if (zero_point_from_min < quant_min_float) {
+      return static_cast<uint16>(quant_min);
+    }
+    if (zero_point_from_min > quant_max_float) {
+      return static_cast<uint16>(quant_max);
+    }
+    return static_cast<uint16>(StdRound(zero_point_from_min));
+  }();
+  *nudged_min = (quant_min_float - nudged_zero_point) * (*scale);
+  *nudged_max = (quant_max_float - nudged_zero_point) * (*scale);
+}
+
+template <typename T>
+using ConstScalar = typename tensorflow::TTypes<T>::ConstScalar;
+template <typename T>
+using Scalar = typename tensorflow::TTypes<T>::Scalar;
+template <typename T>
+using ConstVec = typename tensorflow::TTypes<T>::ConstVec;
+template <typename T>
+using Vec = typename tensorflow::TTypes<T>::Vec;
+template <typename T>
+using ConstFlat = typename tensorflow::TTypes<T>::ConstFlat;
+template <typename T>
+using Flat = typename tensorflow::TTypes<T>::Flat;
+
+// Functor called by FakeQuantWithMinMaxArgsOp to do the work.  Compiles both
+// for CPU and GPU.
+template <typename Device>
+struct FakeQuantWithMinMaxArgsFunctor {
+  void operator()(const Device& d, ConstFlat<float> inputs, const float min,
+                  const float max, const int quant_min, const int quant_max,
+                  Flat<float> outputs) {
+    eigen_assert(min <= 0.0f && "min should be <= 0.0");
+    eigen_assert(max >= 0.0f && "max should be >= 0.0");
+    eigen_assert(min < max && "min should be < max");
+
+    float nudged_min, nudged_max, nudged_scale, inv_nudged_scale;
+    Nudge(min, max, quant_min, quant_max, &nudged_min, &nudged_max,
+          &nudged_scale, &inv_nudged_scale);
+
+    const float quant_zero = floor(-nudged_min * inv_nudged_scale + 0.5f);
+
+    auto clamped = inputs.cwiseMin(nudged_max).cwiseMax(nudged_min);
+    auto clamped_shifted = clamped - nudged_min;
+    outputs.device(d) =
+        (clamped_shifted * inv_nudged_scale - quant_zero + 0.5f).floor() *
+        nudged_scale;
+  }
+};
+
+// Functor called by FakeQuantWithMinMaxArgsGradientOp to do the work.  Compiles
+// both for CPU and GPU.
+template <typename Device>
+struct FakeQuantWithMinMaxArgsGradientFunctor {
+  void operator()(const Device& d, ConstFlat<float> gradients,
+                  ConstFlat<float> inputs, const float min, const float max,
+                  const int quant_min, const int quant_max,
+                  Flat<float> backprops) {
+    eigen_assert(min <= 0.0f && "min should be <= 0.0");
+    eigen_assert(max >= 0.0f && "max should be >= 0.0");
+    eigen_assert(min < max && "min should be < max");
+
+    float nudged_min, nudged_max, nudged_scale, inv_nudged_scale;
+    Nudge(min, max, quant_min, quant_max, &nudged_min, &nudged_max,
+          &nudged_scale, &inv_nudged_scale);
+
+    auto between_nudged_min_max =
+        (inputs >= nudged_min && inputs <= nudged_max)
+            .select(inputs.constant(1.0f), inputs.constant(0.0f));
+    backprops.device(d) = gradients * between_nudged_min_max;
+  }
+};
+
+// Functor called by FakeQuantWithMinMaxVarsOp to do the work.  Compiles both
+// for CPU and GPU.
+template <typename Device>
+struct FakeQuantWithMinMaxVarsFunctor {
+  void operator()(const Device& d, ConstFlat<float> inputs,
+                  ConstScalar<float> min, ConstScalar<float> max,
+                  const int quant_min, const int quant_max,
+                  Flat<float> outputs) {
+    const float min_val = min();
+    const float max_val = max();
+    // If min and max are both zero, we should just return zero.
+    if (min_val == 0.0f && max_val == 0.0f) {
+      outputs.device(d) = outputs.constant(0.0f);
+      return;
+    }
+    float nudged_min, nudged_max, nudged_scale, inv_nudged_scale;
+    Nudge(min_val, max_val, quant_min, quant_max, &nudged_min, &nudged_max,
+          &nudged_scale, &inv_nudged_scale);
+
+    const float quant_zero = floor(-nudged_min * inv_nudged_scale + 0.5f);
+    const auto nudged_scale_repl = inputs.constant(nudged_scale);
+    // const auto inv_nudged_scale_repl = inputs.constant(inv_nudged_scale);
+
+    const auto clamped = inputs.cwiseMin(nudged_max).cwiseMax(nudged_min);
+    const auto clamped_shifted = clamped - nudged_min;
+    outputs.device(d) =
+        (clamped_shifted / nudged_scale_repl - quant_zero + 0.5f).floor() *
+        nudged_scale_repl;
+  }
+};
+
+// Functor called by FakeQuantWithMinMaxVarsGradientOp to do the work.  Compiles
+// both for CPU and GPU.
+template <typename Device>
+struct FakeQuantWithMinMaxVarsGradientFunctor {
+  void operator()(const Device& d, ConstFlat<float> gradients,
+                  ConstFlat<float> inputs, ConstScalar<float> min,
+                  ConstScalar<float> max, const int quant_min,
+                  const int quant_max, Flat<float> backprops_wrt_input,
+                  Scalar<float> backprop_wrt_min,
+                  Scalar<float> backprop_wrt_max) {
+    const float min_val = min();
+    const float max_val = max();
+    // If min and max are both zero, we propagate everything to inputs.
+    if (min_val == 0.0f && max_val == 0.0f) {
+      backprops_wrt_input.device(d) = gradients;
+      backprop_wrt_min.device(d) = backprop_wrt_min.constant(0.0f);
+      backprop_wrt_max.device(d) = backprop_wrt_max.constant(0.0f);
+      return;
+    }
+    float nudged_min, nudged_max, nudged_scale, inv_nudged_scale;
+    Nudge(min_val, max_val, quant_min, quant_max, &nudged_min, &nudged_max,
+          &nudged_scale, &inv_nudged_scale);
+
+    const auto between_min_max =
+        (inputs >= nudged_min && inputs <= nudged_max)
+            .select(inputs.constant(1.0f), inputs.constant(0.0f));
+    backprops_wrt_input.device(d) = gradients * between_min_max;
+
+    const auto below_min =
+        (inputs < nudged_min)
+            .select(inputs.constant(1.0f), inputs.constant(0.0f));
+    backprop_wrt_min.device(d) = (gradients * below_min).sum();
+
+    const auto above_max =
+        (inputs > nudged_max)
+            .select(inputs.constant(1.0f), inputs.constant(0.0f));
+    backprop_wrt_max.device(d) = (gradients * above_max).sum();
+  }
+};
+
+using Index = typename tensorflow::TTypes<float>::ConstTensor::Index;
+
+// Functor called by FakeQuantWithMinMaxVarsPerChannelOp to do the work.
+// Compiles both for CPU and GPU.
+//
+// Already verified: inputs, outputs are of shape [b, d], min, max are of shape
+// [d].
+template <typename Device>
+struct FakeQuantWithMinMaxVarsPerChannelFunctor {
+  void operator()(const Device& d, TTypes<float>::ConstMatrix inputs,
+                  ConstVec<float> min, ConstVec<float> max, const int quant_min,
+                  const int quant_max, TTypes<float>::Matrix outputs) {
+    for (Index i = 0; i < min.size(); ++i) {
+      const float min_val = min(i);
+      const float max_val = max(i);
+      // If min and max are both zero, we should just return zero.
+      if (min_val == 0.0f && max_val == 0.0f) {
+        auto chip = outputs.chip<1>(i);
+        chip.device(d) = chip.constant(0.0f);
+        continue;
+      }
+      float nudged_min, nudged_max, nudged_scale, inv_nudged_scale;
+      Nudge(min_val, max_val, quant_min, quant_max, &nudged_min, &nudged_max,
+            &nudged_scale, &inv_nudged_scale);
+
+      const float quant_zero = floor(-nudged_min * inv_nudged_scale + 0.5f);
+
+      const auto clamped =
+          inputs.chip<1>(i).cwiseMin(nudged_max).cwiseMax(nudged_min);
+      const auto clamped_shifted = clamped - nudged_min;
+
+      outputs.chip<1>(i).device(d) =
+          (clamped_shifted * inv_nudged_scale - quant_zero + 0.5f).floor() *
+          nudged_scale;
+    }
+  }
+};
+
+// Functor called by FakeQuantWithMinMaxVarsPerChannelGradientOp to do the work.
+// Compiles both for CPU and GPU.
+//
+// Already verified: gradients, inputs, backprops_wrt_input are of shape [b, d],
+// min, max, backprop_wrt_min, backprop_wrt_max are of shape [d].
+template <typename Device>
+struct FakeQuantWithMinMaxVarsPerChannelGradientFunctor {
+  void operator()(const Device& d, TTypes<float>::ConstMatrix gradients,
+                  TTypes<float>::ConstMatrix inputs, ConstVec<float> min,
+                  ConstVec<float> max, const int quant_min, const int quant_max,
+                  TTypes<float>::Matrix backprops_wrt_input,
+                  Vec<float> backprop_wrt_min, Vec<float> backprop_wrt_max) {
+    for (Index i = 0; i < min.size(); ++i) {
+      const float min_val = min(i);
+      const float max_val = max(i);
+      const auto gradients_chip = gradients.chip<1>(i);
+      const auto inputs_chip = inputs.chip<1>(i);
+      // If min and max are both zero, we propagate everything to inputs.
+      if (min_val == 0.0f && max_val == 0.0f) {
+        backprops_wrt_input.chip<1>(i).device(d) = gradients_chip;
+        auto min_chip = backprop_wrt_min.chip<0>(i);
+        auto max_chip = backprop_wrt_max.chip<0>(i);
+        min_chip.device(d) = min_chip.constant(0.0f);
+        max_chip.device(d) = max_chip.constant(0.0f);
+        continue;
+      }
+      float nudged_min, nudged_max, nudged_scale, inv_nudged_scale;
+      Nudge(min_val, max_val, quant_min, quant_max, &nudged_min, &nudged_max,
+            &nudged_scale, &inv_nudged_scale);
+
+      const auto between_min_max =
+          (inputs_chip >= nudged_min && inputs_chip <= nudged_max)
+              .select(inputs_chip.constant(1.0f), inputs_chip.constant(0.0f));
+      backprops_wrt_input.chip<1>(i).device(d) =
+          gradients_chip * between_min_max;
+
+      const auto below_min =
+          (inputs_chip < nudged_min)
+              .select(inputs_chip.constant(1.0f), inputs_chip.constant(0.0f));
+      Eigen::DSizes<Index, 1> reduce(0);
+      backprop_wrt_min.chip<0>(i).device(d) =
+          (gradients_chip * below_min).sum(reduce);
+
+      const auto above_max =
+          (inputs_chip > nudged_max)
+              .select(inputs_chip.constant(1.0f), inputs_chip.constant(0.0f));
+      backprop_wrt_max.chip<0>(i).device(d) =
+          (gradients_chip * above_max).sum(reduce);
+    }
+  }
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_FAKE_QUANT_OPS_FUNCTOR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/fft_impl.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/fft_impl.h
new file mode 100644
index 0000000000000000000000000000000000000000..ebaa24dec31f6ac8b5dfe5cac131790ba592b753
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/fft_impl.h
@@ -0,0 +1,39 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_FFT_IMPL_H_
+#define TENSORFLOW_CORE_KERNELS_FFT_IMPL_H_
+
+// Generic interface for N-D FFT implementation.
+// Required to isolate the DUCC FFT implementation on CPU, so we can limit
+// required build flags to a single module.
+
+#include <vector>
+
+#include "absl/status/status.h"
+#include "tensorflow/core/framework/tensor.h"
+
+namespace tensorflow {
+namespace internal {
+
+template <typename Device>
+absl::Status FftImpl(const Device& device, const Tensor& in, Tensor* out,
+                     const uint64_t* fft_shape, const std::vector<size_t>& axes,
+                     bool forward);
+
+}  // namespace internal
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_FFT_IMPL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/fifo_queue.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/fifo_queue.h
new file mode 100644
index 0000000000000000000000000000000000000000..c6faff14962b31df1101a42aa2e7e565886496c7
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/fifo_queue.h
@@ -0,0 +1,93 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_FIFO_QUEUE_H_
+#define TENSORFLOW_CORE_KERNELS_FIFO_QUEUE_H_
+
+#include <deque>
+#include <vector>
+
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/tensor_shape.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/kernels/queue_op.h"
+#include "tensorflow/core/kernels/typed_queue.h"
+#include "tensorflow/core/platform/macros.h"
+#include "tensorflow/core/platform/mutex.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+
+class FIFOQueue : public TypedQueue<std::deque<Tensor> > {
+ public:
+  FIFOQueue(int32_t capacity, const DataTypeVector& component_dtypes,
+            const std::vector<TensorShape>& component_shapes,
+            const string& name);
+
+  // Implementations of QueueInterface methods --------------------------------
+
+  void TryEnqueue(const Tuple& tuple, OpKernelContext* ctx,
+                  DoneCallback callback) override;
+  void TryEnqueueMany(const Tuple& tuple, OpKernelContext* ctx,
+                      DoneCallback callback) override;
+  void TryDequeue(OpKernelContext* ctx, CallbackWithTuple callback) override;
+  void TryDequeueMany(int num_elements, OpKernelContext* ctx,
+                      bool allow_small_batch,
+                      CallbackWithTuple callback) override;
+  Status MatchesNodeDef(const NodeDef& node_def) override;
+
+  int32 size() const override {
+    mutex_lock lock(mu_);
+    return queues_[0].size();
+  }
+
+ protected:
+  ~FIFOQueue() override {}
+
+  // Helper for dequeuing a single element from queues_.
+  void DequeueLocked(OpKernelContext* ctx, Tuple* tuple)
+      TF_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+
+  static Status GetElementComponentFromBatch(const Tuple& tuple, int64_t index,
+                                             int component,
+                                             OpKernelContext* ctx,
+                                             Tensor* out_tensor);
+
+ private:
+  FIFOQueue(const FIFOQueue&) = delete;
+  void operator=(const FIFOQueue&) = delete;
+};
+
+// Defines a FIFOQueueOp, which produces a Queue (specifically, one
+// backed by FIFOQueue) that persists across different graph
+// executions, and sessions. Running this op produces a single-element
+// tensor of handles to Queues in the corresponding device.
+class FIFOQueueOp : public TypedQueueOp {
+ public:
+  explicit FIFOQueueOp(OpKernelConstruction* context);
+
+ private:
+  Status CreateResource(QueueInterface** ret) override
+      TF_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+
+  std::vector<TensorShape> component_shapes_;
+  FIFOQueueOp(const FIFOQueueOp&) = delete;
+  void operator=(const FIFOQueueOp&) = delete;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_FIFO_QUEUE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/fill_empty_rows_functor.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/fill_empty_rows_functor.h
new file mode 100644
index 0000000000000000000000000000000000000000..f8d3c31e8c022b4ea3b329beba8df855534efd16
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/fill_empty_rows_functor.h
@@ -0,0 +1,269 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_FILL_EMPTY_ROWS_OP_H_
+#define TENSORFLOW_CORE_KERNELS_FILL_EMPTY_ROWS_OP_H_
+
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/tensor_types.h"
+#include "tensorflow/core/lib/core/status.h"
+
+using CPUDevice = Eigen::ThreadPoolDevice;
+using GPUDevice = Eigen::GpuDevice;
+
+namespace tensorflow {
+
+namespace functor {
+
+template <typename Device, typename T, typename Tindex, bool RaggedOperands>
+struct FillEmptyRows {
+  // Note that the done callback is only used by the GPU implementation.
+  Status operator()(OpKernelContext* context, const Tensor& default_value_t,
+                    const Tensor& indices_t, const Tensor& values_t,
+                    const Tensor& dense_shape_t,
+                    typename AsyncOpKernel::DoneCallback done = nullptr);
+};
+
+template <typename T, typename Tindex, bool RaggedOperands>
+struct FillEmptyRows<CPUDevice, T, Tindex, RaggedOperands> {
+  static constexpr int IndicesRank = RaggedOperands ? 1 : 2;
+  Status operator()(OpKernelContext* context, const Tensor& default_value_t,
+                    const Tensor& indices_t, const Tensor& values_t,
+                    const Tensor& dense_shape_t,
+                    typename AsyncOpKernel::DoneCallback done) {
+    (void)done;  // Unused (only used in GPU implementation)
+    const int kOutputIndicesOutput = 0;
+    const int kOutputValuesOutput = 1;
+    const int kEmptyRowIndicatorOutput = 2;
+    const int kReverseIndexMapOutput = 3;
+
+    const T& default_value = default_value_t.scalar<T>()();
+    const auto indices = indices_t.tensor<Tindex, IndicesRank>();
+    const auto values = values_t.vec<T>();
+    const auto dense_shape = dense_shape_t.tensor<Tindex, IndicesRank - 1>();
+
+    const Tindex N = indices_t.shape().dim_size(0);
+    const Tindex dense_rows = dense_shape(0);
+
+    bool* empty_row_indicator = nullptr;
+    if (context->output_required(kEmptyRowIndicatorOutput)) {
+      Tensor* empty_row_indicator_t = nullptr;
+      TensorShape output_shape;
+      TF_RETURN_IF_ERROR(
+          TensorShape::BuildTensorShape({dense_rows}, &output_shape));
+      TF_RETURN_IF_ERROR(context->allocate_output(
+          kEmptyRowIndicatorOutput, output_shape, &empty_row_indicator_t));
+      empty_row_indicator = empty_row_indicator_t->vec<bool>().data();
+    }
+    Tindex* reverse_index_map = nullptr;
+    if (context->output_required(kReverseIndexMapOutput)) {
+      Tensor* reverse_index_map_t = nullptr;
+      TensorShape output_shape;
+      TF_RETURN_IF_ERROR(TensorShape::BuildTensorShape({N}, &output_shape));
+      TF_RETURN_IF_ERROR(context->allocate_output(
+          kReverseIndexMapOutput, output_shape, &reverse_index_map_t));
+      reverse_index_map = reverse_index_map_t->vec<Tindex>().data();
+    }
+
+    const int rank = IndicesRank == 1 ? 1 : indices_t.shape().dim_size(1);
+
+    if (dense_rows == 0) {
+      if (N != 0) {
+        return errors::InvalidArgument(
+            "Received SparseTensor with dense_shape[0] = 0 but "
+            "indices.shape[0] = ",
+            N);
+      }
+      Tensor* output_indices_t;
+      TensorShape output_indices_shape;
+      TF_RETURN_IF_ERROR(
+          TensorShape::BuildTensorShape({0, rank}, &output_indices_shape));
+      TF_RETURN_IF_ERROR(context->allocate_output(
+          kOutputIndicesOutput, output_indices_shape, &output_indices_t));
+      Tensor* output_values_t;
+      TF_RETURN_IF_ERROR(context->allocate_output(
+          kOutputValuesOutput, TensorShape({0}), &output_values_t));
+
+      // Exit early, nothing more to do.
+      return OkStatus();
+    }
+
+    auto vec_or_matrix = [](auto tensor, int index1, int index2) -> auto& {
+      std::array<int, IndicesRank> indices;
+      indices[0] = index1;
+      if (IndicesRank == 2) {
+        indices[1] = index2;
+      }
+      return std::apply(tensor, indices);
+    };
+
+    bool rows_are_ordered = true;
+    Tindex last_indices_row = 0;
+    std::vector<Tindex> csr_offset(dense_rows, 0);
+    for (int i = 0; i < N; ++i) {
+      const Tindex row = vec_or_matrix(indices, i, 0);
+      if (row < 0 || row >= dense_rows) {
+        return errors::InvalidArgument("indices(", i, ", 0) is invalid: ", row,
+                                       " >= ", dense_rows);
+      }
+      ++csr_offset[row];
+      rows_are_ordered = rows_are_ordered & (row >= last_indices_row);
+      last_indices_row = row;
+    }
+    bool all_rows_full = true;
+    for (int row = 0; row < dense_rows; ++row) {
+      // csr_offset here describes the number of elements in this dense row
+      bool row_empty = (csr_offset[row] == 0);
+      if (empty_row_indicator) {
+        empty_row_indicator[row] = row_empty;
+      }
+      all_rows_full = all_rows_full & !row_empty;
+      // In filled version, each row has at least one element.
+      csr_offset[row] = std::max(csr_offset[row], Tindex{1});
+      // Update csr_offset to represent the number of elements up to and
+      // including dense_row + 1:
+      //  csr_offset(0) == #{elements of row 0}
+      //  csr_offset(1) == #{elements of row 1} + #{elements of row 0}
+      //  ..
+      //  csr_offset(i) == starting index for elements in row i + 1.
+      if (row > 0) {
+        csr_offset[row] += csr_offset[row - 1];
+      }
+    }
+
+    if (all_rows_full && rows_are_ordered) {
+      context->set_output(kOutputIndicesOutput, indices_t);
+      context->set_output(kOutputValuesOutput, values_t);
+      if (reverse_index_map) {
+        for (Tindex i = 0; i < N; ++i) {
+          reverse_index_map[i] = i;
+        }
+      }
+    } else {
+      Tensor* output_indices_t;
+      const Tindex N_full = csr_offset[dense_rows - 1];
+      TensorShape output_indices_shape;
+      if constexpr (RaggedOperands) {
+        TF_RETURN_IF_ERROR(
+            TensorShape::BuildTensorShape({N_full}, &output_indices_shape));
+      } else {
+        TF_RETURN_IF_ERROR(TensorShape::BuildTensorShape(
+            {N_full, rank}, &output_indices_shape));
+      }
+      TF_RETURN_IF_ERROR(context->allocate_output(
+          kOutputIndicesOutput, output_indices_shape, &output_indices_t));
+      auto output_indices = output_indices_t->tensor<Tindex, IndicesRank>();
+
+      Tensor* output_values_t;
+      TF_RETURN_IF_ERROR(context->allocate_output(
+          kOutputValuesOutput, TensorShape({N_full}), &output_values_t));
+      auto output_values = output_values_t->vec<T>();
+
+      std::vector<Tindex> filled_count(dense_rows, 0);
+
+      // Fill in values for rows that are not missing
+      for (Tindex i = 0; i < N; ++i) {
+        const Tindex row = vec_or_matrix(indices, i, 0);
+        Tindex& offset = filled_count[row];
+        const Tindex output_i = ((row == 0) ? 0 : csr_offset[row - 1]) + offset;
+        offset++;  // Increment the filled count for this row.
+        std::copy_n(&vec_or_matrix(indices, i, 0), rank,
+                    &vec_or_matrix(output_indices, output_i, 0));
+        output_values(output_i) = values(i);
+        // We'll need this reverse index map to backprop correctly.
+        if (reverse_index_map) {
+          reverse_index_map[i] = output_i;
+        }
+      }
+
+      // Fill in values for rows that are missing
+      for (Tindex row = 0; row < dense_rows; ++row) {
+        const Tindex row_count = filled_count[row];
+        if (row_count == 0) {  // We haven't filled this row
+          const Tindex starting_index = (row == 0) ? 0 : csr_offset[row - 1];
+          // Remaining index values were set to zero already.
+          // Just need to set the row index in the right location.
+          vec_or_matrix(output_indices, starting_index, 0) = row;
+          for (Tindex col = 1; col < rank; ++col) {
+            vec_or_matrix(output_indices, starting_index, col) = 0;
+          }
+          output_values(starting_index) = default_value;
+        }
+      }
+    }
+
+    return OkStatus();
+  }
+};
+
+template <typename Device, typename T, typename Tindex>
+struct FillEmptyRowsGrad {
+  Status operator()(OpKernelContext* context,
+                    typename TTypes<Tindex>::ConstVec reverse_index_map,
+                    typename TTypes<T>::ConstVec grad_values,
+                    typename TTypes<T>::Vec d_values,
+                    typename TTypes<T>::Scalar d_default_value);
+};
+
+template <typename T, typename Tindex>
+struct FillEmptyRowsGrad<CPUDevice, T, Tindex> {
+  Status operator()(OpKernelContext* context,
+                    typename TTypes<Tindex>::ConstVec reverse_index_map,
+                    typename TTypes<T>::ConstVec grad_values,
+                    typename TTypes<T>::Vec d_values,
+                    typename TTypes<T>::Scalar d_default_value) {
+    const CPUDevice& device = context->eigen_device<CPUDevice>();
+    const Tindex N = reverse_index_map.dimension(0);
+    const Tindex N_full = grad_values.dimension(0);
+
+    T& d_default_value_scalar = d_default_value();
+    d_default_value_scalar = T();
+
+    Tensor visited_t;
+    TF_RETURN_IF_ERROR(
+        context->allocate_temp(DT_BOOL, TensorShape({N_full}), &visited_t));
+    auto visited = visited_t.vec<bool>();
+    visited.device(device) = visited.constant(false);
+
+    for (int i = 0; i < N; ++i) {
+      // Locate the index of the output of the forward prop associated
+      // with this location in the input of the forward prop.  Copy
+      // the gradient into it.  Mark it as visited.
+      int64_t reverse_index = reverse_index_map(i);
+      if (reverse_index < 0 || reverse_index >= N_full) {
+        return errors::InvalidArgument(
+            "Elements in reverse index must be in [0, ", N_full, ") but got ",
+            reverse_index);
+      }
+      d_values(i) = grad_values(reverse_index);
+      visited(reverse_index) = true;
+    }
+    for (int j = 0; j < N_full; ++j) {
+      // The default value gradient gets the accumulated remainder of
+      // the backprop values (since the default value was used to fill
+      // in these slots in the forward calculation).
+      if (!visited(j)) {
+        d_default_value_scalar += grad_values(j);
+      }
+    }
+    return OkStatus();
+  }
+};
+
+}  // namespace functor
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_FILL_EMPTY_ROWS_OP_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/fill_functor.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/fill_functor.h
new file mode 100644
index 0000000000000000000000000000000000000000..abdc10ee713e7ecafd84b8917170fc8bb83cf3f5
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/fill_functor.h
@@ -0,0 +1,96 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_FILL_FUNCTOR_H_
+#define TENSORFLOW_CORE_KERNELS_FILL_FUNCTOR_H_
+
+#define EIGEN_USE_THREADS
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/framework/tensor_types.h"
+#include "tensorflow/core/framework/types.h"
+
+namespace tensorflow {
+namespace functor {
+
+template <typename Device, typename T>
+struct FillFunctor {
+  // Computes on device "d": out = out.constant(in(0)),
+  void operator()(const Device& d, typename TTypes<T>::Flat out,
+                  typename TTypes<T>::ConstScalar in);
+};
+
+template <typename Device, typename T>
+struct SetZeroFunctor {
+  // Computes on device "d": out = out.setZero(),
+  void operator()(const Device& d, typename TTypes<T>::Flat out);
+};
+
+// Partial specialization of SetZeroFunctor<Device=Eigen::ThreadPoolDevice, T>.
+template <typename T>
+struct SetZeroFunctor<Eigen::ThreadPoolDevice, T> {
+  void operator()(const Eigen::ThreadPoolDevice& d,
+                  typename TTypes<T>::Flat out);
+};
+
+
+template <>
+struct SetZeroFunctor<Eigen::ThreadPoolDevice, tstring> {
+  void operator()(const Eigen::ThreadPoolDevice& d,
+                  typename TTypes<tstring>::Flat out);
+};
+
+template <typename Device, typename T>
+struct SetOneFunctor {
+  // Computes on device "d": out = out.setOne(),
+  void operator()(const Device& d, typename TTypes<T>::Flat out);
+};
+
+// Partial specialization of SetOneFunctor<Device=Eigen::ThreadPoolDevice, T>.
+template <typename T>
+struct SetOneFunctor<Eigen::ThreadPoolDevice, T> {
+  void operator()(const Eigen::ThreadPoolDevice& d,
+                  typename TTypes<T>::Flat out);
+};
+
+
+template <>
+struct SetOneFunctor<Eigen::ThreadPoolDevice, tstring> {
+  void operator()(const Eigen::ThreadPoolDevice& d,
+                  typename TTypes<tstring>::Flat out);
+};
+
+template <typename Device, typename T>
+struct SetNanFunctor {
+  void operator()(const Device& d, typename TTypes<T>::Flat out);
+};
+
+// Partial specialization of SetNanFunctor<Device=Eigen::ThreadPoolDevice, T>.
+template <typename T>
+struct SetNanFunctor<Eigen::ThreadPoolDevice, T> {
+  void operator()(const Eigen::ThreadPoolDevice& d,
+                  typename TTypes<T>::Flat out);
+};
+
+template <>
+struct SetNanFunctor<Eigen::ThreadPoolDevice, tstring> {
+  void operator()(const Eigen::ThreadPoolDevice& d,
+                  typename TTypes<tstring>::Flat out);
+};
+
+}  // namespace functor
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_FILL_FUNCTOR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/fractional_pool_common.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/fractional_pool_common.h
new file mode 100644
index 0000000000000000000000000000000000000000..0abb20d24f1f1033f7120e0e68c510a54cbb32e8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/fractional_pool_common.h
@@ -0,0 +1,79 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_KERNELS_FRACTIONAL_POOL_COMMON_H_
+#define TENSORFLOW_CORE_KERNELS_FRACTIONAL_POOL_COMMON_H_
+
+#include <algorithm>
+#include <vector>
+
+#include "tensorflow/core/util/guarded_philox_random.h"
+
+namespace tensorflow {
+
+// Shuffle a container randomly, copied from random_shuffle_op.cc
+template <class Iter, class Random>
+static inline void RandomShuffle(Iter first, Iter last, const Random& uniform) {
+  if (first == last) {
+    return;
+  }
+  const auto stop = last - 1;
+  for (auto i = first; i != stop; ++i) {
+    using std::iter_swap;
+    iter_swap(i, i + uniform(last - i));
+  }
+}
+
+// Generate pooling sequence for fractional pooling along one dimension.
+//
+// Regular max/avg pooling can be viewed as a special case, in which given the
+//     * input_length: e.g. 10
+//     * output_length: e.g. 5
+// it will generate pooling sequence as
+//     diff sequence: [2, 2, 2, 2, 2]
+// or as
+//     cumulative sequence: [0, 2, 4, 6, 8, 10]
+//
+// In the case of fractional pooling, input_length is not an integer multiple of
+// output_length, randomness plays a role when generating pooling sequence.
+// There are two type of randomness (random vs pseudo-random) defined in paper:
+// http://arxiv.org/abs/1412.6071
+// You can check the paper for the difference between these two types.
+//
+// In summary, the generated diff sequence satisfy the following properties for
+// both types of randomness:
+//     * length(generated_diff_pooling_sequence) = output_length
+//     * sum(generated_diff_pooling_sequence) = input_length
+//     * Let's define floor(input_length / output_length) = K, then
+//       K <= generated_diff_pooling_sequence[i] <= K+1
+// For example, when input_length = 10, output_length = 6, the following are
+// valid pooling sequence:
+//     * [1, 2, 2, 1, 2, 2]
+//     * [1, 1, 2, 2, 2, 2]
+// [1, 3, 2, 2, 2, 2] is not valid.
+//
+// Args:
+//   input_length:  See above explanation
+//   output_length:  See above explanation
+//   generator:  Parallel version of random number generator
+//   pseudo_random:  Whether or not use pseudo-random
+// Returns:
+//   pooling_sequence:  This is the cumulative pooling sequence.
+std::vector<int64_t> GeneratePoolingSequence(int input_length,
+                                             int output_length,
+                                             GuardedPhiloxRandom* generator,
+                                             bool pseudo_random);
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_FRACTIONAL_POOL_COMMON_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/function_ops.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/function_ops.h
new file mode 100644
index 0000000000000000000000000000000000000000..552e1e6c515e3bf0fb5b789e7642f43eefd26d15
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/function_ops.h
@@ -0,0 +1,91 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_FUNCTION_OPS_H_
+#define TENSORFLOW_CORE_KERNELS_FUNCTION_OPS_H_
+
+#include "tensorflow/core/framework/full_type_util.h"
+#include "tensorflow/core/framework/function.h"
+#include "tensorflow/core/framework/op_kernel.h"
+
+namespace tensorflow {
+
+static const char* const kArgOp = FunctionLibraryDefinition::kArgOp;
+static const char* const kDeviceArgOp = FunctionLibraryDefinition::kDeviceArgOp;
+static const char* const kRetOp = FunctionLibraryDefinition::kRetOp;
+static const char* const kDeviceRetOp = FunctionLibraryDefinition::kDeviceRetOp;
+
+class ArgOp : public OpKernel {
+ public:
+  explicit ArgOp(OpKernelConstruction* ctx);
+
+  void Compute(OpKernelContext* ctx) override;
+
+  bool IsExpensive() override { return false; }
+
+ private:
+  int index_;
+  DataType dtype_;
+
+  ArgOp(const ArgOp&) = delete;
+  void operator=(const ArgOp&) = delete;
+};
+
+class RetvalOp : public OpKernel {
+ public:
+  explicit RetvalOp(OpKernelConstruction* ctx);
+
+  void Compute(OpKernelContext* ctx) override;
+
+  bool IsExpensive() override { return false; }
+
+ private:
+  int index_;
+  DataType dtype_;
+
+  RetvalOp(const RetvalOp&) = delete;
+  void operator=(const RetvalOp&) = delete;
+};
+
+class RemoteCallOp : public AsyncOpKernel {
+ public:
+  explicit RemoteCallOp(OpKernelConstruction* ctx);
+
+  ~RemoteCallOp() override {}
+
+  void ComputeAsync(OpKernelContext* ctx, DoneCallback done) override;
+
+  string TraceString(const OpKernelContext& ctx, bool verbose) const override;
+
+ private:
+  NameAttrList func_;
+  DataTypeVector input_dtypes_;
+  DataTypeVector output_dtypes_;
+  // Note that in the future if all RemoteCall ops have full type
+  // information, the kernel will not need access to the "Tout" Attr and
+  // return_type_ will replace output_dtypes_.
+  FullTypeDef return_type_;
+
+  mutex mu_;
+  typedef std::pair<string, FunctionLibraryRuntime*> FunctionTarget;
+  std::map<FunctionTarget, FunctionLibraryRuntime::Handle> handle_cache_
+      TF_GUARDED_BY(mu_);
+
+  RemoteCallOp(const RemoteCallOp&) = delete;
+  void operator=(const RemoteCallOp&) = delete;
+};
+
+}  // namespace tensorflow
+#endif  // TENSORFLOW_CORE_KERNELS_FUNCTION_OPS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/fused_batch_norm_op.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/fused_batch_norm_op.h
new file mode 100644
index 0000000000000000000000000000000000000000..2e2d32b8f5ab415ba21c2720bdc537551d5d53ed
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/fused_batch_norm_op.h
@@ -0,0 +1,72 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_FUSED_BATCH_NORM_OP_H_
+#define TENSORFLOW_CORE_KERNELS_FUSED_BATCH_NORM_OP_H_
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/tensor_types.h"
+#include "tensorflow/core/util/tensor_format.h"
+
+namespace tensorflow {
+namespace functor {
+
+// FusedBatchNormEx op supports side inputs and activations:
+//   (1) batch_norm + activation
+//   (2) batch norm + side input + activation
+enum class FusedBatchNormActivationMode { kIdentity, kRelu };
+
+std::string ToString(FusedBatchNormActivationMode activation_mode);
+
+Status ParseActivationMode(OpKernelConstruction* context,
+                           FusedBatchNormActivationMode* activation_mode);
+
+#if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+
+// This is a functor to launch custom CUDA kernel for FusedBatchNorm with side
+// input and activation when 'is_training=False'. In training we rely on cuDNN.
+template <typename Device, typename T, typename U>
+struct FusedBatchNormInferenceFunctor {
+  void operator()(OpKernelContext* context, TensorFormat tensor_format,
+                  typename TTypes<T, 4>::ConstTensor in,
+                  typename TTypes<U>::ConstVec scale,
+                  typename TTypes<U>::ConstVec offset,
+                  typename TTypes<U>::ConstVec estimated_mean,
+                  typename TTypes<U>::ConstVec estimated_variance,
+                  typename TTypes<T, 4>::ConstTensor side_input, U epsilon,
+                  FusedBatchNormActivationMode activation_mode,
+                  typename TTypes<T, 4>::Tensor out);
+};
+
+#endif  // GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+
+// Functor used by FusedBatchNormGradOp to do the computations when
+// is_training=False.
+template <typename Device, typename T, typename U>
+struct FusedBatchNormFreezeGrad {
+  void operator()(OpKernelContext* context, const Tensor& y_backprop_input,
+                  const Tensor& x_input, const Tensor& scale_input,
+                  const Tensor& pop_mean_input,
+                  const Tensor& pop_variance_input, U epsilon,
+                  Tensor* x_backprop_output, Tensor* scale_backprop_output,
+                  Tensor* offset_backprop_output) {}
+};
+
+}  // namespace functor
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_FUSED_BATCH_NORM_OP_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/fused_eigen_output_kernels.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/fused_eigen_output_kernels.h
new file mode 100644
index 0000000000000000000000000000000000000000..c264925055286f175ebd8207e63cf5dd27abc5cc
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/fused_eigen_output_kernels.h
@@ -0,0 +1,441 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// Output kernels for fusing computation into Eigen Tensor contractions:
+//   (1) FusedConv2DOp
+//   (2) FusedMatMulOp
+//
+// Supported fused computations:
+//   (1) {Conv2D/MatMul} + BiasAdd + <Activation>
+//   (2) {Conv2D/MatMul} + FusedBatchNorm + <Activation>
+//
+// Activation: Relu, Relu6, Elu, etc...
+
+#ifndef TENSORFLOW_CORE_KERNELS_FUSED_EIGEN_OUTPUT_KERNELS_H_
+#define TENSORFLOW_CORE_KERNELS_FUSED_EIGEN_OUTPUT_KERNELS_H_
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/tensor_types.h"
+
+namespace tensorflow {
+
+enum class FusedComputationType {
+  kUndefined,
+  kBiasAdd,
+  kBiasAddWithRelu,
+  kBiasAddWithRelu6,
+  kBiasAddWithTanh,
+  kBiasAddWithSigmoid,
+  kBiasAddWithElu,
+  kBiasAddWithLeakyRelu,
+  kBiasAddWithGeluApproximate,
+  kBiasAddWithGeluExact,
+  kFusedBatchNorm,
+  kFusedBatchNormWithRelu,
+  kFusedBatchNormWithRelu6,
+  kFusedBatchNormWithElu,
+  kFusedBatchNormWithLeakyRelu
+};
+
+// We have to pass around additional arguments for all possible fusion types.
+struct FusedComputationArgs {
+  float epsilon = 0.0;          // Used by `FusedBatchNorm` fusion only
+  float leakyrelu_alpha = 0.0;  // Used by `LeakyRelu` fusion only
+};
+
+struct FusedComputationPattern {
+  FusedComputationType fused_computation;
+  std::vector<string> fused_ops;
+};
+
+// Parse attributes from the kernel construction context, and verifies that they
+// specify valid fused computation pattern.
+Status InitializeFusedComputation(
+    OpKernelConstruction* context, const string& kernel_name,
+    const std::vector<FusedComputationPattern>& patterns,
+    FusedComputationType* fused_computation,
+    FusedComputationArgs* fused_computation_args);
+
+// Type alias for the tensor contraction output mapper.
+template <typename Scalar, typename StorageIndex>
+using ContractionOutputMapper =
+    Eigen::internal::blas_data_mapper<Scalar, StorageIndex, Eigen::ColMajor>;
+
+// Returns input expression without any transformations.
+struct Identity {
+  template <typename XprType>
+  static auto apply(XprType expr) -> XprType {
+    return expr;
+  };
+};
+
+// Applies `Relu` to the passed input expression.
+struct Relu {
+  template <typename XprType>
+  static auto apply(XprType expr)
+      -> decltype(expr.cwiseMax(std::declval<typename XprType::Scalar>())) {
+    return expr.cwiseMax(static_cast<typename XprType::Scalar>(0));
+  };
+};
+
+// Applies `Relu6` to the passed input expression.
+struct Relu6 {
+  template <typename XprType>
+  static auto apply(XprType expr)
+      -> decltype(expr.cwiseMax(std::declval<typename XprType::Scalar>())
+                      .cwiseMin(std::declval<typename XprType::Scalar>())) {
+    return expr.cwiseMax(static_cast<typename XprType::Scalar>(0))
+        .cwiseMin(static_cast<typename XprType::Scalar>(6));
+  };
+};
+
+// Applies `Elu` to the passed input expression.
+struct Elu {
+  template <typename XprType>
+  static auto apply(XprType expr) -> decltype(
+      (expr < std::declval<typename XprType::Scalar>())
+          .select(expr.exp() -
+                      expr.constant(std::declval<typename XprType::Scalar>()),
+                  expr)) {
+    return (expr < static_cast<typename XprType::Scalar>(0))
+        .select(expr.exp() -
+                    expr.constant(static_cast<typename XprType::Scalar>(1)),
+                expr);
+  };
+};
+
+// Applies `LeakyRelu` to the passed input expression.
+struct LeakyRelu {
+  template <typename XprType>
+  static auto apply(XprType expr, const float leakyrelu_alpha) -> decltype(
+      (expr < std::declval<typename XprType::Scalar>())
+          .select(expr *
+                      expr.constant(std::declval<typename XprType::Scalar>()),
+                  expr)) {
+    return (expr < static_cast<typename XprType::Scalar>(0))
+        .select(expr * expr.constant(static_cast<typename XprType::Scalar>(
+                           leakyrelu_alpha)),
+                expr);
+  };
+};
+
+template <typename T>
+struct BiasAddArgs {
+  const T* bias_add_data = nullptr;
+  float leakyrelu_alpha;
+
+  static bool IsSupported(FusedComputationType fusion) {
+    return fusion == FusedComputationType::kBiasAdd ||
+           fusion == FusedComputationType::kBiasAddWithRelu ||
+           fusion == FusedComputationType::kBiasAddWithRelu6 ||
+           fusion == FusedComputationType::kBiasAddWithElu ||
+           fusion == FusedComputationType::kBiasAddWithLeakyRelu;
+  }
+};
+
+template <typename T>
+struct FusedBatchNormArgs {
+  const T* scale_data = nullptr;
+  const T* offset_data = nullptr;
+  const T* estimated_mean_data = nullptr;
+  const T* estimated_variance_data = nullptr;
+
+  // Precomputed expression:
+  //   scaling_factor = (estimated_variance + epsilon).rsqrt() * scale
+  Eigen::Tensor<T, 1, Eigen::RowMajor> scaling_factor;
+
+  float leakyrelu_alpha;
+
+  static bool IsSupported(FusedComputationType fusion) {
+    return fusion == FusedComputationType::kFusedBatchNorm ||
+           fusion == FusedComputationType::kFusedBatchNormWithRelu ||
+           fusion == FusedComputationType::kFusedBatchNormWithRelu6 ||
+           fusion == FusedComputationType::kFusedBatchNormWithElu ||
+           fusion == FusedComputationType::kFusedBatchNormWithLeakyRelu;
+  }
+};
+
+// TensorContraction swaps lhs with rhs, and changes layout from RowMajor
+// (default in Tensorflow) to ColMajor (preferred in Eigen), and computes matmul
+// using these tensors.
+//
+// (1) Spatial Convolution (see eigen_spatial_convolutions.h):
+//
+//   TensorContraction output matrix (before reshape) has a ColMajor layout, and
+//   has dimensions:
+//   - rows: output_channels
+//   - cols: all other dimensions
+//
+//   First element in every column is:
+//     [batch ??, height ??, width ??, out_channel = i]
+//
+//   We do not know what are the values of the 'batch', 'height', and 'width'
+//   here (if we know original dimensions, they can be computed from 'j').
+//
+//   Each column of an output block is a continuous slice along the output
+//   channel dimension, so we can use it to efficiently compute any
+//   transformation that depends only on a channel value (e.g. add channel
+//   bias).
+//
+// (2) Matrix Multiplication (see matmul_op.cc):
+//
+//   For the `MxK * KxN` matrix multiplication, output matrix has a `MxN`
+//   dimensions. Each column in output block is a slice of the innermost
+//   dimension of the output matrix starting at offset 'i'.
+//
+//   Example: In Tensorflow MatMul [8x32] * [32x64], each output block column
+//   will correspond to MatMul output row of size 64 (because Tensorflow uses
+//   row major storage order).
+
+// Output kernel that fuses BiasAdd operation into the output of tensor
+// contraction + activation function defined by Activation.
+template <typename T, typename Activation = Identity>
+struct BiasAddOutputKernel {
+  explicit BiasAddOutputKernel(const BiasAddArgs<T>& args)
+      : bias_data(args.bias_add_data) {}
+
+  template <typename StorageIndex, typename Scalar>
+  EIGEN_ALWAYS_INLINE void operator()(
+      const ContractionOutputMapper<Scalar, StorageIndex>& output_mapper,
+      const Eigen::TensorContractionParams& params, StorageIndex i,
+      StorageIndex j, StorageIndex num_rows, StorageIndex num_cols) const {
+    DCHECK(params.swapped_arguments);
+
+    const T* bias_base = bias_data + i;
+    typename TTypes<T>::UnalignedConstTensor bias(bias_base, num_rows);
+
+    for (int col = 0; col < num_cols; ++col) {
+      T* output_base = &output_mapper(0, col);
+      typename TTypes<T>::UnalignedTensor output(output_base, num_rows);
+      const auto expr = output + bias;
+      output = Activation::template apply<decltype(expr)>(expr);
+    }
+  }
+
+ private:
+  const T* bias_data;
+};
+
+template <typename T>
+struct BiasAddOutputKernel<T, LeakyRelu> {
+  explicit BiasAddOutputKernel(const BiasAddArgs<T>& args)
+      : bias_data(args.bias_add_data), leakyrelu_alpha(args.leakyrelu_alpha) {}
+
+  template <typename StorageIndex, typename Scalar>
+  EIGEN_ALWAYS_INLINE void operator()(
+      const ContractionOutputMapper<Scalar, StorageIndex>& output_mapper,
+      const Eigen::TensorContractionParams& params, StorageIndex i,
+      StorageIndex j, StorageIndex num_rows, StorageIndex num_cols) const {
+    DCHECK(params.swapped_arguments);
+
+    const T* bias_base = bias_data + i;
+    typename TTypes<T>::UnalignedConstTensor bias(bias_base, num_rows);
+
+    for (int col = 0; col < num_cols; ++col) {
+      T* output_base = &output_mapper(0, col);
+      typename TTypes<T>::UnalignedTensor output(output_base, num_rows);
+      const auto expr = output + bias;
+      output = LeakyRelu::template apply<decltype(expr)>(expr, leakyrelu_alpha);
+    }
+  }
+
+ private:
+  const T* bias_data;
+  float leakyrelu_alpha;
+};
+
+// Output kernel that fuses FusedBatchNorm operation into the output of tensor
+// contraction + activation function defined by Activation.
+template <typename T, typename Activation = Identity>
+struct FusedBatchNormOutputKernel {
+  FusedBatchNormOutputKernel(T epsilon, const FusedBatchNormArgs<T>& args)
+      : epsilon(epsilon),
+        scaling_factor_data(args.scaling_factor.data()),
+        offset_data(args.offset_data),
+        estimated_mean_data(args.estimated_mean_data) {}
+
+  template <typename StorageIndex, typename Scalar>
+  EIGEN_ALWAYS_INLINE void operator()(
+      const ContractionOutputMapper<Scalar, StorageIndex>& output_mapper,
+      const Eigen::TensorContractionParams& params, StorageIndex i,
+      StorageIndex j, StorageIndex num_rows, StorageIndex num_cols) const {
+    DCHECK(params.swapped_arguments);
+
+    const T* scaling_factor_base = scaling_factor_data + i;
+    const T* offset_base = offset_data + i;
+    const T* mean_base = estimated_mean_data + i;
+
+    typename TTypes<T>::UnalignedConstTensor scaling_factor(scaling_factor_base,
+                                                            num_rows);
+    typename TTypes<T>::UnalignedConstTensor offset(offset_base, num_rows);
+    typename TTypes<T>::UnalignedConstTensor mean(mean_base, num_rows);
+
+    for (int col = 0; col < num_cols; ++col) {
+      T* output_base = &output_mapper(0, col);
+      typename TTypes<T>::UnalignedTensor output(output_base, num_rows);
+
+      auto scaled = (output - mean) * scaling_factor;
+      auto shifted = scaled + offset;
+
+      output = Activation::template apply<decltype(shifted)>(shifted);
+    }
+  }
+
+ private:
+  T epsilon;
+  const T* scaling_factor_data;
+  const T* offset_data;
+  const T* estimated_mean_data;
+};
+
+template <typename T>
+struct FusedBatchNormOutputKernel<T, LeakyRelu> {
+  FusedBatchNormOutputKernel(T epsilon, const FusedBatchNormArgs<T>& args)
+      : epsilon(epsilon),
+        scaling_factor_data(args.scaling_factor.data()),
+        offset_data(args.offset_data),
+        estimated_mean_data(args.estimated_mean_data),
+        leakyrelu_alpha(args.leakyrelu_alpha) {}
+
+  template <typename StorageIndex, typename Scalar>
+  EIGEN_ALWAYS_INLINE void operator()(
+      const ContractionOutputMapper<Scalar, StorageIndex>& output_mapper,
+      const Eigen::TensorContractionParams& params, StorageIndex i,
+      StorageIndex j, StorageIndex num_rows, StorageIndex num_cols) const {
+    DCHECK(params.swapped_arguments);
+
+    const T* scaling_factor_base = scaling_factor_data + i;
+    const T* offset_base = offset_data + i;
+    const T* mean_base = estimated_mean_data + i;
+
+    typename TTypes<T>::UnalignedConstTensor scaling_factor(scaling_factor_base,
+                                                            num_rows);
+    typename TTypes<T>::UnalignedConstTensor offset(offset_base, num_rows);
+    typename TTypes<T>::UnalignedConstTensor mean(mean_base, num_rows);
+
+    for (int col = 0; col < num_cols; ++col) {
+      T* output_base = &output_mapper(0, col);
+      typename TTypes<T>::UnalignedTensor output(output_base, num_rows);
+
+      auto scaled = (output - mean) * scaling_factor;
+      auto shifted = scaled + offset;
+
+      output = LeakyRelu::template apply<decltype(shifted)>(shifted,
+                                                            leakyrelu_alpha);
+    }
+  }
+
+ private:
+  T epsilon;
+  const T* scaling_factor_data;
+  const T* offset_data;
+  const T* estimated_mean_data;
+  float leakyrelu_alpha;
+};
+
+// Type aliases for the output kernels, purely for the sake of better launch
+// dispatching code readability.
+template <typename T>
+using WithBiasAdd = BiasAddOutputKernel<T>;
+template <typename T>
+using WithBiasAddAndRelu = BiasAddOutputKernel<T, Relu>;
+template <typename T>
+using WithBiasAddAndRelu6 = BiasAddOutputKernel<T, Relu6>;
+template <typename T>
+using WithBiasAddAndElu = BiasAddOutputKernel<T, Elu>;
+template <typename T>
+using WithBiasAddAndLeakyRelu = BiasAddOutputKernel<T, LeakyRelu>;
+template <typename T>
+using WithFusedBatchNorm = FusedBatchNormOutputKernel<T>;
+template <typename T>
+using WithFusedBatchNormAndRelu = FusedBatchNormOutputKernel<T, Relu>;
+template <typename T>
+using WithFusedBatchNormAndRelu6 = FusedBatchNormOutputKernel<T, Relu6>;
+template <typename T>
+using WithFusedBatchNormAndElu = FusedBatchNormOutputKernel<T, Elu>;
+template <typename T>
+using WithFusedBatchNormAndLeakyRelu = FusedBatchNormOutputKernel<T, LeakyRelu>;
+
+template <typename T>
+Status InitBiasAddArgs(OpKernelContext* context, BiasAddArgs<T>* args,
+                       const float* leakyrelu_alpha = nullptr) {
+  // Bias of the following dimensions: [ output_depth ]
+  const Tensor& bias = context->input(2);
+
+  if (bias.dims() != 1)
+    return errors::InvalidArgument("bias must be 1-dimensional",
+                                   bias.shape().DebugString());
+
+  const auto data_ptr = [](const Tensor& tensor) -> const T* {
+    return reinterpret_cast<const T*>(tensor.tensor_data().data());
+  };
+
+  args->bias_add_data = data_ptr(bias);
+
+  if (leakyrelu_alpha) {
+    args->leakyrelu_alpha = *leakyrelu_alpha;
+  }
+
+  return OkStatus();
+}
+
+template <typename T>
+Status InitFusedBatchNormArgs(OpKernelContext* context, float epsilon,
+                              FusedBatchNormArgs<T>* args,
+                              const float* leakyrelu_alpha = nullptr) {
+  const Tensor& scale = context->input(2);
+  const Tensor& offset = context->input(3);
+  const Tensor& estimated_mean = context->input(4);
+  const Tensor& estimated_variance = context->input(5);
+
+  if (scale.dims() != 1)
+    return errors::InvalidArgument("scale must be 1-dimensional",
+                                   scale.shape().DebugString());
+  if (offset.dims() != 1)
+    return errors::InvalidArgument("offset must be 1-dimensional",
+                                   offset.shape().DebugString());
+  if (estimated_mean.dims() != 1)
+    return errors::InvalidArgument("estimated_mean must be 1-dimensional",
+                                   estimated_mean.shape().DebugString());
+  if (estimated_variance.dims() != 1)
+    return errors::InvalidArgument("estimated_variance must be 1-dimensional",
+                                   estimated_variance.shape().DebugString());
+
+  const auto data_ptr = [](const Tensor& tensor) -> const T* {
+    return reinterpret_cast<const T*>(tensor.tensor_data().data());
+  };
+
+  args->scale_data = data_ptr(scale);
+  args->offset_data = data_ptr(offset);
+  args->estimated_mean_data = data_ptr(estimated_mean);
+  args->estimated_variance_data = data_ptr(estimated_variance);
+
+  // Precompute scaling factor once for all output blocks (kernels).
+  args->scaling_factor =
+      (estimated_variance.flat<T>() + static_cast<T>(epsilon)).rsqrt() *
+      scale.flat<T>();
+
+  if (leakyrelu_alpha) {
+    args->leakyrelu_alpha = *leakyrelu_alpha;
+  }
+
+  return OkStatus();
+}
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_FUSED_EIGEN_OUTPUT_KERNELS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/gather_functor.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/gather_functor.h
new file mode 100644
index 0000000000000000000000000000000000000000..b0cadf3eda2bae0ff158a40cba7fdca391efb9c7
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/gather_functor.h
@@ -0,0 +1,185 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_GATHER_FUNCTOR_H_
+#define TENSORFLOW_CORE_KERNELS_GATHER_FUNCTOR_H_
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+
+#include "tensorflow/core/framework/bounds_check.h"
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/tensor_types.h"
+#include "tensorflow/core/framework/type_traits.h"
+#include "tensorflow/core/framework/variant.h"
+#include "tensorflow/core/platform/prefetch.h"
+#include "tensorflow/core/platform/types.h"
+#include "tensorflow/core/util/work_sharder.h"
+
+namespace tensorflow {
+typedef Eigen::ThreadPoolDevice CPUDevice;
+typedef Eigen::GpuDevice GPUDevice;
+
+namespace functor {
+
+// Helper method to copy using memcpy.
+template <typename T, typename Index, typename SliceIndex,
+          SliceIndex static_slice_elems>
+SliceIndex HandleCopies(OpKernelContext* ctx,
+                        typename TTypes<T, 3>::ConstTensor params,
+                        typename TTypes<Index>::ConstFlat indices,
+                        SliceIndex slice_elems,
+                        typename TTypes<T, 3>::Tensor out) {
+  const SliceIndex indices_size = static_cast<SliceIndex>(indices.dimension(0));
+  const SliceIndex batch_size = static_cast<SliceIndex>(params.dimension(0));
+  const Index limit = static_cast<Index>(params.dimension(1));
+  T* out_base = out.data();
+  const T* params_base = params.data();
+  if (static_slice_elems >= 0) {
+    // Give compiler static knowledge of the number of elements/bytes
+    slice_elems = static_slice_elems;
+  }
+  // Compute slice_bytes here so that static knowledge is available
+  const size_t slice_bytes = slice_elems * sizeof(T);
+  auto* worker_threads = ctx->device()->tensorflow_cpu_worker_threads();
+  mutex mu;
+  // Store the value of invalidate index for printing error information, it's a
+  // shared variable.
+  SliceIndex result = -1;
+  auto work = [&](int64_t start, int64_t end) {
+    SliceIndex batch_idx = static_cast<SliceIndex>(start / indices_size);
+    SliceIndex indices_idx = static_cast<SliceIndex>(start % indices_size);
+    SliceIndex batch_idx_end = static_cast<SliceIndex>(end / indices_size);
+    SliceIndex indices_idx_end = static_cast<SliceIndex>(end % indices_size);
+
+    while ((batch_idx < batch_idx_end) ||
+           (batch_idx == batch_idx_end && indices_idx < indices_idx_end)) {
+      SliceIndex i_next = indices_idx + 1;
+      SliceIndex b_next = batch_idx + 1;
+      const Index index = internal::SubtleMustCopy(indices(indices_idx));
+      if (!FastBoundsCheck(index, limit)) {
+        mutex_lock l(mu);
+        result = indices_idx;
+        return;
+      }
+      if ((batch_idx == batch_idx_end && i_next < indices_idx_end) ||
+          (i_next < indices_size)) {
+        port::prefetch<port::PREFETCH_HINT_T0>(
+            &params(batch_idx, indices(i_next), 0));
+        port::prefetch<port::PREFETCH_HINT_T0>(&out(batch_idx, i_next, 0));
+        b_next = batch_idx;
+      } else if (b_next <= batch_idx_end) {
+        port::prefetch<port::PREFETCH_HINT_T0>(&params(b_next, indices(0), 0));
+        port::prefetch<port::PREFETCH_HINT_T0>(&out(b_next, 0, 0));
+        i_next = 0;
+      }
+      // Copy using memcpy if possible, otherwise an Eigen loop
+      // TODO(cwhipkey): avoid linking to framework to get Allocator (to improve
+      // ahead-of-time compilation binary size).
+      if (is_simple_type<T>::value) {
+        // Avoid auto-promotion to Index from SliceIndex by casting.
+        memcpy(
+            out_base + (batch_idx * indices_size + indices_idx) * slice_elems,
+            params_base + (batch_idx * static_cast<SliceIndex>(limit) +
+                           static_cast<SliceIndex>(index)) *
+                              slice_elems,
+            slice_bytes);
+      } else {
+        // For non-"simple" types (e.g. strings).
+        out.template chip<0>(batch_idx).template chip<0>(indices_idx) =
+            params.template chip<0>(batch_idx).template chip<0>(index);
+      }
+      indices_idx = i_next;
+      batch_idx = b_next;
+    }
+  };
+
+  Shard(worker_threads->num_threads, worker_threads->workers,
+        batch_size * indices_size, slice_elems * sizeof(T), work);
+  return result;
+}
+
+template <typename T, typename Index>
+struct GatherFunctorCPU {
+  int64_t operator()(OpKernelContext* ctx,
+                     typename TTypes<T, 3>::ConstTensor params,
+                     typename TTypes<Index>::ConstFlat indices,
+                     typename TTypes<T, 3>::Tensor out) {
+    const int64_t indices_size = indices.size();
+    const int64_t slice_size = out.dimension(2);
+    int64_t bad_i;
+
+    const int64_t batch_size = params.dimension(0);
+
+    bool use_large = (slice_size > std::numeric_limits<int32>::max() ||
+                      params.size() > std::numeric_limits<int32>::max() ||
+                      indices_size > std::numeric_limits<int32>::max() ||
+                      batch_size * indices_size * slice_size >
+                          std::numeric_limits<int32>::max());
+#define CALL(elems)                                                        \
+  do {                                                                     \
+    if (use_large) {                                                       \
+      bad_i = HandleCopies<T, Index, int64_t, elems>(ctx, params, indices, \
+                                                     slice_size, out);     \
+    } else {                                                               \
+      const int32 small_slice = static_cast<int32>(slice_size);            \
+      bad_i = HandleCopies<T, Index, int32, elems>(ctx, params, indices,   \
+                                                   small_slice, out);      \
+    }                                                                      \
+  } while (0)
+
+    if (slice_size == 10)
+      CALL(10);
+    else if (slice_size == 20)
+      CALL(20);
+    else
+      CALL(-1);
+#undef CALL
+
+    return bad_i;
+  }
+};
+
+template <typename Device, typename T, typename Index>
+struct GatherFunctor {
+  int64_t operator()(OpKernelContext* ctx,
+                     typename TTypes<T, 3>::ConstTensor params,
+                     typename TTypes<Index>::ConstFlat indices,
+                     typename TTypes<T, 3>::Tensor out);
+};
+
+template <typename T, typename Index>
+struct GatherFunctor<CPUDevice, T, Index> {
+  int64_t operator()(OpKernelContext* ctx,
+                     typename TTypes<T, 3>::ConstTensor params,
+                     typename TTypes<Index>::ConstFlat indices,
+                     typename TTypes<T, 3>::Tensor out) {
+    return GatherFunctorCPU<T, Index>()(ctx, params, indices, out);
+  }
+};
+
+template <typename Index>
+struct GatherFunctor<GPUDevice, Variant, Index> {
+  int64_t operator()(OpKernelContext* ctx,
+                     typename TTypes<Variant, 3>::ConstTensor params,
+                     typename TTypes<Index>::ConstFlat indices,
+                     typename TTypes<Variant, 3>::Tensor out) {
+    return GatherFunctorCPU<Variant, Index>()(ctx, params, indices, out);
+  }
+};
+
+}  // namespace functor
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_GATHER_FUNCTOR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/gather_functor_batched.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/gather_functor_batched.h
new file mode 100644
index 0000000000000000000000000000000000000000..69574529a1fdd9b29db986d4b8bc07e8d9716a62
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/gather_functor_batched.h
@@ -0,0 +1,202 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_GATHER_FUNCTOR_BATCHED_H_
+#define TENSORFLOW_CORE_KERNELS_GATHER_FUNCTOR_BATCHED_H_
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+
+#include "tensorflow/core/framework/bounds_check.h"
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/tensor_types.h"
+#include "tensorflow/core/framework/type_traits.h"
+#include "tensorflow/core/framework/variant.h"
+#include "tensorflow/core/platform/prefetch.h"
+#include "tensorflow/core/platform/types.h"
+#include "tensorflow/core/util/work_sharder.h"
+
+namespace tensorflow {
+typedef Eigen::ThreadPoolDevice CPUDevice;
+typedef Eigen::GpuDevice GPUDevice;
+
+namespace functor {
+
+// Helper method to copy using memcpy.
+template <typename T, typename Index, typename SliceIndex,
+          SliceIndex static_slice_elems>
+SliceIndex HandleCopiesBatched(OpKernelContext* ctx,
+                               typename TTypes<T, 4>::ConstTensor params,
+                               typename TTypes<Index>::ConstFlat indices,
+                               SliceIndex slice_elems,
+                               typename TTypes<T, 4>::Tensor out) {
+  const SliceIndex batch_size = static_cast<SliceIndex>(params.dimension(0));
+  const SliceIndex outer_size = static_cast<SliceIndex>(params.dimension(1));
+  const SliceIndex indices_size =
+      static_cast<SliceIndex>(indices.dimension(0)) / batch_size;
+
+  const Index limit = static_cast<Index>(params.dimension(2));
+  if (static_slice_elems >= 0) {
+    // Give compiler static knowledge of the number of elements/bytes
+    slice_elems = static_slice_elems;
+  }
+  // Compute slice_bytes here so that static knowledge is available
+  const size_t slice_bytes = slice_elems * sizeof(T);
+  auto* worker_threads = ctx->device()->tensorflow_cpu_worker_threads();
+  mutex mu;
+  // Store the value of invalidate index for printing error information, it's a
+  // shared variable.
+  SliceIndex result = -1;
+  auto work = [&](int64_t start, int64_t end) {
+    const int64_t r_start = start % (outer_size * indices_size);
+    SliceIndex batch_idx = static_cast<SliceIndex>(
+        start / (outer_size * indices_size));
+    SliceIndex outer_idx = static_cast<SliceIndex>(r_start / indices_size);
+    SliceIndex indices_idx = static_cast<SliceIndex>(r_start % indices_size);
+
+    SliceIndex batch_offset = batch_idx * indices_size;
+    for (; start < end; ++start) {
+      SliceIndex i_next = indices_idx + 1;
+      SliceIndex o_next = outer_idx;
+      SliceIndex b_next = batch_idx;
+      SliceIndex b_offset_next = batch_offset;
+
+      if (i_next >= indices_size) {
+        i_next = 0;
+        if (++o_next >= outer_size) {
+          o_next = 0;
+          ++b_next;
+          b_offset_next += indices_size;
+        }
+      }
+      if (start + 1 < end) {
+        port::prefetch<port::PREFETCH_HINT_T0>(
+            &params(b_next, o_next, indices(b_offset_next + i_next), 0));
+        port::prefetch<port::PREFETCH_HINT_T0>(&out(b_next, o_next, i_next, 0));
+      }
+      const Index index = internal::SubtleMustCopy(
+          indices(batch_offset + indices_idx));
+      if (!FastBoundsCheck(index, limit)) {
+        mutex_lock l(mu);
+        result = batch_offset + indices_idx;
+        return;
+      }
+
+      // Copy using memcpy if possible, otherwise an Eigen loop
+      // TODO(cwhipkey): avoid linking to framework to get Allocator (to improve
+      // ahead-of-time compilation binary size).
+      if (is_simple_type<T>::value) {
+        // Avoid auto-promotion to Index from SliceIndex by casting.
+        memcpy(
+            &out(batch_idx, outer_idx, indices_idx, 0),
+            &params(batch_idx, outer_idx, static_cast<SliceIndex>(index), 0),
+            slice_bytes);
+      } else {
+        // For non-"simple" types (e.g. strings).
+        out.template chip<0>(batch_idx)
+            .template chip<0>(outer_idx)
+            .template chip<0>(indices_idx) =
+            params.template chip<0>(batch_idx)
+                .template chip<0>(outer_idx)
+                .template chip<0>(static_cast<SliceIndex>(index));
+      }
+
+      indices_idx = i_next;
+      outer_idx = o_next;
+      batch_idx = b_next;
+      batch_offset = b_offset_next;
+    }
+  };
+
+  Shard(worker_threads->num_threads, worker_threads->workers,
+        batch_size * outer_size * indices_size, slice_elems * sizeof(T), work);
+  return result;
+}
+
+template <typename T, typename Index>
+struct GatherFunctorBatchedCPU {
+  int64_t operator()(OpKernelContext* ctx,
+                     typename TTypes<T, 4>::ConstTensor params,
+                     typename TTypes<Index>::ConstFlat indices,
+                     typename TTypes<T, 4>::Tensor out) {
+    const int64_t indices_size = indices.size();  // Includes the batch_size.
+    const int64_t slice_size = out.dimension(3);
+    int64_t bad_i;
+
+    const int64_t batch_size = params.dimension(0);
+    const int64_t outer_size = params.dimension(1);
+
+    bool use_large = (slice_size > std::numeric_limits<int32>::max() ||
+                      params.size() > std::numeric_limits<int32>::max() ||
+                      indices_size > std::numeric_limits<int32>::max() ||
+                      batch_size * outer_size * indices_size * slice_size >
+                          std::numeric_limits<int32>::max());
+#define CALL(elems)                                             \
+  do {                                                          \
+    if (use_large) {                                            \
+      bad_i = HandleCopiesBatched<T, Index, int64_t, elems>(    \
+          ctx, params, indices, slice_size, out);               \
+    } else {                                                    \
+      const int32 small_slice = static_cast<int32>(slice_size); \
+      bad_i = HandleCopiesBatched<T, Index, int32, elems>(      \
+          ctx, params, indices, small_slice, out);              \
+    }                                                           \
+  } while (0)
+
+    // TODO(rmlarsen): Investigate whether these specializations are still
+    // needed and, if yes, whether the slice sizes are appropriate.
+    if (slice_size == 10)
+      CALL(10);
+    else if (slice_size == 20)
+      CALL(20);
+    else
+      CALL(-1);
+#undef CALL
+
+    return bad_i;
+  }
+};
+
+template <typename Device, typename T, typename Index>
+struct GatherFunctorBatched {
+  int64_t operator()(OpKernelContext* ctx,
+                     typename TTypes<T, 4>::ConstTensor params,
+                     typename TTypes<Index>::ConstFlat indices,
+                     typename TTypes<T, 4>::Tensor out);
+};
+
+template <typename T, typename Index>
+struct GatherFunctorBatched<CPUDevice, T, Index> {
+  int64_t operator()(OpKernelContext* ctx,
+                     typename TTypes<T, 4>::ConstTensor params,
+                     typename TTypes<Index>::ConstFlat indices,
+                     typename TTypes<T, 4>::Tensor out) {
+    return GatherFunctorBatchedCPU<T, Index>()(ctx, params, indices, out);
+  }
+};
+
+template <typename Index>
+struct GatherFunctorBatched<GPUDevice, Variant, Index> {
+  int64_t operator()(OpKernelContext* ctx,
+                     typename TTypes<Variant, 4>::ConstTensor params,
+                     typename TTypes<Index>::ConstFlat indices,
+                     typename TTypes<Variant, 4>::Tensor out) {
+    return GatherFunctorBatchedCPU<Variant, Index>()(ctx, params, indices, out);
+  }
+};
+
+}  // namespace functor
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_GATHER_FUNCTOR_BATCHED_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/gather_functor_batched_gpu.cu.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/gather_functor_batched_gpu.cu.h
new file mode 100644
index 0000000000000000000000000000000000000000..e2cb7597955c0db1efa484733e228e4c2a97be09
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/gather_functor_batched_gpu.cu.h
@@ -0,0 +1,183 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_GATHER_FUNCTOR_BATCHED_GPU_CU_H_
+#define TENSORFLOW_CORE_KERNELS_GATHER_FUNCTOR_BATCHED_GPU_CU_H_
+
+#if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+
+#define EIGEN_USE_GPU
+
+#include "tensorflow/core/framework/register_types.h"
+#include "tensorflow/core/kernels/gather_functor_batched.h"
+#include "tensorflow/core/platform/types.h"
+#include "tensorflow/core/util/gpu_kernel_helper.h"
+
+namespace tensorflow {
+
+typedef Eigen::GpuDevice GPUDevice;
+
+template <typename ValueOrVec, typename Index, bool is_axis_zero,
+          bool is_batch_dims_zero>
+__global__ void GatherOpKernel(const ValueOrVec* __restrict__ params,
+                               const Index* __restrict__ indices,
+                               ValueOrVec* __restrict__ out, int64 outer_size,
+                               int64 gather_dim_size, int64 indices_size,
+                               int64 slice_size, int64 out_size) {
+  // params is a tensor of shape
+  // [batch_size, outer_size, gather_dim_size, slice_size].
+  GPU_1D_KERNEL_LOOP(i, out_size) {
+    Index batch_i = 0;  // The batch index into params to use for i.
+    Index outer_i = 0;  // The outer index into params to use for i.
+    Index indices_i = 0;  // The index into indices to use for i.
+    Index slice_i = 0;  // Index into the current slice in params to use for i.
+
+    const Index slices_count = i / slice_size;
+    if (is_batch_dims_zero) {
+      if (is_axis_zero) {
+        indices_i = slices_count;
+      } else {
+        outer_i = slices_count / indices_size;
+        indices_i = slices_count - outer_i * indices_size;
+      }
+    } else {
+      const Index entries_count = slices_count / indices_size;
+      if (is_axis_zero) {
+        batch_i = entries_count;
+      } else {
+        batch_i = entries_count / outer_size;
+        outer_i = entries_count - batch_i * outer_size;
+      }
+      indices_i = slices_count - entries_count * indices_size;
+    }
+    slice_i = i - slices_count * slice_size;
+
+    // Index into the gather axis to use for i.
+    Index gather_i = ldg(indices + batch_i * indices_size + indices_i);
+
+    // Check gather_i is in [0, gather_dim_size).
+    if (!FastBoundsCheck(gather_i, gather_dim_size)) {
+      // Set indices out of range to zero
+      // TODO(fpmc): Log an error for transfer back to host.
+      out[i] = ValueOrVec(0);
+    } else {
+      // Read params[batch_i, outer_i, gather_i, slice_i] and write it to the
+      // i'th position in out.
+      Index params_i = (
+          (batch_i * outer_size + outer_i) * gather_dim_size + gather_i
+      ) * slice_size + slice_i;
+      out[i] = params[params_i];
+    }
+  }
+}
+
+namespace detail {
+
+template <bool is_axis_zero, bool is_batch_dims_zero>
+struct LaunchGatherKernelVectorized {
+  template <int vec_size>
+  struct Impl {
+    template <typename T, typename Index>
+    Status operator()(const GPUDevice& d, const T* params, const Index* indices,
+                      T* out, int64 outer_size, int64 gather_dim_size,
+                      int64 indices_size, int64 slice_size, int64 out_size) {
+      DCHECK_EQ(slice_size % vec_size, 0);
+      DCHECK_EQ(out_size % vec_size, 0);
+      DCHECK_EQ(reinterpret_cast<std::uintptr_t>(params) % vec_size, 0);
+      DCHECK_EQ(reinterpret_cast<std::uintptr_t>(out) % vec_size, 0);
+      int64 out_size_vec = out_size / vec_size;
+      int64 slice_size_vec = slice_size / vec_size;
+      using Tvec = AlignedVector<T, vec_size>;
+      const Tvec* params_vec = reinterpret_cast<const Tvec*>(params);
+      Tvec* out_vec = reinterpret_cast<Tvec*>(out);
+
+      GpuLaunchConfig config = GetGpuLaunchConfig(
+          out_size_vec, d,
+          &GatherOpKernel<Tvec, Index, is_axis_zero, is_batch_dims_zero>,
+          /*dynamic_shared_memory_size=*/0, /*block_size_limit=*/0);
+      return GpuLaunchKernel(
+          GatherOpKernel<Tvec, Index, is_axis_zero, is_batch_dims_zero>,
+          config.block_count, config.thread_per_block, 0, d.stream(),
+          params_vec, indices, out_vec, outer_size, gather_dim_size,
+          indices_size, slice_size_vec, out_size_vec);
+    }
+  };
+};
+
+}  // namespace detail
+
+template <bool is_axis_zero, bool is_batch_dims_zero, typename T,
+          typename Index>
+Status LaunchGatherKernel(const GPUDevice& d, const T* params,
+                          const Index* indices, T* out, int64 outer_size,
+                          int64 gather_dim_size, int64 indices_size,
+                          int64 slice_size, int64 out_size) {
+  // Note that the GPU memory allocator always returns aligned buffers, so the
+  // alignment of data pointers is expected to be deterministic.
+  // There will be performance cliffs when slice_size is not aligned, but there
+  // is no easy way to handle the misalignment because each row will be aligned
+  // differently.
+  return DispatchToVectorized<
+      T, detail::LaunchGatherKernelVectorized<
+             is_axis_zero, is_batch_dims_zero>::template Impl>(
+      MinAlignmentOf(params, out, slice_size), d, params, indices, out,
+      outer_size, gather_dim_size, indices_size, slice_size, out_size);
+}
+
+namespace functor {
+template <typename T, typename Index>
+struct GatherFunctorBatched<GPUDevice, T, Index> {
+  int64 operator()(OpKernelContext* ctx,
+                   typename TTypes<T, 4>::ConstTensor params,
+                   typename TTypes<Index>::ConstFlat indices,
+                   typename TTypes<T, 4>::Tensor out) {
+    const GPUDevice& d = ctx->eigen_gpu_device();
+    const int64 out_size = out.size();
+    if (out_size == 0) {
+      // We need a check here since the CPU version does useful error checking
+      // work if there are nonempty indices but empty slices, so the kernel is
+      // executed in that case.  In the GPU case we don't know how to do error
+      // checking, so we skip the loop entirely.
+      return -1;
+    }
+    const bool is_batch_dims_zero = params.dimension(0) == 1;
+    const bool is_axis_zero = params.dimension(1) == 1;
+    const int64 outer_size = params.dimension(1);
+    const int64 gather_dim_size = params.dimension(2);
+    const int64 indices_size = indices.size() / params.dimension(0);
+    const int64 slice_size = params.dimension(3);
+
+    const auto function =
+        is_axis_zero
+            ? (is_batch_dims_zero ? LaunchGatherKernel<true, true, T, Index>
+                                  : LaunchGatherKernel<true, false, T, Index>)
+            : (is_batch_dims_zero ? LaunchGatherKernel<false, true, T, Index>
+                                  : LaunchGatherKernel<false, false, T, Index>);
+    TF_CHECK_OK(function(d, params.data(), indices.data(), out.data(),
+                         outer_size, gather_dim_size, indices_size, slice_size,
+                         out_size));
+    // TODO(fpmc): enable indices validation on GPU.
+    // Right now checking for indices out of bound in the kernel would
+    // require copying code between GPU/CPU, and thus slow.
+    return -1;
+  }
+};
+
+}  // namespace functor
+}  // namespace tensorflow
+
+#endif  // GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+
+#endif  // TENSORFLOW_CORE_KERNELS_GATHER_FUNCTOR_BATCHED_GPU_CU_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/gather_functor_gpu.cu.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/gather_functor_gpu.cu.h
new file mode 100644
index 0000000000000000000000000000000000000000..3ac0d91294b37259b801e4d8f0ea291e13835465
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/gather_functor_gpu.cu.h
@@ -0,0 +1,165 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_GATHER_FUNCTOR_GPU_CU_H_
+#define TENSORFLOW_CORE_KERNELS_GATHER_FUNCTOR_GPU_CU_H_
+
+#if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+
+#define EIGEN_USE_GPU
+
+#include "tensorflow/core/framework/register_types.h"
+#include "tensorflow/core/kernels/gather_functor.h"
+#include "tensorflow/core/platform/types.h"
+#include "tensorflow/core/util/gpu_kernel_helper.h"
+
+namespace tensorflow {
+
+typedef Eigen::GpuDevice GPUDevice;
+
+template <typename ValueOrVec, typename Index, bool is_axis_zero>
+__global__ void GatherOpKernel(const ValueOrVec* __restrict__ params,
+                               const Index* __restrict__ indices,
+                               ValueOrVec* __restrict__ out,
+                               int64 gather_dim_size, int64 indices_size,
+                               int64 slice_size, int64 out_size) {
+  GPU_1D_KERNEL_LOOP(i, out_size) {
+    Index batch_i = 0;
+    Index indices_i = 0;
+    Index slice_i = 0;
+    if (is_axis_zero) {
+      indices_i = i / slice_size;
+      slice_i = i - indices_i * slice_size;
+    } else {
+      Index batch_indices_i = i / slice_size;
+      // The batch index into params to use for i.
+      batch_i = batch_indices_i / indices_size;
+      // The index into indices to use for i.
+      indices_i = batch_indices_i - batch_i * indices_size;
+      // Index into the current slice in params to use for i.
+      slice_i = i - batch_indices_i * slice_size;
+    }
+
+    // Index into the gather axis to use for i.
+    Index gather_i = ldg(indices + indices_i);
+
+    // Check gather_i is in [0, gather_dim_size).
+    if (!FastBoundsCheck(gather_i, gather_dim_size)) {
+      // Set indices out of range to zero
+      // TODO(fpmc): Log an error for transfer back to host.
+      out[i] = ValueOrVec(0);
+    } else {
+      // params is a [batch_size, gather_dim_size, slice_size] tensor. Read
+      // params[batch_i, gather_i, slice_i] and write it to the i'th position in
+      // out.
+      Index params_i =
+          (batch_i * gather_dim_size + gather_i) * slice_size + slice_i;
+      out[i] = params[params_i];
+    }
+  }
+}
+
+namespace detail {
+
+template <bool is_axis_zero>
+struct LaunchGatherKernelVectorized {
+  template <int vec_size>
+  struct Impl {
+    template <typename T, typename Index>
+    Status operator()(const GPUDevice& d, const T* params, const Index* indices,
+                      T* out, int64 gather_dim_size, int64 indices_size,
+                      int64 slice_size, int64 out_size) {
+      DCHECK_EQ(slice_size % vec_size, 0);
+      DCHECK_EQ(out_size % vec_size, 0);
+      DCHECK_EQ(reinterpret_cast<std::uintptr_t>(params) % vec_size, 0);
+      DCHECK_EQ(reinterpret_cast<std::uintptr_t>(out) % vec_size, 0);
+      int64 out_size_vec = out_size / vec_size;
+      int64 slice_size_vec = slice_size / vec_size;
+      using Tvec = AlignedVector<T, vec_size>;
+      const Tvec* params_vec = reinterpret_cast<const Tvec*>(params);
+      Tvec* out_vec = reinterpret_cast<Tvec*>(out);
+
+      GpuLaunchConfig config = GetGpuLaunchConfig(
+          out_size_vec, d, &GatherOpKernel<Tvec, Index, is_axis_zero>,
+          /*dynamic_shared_memory_size=*/0, /*block_size_limit=*/0);
+      return GpuLaunchKernel(
+          GatherOpKernel<Tvec, Index, is_axis_zero>, config.block_count,
+          config.thread_per_block, 0, d.stream(), params_vec, indices, out_vec,
+          gather_dim_size, indices_size, slice_size_vec, out_size_vec);
+    }
+  };
+};
+
+}  // namespace detail
+
+template <bool is_axis_zero, typename T, typename Index>
+Status LaunchGatherKernel(const GPUDevice& d, const T* params,
+                          const Index* indices, T* out, int64 gather_dim_size,
+                          int64 indices_size, int64 slice_size,
+                          int64 out_size) {
+  // Note that the GPU memory allocator always returns aligned buffers, so the
+  // alignment of data pointers is expected to be deterministic.
+  // There will be performance cliffs when slice_size is not aligned, but there
+  // is no easy way to handle the misalignment because each row will be aligned
+  // differently.
+  return DispatchToVectorized<
+      T, detail::LaunchGatherKernelVectorized<is_axis_zero>::template Impl>(
+      MinAlignmentOf(params, out, slice_size), d, params, indices, out,
+      gather_dim_size, indices_size, slice_size, out_size);
+}
+
+namespace functor {
+template <typename T, typename Index>
+struct GatherFunctor<GPUDevice, T, Index> {
+  int64 operator()(OpKernelContext* ctx,
+                   typename TTypes<T, 3>::ConstTensor params,
+                   typename TTypes<Index>::ConstFlat indices,
+                   typename TTypes<T, 3>::Tensor out) {
+    const GPUDevice& d = ctx->eigen_gpu_device();
+    const int64 out_size = out.size();
+    if (out_size == 0) {
+      // We need a check here since the CPU version does useful error checking
+      // work if there are nonempty indices but empty slices, so the kernel is
+      // executed in that case.  In the GPU case we don't know how to do error
+      // checking, so we skip the loop entirely.
+      return -1;
+    }
+    const bool is_axis_zero = params.dimension(0) == 1;
+    const int64 gather_dim_size = params.dimension(1);
+    const int64 indices_size = indices.size();
+    const int64 slice_size = params.dimension(2);
+
+    if (is_axis_zero) {
+      TF_CHECK_OK(LaunchGatherKernel<true>(d, params.data(), indices.data(),
+                                           out.data(), gather_dim_size,
+                                           indices_size, slice_size, out_size));
+    } else {
+      TF_CHECK_OK(LaunchGatherKernel<false>(
+          d, params.data(), indices.data(), out.data(), gather_dim_size,
+          indices_size, slice_size, out_size));
+    }
+    // TODO(fpmc): enable indices validation on GPU.
+    // Right now checking for indices out of bound in the kernel would
+    // require copying code between GPU/CPU, and thus slow.
+    return -1;
+  }
+};
+
+}  // namespace functor
+}  // namespace tensorflow
+
+#endif  // GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+
+#endif  // TENSORFLOW_CORE_KERNELS_GATHER_FUNCTOR_GPU_CU_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/gather_nd_op.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/gather_nd_op.h
new file mode 100644
index 0000000000000000000000000000000000000000..18470397c89092502df107deb6aa31a26f2c7a3e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/gather_nd_op.h
@@ -0,0 +1,172 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_GATHER_ND_OP_H_
+#define TENSORFLOW_CORE_KERNELS_GATHER_ND_OP_H_
+// Functor definition for GatherOp, must be compilable by nvcc.
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/framework/bounds_check.h"
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/platform/types.h"
+#include "tensorflow/core/util/util.h"
+
+namespace tensorflow {
+class OpKernelContext;
+class Tensor;
+
+namespace functor {
+
+template <typename Device, typename T, typename Index, int IXDIM>
+struct GatherNdSlice {
+  // Performs a slice gather op on (Tparams, Tindices), writing to Tout.
+  // Returns an index to Tindices if the value at that index is out of range.
+  // Returns -1 if all values of Tindices are in range.
+  Index operator()(const Device& d, const Index slice_size,
+                   typename TTypes<int32>::Scalar Tscratch,
+                   typename TTypes<T, IXDIM + 1>::ConstTensor Tparams,
+                   typename TTypes<Index>::ConstMatrix Tindices,
+                   typename TTypes<T>::Matrix Tout);
+};
+
+template <typename Device, typename T, typename Index>
+Status DoGatherNd(OpKernelContext* c, const Tensor& params,
+                  const Tensor& indices, Tensor* out) {
+  if (!TensorShapeUtils::IsVectorOrHigher(params.shape())) {
+    return errors::InvalidArgument("params must be at least a vector");
+  }
+  if (!TensorShapeUtils::IsVectorOrHigher(indices.shape())) {
+    return errors::InvalidArgument("indices must be at least a vector");
+  }
+  if (indices.dim_size(indices.dims() - 1) > params.dims()) {
+    return errors::InvalidArgument(
+        "index innermost dimension length must be <= params rank; saw: ",
+        indices.dim_size(indices.dims() - 1), " vs. ", params.dims());
+  }
+
+  const TensorShape& indices_shape(indices.shape());
+  const int64_t indices_nd = indices_shape.dim_size(indices_shape.dims() - 1);
+
+  // Check that we have enough index space
+  int64_t N_big = 1;
+  for (int i = 0; i < indices_shape.dims() - 1; ++i) {
+    N_big *= indices_shape.dim_size(i);
+  }
+  if (N_big > std::numeric_limits<int>::max()) {
+    return errors::InvalidArgument(
+        "indices has too many elements for int indexing: ", N_big, " > ",
+        std::numeric_limits<int>::max());
+  }
+  if (params.NumElements() > std::numeric_limits<Index>::max()) {
+    return errors::InvalidArgument("params.NumElements() too large for ",
+                                   DataTypeString(DataTypeToEnum<Index>::v()),
+                                   " indexing: ", params.NumElements(), " > ",
+                                   std::numeric_limits<Index>::max());
+  }
+
+  // The result shape is
+  //   indices.shape[:-1] + params.shape[indices.shape[-1]:]
+  Index N_result = 1;
+  for (int i = 0; i < indices_shape.dims() - 1; ++i) {
+    N_result *= indices_shape.dim_size(i);
+  }
+
+  const TensorShape& params_shape(params.shape());
+  Index total_nd = params_shape.dims();
+
+  TensorShape result_shape(indices_shape);
+  result_shape.RemoveLastDims(1);
+
+  int64_t slice_size_big = 1;
+  for (Index i = indices_nd; i < total_nd; ++i) {
+    slice_size_big *= params_shape.dim_size(i);
+    TF_RETURN_IF_ERROR(result_shape.AddDimWithStatus(params_shape.dim_size(i)));
+  }
+
+  if (slice_size_big > std::numeric_limits<Index>::max()) {
+    return errors::InvalidArgument(
+        "slice size is too large for indexing: ", slice_size_big, " > ",
+        std::numeric_limits<Index>::max());
+  }
+
+  const Index slice_size = static_cast<Index>(slice_size_big);
+
+  TF_RETURN_IF_ERROR(
+      c->allocate_temp(DataTypeToEnum<T>::value, result_shape, out));
+
+  if (N_result > 0) {
+    if (params_shape.num_elements() == 0) {
+      return errors::InvalidArgument(
+          "Requested more than 0 entries, but "
+          "params is empty.  Params shape: ",
+          params_shape.DebugString());
+    }
+
+    auto indices_mat = indices.flat_inner_dims<Index>();
+
+    Index bad_i = -1;
+
+    // Request to copy slices / subtensors
+    // Make out a matrix with the slices the col size.
+    auto out_mat = out->shaped<T, 2>({N_result, slice_size});
+    Tensor scratch;
+    TF_RETURN_IF_ERROR(c->allocate_temp(DT_INT32, TensorShape(), &scratch));
+    auto scratch_scalar = scratch.scalar<int32>();
+
+    switch (indices_nd) {
+#define PARAMS_CASE(IXDIM)                                              \
+  case IXDIM: {                                                         \
+    functor::GatherNdSlice<Device, T, Index, IXDIM> func;               \
+    auto params_flat = params.flat_outer_dims<T, IXDIM + 1>();          \
+    bad_i = func(c->eigen_device<Device>(), slice_size, scratch_scalar, \
+                 params_flat, indices_mat, out_mat);                    \
+  } break
+      PARAMS_CASE(0);
+      PARAMS_CASE(1);
+      PARAMS_CASE(2);
+      PARAMS_CASE(3);
+      PARAMS_CASE(4);
+      PARAMS_CASE(5);
+      PARAMS_CASE(6);
+      PARAMS_CASE(7);
+#undef PARAMS_CASE
+      default:
+        return errors::InvalidArgument(
+            "Only indices.shape[-1] values between 1 and 7 "
+            "are currently supported.  Requested rank: ",
+            indices_nd);
+    }
+
+    // bad_i will only return >= 0 on CPUs right now.
+    if (bad_i >= 0) {
+      auto shape = indices.shape();
+      shape.RemoveLastDims(1);
+      return errors::InvalidArgument(
+          "indices", SliceDebugString(shape, bad_i), " = [",
+          str_util::Join(
+              gtl::ArraySlice<Index>(&indices_mat(bad_i, 0), indices_nd), ", "),
+          "] does not index into param shape ", params.shape().DebugString(),
+          ", node name: ", c->op_kernel().name());
+    }
+  }
+  return OkStatus();
+}
+
+}  // namespace functor
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_GATHER_ND_OP_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/gather_nd_op_cpu_impl.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/gather_nd_op_cpu_impl.h
new file mode 100644
index 0000000000000000000000000000000000000000..524f303e3d064a70f7df43fd10e1a41291d3867b
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/gather_nd_op_cpu_impl.h
@@ -0,0 +1,149 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_GATHER_ND_OP_CPU_IMPL_H_
+#define TENSORFLOW_CORE_KERNELS_GATHER_ND_OP_CPU_IMPL_H_
+
+// Specialization of GatherNdSlice to CPU
+
+#define EIGEN_USE_THREADS
+
+#include <atomic>
+
+#include "tensorflow/core/framework/bounds_check.h"
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/register_types.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/kernels/gather_nd_op.h"
+#include "tensorflow/core/platform/logging.h"
+#include "tensorflow/core/platform/mem.h"
+#include "tensorflow/core/platform/types.h"
+#include "tensorflow/core/util/util.h"
+
+namespace tensorflow {
+
+typedef Eigen::ThreadPoolDevice CPUDevice;
+
+namespace generator {
+
+template <typename T, typename Index, int IXDIM>
+class GatherNdSliceGenerator {
+ public:
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE GatherNdSliceGenerator(
+      const Index slice_size, typename TTypes<Index>::ConstMatrix Tindices,
+      typename TTypes<T, IXDIM + 1>::ConstTensor Tparams,
+      typename TTypes<T>::Matrix Tout, std::atomic<Index>* error_loc)
+      : slice_size_(slice_size),
+        Tindices_(Tindices),
+        Tparams_(Tparams),
+        Tout_(Tout),
+        error_loc_(error_loc) {}
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE bool GenerateIndices(
+      const Index loc, Eigen::array<Eigen::DenseIndex, IXDIM + 1>* ix) const {
+    (*ix)[IXDIM] = 0;
+    bool out_of_bounds = false;
+    for (int i = 0; i < IXDIM; ++i) {
+      const Index ix_i = internal::SubtleMustCopy(Tindices_(loc, i));
+      (*ix)[i] = ix_i;
+      out_of_bounds |= !FastBoundsCheck(ix_i, Tparams_.dimension(i));
+    }
+    return out_of_bounds;
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE int32
+  operator()(const Eigen::array<Eigen::DenseIndex, 1>& loc_array) const {
+    const Index loc = loc_array[0];
+    Eigen::array<Eigen::DenseIndex, IXDIM + 1> ix;
+    Eigen::array<Eigen::DenseIndex, 2> ix_out;
+    ix_out[0] = loc;
+    ix_out[1] = 0;
+    const bool out_of_bounds = GenerateIndices(loc, &ix);
+    if (TF_PREDICT_FALSE(out_of_bounds)) {
+      error_loc_->store(loc);
+      std::fill_n(&Tout_(ix_out), slice_size_, T());
+    } else {
+      std::copy_n(&Tparams_(ix), slice_size_, &Tout_(ix_out));
+    }
+
+    return static_cast<int32>(0);  // Return something...
+  }
+
+ private:
+  const Index slice_size_;
+  const typename TTypes<Index>::ConstMatrix Tindices_;
+  const typename TTypes<T, IXDIM + 1>::ConstTensor Tparams_;
+  mutable typename TTypes<T>::Matrix Tout_;
+  std::atomic<Index>* error_loc_;
+};
+
+}  // namespace generator
+
+namespace functor {
+
+template <typename T, typename Index, int IXDIM>
+struct GatherNdSlice<CPUDevice, T, Index, IXDIM> {
+  Index operator()(const CPUDevice& d, const Index slice_size,
+                   typename TTypes<int32>::Scalar Tscratch,
+                   typename TTypes<T, IXDIM + 1>::ConstTensor Tparams,
+                   typename TTypes<Index>::ConstMatrix Tindices,
+                   typename TTypes<T>::Matrix Tout) {
+    std::atomic<Index> error_loc(-1);
+    const Eigen::Index batch_size = Tindices.dimension(0);
+    generator::GatherNdSliceGenerator<T, Index, IXDIM> gather_nd_generator(
+        slice_size, Tindices, Tparams, Tout, &error_loc);
+
+    auto compute_shard = [&](Eigen::Index begin, Eigen::Index end) {
+      for (Eigen::Index i = begin; i < end; ++i) {
+        const Eigen::array<Eigen::Index, 1> loc{i};
+        gather_nd_generator(loc);
+      }
+    };
+    Eigen::Index bytes_moved = sizeof(T) * (slice_size + IXDIM);
+    auto cost = Eigen::TensorOpCost(bytes_moved /* bytes loaded */,
+                                    bytes_moved /* bytes stored */,
+                                    slice_size + IXDIM /* compute cycles */);
+    d.parallelFor(batch_size, cost, compute_shard);
+
+    // error_loc() returns -1 if there's no out-of-bounds index,
+    // otherwise it returns the location of an OOB index in Tindices.
+    return error_loc.load();
+  }
+};
+
+#define REGISTER_GATHER_ND_FULL(T, Index)                              \
+  template Index                                                       \
+  GatherNdSlice<CPUDevice, T, Index, CPU_PROVIDED_IXDIM>::operator()(  \
+      const CPUDevice& d, const Index slice_size,                      \
+      typename TTypes<int32>::Scalar Tscratch,                         \
+      typename TTypes<T, CPU_PROVIDED_IXDIM + 1>::ConstTensor Tparams, \
+      typename TTypes<Index>::ConstMatrix Tindices,                    \
+      typename TTypes<T>::Matrix Tout);
+
+#define REGISTER_GATHER_ND_CPU(type)    \
+  REGISTER_GATHER_ND_FULL(type, int16); \
+  REGISTER_GATHER_ND_FULL(type, int32); \
+  REGISTER_GATHER_ND_FULL(type, int64)
+
+TF_CALL_ALL_TYPES(REGISTER_GATHER_ND_CPU);
+TF_CALL_QUANTIZED_TYPES(REGISTER_GATHER_ND_CPU);
+TF_CALL_float8_e5m2(REGISTER_GATHER_ND_CPU);
+TF_CALL_float8_e4m3fn(REGISTER_GATHER_ND_CPU);
+
+}  // namespace functor
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_GATHER_ND_OP_CPU_IMPL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/gemm_functors.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/gemm_functors.h
new file mode 100644
index 0000000000000000000000000000000000000000..22d8bd1f5bb66b1bbde15c26e6073f64c195dbd4
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/gemm_functors.h
@@ -0,0 +1,153 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// This is a set of different implementations for the basic matrix by matrix
+// multiply function, commonly known as GEMM after the BLAS library's naming.
+// Having a standard interface enables us to swap out implementations on
+// different platforms, to make sure we're using the optimal version. They are
+// implemented as C++ template functors, so they're easy to swap into all of the
+// different kernels that use them.
+
+#if !defined(EIGEN_USE_THREADS)
+#error "EIGEN_USE_THREADS must be enabled by all .cc files including this."
+#endif  // EIGEN_USE_THREADS
+
+#ifndef TENSORFLOW_CORE_KERNELS_GEMM_FUNCTORS_H_
+#define TENSORFLOW_CORE_KERNELS_GEMM_FUNCTORS_H_
+
+#include <string.h>
+
+#include <map>
+#include <vector>
+
+#include "tensorflow/core/common_runtime/threadpool_device.h"
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/tensor_types.h"
+
+#if defined(TENSORFLOW_USE_CUSTOM_CONTRACTION_KERNEL)
+#include "tsl/framework/contraction/eigen_contraction_kernel.h"
+#endif
+
+// Apple provides an optimized BLAS library that is better than Eigen for their
+// devices, so use that if possible.
+#if defined(__APPLE__) && defined(USE_GEMM_FOR_CONV)
+#include <Accelerate/Accelerate.h>
+#define USE_CBLAS_GEMM
+#endif  // __APPLE__
+
+// Older Raspberry Pi systems don't have NEON SIMD acceleration, so Eigen falls
+// back to scalar code, but OpenBLAS has much faster support so prefer that.
+#if defined(RASPBERRY_PI) && defined(USE_GEMM_FOR_CONV) && defined(USE_OPENBLAS)
+#include <cblas.h>
+#define USE_CBLAS_GEMM
+#endif
+
+// A readable but slow implementation of matrix multiplication, useful for
+// debugging and understanding the algorithm. Use instead of FastGemmFunctor in
+// the Im2ColConvFunctor template definition inside the op registration to
+// enable. Assumes row-major ordering of the values in memory.
+template <class T1, class T2, class T3>
+class ReferenceGemmFunctor {
+ public:
+  void operator()(tensorflow::OpKernelContext* ctx, size_t m, size_t n,
+                  size_t k, const T1* a, size_t lda, const T2* b, size_t ldb,
+                  T3* c, size_t ldc) {
+    const size_t a_i_stride = lda;
+    const size_t a_l_stride = 1;
+    const size_t b_j_stride = 1;
+    const size_t b_l_stride = ldb;
+    const size_t c_i_stride = ldc;
+    const size_t c_j_stride = 1;
+    size_t i, j, l;
+    for (j = 0; j < n; j++) {
+      for (i = 0; i < m; i++) {
+        T3 total(0);
+        for (l = 0; l < k; l++) {
+          const size_t a_index = ((i * a_i_stride) + (l * a_l_stride));
+          const T1 a_value = a[a_index];
+          const size_t b_index = ((j * b_j_stride) + (l * b_l_stride));
+          const T2 b_value = b[b_index];
+          total += (a_value * b_value);
+        }
+        const size_t c_index = ((i * c_i_stride) + (j * c_j_stride));
+        c[c_index] = total;
+      }
+    }
+  }
+};
+
+// Uses the optimized EigenTensor library to implement the matrix multiplication
+// required by the Im2ColConvFunctor class. We supply the two input and one
+// output types so that the accumulator can potentially be higher-precision than
+// the inputs, even though we don't currently take advantage of this.
+template <class T1, class T2, class T3>
+class FastGemmFunctor {
+ public:
+  void operator()(tensorflow::OpKernelContext* ctx, size_t m, size_t n,
+                  size_t k, const T1* a, size_t lda, const T2* b, size_t ldb,
+                  T3* c, size_t ldc) {
+    typename tensorflow::TTypes<const T1>::Matrix a_matrix(a, m, k);
+    typename tensorflow::TTypes<const T2>::Matrix b_matrix(b, k, n);
+    typename tensorflow::TTypes<T3>::Matrix c_matrix(c, m, n);
+
+    Eigen::array<Eigen::IndexPair<Eigen::DenseIndex>, 1> dim_pair;
+    dim_pair[0].first = 1;
+    dim_pair[0].second = 0;
+    c_matrix.device(ctx->eigen_device<Eigen::ThreadPoolDevice>()) =
+        a_matrix.contract(b_matrix, dim_pair);
+  }
+};
+
+// Use float32 accumulation for bfloat16 to deal with precision accumulation
+// issues.
+template <>
+class FastGemmFunctor<Eigen::bfloat16, Eigen::bfloat16, Eigen::bfloat16> {
+ public:
+  void operator()(tensorflow::OpKernelContext* ctx, size_t m, size_t n,
+                  size_t k, const Eigen::bfloat16* a, size_t lda,
+                  const Eigen::bfloat16* b, size_t ldb, Eigen::bfloat16* c,
+                  size_t ldc) {
+    using ConstMatrix =
+        typename tensorflow::TTypes<const Eigen::bfloat16>::Matrix;
+    ConstMatrix a_matrix(a, m, k);
+    ConstMatrix b_matrix(b, k, n);
+    typename tensorflow::TTypes<Eigen::bfloat16>::Matrix c_matrix(c, m, n);
+
+    Eigen::array<Eigen::IndexPair<Eigen::DenseIndex>, 1> dim_pair;
+    dim_pair[0].first = 1;
+    dim_pair[0].second = 0;
+    c_matrix.device(ctx->eigen_device<Eigen::ThreadPoolDevice>()) =
+        a_matrix.cast<float>()
+            .contract(b_matrix.cast<float>(), dim_pair)
+            .template cast<Eigen::bfloat16>();
+  }
+};
+
+// If we have a fast CBLAS library, use its implementation through a wrapper.
+#if defined(USE_CBLAS_GEMM)
+template <>
+class FastGemmFunctor<float, float, float> {
+ public:
+  void operator()(tensorflow::OpKernelContext* ctx, size_t m, size_t n,
+                  size_t k, const float* a, size_t lda, const float* b,
+                  size_t ldb, float* c, size_t ldc) {
+    cblas_sgemm(CblasRowMajor, CblasNoTrans, CblasNoTrans, m, n, k, 1.0f, a,
+                lda, b, ldb, 0.0f, c, ldc);
+  }
+};
+#endif  // USE_CBLAS_GEMM
+
+#endif  // TENSORFLOW_CORE_KERNELS_GEMM_FUNCTORS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/gpu_device_array.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/gpu_device_array.h
new file mode 100644
index 0000000000000000000000000000000000000000..fe3e455d96717d51717c17e6014db3b55fa26b61
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/gpu_device_array.h
@@ -0,0 +1,125 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_KERNELS_GPU_DEVICE_ARRAY_H_
+#define TENSORFLOW_CORE_KERNELS_GPU_DEVICE_ARRAY_H_
+
+#if (defined(GOOGLE_CUDA) && GOOGLE_CUDA) || \
+    (defined(TENSORFLOW_USE_ROCM) && TENSORFLOW_USE_ROCM)
+
+#include "tensorflow/core/common_runtime/gpu/gpu_event_mgr.h"
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/tensor_reference.h"
+#include "tensorflow/core/kernels/gpu_device_array_gpu.h"
+
+namespace tensorflow {
+
+// Create an array of value on the host, to be sent to kernel using
+// GpuDeviceArrayStruct.
+//
+// Usage:
+//   int size = ...;
+//   GpuDeviceArrayOnHost ptrs(context, size);
+//   OP_REQUIRES_OK(ptrs.Init());
+//   for (int i = 0; i < size; ++i) {
+//     ptrs.Set(i, ...);
+//   }
+//   OP_REQUIRES_OK(ptrs.Finalize());
+//   launchKernel(..., ptrs.data, ...);
+//
+// ValueType must be memcopyable.
+template <typename ValueType, int MaxInlineValues = 8>
+class GpuDeviceArrayOnHost {
+ public:
+  GpuDeviceArrayOnHost(OpKernelContext* context, int32_t size)
+      : context_(context),
+        total_bytes_(static_cast<int64_t>(size) * sizeof(ValueType)) {
+    data_.size = size;
+  }
+
+  Status Init() {
+    if (inlined()) {
+      values_ = data_.inline_values;
+      return OkStatus();
+    }
+
+    // Out-of-line: allocate data that will be memcopied.
+    AllocatorAttributes attr;
+    attr.set_on_host(true);
+    attr.set_gpu_compatible(true);
+    TF_RETURN_IF_ERROR(
+        context_->allocate_temp(DT_INT8, TensorShape{total_bytes_},
+                                &out_of_line_values_on_host_, attr));
+    values_ = reinterpret_cast<ValueType*>(
+        out_of_line_values_on_host_.flat<int8>().data());
+    return OkStatus();
+  }
+
+  void Set(int index, ValueType val) {
+    DCHECK(values_);  // ensure Init was called.
+    DCHECK_LT(index, data_.size);
+    *(values_ + index) = val;
+  }
+
+  Status Finalize() {
+    if (inlined()) {
+      return OkStatus();
+    }
+
+    // Out-of-line - copy pointers to device.
+    auto stream = context_->op_device_context()->stream();
+    TensorReference tensor_ref(out_of_line_values_on_host_);
+    TF_RETURN_IF_ERROR(context_->allocate_temp(
+        DT_INT8, TensorShape{total_bytes_}, &out_of_line_values_on_gpu_));
+    se::DeviceMemoryBase output_values_base{
+        out_of_line_values_on_gpu_.flat<int8>().data(),
+        static_cast<uint64>(total_bytes_)};
+    stream->ThenMemcpy(&output_values_base,
+                       out_of_line_values_on_host_.flat<int8>().data(),
+                       total_bytes_);
+    context_->device()
+        ->tensorflow_accelerator_device_info()
+        ->event_mgr->ThenExecute(stream,
+                                 [tensor_ref]() { tensor_ref.Unref(); });
+    data_.out_of_line_values = reinterpret_cast<ValueType*>(
+        out_of_line_values_on_gpu_.flat<int8>().data());
+    return OkStatus();
+  }
+
+  const GpuDeviceArrayStruct<ValueType, MaxInlineValues>& data() const {
+    // Ensure Finalize is called.
+    DCHECK(inlined() || out_of_line_values_on_gpu_.IsInitialized());
+    return data_;
+  }
+
+ private:
+  bool inlined() const { return data_.size <= MaxInlineValues; }
+
+  OpKernelContext* const context_;
+  const int64_t total_bytes_;  // total size of all pointers.
+  ValueType* values_ = nullptr;
+  GpuDeviceArrayStruct<ValueType, MaxInlineValues> data_;
+
+  Tensor out_of_line_values_on_host_;
+  Tensor out_of_line_values_on_gpu_;
+
+  GpuDeviceArrayOnHost(const GpuDeviceArrayOnHost&) = delete;
+  void operator=(const GpuDeviceArrayOnHost&) = delete;
+};
+
+}  // namespace tensorflow
+
+#endif  // GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+
+#endif  // TENSORFLOW_CORE_KERNELS_GPU_DEVICE_ARRAY_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/gpu_device_array_gpu.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/gpu_device_array_gpu.h
new file mode 100644
index 0000000000000000000000000000000000000000..15a09e3dd0930054102302b566f0ae828fed9fa6
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/gpu_device_array_gpu.h
@@ -0,0 +1,50 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// Contains structs and functions to be included in device code.
+
+#ifndef TENSORFLOW_CORE_KERNELS_GPU_DEVICE_ARRAY_GPU_H_
+#define TENSORFLOW_CORE_KERNELS_GPU_DEVICE_ARRAY_GPU_H_
+
+#if (defined(GOOGLE_CUDA) && GOOGLE_CUDA) || \
+    (defined(TENSORFLOW_USE_ROCM) && TENSORFLOW_USE_ROCM)
+
+namespace tensorflow {
+
+// To decode on the device side, use GetGpuDeviceArrayOnDevice.
+// To encode on the host side, use GpuDeviceArrayOnHost.
+template <typename ValueType, int MaxInlineValues = 8>
+struct GpuDeviceArrayStruct {
+  int32 size;
+  // used if size <= MaxInlineValues;
+  ValueType inline_values[MaxInlineValues];
+  ValueType* out_of_line_values = nullptr;  // used if size > MaxInlineValues;
+};
+
+template <typename ValueType, int MaxInlineValues = 8>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ValueType* GetGpuDeviceArrayOnDevice(
+    GpuDeviceArrayStruct<ValueType, MaxInlineValues>* data) {
+  if (data->size <= MaxInlineValues) {
+    return data->inline_values;
+  } else {
+    return data->out_of_line_values;
+  }
+}
+
+}  // namespace tensorflow
+
+#endif  // GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+
+#endif  // TENSORFLOW_CORE_KERNELS_GPU_DEVICE_ARRAY_GPU_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/gpu_prim.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/gpu_prim.h
new file mode 100644
index 0000000000000000000000000000000000000000..bef22b50ada12c7068b47ba86af47c49f14c9bfc
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/gpu_prim.h
@@ -0,0 +1,117 @@
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+To in writing unless required by applicable law or agreed,
+distributed on an, software distributed under the license is "AS IS"
+BASIS, WITHOUT OF ANY KIND WARRANTIES OR CONDITIONS, either express
+or implied. For the specific language governing permissions and
+limitations under the license, the license you must see.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_KERNELS_GPU_PRIM_H_
+#define TENSORFLOW_CORE_KERNELS_GPU_PRIM_H_
+
+#include "tensorflow/core/platform/bfloat16.h"
+
+#if GOOGLE_CUDA
+#include "cub/block/block_load.cuh"
+#include "cub/block/block_scan.cuh"
+#include "cub/block/block_store.cuh"
+#include "cub/device/device_histogram.cuh"
+#include "cub/device/device_radix_sort.cuh"
+#include "cub/device/device_reduce.cuh"
+#include "cub/device/device_scan.cuh"
+#include "cub/device/device_segmented_radix_sort.cuh"
+#include "cub/device/device_segmented_reduce.cuh"
+#include "cub/device/device_select.cuh"
+#include "cub/iterator/counting_input_iterator.cuh"
+#include "cub/iterator/transform_input_iterator.cuh"
+#include "cub/thread/thread_operators.cuh"
+#include "cub/warp/warp_reduce.cuh"
+#include "third_party/gpus/cuda/include/cusparse.h"
+
+namespace gpuprim = ::cub;
+
+// Required for sorting Eigen::half and bfloat16.
+namespace cub {
+template <>
+__device__ __forceinline__ void ThreadStoreVolatilePtr<Eigen::half>(
+    Eigen::half *ptr, Eigen::half val, Int2Type<true> /*is_primitive*/) {
+  *reinterpret_cast<volatile uint16_t *>(ptr) =
+      Eigen::numext::bit_cast<uint16_t>(val);
+}
+
+template <>
+__device__ __forceinline__ Eigen::half ThreadLoadVolatilePointer<Eigen::half>(
+    Eigen::half *ptr, Int2Type<true> /*is_primitive*/) {
+  uint16_t result = *reinterpret_cast<volatile uint16_t *>(ptr);
+  return Eigen::numext::bit_cast<Eigen::half>(result);
+}
+
+template <>
+__device__ __forceinline__ void ThreadStoreVolatilePtr<Eigen::bfloat16>(
+    Eigen::bfloat16 *ptr, Eigen::bfloat16 val,
+    Int2Type<true> /*is_primitive*/) {
+  *reinterpret_cast<volatile uint16_t *>(ptr) =
+      Eigen::numext::bit_cast<uint16_t>(val);
+}
+
+template <>
+__device__ __forceinline__ Eigen::bfloat16
+ThreadLoadVolatilePointer<Eigen::bfloat16>(Eigen::bfloat16 *ptr,
+                                           Int2Type<true> /*is_primitive*/) {
+  uint16_t result = *reinterpret_cast<volatile uint16_t *>(ptr);
+  return Eigen::numext::bit_cast<Eigen::bfloat16>(result);
+}
+
+template <>
+struct NumericTraits<Eigen::half>
+    : BaseTraits</*_CATEGORY=*/FLOATING_POINT, /*_PRIMITIVE=*/true,
+                 /*_NULL_TYPE=*/false, /*_UnsignedBits=*/uint16_t,
+                 /*T=*/Eigen::half> {};
+template <>
+struct NumericTraits<tensorflow::bfloat16>
+    : BaseTraits</*_CATEGORY=*/FLOATING_POINT, /*_PRIMITIVE=*/true,
+                 /*_NULL_TYPE=*/false, /*_UnsignedBits=*/uint16_t,
+                 /*T=*/tensorflow::bfloat16> {};
+}  // namespace cub
+#elif TENSORFLOW_USE_ROCM
+#include "rocm/include/hipcub/hipcub.hpp"
+#include "rocm/rocm_config.h"
+namespace gpuprim = ::hipcub;
+
+// Required for sorting Eigen::half and bfloat16.
+namespace rocprim {
+namespace detail {
+#if (TF_ROCM_VERSION >= 50200)
+template <>
+struct float_bit_mask<Eigen::half> {
+  static constexpr uint16_t sign_bit = 0x8000;
+  static constexpr uint16_t exponent = 0x7C00;
+  static constexpr uint16_t mantissa = 0x03FF;
+  using bit_type = uint16_t;
+};
+
+template <>
+struct float_bit_mask<Eigen::bfloat16> {
+  static constexpr uint16_t sign_bit = 0x8000;
+  static constexpr uint16_t exponent = 0x7F80;
+  static constexpr uint16_t mantissa = 0x007F;
+  using bit_type = uint16_t;
+};
+#endif
+template <>
+struct radix_key_codec_base<Eigen::half>
+    : radix_key_codec_floating<Eigen::half, uint16_t> {};
+template <>
+struct radix_key_codec_base<tensorflow::bfloat16>
+    : radix_key_codec_floating<tensorflow::bfloat16, uint16_t> {};
+};  // namespace detail
+};  // namespace rocprim
+
+#endif  // TENSORFLOW_USE_ROCM
+
+#endif  // TENSORFLOW_CORE_KERNELS_GPU_PRIM_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/gpu_prim_helpers.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/gpu_prim_helpers.h
new file mode 100644
index 0000000000000000000000000000000000000000..39e5cf8672d871edc1f4e0bc3842a48aea71361f
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/gpu_prim_helpers.h
@@ -0,0 +1,290 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_KERNELS_GPU_PRIM_HELPERS_H_
+#define TENSORFLOW_CORE_KERNELS_GPU_PRIM_HELPERS_H_
+
+#if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+
+#define EIGEN_USE_GPU
+
+#include "xla/stream_executor/stream.h"
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/kernels/gpu_prim.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/util/gpu_kernel_helper.h"
+
+namespace tensorflow {
+
+namespace detail {
+
+template <typename T>
+__global__ void RangeInitKernel(const T start, const T delta, const T size,
+                                T* out) {
+  GPU_1D_KERNEL_LOOP(i, size) { out[i] = start + i * delta; }
+}
+
+// Initialize out with range start, start + delta, start + 2 * delta, ...
+template <typename T>
+Status RangeInit(const Eigen::GpuDevice& d, const T start, const T delta,
+                 const T size, T* out) {
+  if (size == 0) return OkStatus();
+  GpuLaunchConfig config = GetGpuLaunchConfig(size, d);
+  return GpuLaunchKernel(RangeInitKernel<T>, config.block_count,
+                         config.thread_per_block, 0, d.stream(), start, delta,
+                         size, out);
+}
+
+// Computes keys_out = sorted(keys_in), and indices_out = argsort(keys_in).
+// If keys_out is not required, it can be set to nullptr.
+// If indices_in is nullptr, the range of input indices [0, size) will be used.
+template <bool Descending, typename Tkey, typename Tindex>
+Status GpuRadixSortImpl(OpKernelContext* context, int size, const Tkey* keys_in,
+                        Tkey* keys_out,            // Optional
+                        const Tindex* indices_in,  // Optional
+                        Tindex* indices_out, int num_bits = sizeof(Tkey) * 8) {
+  if (size == 0) return OkStatus();
+  if (num_bits == 0) {
+    // Workaround for CUB failing when begin_bit = end_bit = 0 (e.g., when all
+    // keys are 0, so no sorting is needed).
+    se::Stream* stream = context->op_device_context()->stream();
+    if (keys_out) {
+      // Copy keys_in to keys_out.
+      size_t num_bytes = size * sizeof(Tkey);
+      se::DeviceMemoryBase src(const_cast<Tkey*>(keys_in), num_bytes);
+      se::DeviceMemoryBase dst(keys_out, num_bytes);
+      if (!stream->ThenMemcpy(&dst, src, num_bytes).ok()) {
+        return errors::Internal("Failed to copy keys_in to keys_out");
+      }
+    }
+    if (indices_in) {
+      // Copy indices_in to indices_out.
+      size_t num_bytes = size * sizeof(Tindex);
+      se::DeviceMemoryBase src(const_cast<Tindex*>(indices_in), num_bytes);
+      se::DeviceMemoryBase dst(indices_out, num_bytes);
+      if (!stream->ThenMemcpy(&dst, src, num_bytes).ok()) {
+        return errors::Internal("Failed to copy indices_in to indices_out");
+      }
+    } else {
+      // Set output indices to range.
+      const Eigen::GpuDevice& device =
+          context->eigen_device<Eigen::GpuDevice>();
+      TF_RETURN_IF_ERROR(detail::RangeInit(device, Tindex(0), Tindex(1),
+                                           Tindex(size), indices_out));
+    }
+    return OkStatus();
+  }
+  // Allocate temporary inputs/outputs if necessary.
+  Tensor tmp_indices_in;
+  if (!indices_in) {
+    TF_RETURN_IF_ERROR(context->allocate_temp(
+        DataTypeToEnum<Tindex>::value, TensorShape({size}), &tmp_indices_in));
+    Tindex* mutable_indices_in = tmp_indices_in.flat<Tindex>().data();
+    indices_in = mutable_indices_in;
+    const Eigen::GpuDevice& device = context->eigen_device<Eigen::GpuDevice>();
+    // Initialize indices_in to the input index range.
+    TF_RETURN_IF_ERROR(detail::RangeInit(device, Tindex(0), Tindex(1),
+                                         Tindex(size), mutable_indices_in));
+  }
+  Tensor tmp_keys_out;
+  if (!keys_out) {
+    TF_RETURN_IF_ERROR(context->allocate_temp(
+        DataTypeToEnum<Tkey>::value, TensorShape({size}), &tmp_keys_out));
+    keys_out = tmp_keys_out.flat<Tkey>().data();
+  }
+  // Determine temporary device storage requirements.
+  Tensor temp_storage;
+  size_t temp_storage_bytes = 0;
+  const auto& cu_stream = GetGpuStream(context);
+  gpuError_t err;
+  if constexpr (Descending) {
+    err = gpuprim::DeviceRadixSort::SortPairsDescending(
+        nullptr, temp_storage_bytes, keys_in, keys_out, indices_in, indices_out,
+        size, /*begin_bit=*/0, /*end_bit=*/num_bits, cu_stream);
+  } else {
+    err = gpuprim::DeviceRadixSort::SortPairs(
+        nullptr, temp_storage_bytes, keys_in, keys_out, indices_in, indices_out,
+        size, /*begin_bit=*/0, /*end_bit=*/num_bits, cu_stream);
+  }
+  if (err != 0) {
+    return errors::Internal(
+        "Failed to launch gpuprim::DeviceRadixSort::SortPairs to calculate "
+        "temp_storage_bytes, status: ",
+        cudaGetErrorString(err));
+  }
+  // Allocate temporary storage.
+  TF_RETURN_IF_ERROR(context->allocate_temp(
+      DT_INT8, TensorShape({static_cast<int64_t>(temp_storage_bytes)}),
+      &temp_storage));
+  // Sort indices by keys.
+  if constexpr (Descending) {
+    err = gpuprim::DeviceRadixSort::SortPairsDescending(
+        temp_storage.flat<int8>().data(), temp_storage_bytes, keys_in, keys_out,
+        indices_in, indices_out, size, /*begin_bit=*/0, /*end_bit=*/num_bits,
+        cu_stream);
+  } else {
+    err = gpuprim::DeviceRadixSort::SortPairs(
+        temp_storage.flat<int8>().data(), temp_storage_bytes, keys_in, keys_out,
+        indices_in, indices_out, size, /*begin_bit=*/0, /*end_bit=*/num_bits,
+        cu_stream);
+  }
+  if (err != 0) {
+    return errors::Internal(
+        "Failed to launch gpuprim::DeviceRadixSort::SortPairs, "
+        "temp_storage_bytes: ",
+        temp_storage_bytes, "status: ", cudaGetErrorString(err));
+  }
+  return OkStatus();
+}
+
+}  // namespace detail
+
+template <typename Tkey, typename Tindex>
+Status GpuRadixSort(OpKernelContext* context, int size, const Tkey* keys_in,
+                    Tkey* keys_out,            // Optional
+                    const Tindex* indices_in,  // Optional
+                    Tindex* indices_out, int num_bits = sizeof(Tkey) * 8) {
+  return detail::GpuRadixSortImpl</*Descending=*/false>(
+      context, size, keys_in, keys_out, indices_in, indices_out, num_bits);
+}
+
+template <typename Tkey, typename Tindex>
+Status GpuRadixSortDescending(OpKernelContext* context, int size,
+                              const Tkey* keys_in,
+                              Tkey* keys_out,            // Optional
+                              const Tindex* indices_in,  // Optional
+                              Tindex* indices_out,
+                              int num_bits = sizeof(Tkey) * 8) {
+  return detail::GpuRadixSortImpl</*Descending=*/true>(
+      context, size, keys_in, keys_out, indices_in, indices_out, num_bits);
+}
+
+template <typename InputIteratorT, typename OutputIteratorT>
+Status GpuInclusivePrefixSum(OpKernelContext* context, int size,
+                             InputIteratorT input, OutputIteratorT output) {
+  static_assert(
+      !std::is_same<typename std::remove_reference<decltype(*input)>::type,
+                    bool>::value,
+      "GpuInclusivePrefixSum does not work correct with booleans, please use "
+      "TransformInputIterator to explicitly cast to an integer.");
+  if (size == 0) return OkStatus();
+  const auto& cu_stream = GetGpuStream(context);
+  size_t temp_storage_bytes;
+  auto err = gpuprim::DeviceScan::InclusiveSum(nullptr, temp_storage_bytes,
+                                               input, output, size, cu_stream);
+  if (err != 0) {
+    return errors::Internal(
+        "Failed to launch gpuprim::DeviceScan::InclusiveSum to calculate "
+        "temp_storage_bytes, status: ",
+        cudaGetErrorString(err));
+  }
+  Tensor temp_storage;
+  TF_RETURN_IF_ERROR(context->allocate_temp(
+      DT_INT8, TensorShape({static_cast<int64_t>(temp_storage_bytes)}),
+      &temp_storage));
+  err = gpuprim::DeviceScan::InclusiveSum(temp_storage.flat<int8>().data(),
+                                          temp_storage_bytes, input, output,
+                                          size, cu_stream);
+  if (err != 0) {
+    return errors::Internal(
+        "Failed to launch gpuprim::DeviceScan::InclusiveSum, "
+        "temp_storage_bytes: ",
+        temp_storage_bytes, ", status: ", cudaGetErrorString(err));
+  }
+  return OkStatus();
+}
+
+// Note that this behaves deterministically for repeat calls on the same device.
+template <typename InputIteratorT, typename OutputIteratorT,
+          typename OffsetIteratorT, typename ReduceOp, typename T>
+Status GpuSegmentedReduce(
+    OpKernelContext* context, int num_segments, ReduceOp reduce_op,
+    const T& initial_value,
+    InputIteratorT input,             // [any]
+    OffsetIteratorT segment_offsets,  // [num_segments + 1]
+    OutputIteratorT output) {         // [num_segments]
+  if (num_segments == 0) return OkStatus();
+  const auto& cu_stream = GetGpuStream(context);
+  size_t temp_storage_bytes;
+  auto err = gpuprim::DeviceSegmentedReduce::Reduce(
+      nullptr, temp_storage_bytes, input, output, num_segments, segment_offsets,
+      segment_offsets + 1, reduce_op, initial_value, cu_stream);
+  if (err != 0) {
+    return errors::Internal(
+        "Failed to launch gpuprim::DeviceSegmentedReduce::Reduce to calculate "
+        "temp_storage_bytes, status: ",
+        cudaGetErrorString(err));
+  }
+  Tensor temp_storage;
+  TF_RETURN_IF_ERROR(context->allocate_temp(
+      DT_INT8, TensorShape({static_cast<int64_t>(temp_storage_bytes)}),
+      &temp_storage));
+  err = gpuprim::DeviceSegmentedReduce::Reduce(
+      temp_storage.flat<int8>().data(), temp_storage_bytes, input, output,
+      num_segments, segment_offsets, segment_offsets + 1, reduce_op,
+      initial_value, cu_stream);
+  if (err != 0) {
+    return errors::Internal(
+        "Failed to launch gpuprim::DeviceSegmentedReduce::Reduce"
+        ", temp_storage_bytes: ",
+        temp_storage_bytes, ", status: ", cudaGetErrorString(err));
+  }
+  return OkStatus();
+}
+
+template <typename InputIteratorT, typename FlagIteratorT,
+          typename OutputIteratorT, typename NumSelectedT = int>
+Status GpuSelectFlagged(OpKernelContext* context, int size,
+                        InputIteratorT input, FlagIteratorT flags,
+                        OutputIteratorT output,
+                        NumSelectedT* out_num_selected = nullptr) {
+  const auto& cu_stream = GetGpuStream(context);
+  Tensor out_num_selected_t;
+  if (!out_num_selected) {
+    TF_RETURN_IF_ERROR(
+        context->allocate_temp(DataTypeToEnum<NumSelectedT>::value,
+                               TensorShape({}), &out_num_selected_t));
+    out_num_selected = out_num_selected_t.scalar<NumSelectedT>().data();
+  }
+  size_t temp_storage_bytes;
+  auto err =
+      gpuprim::DeviceSelect::Flagged(nullptr, temp_storage_bytes, input, flags,
+                                     output, out_num_selected, size, cu_stream);
+  if (err != 0) {
+    return errors::Internal(
+        "Failed to launch gpuprim::DeviceSelect::Flagged to calculate "
+        "temp_storage_bytes, status: ",
+        cudaGetErrorString(err));
+  }
+  Tensor temp_storage;
+  TF_RETURN_IF_ERROR(context->allocate_temp(
+      DT_INT8, TensorShape({static_cast<int64_t>(temp_storage_bytes)}),
+      &temp_storage));
+  err = gpuprim::DeviceSelect::Flagged(temp_storage.flat<int8>().data(),
+                                       temp_storage_bytes, input, flags, output,
+                                       out_num_selected, size, cu_stream);
+  if (err != 0) {
+    return errors::Internal(
+        "Failed to launch gpuprim::DeviceSelect::Flagged, temp_storage_bytes: ",
+        temp_storage_bytes, ", status: ", cudaGetErrorString(err));
+  }
+  return OkStatus();
+}
+
+}  // namespace tensorflow
+
+#endif  // GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+
+#endif  // TENSORFLOW_CORE_KERNELS_GPU_PRIM_HELPERS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/gpu_utils.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/gpu_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..96af46697a859b2bae7131d6aabfd5364bceef7c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/gpu_utils.h
@@ -0,0 +1,444 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_GPU_UTILS_H_
+#define TENSORFLOW_CORE_KERNELS_GPU_UTILS_H_
+
+#if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+
+#include <unordered_map>
+
+#include "absl/strings/str_cat.h"
+#include "absl/types/span.h"
+#include "xla/stream_executor/dnn.h"
+#include "xla/stream_executor/lazy_op_runner.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/lib/strings/str_util.h"
+#include "tensorflow/core/lib/strings/strcat.h"
+#include "tensorflow/core/lib/strings/stringprintf.h"
+#include "tensorflow/core/platform/logging.h"
+#include "tensorflow/core/platform/stream_executor.h"
+
+namespace stream_executor {
+class RedzoneAllocator;
+}  // namespace stream_executor
+
+namespace xla {
+class AutotuneResult;
+}  // namespace xla
+
+namespace tensorflow {
+
+class NodeDef;
+using xla::AutotuneResult;
+
+template <typename T>
+se::DeviceMemory<T> AsDeviceMemory(const T* gpu_memory) {
+  se::DeviceMemoryBase wrapped(const_cast<T*>(gpu_memory));
+  se::DeviceMemory<T> typed(wrapped);
+  return typed;
+}
+
+// Return whether the redzone check is disabled.
+//
+// Controlled by the TF_DISABLE_RZ_CHECK environment variable.
+bool RedzoneCheckDisabled();
+
+// Return an allocated buffer with redzones the size of `buffer`. Does
+// *not* copy the contents of the `buffer` into the newly allocated buffer:
+// assumes that buffer is a pure out-parameter.
+//
+// Returns `buffer` if RedzoneCheckDisabled() is true.
+//
+// On error, return `buffer`, and log an error message (once).
+se::DeviceMemoryBase WrapRedzoneBestEffort(se::RedzoneAllocator* rz_allocator,
+                                           se::DeviceMemoryBase buffer);
+
+// Check the passed allocator for redzone violations.
+// If violations have occurred, mark the corresponding autotune result
+// as a failure.
+void CheckRedzones(const se::RedzoneAllocator& rz_allocator,
+                   AutotuneResult* autotune_result);
+
+template <typename T>
+inline se::DeviceMemory<T> AsDeviceMemory(const T* cuda_memory, uint64 size) {
+  se::DeviceMemoryBase wrapped(const_cast<T*>(cuda_memory), size * sizeof(T));
+  se::DeviceMemory<T> typed(wrapped);
+  return typed;
+}
+
+// Returns whether cuBLASLt is enabled.
+//
+// Controlled by the TF_USE_CUBLASLT environment variable.
+bool EnableCublasLtGemm();
+
+namespace internal {
+
+template <typename Parameters>
+struct AutotuneMapHasher {
+  std::size_t operator()(const Parameters& parameter) const {
+    return parameter.hash();
+  }
+};
+
+}  // namespace internal
+
+// A helper class that looks up the best autotuned config from parameters.
+// Due to the noisy nature of autotune, especially with multiple devices, it
+// only accepts a config if its margin exceeds a threshold.
+// For the same shape configs, if a new best config matches the previous best,
+// they get promoted; otherwise, the winner gets demoted. This process stops
+// when the winner's score exceeds the threshold.
+// In a bad case when two configs are very close to each other and flips
+// back and forth randomly, the expected number of experiments before autotune
+// settles is O(threshold ^ 2). So we recommend that number of warmup runs
+// for any benchmarks.
+template <typename Parameters, typename Config,
+          typename Hasher = internal::AutotuneMapHasher<Parameters>>
+class AutotuneMap {
+ public:
+  bool Find(const Parameters& params, Config* config) const {
+    mutex_lock lock(mu_);
+    auto iter = params_config_map_.find(params);
+    if (iter == params_config_map_.end() ||
+        (iter->second.score < min_score_threshold_ &&
+         iter->second.count <= max_autotune_count_)) {
+      return false;
+    }
+    *config = iter->second.config;
+    return true;
+  }
+  void Insert(const Parameters& params, const Config& config) {
+    mutex_lock lock(mu_);
+    auto iter = params_config_map_.find(params);
+    int new_score = 0;
+    if (iter == params_config_map_.end()) {
+      // Create a new entry if params is new.
+      VLOG(1) << GetActionSummary("creates", params, config);
+      params_config_map_.insert(
+          std::make_pair(params, ValueType{config, 1, 1}));
+      new_score = 1;
+    } else if (iter->second.score < min_score_threshold_ &&
+               iter->second.count <= max_autotune_count_) {
+      DCHECK_GT(iter->second.score, 0);
+      if (iter->second.config != config) {
+        // If it is different from the current winner, demotes the winner.
+        VLOG(1) << GetActionSummary("demotes", params, config);
+        new_score = --iter->second.score;
+        ++iter->second.count;
+        if (new_score <= 0) {
+          VLOG(1) << GetActionSummary("erases", params, config);
+          params_config_map_.erase(iter);
+        }
+      } else {
+        // If it is the same as the current winner, promotes the winner.
+        VLOG(1) << GetActionSummary("promotes", params, config);
+        new_score = ++iter->second.score;
+        ++iter->second.count;
+      }
+    }
+    if (new_score >= min_score_threshold_) {
+      VLOG(1) << GetActionSummary("accepts", params, config);
+    } else if (autotune_global_count_ >= max_autotune_global_count_) {
+      // The autotuning exceeds the max iteration threshold and we accept the
+      // the winner if it exists in the map, otherwise we accept the current
+      // winner.
+      auto winner = params_config_map_.find(params);
+      if (winner == params_config_map_.end()) {
+        VLOG(1) << GetActionSummary("creates", params, config);
+        for (int i = 0; i < min_score_threshold_; ++i) {
+          VLOG(1) << GetActionSummary("promotes", params, config);
+        }
+        params_config_map_.insert(
+            std::make_pair(params, ValueType{config, min_score_threshold_, 1}));
+      } else {
+        int promotes_times = min_score_threshold_ - winner->second.score;
+        for (int i = 0; i < promotes_times; ++i) {
+          VLOG(1) << GetActionSummary("promotes", params, config);
+        }
+        winner->second.score = min_score_threshold_;
+      }
+      VLOG(1) << GetActionSummary("accepts", params, config);
+    }
+    autotune_global_count_++;
+  }
+
+  std::unordered_map<Parameters, Config, Hasher> GetMap() const {
+    mutex_lock lock(mu_);
+    std::unordered_map<Parameters, Config, Hasher> map;
+    for (const auto& entry : params_config_map_) {
+      map.insert(std::make_pair(entry.first, entry.second.config));
+    }
+    return map;
+  }
+
+  // Only for testing
+  void ClearMap() {
+    mutex_lock lock(mu_);
+    params_config_map_.clear();
+  }
+
+ private:
+  // Underlying data structure of values in the map.
+  struct ValueType {
+    Config config;
+    int32 score;
+    int32 count;
+  };
+  AutotuneMap(const std::string& name) : name_(name) {
+    min_score_threshold_ = 1;
+    int min_warmup_iterations = 10;
+    const char* threshold_str = getenv("TF_AUTOTUNE_THRESHOLD");
+    if (threshold_str != nullptr) {
+      VLOG(1) << "TF_AUTOTUNE_THRESHOLD = " << threshold_str;
+      strings::safe_strto32(threshold_str, &min_score_threshold_);
+    }
+    const char* min_warmup_iteration_str =
+        getenv("TF_AUTOTUNE_MIN_WARMUP_ITERATIONS");
+    if (min_warmup_iteration_str != nullptr) {
+      strings::safe_strto32(min_warmup_iteration_str, &min_warmup_iterations);
+    }
+    min_score_threshold_ = std::max(min_score_threshold_, 1);
+    max_autotune_count_ = std::max(
+        5 * min_score_threshold_ * min_score_threshold_, min_warmup_iterations);
+    max_autotune_global_count_ = 2 * max_autotune_count_;
+    autotune_global_count_ = 0;
+  }
+
+  template <class Group, class Params, class Cfg, class Hash>
+  friend class AutotuneSingleton;
+
+  std::string GetActionSummary(StringPiece action, const Parameters& params,
+                               const Config& config) {
+    return strings::Printf("autotune_map %s %s: %s -> (%s)", name_.c_str(),
+                           string(action).c_str(), params.ToString().c_str(),
+                           config.ToString().c_str());
+  }
+
+  mutable mutex mu_;
+
+  std::unordered_map<Parameters, ValueType, Hasher> params_config_map_
+      TF_GUARDED_BY(mu_);
+  std::string name_;
+  int32 min_score_threshold_;
+  int32 max_autotune_count_;
+  int32 max_autotune_global_count_;
+  int32 autotune_global_count_;
+
+  AutotuneMap(const AutotuneMap&) = delete;
+  void operator=(const AutotuneMap&) = delete;
+};
+
+// A Singleton helper that manages the global autotune results by groups.
+// The caller specified arbitrary Group type that can distinguish between
+// different autotune results, even if their Parameters and Configs are the
+// same.
+template <class Group, typename Parameters, typename Config,
+          typename Hasher = internal::AutotuneMapHasher<Parameters>>
+class AutotuneSingleton {
+ public:
+  typedef AutotuneMap<Parameters, Config, Hasher> AutotuneType;
+  static AutotuneType* GetInstance() {
+    static AutotuneType* instance = new AutotuneType(Group::name());
+    return instance;
+  }
+};
+
+// Logs convolution results to customized back-storage.
+void LogConvAutotuneResults(se::dnn::ConvolutionKind kind,
+                            se::dnn::DataType element_type,
+                            se::DeviceMemoryBase input_buffer,
+                            se::DeviceMemoryBase filter_buffer,
+                            se::DeviceMemoryBase output_buffer,
+                            const se::dnn::BatchDescriptor& input_desc,
+                            const se::dnn::FilterDescriptor& filter_desc,
+                            const se::dnn::BatchDescriptor& output_desc,
+                            const se::dnn::ConvolutionDescriptor& conv_desc,
+                            se::StreamExecutor* stream_exec,
+                            absl::Span<const AutotuneResult> results);
+
+// Logs fused convolution results to customized back-storage.
+void LogFusedConvForwardAutotuneResults(
+    se::dnn::DataType element_type, se::DeviceMemoryBase input_buffer,
+    se::DeviceMemoryBase filter_buffer, se::DeviceMemoryBase output_buffer,
+    se::DeviceMemoryBase bias_buffer, se::DeviceMemoryBase side_input_buffer,
+    const se::dnn::BatchDescriptor& input_desc,
+    const se::dnn::FilterDescriptor& filter_desc,
+    const se::dnn::BatchDescriptor& output_desc,
+    const se::dnn::ConvolutionDescriptor& conv_desc, double conv_scale,
+    double side_value_scale, se::dnn::ActivationMode activation_mode,
+    se::StreamExecutor* stream_exec, absl::Span<const AutotuneResult> results);
+
+// Logs fused matmul results to customized back-storage.
+void LogFusedMatmulAutotuneResults(
+    se::dnn::DataType ab_dtype, se::dnn::DataType c_dtype,
+    se::DeviceMemoryBase a_buffer, se::DeviceMemoryBase b_buffer,
+    se::DeviceMemoryBase c_buffer, se::DeviceMemoryBase bias_buffer,
+    bool trans_a, bool trans_b, uint32_t m, uint32_t n, uint32_t k, int32_t lda,
+    int32_t ldb, int32_t ldc, se::dnn::ActivationMode activation_mode,
+    se::StreamExecutor* stream_exec, absl::Span<const AutotuneResult> results);
+
+// Autotuning map entry for cuDNN-frontend-capable APIs.
+//
+// The longer-term intent is to remove the AlgorithmConfig variant and make this
+// contain only the two LazyOpRunners, but for the time being ROCm is stuck on
+// the legacy API and requires an AlgorithmConfig.
+template <typename Op>
+class AutotuneEntry {
+ public:
+  AutotuneEntry() : is_algorithm_config_(true) {}
+
+  // Initialize with legacy-API AlgorithmConfig; used for the ROCm backend only.
+  explicit AutotuneEntry(se::dnn::AlgorithmConfig config)
+      : is_algorithm_config_(true), algorithm_config_(std::move(config)) {}
+
+  AutotuneEntry(std::shared_ptr<se::dnn::LazyOpRunner<Op>> primary,
+                std::shared_ptr<se::dnn::LazyOpRunner<Op>> no_scratch_fallback)
+      : is_algorithm_config_(false),
+        op_runners_{std::move(primary), std::move(no_scratch_fallback)} {}
+
+  // Initialize from config data, without pre-cached runners, such as when
+  // loading AoT autotuning maps.
+  AutotuneEntry(se::dnn::AlgorithmDesc primary,
+                absl::optional<se::dnn::AlgorithmDesc> no_scratch_fallback)
+      : AutotuneEntry(std::make_shared<se::dnn::LazyOpRunner<Op>>(primary),
+                      no_scratch_fallback
+                          ? std::make_shared<se::dnn::LazyOpRunner<Op>>(
+                                *no_scratch_fallback)
+                          : nullptr) {}
+
+  // Initialize with pre-cached OpRunners, such as during autotuning.
+  static StatusOr<AutotuneEntry> FromOpRunners(
+      std::unique_ptr<const se::dnn::OpRunner<typename Op::Signature>> primary,
+      std::unique_ptr<const se::dnn::OpRunner<typename Op::Signature>>
+          no_cache_fallback) {
+    TF_ASSIGN_OR_RETURN(
+        auto primary_cache,
+        se::dnn::LazyOpRunner<Op>::FromOpRunner(std::move(primary)));
+
+    if (no_cache_fallback) {
+      TF_ASSIGN_OR_RETURN(auto fallback_cache,
+                          se::dnn::LazyOpRunner<Op>::FromOpRunner(
+                              std::move(no_cache_fallback)));
+      return AutotuneEntry(std::move(primary_cache), std::move(fallback_cache));
+
+    } else {
+      return AutotuneEntry(std::move(primary_cache), nullptr);
+    }
+  }
+
+  struct OpRunners {
+    OpRunners() = default;
+
+    OpRunners(std::shared_ptr<se::dnn::LazyOpRunner<Op>> primary_,
+              std::shared_ptr<se::dnn::LazyOpRunner<Op>> no_scratch_fallback_)
+        : primary(std::move(primary_)),
+          no_scratch_fallback(std::move(no_scratch_fallback_)) {}
+
+    // Null iff this 'OpRunners' is default-constructed as part of the
+    // fake-variant in AutotuneEntry; users outside gpu_utils.h itself should
+    // never see primary = nullptr.
+    std::shared_ptr<se::dnn::LazyOpRunner<Op>> primary;
+    std::shared_ptr<se::dnn::LazyOpRunner<Op>> no_scratch_fallback;  // Nullable
+
+    bool operator==(const OpRunners& other) const {
+      return *primary == *other.primary &&
+             ((!no_scratch_fallback && !other.no_scratch_fallback) ||
+              (no_scratch_fallback && other.no_scratch_fallback &&
+               *no_scratch_fallback == *other.no_scratch_fallback));
+    }
+  };
+
+  bool is_algorithm_config() const { return is_algorithm_config_; }
+
+  const se::dnn::AlgorithmConfig& GetAlgorithmConfig() const {
+    DCHECK(is_algorithm_config_);
+    return algorithm_config_;
+  }
+
+  const OpRunners& GetOpRunners() const {
+    DCHECK(!is_algorithm_config_);
+    return op_runners_;
+  }
+
+  // AutotuneMap needs to test equality to keep track of the number of times an
+  // algorithm has won autotuning; for this purpose, we can use ToString to
+  // determine whether runners are equal.
+  bool operator==(const AutotuneEntry<Op>& other) const {
+    if (is_algorithm_config_) {
+      return other.is_algorithm_config_ &&
+             algorithm_config_ == other.algorithm_config_;
+    }
+
+    return !other.is_algorithm_config_ && op_runners_ == other.op_runners_;
+  }
+
+  bool operator!=(const AutotuneEntry<Op>& other) const {
+    return !(*this == other);
+  }
+
+  std::string ToString() const {
+    if (is_algorithm_config_) {
+      return algorithm_config_.ToString();
+    }
+    return absl::StrCat("{", op_runners_.primary->ToString(), ", ",
+                        (op_runners_.no_scratch_fallback
+                             ? op_runners_.no_scratch_fallback->ToString()
+                             : "(op_runners have no fallback)"),
+                        "}");
+  }
+
+ private:
+  // NVCC is broken, so we can't use absl::variant here.  Just fake it with a
+  // bool and both fields.
+  bool is_algorithm_config_;
+  se::dnn::AlgorithmConfig algorithm_config_;
+  OpRunners op_runners_;
+};
+
+namespace internal {
+StatusOr<std::tuple<int, int>> BestCudnnConvAlgorithmIndices(
+    absl::Span<const AutotuneResult> results);
+}  // namespace internal
+
+// Returns the best algorithms for the config, one is the fastest, the other is
+// other is fastest with 0 scratch space. Unsuccessful autotuning results are
+// allowed and ignored.
+StatusOr<se::dnn::AlgorithmConfig> BestCudnnConvAlgorithm(
+    absl::Span<const AutotuneResult> results);
+
+// Explicitly-instantiated with ConvOp and FusedConvOp.
+//
+// The definition can't be in the header because including .pb.h files in
+// headers is forbidden.
+template <typename Op>
+StatusOr<AutotuneEntry<Op>> BestCudnnConvAlgorithm(
+    absl::Span<const AutotuneResult> results,
+    std::vector<
+        std::unique_ptr<const se::dnn::OpRunner<typename Op::Signature>>>
+        runners);
+
+// Get the Dnn workspace limit from the environment variable, which is in MB.
+// Return the workspace memory limit in bytes. If no value is set, return the
+// default value.
+int64_t GetDnnWorkspaceLimit(const string& envvar_in_mb,
+                             int64_t default_value_in_bytes);
+
+}  // namespace tensorflow
+
+#endif  // GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+
+#endif  // TENSORFLOW_CORE_KERNELS_GPU_UTILS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/hinge-loss.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/hinge-loss.h
new file mode 100644
index 0000000000000000000000000000000000000000..36576c7653cc6a51cd6a0e2d1a04bc4c464713a1
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/hinge-loss.h
@@ -0,0 +1,126 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_HINGE_LOSS_H_
+#define TENSORFLOW_CORE_KERNELS_HINGE_LOSS_H_
+
+#include <algorithm>
+#include <limits>
+
+#include "tensorflow/core/kernels/loss.h"
+#include "tensorflow/core/lib/core/errors.h"
+#include "tensorflow/core/lib/core/status.h"
+
+namespace tensorflow {
+
+class HingeLossUpdater : public DualLossUpdater {
+ public:
+  // Computes the updated dual variable (corresponding) to a single example. The
+  // updated dual value maximizes the objective function of the dual
+  // optimization problem associated with hinge loss (conditioned on keeping the
+  // rest of the dual variables intact). The method below finds an optimal delta
+  // (difference between updated and previous dual value) using the update rule
+  // within SDCA procedure (see http://arxiv.org/pdf/1209.1873v2.pdf, page 5)
+  // and the particular form of conjugate function for hinge loss.
+  //
+  // The CoCoA+ modification is detailed in readme.md.
+  //
+  // TODO(sibyl-vie3Poto): Write up a doc with concrete derivation and point to it from
+  // here.
+  double ComputeUpdatedDual(const int num_loss_partitions, const double label,
+                            const double example_weight,
+                            const double current_dual, const double wx,
+                            const double weighted_example_norm) const final {
+    // Intuitively there are 3 cases:
+    // a. new optimal value of the dual variable falls within the admissible
+    // range [0, 1]. In this case we set new dual to this value.
+    // b. new optimal value is < 0. Then, because of convexity, the optimal
+    // valid value for new dual = 0
+    // c. new optimal value > 1.0. Then new optimal value should be set to 1.0.
+    const double candidate_optimal_dual =
+        current_dual + (label - wx) / (num_loss_partitions * example_weight *
+                                       weighted_example_norm);
+    if (label * candidate_optimal_dual < 0) {
+      return 0.0;
+    }
+    if (label * candidate_optimal_dual > 1.0) {
+      return label;
+    }
+    return candidate_optimal_dual;
+  }
+
+  // Conjugate of hinge loss. This is computed as:
+  // \phi*(z) = z if z \in [-1, 0] and +infinity everywhere else. See for
+  // instance http://www.eecs.berkeley.edu/~wainwrig/stat241b/lec10.pdf
+  // Here we want the weighted version of the conjugate loss. It turns out, that
+  // if w is the weight of an example, the conjugate of the weighted hinge loss
+  // is given by:
+  // \phi*(z) = z if z \in [-w, 0] and +infinity everywhere else. Here the
+  // conjugate function depends not only on the weight of the example but also
+  // on its label. In particular:
+  // \phi_y*(z) = y*z if y*z \in [-w, 0] and +infinity everywhere else where
+  // y \in {-1,1}. The following method implements \phi_y*(-\alpha/w).
+  double ComputeDualLoss(const double current_dual, const double example_label,
+                         const double example_weight) const final {
+    // For binary classification, there are 2 conjugate functions, one per
+    // label value (-1 and 1).
+    const double y_alpha = current_dual * example_label;  // y \alpha
+    if (y_alpha < 0 || y_alpha > 1.0) {
+      return std::numeric_limits<double>::max();
+    }
+    return -y_alpha * example_weight;
+  }
+
+  // Hinge loss for binary classification for a single example. Hinge loss
+  // equals max(0, 1 - y * wx) (see https://en.wikipedia.org/wiki/Hinge_loss).
+  // For weighted instances loss should be multiplied by the instance weight.
+  double ComputePrimalLoss(const double wx, const double example_label,
+                           const double example_weight) const final {
+    const double y_wx = example_label * wx;
+    return std::max(0.0, 1 - y_wx) * example_weight;
+  }
+
+  double PrimalLossDerivative(const double wx, const double label,
+                              const double example_weight) const final {
+    if (label * wx < 1) {
+      return -label * example_weight;
+    }
+    return 0;
+  }
+
+  // The smoothness constant is 0 since the derivative of the loss is not
+  // Lipschitz
+  double SmoothnessConstant() const final { return 0; }
+
+  // Converts binary example labels from 0.0 or 1.0 to -1.0 or 1.0 respectively
+  // as expected by hinge loss.
+  Status ConvertLabel(float* const example_label) const final {
+    if (*example_label == 0.0) {
+      *example_label = -1;
+      return OkStatus();
+    }
+    if (*example_label == 1.0) {
+      return OkStatus();
+    }
+    return errors::InvalidArgument(
+        "Only labels of 0.0 or 1.0 are supported right now. "
+        "Found example with label: ",
+        *example_label);
+  }
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_HINGE_LOSS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/histogram_op.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/histogram_op.h
new file mode 100644
index 0000000000000000000000000000000000000000..5a368e6852c456269454d9f32be6323c95eadb27
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/histogram_op.h
@@ -0,0 +1,38 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_HISTOGRAM_OP_H_
+#define TENSORFLOW_CORE_KERNELS_HISTOGRAM_OP_H_
+
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/tensor_types.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/lib/core/errors.h"
+
+namespace tensorflow {
+namespace functor {
+
+template <typename Device, typename T, typename Tout>
+struct HistogramFixedWidthFunctor {
+  static Status Compute(OpKernelContext* context,
+                        const typename TTypes<T, 1>::ConstTensor& values,
+                        const typename TTypes<T, 1>::ConstTensor& value_range,
+                        int32_t nbins, typename TTypes<Tout, 1>::Tensor& out);
+};
+
+}  // end namespace functor
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_HISTOGRAM_OP_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/host_constant_op.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/host_constant_op.h
new file mode 100644
index 0000000000000000000000000000000000000000..9ba151ba71b3de62c448f51e502dc4582e8732b2
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/host_constant_op.h
@@ -0,0 +1,44 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_HOST_CONSTANT_OP_H_
+#define TENSORFLOW_CORE_KERNELS_HOST_CONSTANT_OP_H_
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/tensor_types.h"
+#include "tensorflow/core/platform/macros.h"
+
+namespace tensorflow {
+
+// HostConstantOp differs from ConstantOp in that its output is always
+// in host memory.
+class _HostConstantOp : public OpKernel {
+ public:
+  explicit _HostConstantOp(OpKernelConstruction* ctx);
+  void Compute(OpKernelContext* ctx) override;
+  bool IsExpensive() override { return false; }
+  const Tensor* const_tensor() const override { return &tensor_; };
+  ~_HostConstantOp() override {}
+
+ private:
+  Tensor tensor_;
+  _HostConstantOp(const _HostConstantOp&) = delete;
+  void operator=(const _HostConstantOp&) = delete;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_HOST_CONSTANT_OP_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/identity_n_op.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/identity_n_op.h
new file mode 100644
index 0000000000000000000000000000000000000000..7273731f11f63419100759aaab4cbc998c082b6e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/identity_n_op.h
@@ -0,0 +1,51 @@
+/* Copyright 2015-2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_IDENTITY_N_OP_H_
+#define TENSORFLOW_CORE_KERNELS_IDENTITY_N_OP_H_
+
+#include "tensorflow/core/framework/metrics.h"
+#include "tensorflow/core/framework/node_def_util.h"
+#include "tensorflow/core/framework/op_kernel.h"
+
+namespace tensorflow {
+
+class IdentityNOp : public OpKernel {
+ public:
+  explicit IdentityNOp(OpKernelConstruction* context) : OpKernel(context) {}
+
+  void Compute(OpKernelContext* context) override {
+    OpInputList input;
+    OpOutputList output;
+    OP_REQUIRES_OK(context, context->input_list("input", &input));
+    OP_REQUIRES_OK(context, context->output_list("output", &output));
+    OP_REQUIRES(context, input.size() == output.size(),
+                errors::InvalidArgument("Input and output counts must match"));
+    if (absl::StrContains(name(), kTpuExecuteStagingNodeName)) {
+      // TPU staging node execution is used for measuring launch latency.
+      metrics::UpdateTpuVariableDistributionTime(EnvTime::NowMicros() -
+                                                 context->start_time_usecs());
+    }
+    for (int i = 0; i < input.size(); ++i) {
+      output.set(i, input[i]);
+    }
+  }
+
+  bool IsExpensive() override { return false; }
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_IDENTITY_N_OP_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/identity_op.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/identity_op.h
new file mode 100644
index 0000000000000000000000000000000000000000..6b74868ad412ac7a2fbe6cc6d14d06d22d02f4e9
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/identity_op.h
@@ -0,0 +1,40 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_IDENTITY_OP_H_
+#define TENSORFLOW_CORE_KERNELS_IDENTITY_OP_H_
+
+#include "tensorflow/core/framework/op_kernel.h"
+
+namespace tensorflow {
+
+class IdentityOp : public OpKernel {
+ public:
+  explicit IdentityOp(OpKernelConstruction* context) : OpKernel(context) {}
+
+  void Compute(OpKernelContext* context) override {
+    if (IsRefType(context->input_dtype(0))) {
+      context->forward_ref_input_to_ref_output(0, 0);
+    } else {
+      context->set_output(0, context->input(0));
+    }
+  }
+
+  bool IsExpensive() override { return false; }
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_IDENTITY_OP_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/immutable_constant_op.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/immutable_constant_op.h
new file mode 100644
index 0000000000000000000000000000000000000000..264abc8401b3b4943dee75704f1195bb91bb588a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/immutable_constant_op.h
@@ -0,0 +1,50 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_KERNELS_IMMUTABLE_CONSTANT_OP_H_
+#define TENSORFLOW_CORE_KERNELS_IMMUTABLE_CONSTANT_OP_H_
+
+#include <memory>
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/tensor_types.h"
+#include "tensorflow/core/platform/env.h"
+#include "tensorflow/core/platform/macros.h"
+
+namespace tensorflow {
+
+class ImmutableConstantOp : public OpKernel {
+ public:
+  explicit ImmutableConstantOp(OpKernelConstruction* context);
+  void Compute(OpKernelContext* ctx) override;
+  bool IsExpensive() override { return false; }
+  ~ImmutableConstantOp() override;
+
+  // Names of attributes that are used by this op
+  static constexpr char const* kDTypeAttr = "dtype";
+  static constexpr char const* kShapeAttr = "shape";
+  static constexpr char const* kMemoryRegionNameAttr = "memory_region_name";
+
+ private:
+  string region_name_;
+  DataType dtype_;
+  TensorShape shape_;
+  ImmutableConstantOp(const ImmutableConstantOp&) = delete;
+  void operator=(const ImmutableConstantOp&) = delete;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_IMMUTABLE_CONSTANT_OP_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/in_topk_op.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/in_topk_op.h
new file mode 100644
index 0000000000000000000000000000000000000000..877777642ebeb6d177f04f5585a81c221112b28e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/in_topk_op.h
@@ -0,0 +1,100 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_IN_TOPK_OP_H_
+#define TENSORFLOW_CORE_KERNELS_IN_TOPK_OP_H_
+
+#if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+#define EIGEN_USE_GPU
+#endif  // GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/framework/bounds_check.h"
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/tensor_types.h"
+
+namespace tensorflow {
+namespace functor {
+
+typedef Eigen::ThreadPoolDevice CPUDevice;
+typedef Eigen::GpuDevice GPUDevice;
+
+// InTopK argument can be passed either via mode attribute (InTopK op), or as an
+// input tensor (InTopKV2 op).
+struct TopKArg {
+  int64_t k_value = -1;
+  const Tensor* k_tensor = nullptr;
+};
+
+template <typename Device, typename T, typename TargetT>
+struct InTopKFunctor {
+  template <int ndims>
+  using Dims = Eigen::DSizes<Eigen::Index, ndims>;
+
+  void operator()(OpKernelContext* context,
+                  typename TTypes<T, 2>::ConstTensor predictions,
+                  typename TTypes<TargetT>::ConstVec targets, const TopKArg k,
+                  typename TTypes<bool>::Vec output) {}
+};
+
+template <typename T, typename TargetT>
+struct InTopKFunctor<CPUDevice, T, TargetT> {
+  void operator()(OpKernelContext* context,
+                  typename TTypes<T, 2>::ConstTensor predictions,
+                  typename TTypes<TargetT>::ConstVec targets, const TopKArg k,
+                  typename TTypes<bool>::Vec output) {
+    const Eigen::Index num_targets = predictions.dimension(0);
+    const Eigen::Index num_classes = predictions.dimension(1);
+
+    int64_t k_val = k.k_value;
+    if (k.k_tensor != nullptr) {
+      if (k.k_tensor->dtype() == DT_INT32) {
+        k_val = k.k_tensor->scalar<int32>()();
+      } else {
+        k_val = k.k_tensor->scalar<int64_t>()();
+      }
+    }
+
+    for (int batch_idx = 0; batch_idx < num_targets; batch_idx++) {
+      auto target = internal::SubtleMustCopy(targets(batch_idx));
+
+      bool cannot_say = !FastBoundsCheck(target, num_classes) ||
+                        !std::isfinite(predictions(batch_idx, target));
+
+      int more_probable_classes = 0;
+      if (!cannot_say) {
+        const T target_prediction = predictions(batch_idx, target);
+
+        for (int class_idx = 0; class_idx < num_classes; ++class_idx) {
+          T pred = predictions(batch_idx, class_idx);
+          if (!std::isfinite(pred)) {
+            cannot_say = true;
+            break;
+          } else if (pred > target_prediction) {
+            ++more_probable_classes;
+            if (more_probable_classes > k_val) break;
+          }
+        }
+      }
+      output(batch_idx) = cannot_say ? false : (more_probable_classes < k_val);
+    }
+  }
+};
+
+}  // namespace functor
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_IN_TOPK_OP_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/initializable_lookup_table.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/initializable_lookup_table.h
new file mode 100644
index 0000000000000000000000000000000000000000..674352278ef568aa2bc4de808a648e00b8e1b66a
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/initializable_lookup_table.h
@@ -0,0 +1,270 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_INITIALIZABLE_LOOKUP_TABLE_H_
+#define TENSORFLOW_CORE_KERNELS_INITIALIZABLE_LOOKUP_TABLE_H_
+
+#include <atomic>
+
+#include "tensorflow/core/framework/lookup_interface.h"
+#include "tensorflow/core/platform/macros.h"
+
+namespace tensorflow {
+namespace lookup {
+
+// Base class for lookup tables that require initialization.
+class InitializableLookupTable : public LookupInterface {
+ public:
+  class InitTableIterator;
+  class InitializerSerializer;
+
+  // Performs batch lookups, for every element in the key tensor, Find returns
+  // the corresponding value into the values tensor.
+  // If an element is not present in the table, the given default value is used.
+  //
+  // For tables that require initialization, `Find` is available once the table
+  // is marked as initialized.
+  //
+  // Returns the following statuses:
+  // - OK: when the find finishes successfully.
+  // - FailedPrecondition: if the table is not initialized.
+  // - InvalidArgument: if any of the preconditions on the lookup key or value
+  //   fails.
+  // - In addition, other implementations may provide another non-OK status
+  //   specific to their failure modes.
+  Status Find(OpKernelContext* ctx, const Tensor& keys, Tensor* values,
+              const Tensor& default_value) final;
+
+  // Returns errors::Unimplemented.
+  Status Insert(OpKernelContext* ctx, const Tensor& keys,
+                const Tensor& values) final {
+    return errors::Unimplemented(
+        "Insert not supported by InitializableLookupTable implementations");
+  }
+
+  // Returns errors::Unimplemented.
+  Status Remove(OpKernelContext* ctx, const Tensor& keys) final {
+    return errors::Unimplemented(
+        "Remove not supported by InitializableLookupTable implementations");
+  }
+
+  Status ExportValues(OpKernelContext* context) override {
+    return errors::Unimplemented(
+        "ExportValues not supported by InitializableLookupTable "
+        "implementations");
+  }
+
+  Status ImportValues(OpKernelContext* ctx, const Tensor& keys,
+                      const Tensor& values) final;
+
+  TensorShape key_shape() const final { return TensorShape(); }
+
+  TensorShape value_shape() const final { return TensorShape(); }
+
+  // Returns whether the table was initialized and is ready to serve lookups.
+  bool is_initialized() const {
+    return is_initialized_.load(std::memory_order_acquire);
+  }
+
+  // Initializes the table from the given init table iterator.
+  //
+  // Atomically, this operation prepares the table, populates it with the given
+  // iterator, and marks the table as initialized.
+  //
+  // Returns the following statuses:
+  // - OK: when the initialization was successful.
+  // - InvalidArgument: if any of the preconditions on the lookup key or value
+  //   fails.
+  // - FailedPrecondition: if the table is already initialized and
+  //   fail_if_initialized is set to true.
+  // - In addition, other implementations may provide another non-OK status
+  //   specific to their failure modes.
+  Status Initialize(InitTableIterator& iter);
+
+  // Initializes the table from the given init table iterator. `serializer` may
+  // specify how to serialize the table initializer, so that the table can be
+  // serialized using its metadata (as opposed to serializing a handle to the
+  // table).
+  Status Initialize(InitTableIterator& iter,
+                    std::unique_ptr<InitializerSerializer> serializer);
+
+  // Basic iterator to initialize lookup tables.
+  // It yields a sequence of pairs of `keys()` and `values()` Tensors, so that
+  // the consumer may insert key-value pairs in batches.
+  //
+  // Then the iterator is exhausted, valid returns false and status returns
+  // Status::OutOfRange.
+  //
+  // This class is Thread-unsafe.
+  class InitTableIterator {
+   public:
+    InitTableIterator() {}
+
+    virtual ~InitTableIterator() {}
+
+    // Prepares the next batch of key and value tensors.
+    virtual void Next() = 0;
+
+    // Returns true if keys and values point to valid tensors.
+    virtual bool Valid() const = 0;
+
+    // Returns a tensor that contains the current batch of 'key' values.
+    virtual const Tensor& keys() const = 0;
+
+    // Returns a tensor that contains the current batch of 'value' values.
+    virtual const Tensor& values() const = 0;
+
+    // Returns an error if one has occurred, otherwise returns Status::OK.
+    virtual Status status() const = 0;
+
+    // Returns the total number of elements that the iterator will produce.
+    // It might return -1 in case of error.
+    virtual int64_t total_size() const = 0;
+
+   private:
+    InitTableIterator(const InitTableIterator&) = delete;
+    void operator=(const InitTableIterator&) = delete;
+  };
+
+  InitializableLookupTable* GetInitializableLookupTable() override {
+    return this;
+  }
+
+  // Logic specifying how to represent an initializer as a GraphDef, so that a
+  // lookup table can be serialized using its metadata (as opposed to
+  // serializing the content of the table, or a handle to the table).
+  class InitializerSerializer {
+   public:
+    // A function which builds a graph so that executing `*out` will initialize
+    // `table`.
+    using SerializeFn = std::function<Status(GraphDefBuilder* builder,
+                                             Node* table, Node** out)>;
+    // A function which performs any necessary cleanup for the serializer.
+    using CleanupFn = std::function<void()>;
+
+    // Wraps serialization logic that requires no cleanup.
+    explicit InitializerSerializer(SerializeFn serialize)
+        : serialize_(std::move(serialize)), cleanup_([] {}) {}
+
+    // Wraps serialization logic along with a cleanup function. `cleanup` will
+    // be run when the serializer is destroyed.
+    explicit InitializerSerializer(SerializeFn serialize, CleanupFn cleanup)
+        : serialize_(std::move(serialize)), cleanup_(std::move(cleanup)) {}
+
+    ~InitializerSerializer() { cleanup_(); }
+
+    // Builds a graph so that executing `*out` will initialize `table`.
+    Status AsGraphDef(GraphDefBuilder* builder, Node* table, Node** out) {
+      return serialize_(builder, table, out);
+    }
+
+   private:
+    SerializeFn serialize_;
+    CleanupFn cleanup_;
+  };
+
+ protected:
+  // Prepares and allocates the underlying data structure to store the given
+  // number of expected elements.
+  virtual Status DoPrepare(size_t expected_num_elements) = 0;
+
+  // Same as DoPrepare() but derived implementations might choose to skip
+  // calling get_expected_num_elements if size is not needed for DoPrepare.
+  virtual Status DoLazyPrepare(
+      std::function<int64_t(void)> get_expected_num_elements) {
+    int64_t expected_num_elements = get_expected_num_elements();
+    if (expected_num_elements < 0) {
+      return errors::FailedPrecondition("Got negative expected_num_elements.");
+    }
+    return DoPrepare(expected_num_elements);
+  }
+
+  // Populates the table in batches given keys and values as tensors into the
+  // underlying data structure.
+  virtual Status DoInsert(const Tensor& keys, const Tensor& values) = 0;
+
+  // Performs the batch find operation on the underlying data structure.
+  virtual Status DoFind(const Tensor& keys, Tensor* values,
+                        const Tensor& default_value) = 0;
+
+  virtual Status AreEntriesSame(const InitTableIterator& iter, bool* result);
+
+  mutex mu_;
+
+ protected:
+  // When set, provides a mechanism for serializing the table initializer as
+  // GraphDef.
+  std::unique_ptr<InitializerSerializer> initializer_serializer_;
+
+ private:
+  std::atomic<bool> is_initialized_{false};
+};
+
+// Iterator to initialize tables given 'keys' and 'values' tensors.
+//
+// The two tensors are returned in the first iteration. It doesn't loop
+// over each element of the tensor since insertions in the lookup table can
+// process batches.
+class KeyValueTensorIterator
+    : public InitializableLookupTable::InitTableIterator {
+ public:
+  // keys and values are not owned by the iterator.
+  explicit KeyValueTensorIterator(const Tensor* keys, const Tensor* values)
+      : keys_(keys), values_(values), valid_(true), status_(OkStatus()) {
+    TensorShape key_shape = keys_->shape();
+    if (!key_shape.IsSameSize(values_->shape())) {
+      valid_ = false;
+      status_ = errors::InvalidArgument(
+          "keys and values should have the same dimension.",
+          key_shape.DebugString(), " vs ", values_->shape().DebugString());
+    }
+    if (key_shape.num_elements() == 0) {
+      valid_ = false;
+      status_ =
+          errors::InvalidArgument("keys and values cannot be empty tensors.");
+    }
+  }
+
+  bool Valid() const override { return valid_; }
+
+  void Next() override {
+    valid_ = false;
+    status_ = errors::OutOfRange("No more data.");
+  }
+
+  const Tensor& keys() const override { return *keys_; }
+
+  const Tensor& values() const override { return *values_; }
+
+  Status status() const override { return status_; }
+
+  int64_t total_size() const override {
+    return keys_ == nullptr ? -1 : keys_->NumElements();
+  }
+
+ private:
+  KeyValueTensorIterator(const KeyValueTensorIterator&) = delete;
+  void operator=(const KeyValueTensorIterator&) = delete;
+
+  const Tensor* keys_;    // Doesn't own it.
+  const Tensor* values_;  // Doesn't own it.
+  bool valid_;            // true if the iterator points to an existing range.
+  Status status_;
+};
+
+}  // namespace lookup
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_INITIALIZABLE_LOOKUP_TABLE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/inplace_ops_functor.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/inplace_ops_functor.h
new file mode 100644
index 0000000000000000000000000000000000000000..f591fc4f032e944cdbe2e2f1cdc37e435bf22dad
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/inplace_ops_functor.h
@@ -0,0 +1,49 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_INPLACE_OPS_FUNCTOR_H_
+#define TENSORFLOW_CORE_KERNELS_INPLACE_OPS_FUNCTOR_H_
+
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/lib/core/status.h"
+
+namespace tensorflow {
+namespace functor {
+
+template <typename Device>
+Status DoParallelConcat(const Device& device, const Tensor& value, int32_t loc,
+                        Tensor* output);
+
+// Inplace update/add/sub values in 'y'. It computes
+//   y[i, :] = v if op is I_UPDATE
+//   y[i, :] += v if op is I_ADD
+//   y[i, :] -= v if op is I_SUB
+// Returns an error if the operation fails.
+enum InplaceOpType {
+  I_UPDATE,  // x = y
+  I_ADD,     // x += y
+  I_SUB,     // x -= y
+};
+template <typename Device>
+Status DoInplace(const Device& device, InplaceOpType op, const Tensor& i,
+                 const Tensor& v, Tensor* y);
+// Copies x into y.
+template <typename Device>
+Status DoCopy(const Device& device, const Tensor& x, Tensor* y);
+
+}  // end namespace functor
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_INPLACE_OPS_FUNCTOR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/kernel_platform_strings.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/kernel_platform_strings.h
new file mode 100644
index 0000000000000000000000000000000000000000..9bf40c30a56577ebe21d4a4ba9bf371e30803f79
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/kernel_platform_strings.h
@@ -0,0 +1,25 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// Generate platform strings for libtfkernel-*
+
+#ifndef TENSORFLOW_CORE_KERNELS_KERNEL_PLATFORM_STRINGS_H_
+#define TENSORFLOW_CORE_KERNELS_KERNEL_PLATFORM_STRINGS_H_
+
+#include "tensorflow/core/platform/platform_strings.h"
+
+TF_PLATFORM_STRINGS()
+
+#endif  // TENSORFLOW_CORE_KERNELS_KERNEL_PLATFORM_STRINGS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/l2loss_op.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/l2loss_op.h
new file mode 100644
index 0000000000000000000000000000000000000000..2adaacbb7767cb8c930d5c78d66f8e810fc9ddef
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/l2loss_op.h
@@ -0,0 +1,33 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_L2LOSS_OP_H_
+#define TENSORFLOW_CORE_KERNELS_L2LOSS_OP_H_
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/tensor_types.h"
+
+namespace tensorflow {
+
+template <typename Device, typename T>
+struct L2LossOp : public OpKernel {
+  explicit L2LossOp(OpKernelConstruction* context) : OpKernel(context) {}
+
+  void Compute(OpKernelContext* context) {}
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_L2LOSS_OP_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/linalg_ops_common.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/linalg_ops_common.h
new file mode 100644
index 0000000000000000000000000000000000000000..0aa69801f19740cb3d65ff6d3744b9b1e3fb4b3c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/linalg_ops_common.h
@@ -0,0 +1,21 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_KERNELS_LINALG_OPS_COMMON_H_
+#define TENSORFLOW_CORE_KERNELS_LINALG_OPS_COMMON_H_
+
+// Temporary forwarding header.
+#include "tensorflow/core/kernels/linalg/linalg_ops_common.h"
+
+#endif  // TENSORFLOW_CORE_KERNELS_LINALG_OPS_COMMON_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/list_kernels.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/list_kernels.h
new file mode 100644
index 0000000000000000000000000000000000000000..41f475799fc9b92464abd9f4c1b321cbb972931c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/list_kernels.h
@@ -0,0 +1,1134 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_KERNELS_LIST_KERNELS_H_
+#define TENSORFLOW_CORE_KERNELS_LIST_KERNELS_H_
+
+#define EIGEN_USE_THREADS
+#if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+#define EIGEN_USE_GPU
+#endif  // GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/register_types.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/tensor_types.h"
+#include "tensorflow/core/framework/variant.h"
+#include "tensorflow/core/framework/variant_op_registry.h"
+#include "tensorflow/core/kernels/concat_lib.h"
+#include "tensorflow/core/kernels/fill_functor.h"
+#include "tensorflow/core/kernels/tensor_list.h"
+#include "tensorflow/core/kernels/tensor_list_util.h"
+#include "tensorflow/core/lib/core/coding.h"
+#include "tensorflow/core/lib/core/errors.h"
+#include "tensorflow/core/lib/core/refcount.h"
+#include "tensorflow/core/lib/gtl/array_slice.h"
+#include "tensorflow/core/platform/platform.h"
+#include "tensorflow/core/util/tensor_ops_util.h"
+#include "tensorflow/core/util/util.h"
+
+// stream.h isn't available in some platforms such as Android, iOS, ChromiumOS,
+// and Fuchsia. Only include it for platforms that PluggableDevice is tested on.
+#if !defined(PLUGGABLE_DEVICE_SUPPORTED) &&                              \
+    (__x86_64__ || __i386__ || defined(__APPLE__) || defined(_WIN32)) && \
+    !defined(ANDROID) && !defined(__ANDROID__) && !TARGET_OS_IOS &&      \
+    !defined(PLATFORM_CHROMIUMOS) && !defined(__Fuchsia__)
+#define PLUGGABLE_DEVICE_SUPPORTED
+#endif
+
+#ifdef PLUGGABLE_DEVICE_SUPPORTED
+#include "xla/stream_executor/stream.h"
+#endif
+
+namespace tensorflow {
+
+typedef Eigen::ThreadPoolDevice CPUDevice;
+
+Status TensorShapeFromTensor(const Tensor& t, PartialTensorShape* out);
+
+Status GetElementShapeFromInput(OpKernelContext* c,
+                                const TensorList& tensor_list, int index,
+                                PartialTensorShape* element_shape);
+
+Status GetInputList(OpKernelContext* c, int index, const TensorList** list);
+
+Status ForwardInputOrCreateNewList(OpKernelContext* c, int32_t input_index,
+                                   int32_t output_index,
+                                   const TensorList& input_list,
+                                   TensorList** output_list);
+
+// TODO(penporn): Move this to a proper place.
+inline bool IsPluggableDevice(OpKernelContext* c) {
+  return c->op_device_context() && c->op_device_context()->IsPluggableDevice();
+}
+
+template <typename Device, typename T>
+inline void SetZero(OpKernelContext* ctx, Tensor& tensor) {
+#ifdef PLUGGABLE_DEVICE_SUPPORTED
+  if (IsPluggableDevice(ctx)) {
+    auto ptr =
+        se::DeviceMemoryBase(tensor.flat<T>().data(), tensor.TotalBytes());
+    auto stream = ctx->op_device_context()->stream();
+    auto result = stream->ThenMemZero(&ptr, tensor.TotalBytes()).ok();
+    DCHECK_EQ(true, result);
+  } else {
+#endif  // PLUGGABLE_DEVICE_SUPPORTED
+    functor::SetZeroFunctor<Device, T>()(ctx->eigen_device<Device>(),
+                                         tensor.flat<T>());
+#ifdef PLUGGABLE_DEVICE_SUPPORTED
+  }
+#endif  // PLUGGABLE_DEVICE_SUPPORTED
+}
+
+template <typename T>
+inline void CopyTensorPluggableDevice(OpKernelContext* ctx, Tensor& src,
+                                      Tensor& dst) {
+#ifdef PLUGGABLE_DEVICE_SUPPORTED
+  auto src_t = src.unaligned_flat<T>();
+  auto dst_t = dst.flat<T>();
+  DCHECK(DataTypeCanUseMemcpy(DataTypeToEnum<T>::v()));
+  auto src_ptr = se::DeviceMemoryBase(src_t.data(), src.TotalBytes());
+  auto dst_ptr = se::DeviceMemoryBase(dst_t.data(), dst.TotalBytes());
+  auto stream = ctx->op_device_context()->stream();
+  auto result = stream->ThenMemcpy(&dst_ptr, src_ptr, src.TotalBytes()).ok();
+  DCHECK_EQ(true, result);
+#else
+  LOG(FATAL)  // Crash OK.
+      << "PluggableDevice is not supported on this platform.";
+#endif  // PLUGGABLE_DEVICE_SUPPORTED
+}
+
+template <typename Device, typename T>
+inline void CopyTensor(OpKernelContext* ctx, Tensor& src, Tensor& dst) {
+  auto src_t = src.unaligned_flat<T>();
+  auto dst_t = dst.flat<T>();
+  dst_t.device(ctx->eigen_device<Device>()) = src_t;
+}
+
+template <typename T>
+void ConcatPluggableDevice(
+    OpKernelContext* context,
+    const std::vector<std::unique_ptr<typename TTypes<T, 2>::ConstMatrix>>&
+        inputs,
+    typename TTypes<T, 2>::Matrix* output) {
+#ifdef PLUGGABLE_DEVICE_SUPPORTED
+  DCHECK(DataTypeCanUseMemcpy(DataTypeToEnum<T>::v()));
+
+  se::Stream* stream = context->op_device_context()->stream();
+
+  size_t num_inputs = inputs.size();
+  std::vector<ptrdiff_t> sizes;
+  sizes.reserve(num_inputs);
+  int64 row_size = 0;
+  for (const auto& input : inputs) {
+    sizes.push_back(input->dimension(1));
+    row_size += sizes.back();
+  }
+
+  T* out = &(*output)(0, 0);
+  std::vector<const T*> inp;
+  inp.reserve(num_inputs);
+  for (const auto& input : inputs) {
+    inp.push_back(&(*input)(0, 0));
+  }
+  const int64 dim0 = output->dimension(0);
+  for (int64 i = 0; i < dim0; ++i) {
+    for (int64 j = 0; j < num_inputs; ++j) {
+      auto size = sizes[j];
+      se::DeviceMemoryBase out_base{out, size * sizeof(T)};
+      se::DeviceMemoryBase inp_base{const_cast<T*>(inp[j]), size * sizeof(T)};
+      stream->ThenMemcpy(&out_base, inp_base, size * sizeof(T));
+      out += size;
+      inp[j] += size;
+    }
+  }
+#else
+  LOG(FATAL)  // Crash OK.
+      << "PluggableDevice is not supported on this platform.";
+#endif  // PLUGGABLE_DEVICE_SUPPORTED
+}
+
+template <typename Device, typename T>
+class TensorListStack : public OpKernel {
+ public:
+  typedef std::vector<std::unique_ptr<typename TTypes<T, 2>::ConstMatrix>>
+      ConstMatrixVector;
+  explicit TensorListStack(OpKernelConstruction* c) : OpKernel(c) {
+    OP_REQUIRES_OK(c, c->GetAttr("element_dtype", &element_dtype_));
+    OP_REQUIRES_OK(c, c->GetAttr("num_elements", &num_elements_));
+  }
+
+  void Compute(OpKernelContext* c) override {
+    const TensorList* tensor_list = nullptr;
+    OP_REQUIRES_OK(c, GetInputList(c, 0, &tensor_list));
+    OP_REQUIRES(
+        c, element_dtype_ == tensor_list->element_dtype,
+        errors::InvalidArgument(
+            "Invalid data types; op elements ", DataTypeString(element_dtype_),
+            " but list elements ", DataTypeString(tensor_list->element_dtype)));
+    if (num_elements_ != -1) {
+      OP_REQUIRES(c, tensor_list->tensors().size() == num_elements_,
+                  errors::InvalidArgument(
+                      "Operation expected a list with ", num_elements_,
+                      " elements but got a list with ",
+                      tensor_list->tensors().size(), " elements."));
+    }
+    PartialTensorShape partial_element_shape;
+    OP_REQUIRES_OK(c, GetElementShapeFromInput(c, *tensor_list, 1,
+                                               &partial_element_shape));
+    OP_REQUIRES(
+        c,
+        partial_element_shape.IsFullyDefined() ||
+            !tensor_list->tensors().empty(),
+        errors::InvalidArgument("Tried to stack elements of an empty ",
+                                "list with non-fully-defined element_shape: ",
+                                partial_element_shape.DebugString()));
+
+    // Check that `element_shape` input tensor is compatible with the shapes of
+    // element tensors.
+    if (!tensor_list->element_shape.IsFullyDefined()) {
+      for (int i = 0; i < tensor_list->tensors().size(); ++i) {
+        const Tensor& t = tensor_list->tensors()[i];
+        if (t.dtype() != DT_INVALID) {
+          PartialTensorShape tmp = partial_element_shape;
+          OP_REQUIRES_OK(c, tmp.MergeWith(t.shape(), &partial_element_shape));
+        }
+      }
+    }
+
+    // Compute the shape of the output tensor by pre-pending the leading dim to
+    // the element_shape.
+    TensorShape element_shape;
+    OP_REQUIRES(c, partial_element_shape.AsTensorShape(&element_shape),
+                errors::InvalidArgument(
+                    "Tried to stack list which only contains uninitialized ",
+                    "tensors and has a non-fully-defined element_shape: ",
+                    partial_element_shape.DebugString()));
+    TensorShape output_shape = element_shape;
+    output_shape.InsertDim(0, tensor_list->tensors().size());
+    Tensor* output;
+    OP_REQUIRES_OK(c, c->allocate_output(0, output_shape, &output));
+    if (output->NumElements() == 0) {
+      return;
+    }
+
+    ConstMatrixVector inputs_flat;
+    inputs_flat.reserve(tensor_list->tensors().size());
+    Tensor zeros;
+    for (const auto& t : tensor_list->tensors()) {
+      if (t.dtype() != DT_INVALID) {
+        inputs_flat.emplace_back(new typename TTypes<T, 2>::ConstMatrix(
+            t.shaped<T, 2>({1, t.NumElements()})));
+      } else {
+        if (!zeros.NumElements()) {
+          AllocatorAttributes attr;
+          if (element_dtype_ == DT_VARIANT) {
+            attr.set_on_host(true);
+          }
+          OP_REQUIRES_OK(
+              c, c->allocate_temp(element_dtype_, element_shape, &zeros, attr));
+          SetZero<Device, T>(c, zeros);
+        }
+        inputs_flat.emplace_back(new typename TTypes<T, 2>::ConstMatrix(
+            const_cast<const Tensor&>(zeros).shaped<T, 2>(
+                {1, zeros.NumElements()})));
+      }
+    }
+    auto output_flat = output->shaped<T, 2>({1, output->NumElements()});
+
+#if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+    if (std::is_same<Device, Eigen::GpuDevice>::value) {
+      ConcatGPU<T>(c, inputs_flat, output, &output_flat);
+      return;
+    }
+#endif  // GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+    if (IsPluggableDevice(c)) {
+      ConcatPluggableDevice<T>(c, inputs_flat, &output_flat);
+    } else {
+      ConcatCPU<T>(c->device(), inputs_flat, &output_flat);
+    }
+  }
+
+ private:
+  int num_elements_;
+  DataType element_dtype_;
+};
+
+template <typename Device, typename T>
+class TensorListGetItem : public OpKernel {
+ public:
+  explicit TensorListGetItem(OpKernelConstruction* c) : OpKernel(c) {
+    OP_REQUIRES_OK(c, c->GetAttr("element_dtype", &element_dtype_));
+  }
+
+  void Compute(OpKernelContext* c) override {
+    const TensorList* l = nullptr;
+    OP_REQUIRES_OK(c, GetInputList(c, 0, &l));
+    OP_REQUIRES(c, element_dtype_ == l->element_dtype,
+                errors::InvalidArgument("Invalid data types; op elements ",
+                                        DataTypeString(element_dtype_),
+                                        " but list elements ",
+                                        DataTypeString(l->element_dtype)));
+    int32_t index = c->input(1).scalar<int32>()();
+    OP_REQUIRES(c, index < l->tensors().size(),
+                errors::InvalidArgument("Trying to access element ", index,
+                                        " in a list with ", l->tensors().size(),
+                                        " elements."));
+    if (l->tensors()[index].dtype() != DT_INVALID) {
+      c->set_output(0, l->tensors()[index]);
+    } else {
+      PartialTensorShape partial_element_shape;
+      OP_REQUIRES_OK(
+          c, GetElementShapeFromInput(c, *l, 2, &partial_element_shape));
+      TensorShape element_shape;
+      // If l->element_shape and the element_shape input are both not fully
+      // defined, try to infer the shape from other list elements. This requires
+      // that all initialized list elements have the same shape.
+      // NOTE(srbs): This might be a performance bottleneck since we are
+      // iterating over the entire list here. This is necessary for feature
+      // parity with TensorArray.read. TensorArray has a mode in which all
+      // elements are required to be of the same shape, TensorList does not.
+      // In that mode TensorArray sets the array's element_shape on the first
+      // write call. We could do something similar here if needed.
+      if (!partial_element_shape.IsFullyDefined()) {
+        for (const Tensor& t : l->tensors()) {
+          if (t.dtype() != DT_INVALID) {
+            PartialTensorShape tmp = partial_element_shape;
+            OP_REQUIRES_OK(c, tmp.MergeWith(t.shape(), &partial_element_shape));
+          }
+        }
+      }
+      OP_REQUIRES(
+          c, partial_element_shape.AsTensorShape(&element_shape),
+          errors::InvalidArgument("Trying to read an uninitialized tensor but ",
+                                  "element_shape is not fully defined: ",
+                                  partial_element_shape.DebugString(),
+                                  " and no list element is set."));
+      Tensor* result;
+      AllocatorAttributes attr;
+      if (element_dtype_ == DT_VARIANT) {
+        attr.set_on_host(true);
+      }
+      OP_REQUIRES_OK(c, c->allocate_output(0, element_shape, &result, attr));
+      SetZero<Device, T>(c, *result);
+    }
+  }
+
+ private:
+  DataType element_dtype_;
+};
+
+template <typename Device, typename T>
+class TensorListPopBack : public OpKernel {
+ public:
+  explicit TensorListPopBack(OpKernelConstruction* c) : OpKernel(c) {
+    OP_REQUIRES_OK(c, c->GetAttr("element_dtype", &element_dtype_));
+  }
+
+  void Compute(OpKernelContext* c) override {
+    const TensorList* l = nullptr;
+    OP_REQUIRES_OK(c, GetInputList(c, 0, &l));
+    OP_REQUIRES(c, element_dtype_ == l->element_dtype,
+                errors::InvalidArgument("Invalid data types; op elements ",
+                                        DataTypeString(element_dtype_),
+                                        " but list elements ",
+                                        DataTypeString(l->element_dtype)));
+
+    OP_REQUIRES(c, !l->tensors().empty(),
+                errors::InvalidArgument("Trying to pop from an empty list."));
+
+    const Tensor& t = l->tensors().back();
+    if (t.dtype() != DT_INVALID) {
+      c->set_output(1, t);
+    } else {
+      PartialTensorShape partial_element_shape;
+      OP_REQUIRES_OK(
+          c, GetElementShapeFromInput(c, *l, 1, &partial_element_shape));
+      TensorShape element_shape;
+      OP_REQUIRES(
+          c, partial_element_shape.AsTensorShape(&element_shape),
+          errors::InvalidArgument("Trying to read an uninitialized tensor but ",
+                                  "element_shape is not fully defined.",
+                                  partial_element_shape.DebugString()));
+      Tensor* result;
+      AllocatorAttributes attr;
+      if (element_dtype_ == DT_VARIANT) {
+        attr.set_on_host(true);
+      }
+      OP_REQUIRES_OK(c, c->allocate_output(1, element_shape, &result, attr));
+      SetZero<Device, T>(c, *result);
+    }
+
+    TensorList* output_list = nullptr;
+    OP_REQUIRES_OK(c, ForwardInputOrCreateNewList(c, 0, 0, *l, &output_list));
+    output_list->tensors().pop_back();
+  }
+
+ private:
+  DataType element_dtype_;
+};
+
+template <typename Device, typename T>
+class TensorListConcat : public OpKernel {
+ public:
+  using ConstMatrixVector =
+      std::vector<std::unique_ptr<typename TTypes<T, 2>::ConstMatrix>>;
+  explicit TensorListConcat(OpKernelConstruction* c) : OpKernel(c) {
+    OP_REQUIRES_OK(c, c->GetAttr("element_dtype", &element_dtype_));
+    if (c->HasAttr("element_shape")) {
+      OP_REQUIRES_OK(c, c->GetAttr("element_shape", &element_shape_));
+    }
+  }
+
+  void Compute(OpKernelContext* c) override {
+    PartialTensorShape element_shape_except_first_dim;
+    if (!element_shape_.unknown_rank()) {
+      auto dim_sizes = element_shape_.dim_sizes();
+      OP_REQUIRES(c, !dim_sizes.empty(),
+                  errors::InvalidArgument("element_shape must not be empty"));
+      element_shape_except_first_dim =
+          PartialTensorShape(gtl::ArraySlice<int64_t>(dim_sizes).subspan(1));
+    }
+    // Check that the input Variant tensor is indeed a TensorList and has the
+    // correct element type.
+    const TensorList* tensor_list = nullptr;
+    OP_REQUIRES_OK(c, GetInputList(c, 0, &tensor_list));
+    OP_REQUIRES(
+        c, element_dtype_ == tensor_list->element_dtype,
+        errors::InvalidArgument(
+            "Invalid data types; op elements ", DataTypeString(element_dtype_),
+            " but list elements ", DataTypeString(tensor_list->element_dtype)));
+    // The leading dimension of all list elements if they are all the same.
+    // This is used as the leading dim of uninitialized tensors in the list
+    // if leading_dims is not provided.
+    int64_t first_dim = -1;
+    if (c->num_inputs() > 1) {
+      // TensorListConcatV2
+      PartialTensorShape element_shape;
+      OP_REQUIRES_OK(
+          c, GetElementShapeFromInput(c, *tensor_list, 1, &element_shape));
+      OP_REQUIRES(c, element_shape.unknown_rank() || element_shape.dims() >= 1,
+                  errors::InvalidArgument(
+                      "Concat requires elements to be at least vectors, ",
+                      "found scalars instead."));
+      // Split `element_shape` into `first_dim` and
+      // `element_shape_except_first_dim`.
+      first_dim = element_shape.dim_size(0);
+      element_shape_except_first_dim = element_shape;
+      element_shape_except_first_dim.RemoveDim(0);
+    }
+    // If the TensorList is empty, element_shape_except_first_dim must be fully
+    // defined.
+    OP_REQUIRES(c,
+                !tensor_list->tensors().empty() ||
+                    element_shape_except_first_dim.IsFullyDefined(),
+                errors::InvalidArgument(
+                    "All except the first dimension must be fully defined ",
+                    "when concating an empty tensor list. element_shape: ",
+                    element_shape_except_first_dim.DebugString()));
+    // 1. Check that `element_shape_except_first_dim` input tensor is
+    //    compatible with the shapes of element tensors.
+    // 2. Check that the elements have the same shape except the first dim.
+    // 3. If `first_dim` is known, check that it is compatible with the leading
+    //    dims of all elements.
+    // 4. If `first_dim` is unknown (-1), check whether all initialized
+    //    elements have the same leading dim and if so set `first_dim` to that
+    //    value.
+    if (!tensor_list->element_shape.IsFullyDefined()) {
+      bool check_dim = (first_dim == -1);
+      int64_t inferred_first_dim = first_dim;
+      for (int i = 0; i < tensor_list->tensors().size(); ++i) {
+        const Tensor& t = tensor_list->tensors()[i];
+        if (t.dtype() != DT_INVALID) {
+          PartialTensorShape tmp = element_shape_except_first_dim;
+          OP_REQUIRES(
+              c, TensorShapeUtils::IsVectorOrHigher(t.shape()),
+              errors::InvalidArgument("Concat saw a scalar shape at index ", i,
+                                      " but requires at least vectors."));
+          TensorShape shape_except_first_dim = TensorShape(
+              gtl::ArraySlice<int64_t>(t.shape().dim_sizes()).subspan(1));
+          OP_REQUIRES_OK(c, tmp.MergeWith(shape_except_first_dim,
+                                          &element_shape_except_first_dim));
+          OP_REQUIRES(c, first_dim == -1 || first_dim == t.shape().dim_size(0),
+                      errors::InvalidArgument(
+                          "First entry of element_shape input does not match ",
+                          "the first dim of list element at index: ", i,
+                          " Expected: ", first_dim,
+                          " Actual: ", t.shape().dim_size(0)));
+          if (check_dim) {
+            if (inferred_first_dim == -1) {
+              inferred_first_dim = t.shape().dim_size(0);
+            } else if (inferred_first_dim != t.shape().dim_size(0)) {
+              inferred_first_dim = -1;
+              check_dim = false;
+            }
+          }
+        }
+      }
+      first_dim = inferred_first_dim;
+    }
+    TensorShape output_shape;
+    OP_REQUIRES(c, element_shape_except_first_dim.AsTensorShape(&output_shape),
+                errors::InvalidArgument(
+                    "Trying to concat list with only uninitialized tensors ",
+                    "but element_shape_except_first_dim is not fully defined: ",
+                    element_shape_except_first_dim.DebugString()));
+    // Build the lengths_tensor and leading dim of the output tensor by
+    // iterating over all element tensors.
+    Tensor* lengths_tensor = nullptr;
+    OP_REQUIRES_OK(c, c->allocate_output(1,
+                                         TensorShape({static_cast<int64_t>(
+                                             tensor_list->tensors().size())}),
+                                         &lengths_tensor));
+    auto lengths_tensor_vec = lengths_tensor->vec<int64_t>();
+    int64_t leading_dim = 0;
+    for (size_t i = 0; i < tensor_list->tensors().size(); i++) {
+      int64_t dim;
+      if (tensor_list->tensors()[i].dtype() != DT_INVALID) {
+        dim = tensor_list->tensors()[i].shape().dim_size(0);
+      } else {
+        // If leading_dims is not provided or does not contain an entry for
+        // index i use the inferred `first_dim` if set.
+        if ((c->num_inputs() <= 2 || i >= c->input(2).NumElements()) &&
+            first_dim != -1) {
+          dim = first_dim;
+        } else {
+          OP_REQUIRES(c, c->num_inputs() > 2,
+                      errors::InvalidArgument(
+                          "Concating lists with uninitialized tensors is not ",
+                          "supported in this version of TensorListConcat. ",
+                          "Consider updating your GraphDef to run the newer ",
+                          "version."));
+          OP_REQUIRES(c, i < c->input(2).NumElements(),
+                      errors::InvalidArgument(
+                          "List contains uninitialized tensor at index ", i,
+                          " but leading_dims has only ",
+                          c->input(2).NumElements(), " elements."));
+          dim = c->input(2).vec<int64_t>()(i);
+        }
+      }
+      leading_dim += dim;
+      lengths_tensor_vec(i) = dim;
+    }
+    output_shape.InsertDim(0, leading_dim);
+    Tensor* output;
+    // Allocate the output tensor and fill it up with the concated element
+    // tensors.
+    OP_REQUIRES_OK(c, c->allocate_output(0, output_shape, &output));
+    if (output->NumElements() == 0) {
+      return;
+    }
+
+    ConstMatrixVector inputs_flat;
+    inputs_flat.reserve(tensor_list->tensors().size());
+    // Store the zeros tensors in a vector to prevent them from being GC'ed till
+    // concat is complete.
+    std::vector<Tensor> zeros_vec;
+    for (int i = 0; i < tensor_list->tensors().size(); i++) {
+      const Tensor& element_tensor = tensor_list->tensors()[i];
+      if (element_tensor.dtype() != DT_INVALID) {
+        if (element_tensor.NumElements() > 0) {
+          inputs_flat.emplace_back(new typename TTypes<T, 2>::ConstMatrix(
+              element_tensor.shaped<T, 2>({1, element_tensor.NumElements()})));
+        }
+      } else {
+        AllocatorAttributes attr;
+        if (element_dtype_ == DT_VARIANT) {
+          attr.set_on_host(true);
+        }
+        TensorShape element_shape = output_shape;
+        element_shape.set_dim(0, lengths_tensor_vec(i));
+        zeros_vec.emplace_back();
+        Tensor& zeros = zeros_vec.back();
+        OP_REQUIRES_OK(
+            c, c->allocate_temp(element_dtype_, element_shape, &zeros, attr));
+        SetZero<Device, T>(c, zeros);
+        inputs_flat.emplace_back(new typename TTypes<T, 2>::ConstMatrix(
+            const_cast<const Tensor&>(zeros).shaped<T, 2>(
+                {1, zeros.NumElements()})));
+      }
+    }
+    auto output_flat = output->shaped<T, 2>({1, output->NumElements()});
+
+#if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+    if (std::is_same<Device, Eigen::GpuDevice>::value) {
+      ConcatGPU<T>(c, inputs_flat, output, &output_flat);
+      return;
+    }
+#endif  // GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+    if (IsPluggableDevice(c)) {
+      ConcatPluggableDevice<T>(c, inputs_flat, &output_flat);
+    } else {
+      ConcatCPU<T>(c->device(), inputs_flat, &output_flat);
+    }
+  }
+
+ private:
+  DataType element_dtype_;
+  PartialTensorShape element_shape_;
+};
+
+template <typename Device, typename T>
+class TensorListSplit : public OpKernel {
+ public:
+  TensorListSplit(OpKernelConstruction* c) : OpKernel(c) {}
+
+  void Compute(OpKernelContext* c) override {
+    Tensor* output_tensor;
+    AllocatorAttributes attr;
+    attr.set_on_host(true);
+    OP_REQUIRES_OK(c, c->allocate_output(0, {}, &output_tensor, attr));
+    PartialTensorShape element_shape;
+    OP_REQUIRES_OK(c, TensorShapeFromTensor(c->input(1), &element_shape));
+    OP_REQUIRES(c, element_shape.unknown_rank() || element_shape.dims() >= 1,
+                errors::InvalidArgument(
+                    "TensorListSplit requires element_shape to be at least of ",
+                    "rank 1, but saw: ", element_shape.DebugString()));
+    TensorList output_list;
+    const Tensor& input_tensor = c->input(0);
+    output_list.element_dtype = input_tensor.dtype();
+    OP_REQUIRES(c, TensorShapeUtils::IsVectorOrHigher(input_tensor.shape()),
+                errors::InvalidArgument(
+                    "Tensor must be at least a vector, but saw shape: ",
+                    input_tensor.shape().DebugString()));
+    TensorShape tensor_shape_without_first_dim(input_tensor.shape());
+    tensor_shape_without_first_dim.RemoveDim(0);
+    PartialTensorShape element_shape_without_first_dim;
+    if (!element_shape.unknown_rank()) {
+      element_shape_without_first_dim =
+          PartialTensorShape(element_shape.dim_sizes());
+      element_shape_without_first_dim.RemoveDim(0);
+    }
+    OP_REQUIRES(c,
+                element_shape_without_first_dim.IsCompatibleWith(
+                    tensor_shape_without_first_dim),
+                errors::InvalidArgument(
+                    "tensor shape ", input_tensor.shape().DebugString(),
+                    " is not compatible with element_shape ",
+                    element_shape.DebugString()));
+    output_list.element_shape = element_shape;
+    const Tensor& lengths = c->input(2);
+    OP_REQUIRES(c, TensorShapeUtils::IsVector(lengths.shape()),
+                errors::InvalidArgument(
+                    "Expected lengths to be a vector, received shape: ",
+                    lengths.shape().DebugString()));
+    output_list.tensors().reserve(lengths.shape().dim_size(0));
+
+    const auto copy_tensor = IsPluggableDevice(c)
+                                 ? &CopyTensorPluggableDevice<T>
+                                 : &CopyTensor<Device, T>;
+
+    int64_t start = 0;
+    int64_t end = 0;
+    for (int i = 0; i < lengths.shape().dim_size(0); ++i) {
+      int64_t length = lengths.vec<int64_t>()(i);
+      OP_REQUIRES(
+          c, length >= 0,
+          errors::InvalidArgument("Invalid value in lengths: ", length));
+      end = start + length;
+      OP_REQUIRES(c, end <= input_tensor.shape().dim_size(0),
+                  errors::InvalidArgument("Attempting to slice [", start, ", ",
+                                          end, "] from tensor with length ",
+                                          input_tensor.shape().dim_size(0)));
+      Tensor tmp = input_tensor.Slice(start, end);
+      start = end;
+      // TODO(apassos) maybe not always align; but weird compiler bugs seem to
+      // prevent this.
+      Tensor aligned;
+      OP_REQUIRES_OK(c, c->allocate_temp(tmp.dtype(), tmp.shape(), &aligned));
+      copy_tensor(c, tmp, aligned);
+      output_list.tensors().emplace_back(aligned);
+    }
+    OP_REQUIRES(c, end == input_tensor.shape().dim_size(0),
+                errors::InvalidArgument(
+                    "Unused values in tensor. Length of tensor: ",
+                    input_tensor.shape().dim_size(0), " Values used: ", end));
+    output_tensor->scalar<Variant>()() = std::move(output_list);
+  }
+};
+
+template <typename Device, typename T>
+class TensorListGather : public OpKernel {
+ public:
+  typedef std::vector<std::unique_ptr<typename TTypes<T, 2>::ConstMatrix>>
+      ConstMatrixVector;
+  explicit TensorListGather(OpKernelConstruction* c) : OpKernel(c) {
+    OP_REQUIRES_OK(c, c->GetAttr("element_dtype", &element_dtype_));
+  }
+
+  void Compute(OpKernelContext* c) override {
+    const TensorList* tensor_list = nullptr;
+    OP_REQUIRES_OK(c, GetInputList(c, 0, &tensor_list));
+    OP_REQUIRES(
+        c, element_dtype_ == tensor_list->element_dtype,
+        errors::InvalidArgument(
+            "Invalid data types; op elements ", DataTypeString(element_dtype_),
+            " but list elements ", DataTypeString(tensor_list->element_dtype)));
+    const Tensor& indices = c->input(1);
+    PartialTensorShape partial_element_shape;
+    OP_REQUIRES_OK(c, GetElementShapeFromInput(c, *tensor_list, 2,
+                                               &partial_element_shape));
+    OP_REQUIRES(
+        c, partial_element_shape.IsFullyDefined() || indices.NumElements() > 0,
+        errors::InvalidArgument("Tried to gather 0-elements from "
+                                "a list with non-fully-defined shape: ",
+                                partial_element_shape.DebugString()));
+
+    // Check that `element_shape` input tensor is compatible with the shapes of
+    // element tensors.
+    if (!tensor_list->element_shape.IsFullyDefined()) {
+      for (int index = 0; index < indices.NumElements(); ++index) {
+        const int i = indices.flat<int32>()(index);
+
+        OP_REQUIRES(c, 0 <= i && i < tensor_list->tensors().size(),
+                    absl::InvalidArgumentError(absl::StrCat(
+                        "Trying to gather element ", i, " in a list with ",
+                        tensor_list->tensors().size(), " elements.")));
+
+        const Tensor& t = tensor_list->tensors()[i];
+        if (t.dtype() != DT_INVALID) {
+          PartialTensorShape tmp = partial_element_shape;
+          OP_REQUIRES_OK(c, tmp.MergeWith(t.shape(), &partial_element_shape));
+        }
+      }
+    }
+
+    // Compute the shape of the output tensor by pre-pending the leading dim to
+    // the element_shape.
+    TensorShape element_shape;
+    OP_REQUIRES(
+        c, partial_element_shape.AsTensorShape(&element_shape),
+        errors::InvalidArgument("Tried to gather uninitialized tensors from a ",
+                                "list with non-fully-defined element_shape: ",
+                                partial_element_shape.DebugString()));
+    TensorShape output_shape = element_shape;
+    output_shape.InsertDim(0, indices.NumElements());
+    Tensor* output;
+    OP_REQUIRES_OK(c, c->allocate_output(0, output_shape, &output));
+    if (output->NumElements() == 0) {
+      return;
+    }
+
+    ConstMatrixVector inputs_flat;
+    inputs_flat.reserve(indices.NumElements());
+    Tensor zeros;
+    for (int index = 0; index < indices.NumElements(); ++index) {
+      const int i = indices.flat<int32>()(index);
+      OP_REQUIRES(
+          c, i < tensor_list->tensors().size(),
+          errors::InvalidArgument("Index ", i, " out o range; list only has ",
+                                  tensor_list->tensors().size(), " elements."));
+      const Tensor& t = tensor_list->tensors()[i];
+      if (t.dtype() != DT_INVALID) {
+        inputs_flat.emplace_back(new typename TTypes<T, 2>::ConstMatrix(
+            t.shaped<T, 2>({1, t.NumElements()})));
+      } else {
+        if (!zeros.NumElements()) {
+          AllocatorAttributes attr;
+          if (element_dtype_ == DT_VARIANT) {
+            attr.set_on_host(true);
+          }
+          OP_REQUIRES_OK(
+              c, c->allocate_temp(element_dtype_, element_shape, &zeros, attr));
+          SetZero<Device, T>(c, zeros);
+        }
+        inputs_flat.emplace_back(new typename TTypes<T, 2>::ConstMatrix(
+            const_cast<const Tensor&>(zeros).shaped<T, 2>(
+                {1, zeros.NumElements()})));
+      }
+    }
+    auto output_flat = output->shaped<T, 2>({1, output->NumElements()});
+
+#if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+    if (std::is_same<Device, Eigen::GpuDevice>::value) {
+      ConcatGPU<T>(c, inputs_flat, output, &output_flat);
+      return;
+    }
+#endif  // GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+    if (IsPluggableDevice(c)) {
+      ConcatPluggableDevice<T>(c, inputs_flat, &output_flat);
+    } else {
+      ConcatCPU<T>(c->device(), inputs_flat, &output_flat);
+    }
+  }
+
+ private:
+  DataType element_dtype_;
+};
+
+template <typename Device, typename T>
+class TensorListFromTensor : public OpKernel {
+ public:
+  TensorListFromTensor(OpKernelConstruction* c) : OpKernel(c) {}
+
+  void Compute(OpKernelContext* c) override {
+    Tensor* output_tensor;
+    AllocatorAttributes attr;
+    attr.set_on_host(true);
+    OP_REQUIRES_OK(c, c->allocate_output(0, {}, &output_tensor, attr));
+    PartialTensorShape element_shape;
+    OP_REQUIRES(
+        c, !TensorShapeUtils::IsMatrixOrHigher(c->input(1).shape()),
+        errors::InvalidArgument(
+            "TensorListFromTensor: element_shape must be at most rank 1 but ",
+            "has the shape of ", c->input(1).shape().DebugString()));
+    OP_REQUIRES_OK(c, TensorShapeFromTensor(c->input(1), &element_shape));
+    TensorList output_list;
+    const Tensor& t = c->input(0);
+    output_list.element_dtype = t.dtype();
+    OP_REQUIRES(c, TensorShapeUtils::IsVectorOrHigher(t.shape()),
+                errors::InvalidArgument(
+                    "Tensor must be at least a vector, but saw shape: ",
+                    t.shape().DebugString()));
+    TensorShape output_shape(t.shape());
+    output_shape.RemoveDim(0);
+    OP_REQUIRES(c, element_shape.IsCompatibleWith(output_shape),
+                errors::InvalidArgument(
+                    "Specified a list with shape ", element_shape.DebugString(),
+                    " from a tensor with shape ", output_shape.DebugString()));
+    output_list.element_shape = element_shape;
+    output_list.tensors().reserve(t.shape().dim_size(0));
+
+    const auto copy_tensor = IsPluggableDevice(c)
+                                 ? &CopyTensorPluggableDevice<T>
+                                 : &CopyTensor<Device, T>;
+
+    for (int i = 0; i < t.shape().dim_size(0); ++i) {
+      Tensor tmp = t.Slice(i, i + 1);
+      TensorShape tmp_shape = tmp.shape();
+      tmp_shape.RemoveDim(0);
+      OP_REQUIRES(c, tmp.CopyFrom(tmp, tmp_shape),
+                  errors::Unknown("Unexpected shape error."));
+      // TODO(apassos) maybe not always align; but weird compiler bugs seem to
+      // prevent this.
+      Tensor aligned;
+      OP_REQUIRES_OK(c, c->allocate_temp(tmp.dtype(), tmp.shape(), &aligned));
+      copy_tensor(c, tmp, aligned);
+      output_list.tensors().push_back(aligned);
+    }
+    output_tensor->scalar<Variant>()() = std::move(output_list);
+  }
+};
+
+// Scatters values in `value` into `list`. Assumes that `indices` are valid.
+template <typename Device, typename T>
+Status Scatter(OpKernelContext* c, const Tensor& value, const Tensor& indices,
+               TensorList* list) {
+  const auto copy_tensor = IsPluggableDevice(c) ? &CopyTensorPluggableDevice<T>
+                                                : &CopyTensor<Device, T>;
+  for (int index = 0; index < indices.NumElements(); ++index) {
+    const int i = indices.flat<int32>()(index);
+    Tensor tmp = value.Slice(index, index + 1);
+    TensorShape tmp_shape = tmp.shape();
+    tmp_shape.RemoveDim(0);
+    if (!tmp.CopyFrom(tmp, tmp_shape)) {
+      return errors::Unknown("Unexpected shape error.");
+    }
+    // TODO(apassos) maybe not always align; but weird compiler bugs seem to
+    // prevent this.
+    Tensor aligned;
+    TF_RETURN_IF_ERROR(c->allocate_temp(tmp.dtype(), tmp.shape(), &aligned));
+    // TODO(apassos) do all slices in a single kernel invocation instead of
+    // many small ones.
+    copy_tensor(c, tmp, aligned);
+    std::swap(list->tensors()[i], aligned);
+  }
+  return OkStatus();
+}
+
+template <typename Device, typename T>
+class TensorListScatterIntoExistingList : public OpKernel {
+ public:
+  TensorListScatterIntoExistingList(OpKernelConstruction* c) : OpKernel(c) {}
+
+  void Compute(OpKernelContext* c) override {
+    const TensorList* l = nullptr;
+    OP_REQUIRES_OK(c, GetInputList(c, 0, &l));
+    const Tensor& input_tensor = c->input(1);
+    const Tensor& indices = c->input(2);
+
+    // Check that inputs are valid.
+    OP_REQUIRES(c, input_tensor.dtype() == l->element_dtype,
+                errors::InvalidArgument(
+                    "Invalid data types; input tensor type: ",
+                    DataTypeString(input_tensor.dtype()),
+                    " list element_type: ", DataTypeString(l->element_dtype)));
+    OP_REQUIRES(c, TensorShapeUtils::IsVectorOrHigher(input_tensor.shape()),
+                errors::InvalidArgument(
+                    "Tensor must be at least a vector, but saw shape: ",
+                    input_tensor.shape().DebugString()));
+    OP_REQUIRES(c, TensorShapeUtils::IsVector(indices.shape()),
+                errors::InvalidArgument(
+                    "Expected indices to be a vector, but received shape: ",
+                    indices.shape().DebugString()));
+    OP_REQUIRES(
+        c, indices.NumElements() == input_tensor.shape().dim_size(0),
+        errors::InvalidArgument(
+            "Expected len(indices) == tensor.shape[0], but saw: ",
+            indices.NumElements(), " vs. ", input_tensor.shape().dim_size(0)));
+
+    // Resize the list if needed to accommodate all indices.
+    TensorList* output_list = nullptr;
+    OP_REQUIRES_OK(c, ForwardInputOrCreateNewList(c, 0, 0, *l, &output_list));
+    const auto indices_vec = indices.vec<int32>();
+    int32_t max_index =
+        (indices.NumElements() == 0)
+            ? -1
+            : *std::max_element(indices_vec.data(),
+                                indices_vec.data() + indices.NumElements());
+    if (max_index + 1 > output_list->tensors().size()) {
+      output_list->tensors().resize(max_index + 1);
+    }
+
+    // Scatter the values.
+    OP_REQUIRES_OK(c,
+                   Scatter<Device, T>(c, input_tensor, indices, output_list));
+  }
+};
+
+template <typename Device, typename T>
+class TensorListScatter : public OpKernel {
+ public:
+  TensorListScatter(OpKernelConstruction* c) : OpKernel(c) {}
+
+  void Compute(OpKernelContext* c) override {
+    Tensor* output_tensor;
+    AllocatorAttributes attr;
+    attr.set_on_host(true);
+    OP_REQUIRES_OK(c, c->allocate_output(0, {}, &output_tensor, attr));
+    Tensor indices = c->input(1);
+    PartialTensorShape element_shape;
+    OP_REQUIRES(
+        c, !TensorShapeUtils::IsMatrixOrHigher(c->input(2).shape()),
+        errors::InvalidArgument(
+            "TensorListScatter: element_shape must be at most rank 1 but has ",
+            "the shape of ", c->input(2).shape().DebugString()));
+    OP_REQUIRES_OK(c, TensorShapeFromTensor(c->input(2), &element_shape));
+    // TensorListScatterV2 passes the num_elements input, TensorListScatter does
+    // not.
+    int num_elements = -1;
+    if (c->num_inputs() >= 4) {
+      OP_REQUIRES(c, TensorShapeUtils::IsScalar(c->input(3).shape()),
+                  errors::InvalidArgument("num_elements must be a scalar"));
+      num_elements = c->input(3).scalar<int>()();
+    }
+    OP_REQUIRES(c, num_elements >= -1,
+                errors::InvalidArgument(
+                    "TensorListScatter expects num_elements >= -1, found: ",
+                    num_elements));
+    TensorList output_list;
+    const Tensor& input_tensor = c->input(0);
+    output_list.element_dtype = input_tensor.dtype();
+    OP_REQUIRES(c, TensorShapeUtils::IsVectorOrHigher(input_tensor.shape()),
+                errors::InvalidArgument(
+                    "Tensor must be at least a vector, but saw shape: ",
+                    input_tensor.shape().DebugString()));
+    TensorShape output_shape(input_tensor.shape());
+    output_shape.RemoveDim(0);
+    OP_REQUIRES(c, element_shape.IsCompatibleWith(output_shape),
+                errors::InvalidArgument(
+                    "Specified a list with shape ", element_shape.DebugString(),
+                    " from a tensor with shape ", output_shape.DebugString()));
+    output_list.element_shape = element_shape;
+
+    OP_REQUIRES(c, indices.NumElements() == input_tensor.shape().dim_size(0),
+                errors::InvalidArgument(
+                    "Invalid number of rows in input tensor. Expected: ",
+                    indices.NumElements(),
+                    " Actual: ", input_tensor.shape().dim_size(0)));
+
+    // Validate indices and resize output_list.tensors to fit the highest index.
+    {
+      int highest_index = -1;
+      for (int index = 0; index < indices.NumElements(); ++index) {
+        const int i = indices.flat<int32>()(index);
+        OP_REQUIRES(
+            c, i >= 0,
+            errors::InvalidArgument(
+                "Indices in TensorListScatter must all be non-negative."));
+        OP_REQUIRES(c, num_elements == -1 || i < num_elements,
+                    errors::InvalidArgument(
+                        "TensorListScatter: Trying to scatter at index ", i,
+                        " in list with size ", num_elements));
+        if (i > highest_index) {
+          highest_index = i;
+        }
+      }
+      output_list.tensors().resize(std::max(highest_index + 1, num_elements),
+                                   Tensor(DT_INVALID));
+    }
+
+    OP_REQUIRES_OK(c,
+                   Scatter<Device, T>(c, input_tensor, indices, &output_list));
+    output_tensor->scalar<Variant>()() = std::move(output_list);
+  }
+};
+
+template <typename Device>
+Status TensorListBinaryAdd(OpKernelContext* c, const TensorList& a,
+                           const TensorList& b, TensorList* out) {
+  return TensorListBinaryAdd(c, a, b, out, BinaryAddTensors<Device>);
+}
+
+template <typename Device>
+Status TensorListZerosLike(OpKernelContext* c, const TensorList& x,
+                           TensorList* y) {
+  return TensorListZerosLike(c, x, y, ZerosLikeTensor<Device>);
+}
+
+template <typename Device, typename T>
+class TensorListPushBackBatch : public OpKernel {
+ public:
+  explicit TensorListPushBackBatch(OpKernelConstruction* c) : OpKernel(c) {
+    OP_REQUIRES_OK(c, c->GetAttr("element_dtype", &element_dtype_));
+  }
+
+  void Compute(OpKernelContext* c) override {
+    const Tensor& input = c->input(1);
+    OP_REQUIRES(c, element_dtype_ == input.dtype(),
+                errors::InvalidArgument("Invalid data types; list elements ",
+                                        DataTypeString(element_dtype_),
+                                        " but tried to append ",
+                                        DataTypeString(input.dtype())));
+    OP_REQUIRES(c, TensorShapeUtils::IsVectorOrHigher(input.shape()),
+                errors::InvalidArgument(
+                    "Expected tensor to be at least a vector, but saw shape: ",
+                    input.shape().DebugString()));
+
+    const TensorShape& tls_shape = c->input(0).shape();
+
+    // For purposes of input forwarding, we want the least restrictive
+    // AllocatorAttributes possible.  If we need to allocate later,
+    // we'll request the DT_VARIANT be allocated on host.
+    AllocatorAttributes attr;
+
+    std::unique_ptr<Tensor> tls_alias = c->forward_input(
+        0 /*input_index*/, 0 /*output_index*/, DT_VARIANT, tls_shape,
+        DEVICE_MEMORY /* input is always on DEVICE_MEMORY */, attr);
+
+    bool ok_to_alias = tls_alias != nullptr;
+    if (tls_alias && tls_alias->dtype() == DT_VARIANT &&
+        tls_alias->NumElements() > 0) {
+      auto alias_t = tls_alias->flat<Variant>();
+      for (int i = 0; i < tls_alias->NumElements(); ++i) {
+        TensorList* tl_i = alias_t(i).get<TensorList>();
+        if (tl_i == nullptr || !tl_i->RefCountIsOne()) {
+          ok_to_alias = false;
+          break;
+        }
+      }
+    }
+    const Tensor& tls = ok_to_alias ? *tls_alias : c->input(0);
+
+    OP_REQUIRES(c, tls.dtype() == DT_VARIANT,
+                errors::InvalidArgument(
+                    "Expected input_handles dtype to be Variant, but saw: ",
+                    DataTypeString(tls.dtype())));
+    OP_REQUIRES(c, TensorShapeUtils::IsVector(tls_shape),
+                errors::InvalidArgument(
+                    "Expected input_handles to be a vector, but saw shape: ",
+                    tls_shape.DebugString()));
+    const int64_t batch_size = tls.NumElements();
+    OP_REQUIRES(c, input.dim_size(0) == batch_size,
+                errors::InvalidArgument(
+                    "Expected tensor.shape[0] == input_handles.size, but saw ",
+                    input.dim_size(0), " vs. ", batch_size));
+    auto tls_t = tls.vec<Variant>();
+
+    TensorShape input_element_shape = input.shape();
+    input_element_shape.RemoveDim(0);
+    std::vector<const TensorList*> tl_batch;
+    for (int64_t b = 0; b < batch_size; ++b) {
+      const TensorList* l = tls_t(b).get<TensorList>();
+      OP_REQUIRES(c, l != nullptr,
+                  errors::InvalidArgument("Input handle at index ", b,
+                                          " is not a list. Saw: '",
+                                          tls_t(b).DebugString(), "'"));
+      OP_REQUIRES(
+          c, l->element_shape.IsCompatibleWith(input_element_shape),
+          errors::InvalidArgument(
+              "Tried to append a tensor with incompatible shape to a "
+              "list at index ",
+              b, ". Op element shape: ", input_element_shape.DebugString(),
+              " list shape: ", l->element_shape.DebugString()));
+      OP_REQUIRES(c, element_dtype_ == l->element_dtype,
+                  errors::InvalidArgument(
+                      "Invalid data type at index ", b, "; op elements ",
+                      DataTypeString(element_dtype_), " but list elements ",
+                      DataTypeString(l->element_dtype)));
+      tl_batch.push_back(l);
+    }
+
+    Tensor* result;
+
+    if (ok_to_alias) {
+      result = tls_alias.get();
+      c->set_output(0, *result);
+    } else {
+      // DT_VARIANT tensors always allocated on host.
+      AllocatorAttributes attr;
+      attr.set_on_host(true);
+      OP_REQUIRES_OK(
+          c, c->allocate_output(0, TensorShape{batch_size}, &result, attr));
+    }
+
+    if (batch_size == 0) {
+      return;
+    }
+
+    auto input_t = input.flat_outer_dims<T, 2>();
+    auto result_t = result->vec<Variant>();
+
+    for (int64_t b = 0; b < batch_size; ++b) {
+      if (!ok_to_alias) {
+        result_t(b) = tl_batch[b]->Copy();
+      }
+      TensorList* output = result_t(b).get<TensorList>();
+      DCHECK(output != nullptr);
+      Tensor frame;
+      OP_REQUIRES_OK(
+          c, c->allocate_temp(element_dtype_, input_element_shape, &frame));
+      if (input_element_shape.num_elements() > 0) {
+        auto frame_t = frame.flat<T>();
+        // TODO(penporn): Get this if out of the batch loop.
+        if (IsPluggableDevice(c)) {
+          // The chip method need Eigen Device, so need to use Tensor.Slice
+          // instead of chip for pluggable device. The input should be reshaped
+          // to 2-D and so can be sliced by batch dim.
+          auto input_t_shape =
+              TensorShape({input_t.dimension(0), input_t.dimension(1)});
+          auto input_reshaped = Tensor();
+          OP_REQUIRES(c, input_reshaped.CopyFrom(input, input_t_shape),
+                      errors::Unknown("Unexpected shape error."));
+
+          auto input_batch = input_reshaped.Slice(b, b + 1);
+          CopyTensorPluggableDevice<T>(c, input_batch, frame);
+        } else {
+          frame_t.device(c->eigen_device<Device>()) =
+              input_t.template chip<0>(b);
+        }
+      }
+      output->tensors().push_back(std::move(frame));
+    }
+  }
+
+ private:
+  DataType element_dtype_;
+};
+
+}  // namespace tensorflow
+
+#undef PLUGGABLE_DEVICE_SUPPORTED
+#endif  // TENSORFLOW_CORE_KERNELS_LIST_KERNELS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/logging_ops.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/logging_ops.h
new file mode 100644
index 0000000000000000000000000000000000000000..5cb1213998f4990bf3239d56987dc04f6f97b819
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/logging_ops.h
@@ -0,0 +1,33 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_KERNELS_LOGGING_OPS_H_
+#define TENSORFLOW_CORE_KERNELS_LOGGING_OPS_H_
+
+#include "tensorflow/core/framework/op_kernel.h"
+
+namespace tensorflow {
+
+class AssertOp : public OpKernel {
+ public:
+  explicit AssertOp(OpKernelConstruction* c);
+  void Compute(OpKernelContext* ctx) override;
+
+ private:
+  int32 summarize_ = 0;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_LOGGING_OPS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/logistic-loss.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/logistic-loss.h
new file mode 100644
index 0000000000000000000000000000000000000000..6a7016a9625345951bb01f66b68eb30c2bb62a73
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/logistic-loss.h
@@ -0,0 +1,134 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_LOGISTIC_LOSS_H_
+#define TENSORFLOW_CORE_KERNELS_LOGISTIC_LOSS_H_
+
+#include <cmath>
+
+#include "tensorflow/core/kernels/loss.h"
+#include "tensorflow/core/lib/core/errors.h"
+
+namespace tensorflow {
+
+class LogisticLossUpdater : public DualLossUpdater {
+ public:
+  // Adding vs. Averaging in Distributed Primal-Dual Optimization.
+  // Chenxin Ma, Virginia Smith, Martin Jaggi, Michael I. Jordan, Peter
+  // Richtarik, Martin Takac http://arxiv.org/abs/1502.03508
+  double ComputeUpdatedDual(const int num_loss_partitions, const double label,
+                            const double example_weight,
+                            const double current_dual, const double wx,
+                            const double weighted_example_norm) const final {
+    // Newton algorithm converges quadratically so 10 steps will be largely
+    // enough to achieve a very good precision
+    static const int newton_total_steps = 10;
+    double x = 0;
+    for (int i = 0; i < newton_total_steps; ++i) {
+      x = NewtonStep(x, num_loss_partitions, label, wx, example_weight,
+                     weighted_example_norm, current_dual);
+    }
+    return 0.5 * (1 + tanh(x)) / label;
+  }
+
+  // Dual of logistic loss function.
+  // https://en.wikipedia.org/wiki/Convex_conjugate
+  double ComputeDualLoss(const double current_dual, const double example_label,
+                         const double example_weight) const final {
+    // Dual of the logistic loss function is
+    // ay * log(ay) + (1-ay) * log (1-ay), where a is the dual variable.
+    const double ay = current_dual * example_label;
+    const double log_ay = (ay > 0) ? log(ay) : 0;
+    const double one_minus_ay = 1 - ay;
+    const double log_one_minus_ay = (one_minus_ay > 0) ? log(one_minus_ay) : 0;
+    return ((ay * log_ay) + (one_minus_ay * log_one_minus_ay)) * example_weight;
+  }
+
+  // Logistic loss for binary classification.
+  // https://en.wikipedia.org/wiki/Loss_functions_for_classification
+  double ComputePrimalLoss(const double wx, const double example_label,
+                           const double example_weight) const final {
+    // Logistic loss:
+    //   log(1 + e^(-ywx))
+    //   log(e^0 + e^(-ywx))
+    //   a + log(e^(0-a) + e^(-ywx - a)),  where a is max(0, -ywx)
+    // https://hips.seas.harvard.edu/blog/2013/01/09/computing-log-sum-exp/
+    const double y_wx = example_label * wx;
+    if (y_wx > 0) {
+      // 0 + log(e^(0) + e^(-ywx - 0))
+      // log(1 + e^(-ywx))
+      return log1p(exp(-y_wx)) * example_weight;
+    }
+    // -ywx + log(e^(ywx) + e^(-ywx + ywx))
+    // log(e^(ywx) + e^(0)) - ywx
+    // log(1 + e^(ywx)) - ywx
+    return (log1p(exp(y_wx)) - y_wx) * example_weight;
+  }
+
+  // Derivative of logistic loss
+  double PrimalLossDerivative(const double wx, const double label,
+                              const double example_weight) const final {
+    double inverse_exp_term = 0;
+    if (label * wx > 0) {
+      inverse_exp_term = exp(-label * wx) / (1 + exp(-label * wx));
+    } else {
+      inverse_exp_term = 1 / (1 + exp(label * wx));
+    }
+    return -inverse_exp_term * label * example_weight;
+  }
+
+  // The smoothness constant is 4 since the derivative of logistic loss, which
+  // is exp(-x) / (1 + exp(-x)) can be shown to 0.25-Lipschitz (its derivative
+  // is bounded by 0.25)
+  double SmoothnessConstant() const final { return 4; }
+
+  // Converts binary example labels from 0.0 or 1.0 to -1.0 or 1.0 respectively
+  // as expected by logistic regression.
+  Status ConvertLabel(float* const example_label) const final {
+    if (*example_label == 0.0) {
+      *example_label = -1;
+      return OkStatus();
+    }
+    if (*example_label == 1.0) {
+      return OkStatus();
+    }
+    return errors::InvalidArgument(
+        "Only labels of 0.0 or 1.0 are supported right now. "
+        "Found example with label: ",
+        *example_label);
+  }
+
+ private:
+  // We use Newton algorithm on a modified function (see readme.md).
+  double NewtonStep(const double x, const int num_loss_partitions,
+                    const double label, const double wx,
+                    const double example_weight,
+                    const double weighted_example_norm,
+                    const double current_dual) const {
+    const double tanhx = tanh(x);
+    const double numerator = -2 * label * x - wx -
+                             num_loss_partitions * weighted_example_norm *
+                                 example_weight *
+                                 (0.5 * (1 + tanhx) / label - current_dual);
+    const double denominator =
+        -2 * label - num_loss_partitions * weighted_example_norm *
+                         example_weight * (1 - tanhx * tanhx) * 0.5 / label;
+    return x - numerator / denominator;
+  }
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_LOGISTIC_LOSS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/lookup_table_init_op.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/lookup_table_init_op.h
new file mode 100644
index 0000000000000000000000000000000000000000..6f72775eb442f98da4c322b3618bab921ae6604c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/lookup_table_init_op.h
@@ -0,0 +1,33 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_LOOKUP_TABLE_INIT_OP_H_
+#define TENSORFLOW_CORE_KERNELS_LOOKUP_TABLE_INIT_OP_H_
+
+#include "tensorflow/core/kernels/initializable_lookup_table.h"
+
+namespace tensorflow {
+namespace lookup {
+
+// Helper function to initialize an InitializableLookupTable from a text file.
+Status InitializeTableFromTextFile(const string& filename, int64_t vocab_size,
+                                   char delimiter, int32_t key_index,
+                                   int32_t value_index, Env* env,
+                                   InitializableLookupTable* table);
+
+}  // namespace lookup
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_LOOKUP_TABLE_INIT_OP_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/lookup_table_op.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/lookup_table_op.h
new file mode 100644
index 0000000000000000000000000000000000000000..97d5f404d7c1df8ae45a4ae23cb90fef792668a8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/lookup_table_op.h
@@ -0,0 +1,352 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_LOOKUP_TABLE_OP_H_
+#define TENSORFLOW_CORE_KERNELS_LOOKUP_TABLE_OP_H_
+
+#include "absl/container/flat_hash_map.h"
+#include "tensorflow/core/framework/bounds_check.h"
+#include "tensorflow/core/framework/lookup_interface.h"
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/resource_mgr.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/tensor_shape.h"
+#include "tensorflow/core/graph/graph_def_builder.h"
+#include "tensorflow/core/kernels/lookup_util.h"
+#include "tensorflow/core/lib/core/errors.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/lib/gtl/map_util.h"
+#include "tensorflow/core/platform/errors.h"
+#include "tensorflow/core/platform/macros.h"
+#include "tensorflow/core/platform/thread_annotations.h"
+
+namespace tensorflow {
+
+// Lookup table op that supports different table implementations specified by
+// the 'Container' template. Container must be derived from LookupInterface. The
+// key and value are of the templated type "key_dtype" and "value_dtype"
+// respectively.
+template <class Container, class key_dtype, class value_dtype>
+class LookupTableOp : public OpKernel {
+ public:
+  // ctx is not owned by this class.
+  explicit LookupTableOp(OpKernelConstruction* ctx)
+      : OpKernel(ctx), table_set_(false) {
+    if (ctx->output_type(0) == DT_RESOURCE) {
+      OP_REQUIRES_OK(ctx,
+                     ctx->allocate_temp(tensorflow::DT_RESOURCE,
+                                        tensorflow::TensorShape({}), &table_));
+    } else {
+      OP_REQUIRES_OK(ctx,
+                     ctx->allocate_temp(tensorflow::DT_STRING,
+                                        tensorflow::TensorShape({2}), &table_));
+    }
+    OP_REQUIRES_OK(
+        ctx, ctx->GetAttr("use_node_name_sharing", &use_node_name_sharing_));
+  }
+
+  // ctx is not owned by this function.
+  void Compute(OpKernelContext* ctx) override {
+    mutex_lock l(mu_);
+
+    if (!table_set_) {
+      OP_REQUIRES_OK(ctx, cinfo_.Init(ctx->resource_manager(), def(),
+                                      use_node_name_sharing_));
+    }
+
+    auto creator =
+        [ctx, this](lookup::LookupInterface** ret)
+            TF_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
+              lookup::LookupInterface* container = new Container(ctx, this);
+              if (!ctx->status().ok()) {
+                container->Unref();
+                return ctx->status();
+              }
+              if (ctx->track_allocations()) {
+                ctx->record_persistent_memory_allocation(
+                    container->MemoryUsed() + table_.AllocatedBytes());
+              }
+              *ret = container;
+              return OkStatus();
+            };
+
+    lookup::LookupInterface* table = nullptr;
+    OP_REQUIRES_OK(ctx,
+                   cinfo_.resource_manager()
+                       ->template LookupOrCreate<lookup::LookupInterface>(
+                           cinfo_.container(), cinfo_.name(), &table, creator));
+    core::ScopedUnref unref_me(table);
+
+    OP_REQUIRES_OK(ctx, lookup::CheckTableDataTypes(
+                            *table, DataTypeToEnum<key_dtype>::v(),
+                            DataTypeToEnum<value_dtype>::v(), cinfo_.name()));
+
+    if (ctx->expected_output_dtype(0) == DT_RESOURCE) {
+      if (!table_set_) {
+        auto h = table_.template scalar<ResourceHandle>();
+        h() = MakeResourceHandle<lookup::LookupInterface>(
+            ctx, cinfo_.container(), cinfo_.name());
+      }
+      ctx->set_output(0, table_);
+    } else {
+      if (!table_set_) {
+        auto h = table_.template flat<tstring>();
+        h(0) = cinfo_.container();
+        h(1) = cinfo_.name();
+      }
+      ctx->set_output_ref(0, &mu_, &table_);
+    }
+    table_set_ = true;
+  }
+
+  ~LookupTableOp() override {
+    // If the table object was not shared, delete it.
+    if (table_set_ && cinfo_.resource_is_private_to_kernel()) {
+      if (!cinfo_.resource_manager()
+               ->template Delete<lookup::LookupInterface>(cinfo_.container(),
+                                                          cinfo_.name())
+               .ok()) {
+        // Do nothing; the resource can have been deleted by session resets.
+      }
+    }
+  }
+
+ private:
+  mutex mu_;
+  Tensor table_ TF_GUARDED_BY(mu_);
+  bool table_set_ TF_GUARDED_BY(mu_);
+  ContainerInfo cinfo_;
+  bool use_node_name_sharing_;
+
+  LookupTableOp(const LookupTableOp&) = delete;
+  void operator=(const LookupTableOp&) = delete;
+};
+
+// An anonymous version of LookupTableOp, which creates a new table resource
+// everytime `Compute` is called. The resource can only be accessed by the
+// returned resource handle (e.g. it can't be looked up by a name in a resource
+// manager). The resource will be automatically deleted when all resource
+// handles pointing to it are gone.
+template <class Container, class key_dtype, class value_dtype>
+class AnonymousLookupTableOp : public OpKernel {
+ public:
+  explicit AnonymousLookupTableOp(OpKernelConstruction* ctx) : OpKernel(ctx) {}
+
+  void Compute(OpKernelContext* ctx) override {
+    lookup::LookupInterface* table = new Container(ctx, this);
+    if (!ctx->status().ok()) {
+      table->Unref();
+      return;
+    }
+    Tensor table_tensor;
+    OP_REQUIRES_OK(
+        ctx, ctx->allocate_temp(tensorflow::DT_RESOURCE,
+                                tensorflow::TensorShape({}), &table_tensor));
+    if (ctx->track_allocations()) {
+      ctx->record_persistent_memory_allocation(table->MemoryUsed() +
+                                               table_tensor.AllocatedBytes());
+    }
+    table_tensor.scalar<ResourceHandle>()() =
+        ResourceHandle::MakeRefCountingHandle<lookup::LookupInterface>(
+            table, ctx->device()->name());
+    ctx->set_output(0, table_tensor);
+  }
+
+ private:
+  AnonymousLookupTableOp(const AnonymousLookupTableOp&) = delete;
+  void operator=(const AnonymousLookupTableOp&) = delete;
+};
+
+namespace lookup {
+
+// Ensure that the compiler cannot elide a copy into a local, for
+// bounds checking on source tensors that might be updated asynchronously for
+// integral types. However non-integer variables are not allowed and therefore
+// the local copy is unnecessary.
+template <typename T>
+T SubtleMustCopyIfIntegral(const T& value) {
+  return internal::SubtleMustCopy(value);
+}
+
+inline const tstring& SubtleMustCopyIfIntegral(const tstring& value) {
+  return value;
+}
+
+inline const float SubtleMustCopyIfIntegral(const float value) { return value; }
+
+inline const double SubtleMustCopyIfIntegral(const double value) {
+  return value;
+}
+
+inline const Variant& SubtleMustCopyIfIntegral(const Variant& value) {
+  return value;
+}
+
+inline const ResourceHandle& SubtleMustCopyIfIntegral(
+    const ResourceHandle& value) {
+  return value;
+}
+
+// Returns a unique node name starting with "base".
+std::string UniqueNodeName(const std::string& base);
+
+// Lookup table that wraps an flat_hash_map, where the key and value data type
+// is specified.
+//
+// This table is recommended for any variations to key values.
+//
+// For look up, the table is required to be initialized (allocated
+// and populated). Once the table is marked as initialized it becomes read-only.
+//
+// Sample use case:
+//
+// HashTable<int64, int64> table;  // int64 -> int64.
+// table.Initialize(...);
+// table.Find(in_t, &out_t, default_t)
+//
+template <class K, class V>
+class HashTable : public InitializableLookupTable {
+ public:
+  HashTable(OpKernelContext* ctx, OpKernel* kernel) {}
+
+  Status AsGraphDef(GraphDefBuilder* builder, Node** out) const override {
+    // We set use_node_name_sharing with a unique node name so that the resource
+    // can outlive the HashTableV2 kernel. This means that the lifetime of the
+    // HashTable resource will be tied to the lifetime of the resource manager
+    // it is created in.
+    // TODO(b/181695913): Provide a mechanism for deleting this resource
+    // earlier when appropriate.
+    Node* hash_table_node = ops::SourceOp(
+        "HashTableV2", builder->opts()
+                           .WithName(UniqueNodeName("HashTableFromGraphDef"))
+                           .WithAttr("key_dtype", key_dtype())
+                           .WithAttr("value_dtype", value_dtype())
+                           .WithAttr("use_node_name_sharing", true));
+    if (table_.empty()) {
+      *out = hash_table_node;
+      return OkStatus();
+    }
+
+    if (initializer_serializer_ == nullptr) {
+      std::string message =
+          "Failed to serialize lookup table: no initialization function was "
+          "specified. Falling back to serializing a handle to the table.";
+      LOG(WARNING) << message;
+      return errors::Unimplemented(message);
+    }
+    Node* initializer;
+    TF_RETURN_IF_ERROR(initializer_serializer_->AsGraphDef(
+        builder, hash_table_node, &initializer));
+    *out = ops::UnaryOp("Identity", hash_table_node,
+                        builder->opts().WithControlInput(initializer));
+    return OkStatus();
+  }
+
+  size_t size() const override {
+    if (!is_initialized())
+      return 0;
+    else
+      return table_.size();
+  }
+
+  Status ExportValues(OpKernelContext* context) override {
+    if (!is_initialized()) {
+      return errors::Aborted("HashTable is not initialized.");
+    }
+
+    const int64_t size = table_.size();
+
+    Tensor* keys;
+    Tensor* values;
+    TF_RETURN_IF_ERROR(
+        context->allocate_output("keys", TensorShape({size}), &keys));
+    TF_RETURN_IF_ERROR(
+        context->allocate_output("values", TensorShape({size}), &values));
+
+    auto keys_data = keys->flat<K>();
+    auto values_data = values->flat<V>();
+    int64_t i = 0;
+    for (auto it = table_.begin(); it != table_.end(); ++it, ++i) {
+      keys_data(i) = it->first;
+      values_data(i) = it->second;
+    }
+    return OkStatus();
+  }
+
+  DataType key_dtype() const override { return DataTypeToEnum<K>::v(); }
+
+  DataType value_dtype() const override { return DataTypeToEnum<V>::v(); }
+
+ protected:
+  Status DoPrepare(size_t size) override {
+    if (is_initialized()) {
+      return errors::Aborted("HashTable already initialized.");
+    }
+    if (size > 0) {
+      table_.reserve(size);
+    }
+    return OkStatus();
+  };
+
+  Status DoLazyPrepare(std::function<int64(void)> size_fn) override {
+    return DoPrepare(size_fn());
+  }
+
+  Status DoInsert(const Tensor& keys, const Tensor& values) override {
+    const auto key_values = keys.flat<K>();
+    const auto value_values = values.flat<V>();
+    for (int64_t i = 0; i < key_values.size(); ++i) {
+      auto&& key = SubtleMustCopyIfIntegral(key_values(i));
+      auto&& value = SubtleMustCopyIfIntegral(value_values(i));
+      auto result = table_.try_emplace(key, value);
+      if (!result.second && result.first->second != value) {
+        return errors::FailedPrecondition(
+            "HashTable has different value for same key. Key ", key, " has ",
+            result.first->second, " and trying to add value ", value);
+      }
+    }
+    return OkStatus();
+  }
+
+  Status DoFind(const Tensor& key, Tensor* value,
+                const Tensor& default_value) override {
+    const V default_val = default_value.flat<V>()(0);
+    const auto key_values = key.flat<K>();
+    auto value_values = value->flat<V>();
+
+    for (int64_t i = 0; i < key_values.size(); ++i) {
+      value_values(i) = gtl::FindWithDefault(
+          table_, SubtleMustCopyIfIntegral(key_values(i)), default_val);
+    }
+    return OkStatus();
+  }
+
+  int64_t MemoryUsed() const override {
+    if (!is_initialized()) {
+      return 0;
+    }
+    const int64_t num_elements = table_.size();
+    return num_elements * (sizeof(K) + sizeof(V));
+  }
+
+ private:
+  absl::flat_hash_map<K, V> table_;
+};
+
+}  // namespace lookup
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_LOOKUP_TABLE_OP_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/lookup_util.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/lookup_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..2094f894bc5b4b4f73909d7559c44e0c95916544
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/lookup_util.h
@@ -0,0 +1,71 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_LOOKUP_UTIL_H_
+#define TENSORFLOW_CORE_KERNELS_LOOKUP_UTIL_H_
+
+#include "tensorflow/core/framework/lookup_interface.h"
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/kernels/initializable_lookup_table.h"
+
+namespace tensorflow {
+namespace data {
+class DatasetBase;
+}  // namespace data
+}  // namespace tensorflow
+
+namespace tensorflow {
+namespace lookup {
+
+// Gets the LookupTable stored in the ctx->resource_manager() with key
+// passed by attribute with name input_name, returns null if the table
+// doesn't exist. Use GetResourceLookupTable() or GetReferenceLookupTable() if
+// the input dtype is known.
+Status GetLookupTable(StringPiece input_name, OpKernelContext* ctx,
+                      LookupInterface** table);
+Status GetResourceLookupTable(StringPiece input_name, OpKernelContext* ctx,
+                              LookupInterface** table);
+Status GetReferenceLookupTable(StringPiece input_name, OpKernelContext* ctx,
+                               LookupInterface** table);
+
+// Gets the InitializableLookupTable stored in the
+// ctx->resource_manager() with key passed by attribute with name
+// input_name, returns null if the table doesn't exist.
+Status GetInitializableLookupTable(StringPiece input_name, OpKernelContext* ctx,
+                                   InitializableLookupTable** table);
+
+// Verify that the given key_dtype and value_dtype matches the corresponding
+// table's data types.
+Status CheckTableDataTypes(const LookupInterface& table, DataType key_dtype,
+                           DataType value_dtype, const string& table_name);
+
+// Initializes `table` from `filename`.
+Status InitializeTableFromTextFile(const string& filename, int64_t vocab_size,
+                                   char delimiter, int32_t key_index,
+                                   int32_t value_index, int64_t offset,
+                                   Env* env, InitializableLookupTable* table);
+
+// Initializes `table` from `filename`. `func` may specify how to represent the
+// initializer as a graphdef, so that the table can be serialized as metadata.
+Status InitializeTableFromTextFile(
+    const string& filename, int64_t vocab_size, char delimiter,
+    int32_t key_index, int32_t value_index, int64_t offset, Env* env,
+    std::unique_ptr<InitializableLookupTable::InitializerSerializer> serializer,
+    InitializableLookupTable* table);
+
+}  // namespace lookup
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_LOOKUP_UTIL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/loss.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/loss.h
new file mode 100644
index 0000000000000000000000000000000000000000..7db348800e92a31440bd8a19ed9f98062e2e567c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/loss.h
@@ -0,0 +1,59 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_KERNELS_LOSS_H_
+#define TENSORFLOW_CORE_KERNELS_LOSS_H_
+
+#include "tensorflow/core/lib/core/status.h"
+
+namespace tensorflow {
+
+class DualLossUpdater {
+ public:
+  virtual ~DualLossUpdater() {}
+
+  // Compute update dual (alpha), based on a single example. Various strategies
+  // can be employed here, like newton step and/or line search or approximate
+  // step that decreases the dual sub-optimality.
+  virtual double ComputeUpdatedDual(
+      const int num_loss_partitions, const double label,
+      const double example_weight, const double current_dual, const double wx,
+      const double weighted_example_norm) const = 0;
+
+  // Compute dual loss based on the current dual (alpha), example label (y)
+  // and example weight (cost).
+  virtual double ComputeDualLoss(const double current_dual,
+                                 const double example_label,
+                                 const double example_weight) const = 0;
+
+  // Compute the primal loss based on current estimate of log-odds(wx),
+  // example label (y) and example weight (cost).
+  virtual double ComputePrimalLoss(const double wx, const double example_label,
+                                   const double example_weight) const = 0;
+
+  // Primal loss derivative used to compute the dual residue in AdaSDCA
+  virtual double PrimalLossDerivative(const double wx,
+                                      const double example_label,
+                                      const double example_weight) const = 0;
+
+  // This is gamma such that the loss derivative is 1/gamma Lipschitz
+  virtual double SmoothnessConstant() const = 0;
+
+  // Converts binary example labels from 0.0 or 1.0 to appropriate range for
+  // each loss function.
+  virtual Status ConvertLabel(float* const example_label) const = 0;
+};
+
+}  // namespace tensorflow
+#endif  // TENSORFLOW_CORE_KERNELS_LOSS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/map_kernels.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/map_kernels.h
new file mode 100644
index 0000000000000000000000000000000000000000..6a05762983d627916530e4e9fdd56c5b033c1f67
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/map_kernels.h
@@ -0,0 +1,255 @@
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_KERNELS_MAP_KERNELS_H_
+#define TENSORFLOW_CORE_KERNELS_MAP_KERNELS_H_
+
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/kernels/tensor_map.h"
+#include "tensorflow/core/util/batch_util.h"
+#include "tensorflow/core/util/tensor_ops_util.h"
+
+namespace tensorflow {
+
+inline Status GetInputMap(OpKernelContext* ctx, int index,
+                          const TensorMap** ret_map) {
+  if (!TensorShapeUtils::IsScalar(ctx->input(index).shape())) {
+    return errors::InvalidArgument("Input map must be a scalar. Saw: ",
+                                   ctx->input(index).shape().DebugString());
+  }
+  const TensorMap* map = ctx->input(index).scalar<Variant>()().get<TensorMap>();
+  if (map == nullptr) {
+    return errors::InvalidArgument(
+        "Input handle is not a map. Saw: '",
+        ctx->input(index).scalar<Variant>()().DebugString(), "'");
+  }
+  *ret_map = map;
+  return OkStatus();
+}
+
+// TODO(kattian): change into templated function
+inline Status ForwardInputOrCreateNewMap(OpKernelContext* ctx,
+                                         int32_t input_index,
+                                         int32_t output_index,
+                                         const TensorMap& input_map,
+                                         TensorMap** output_map) {
+  // Attempt to forward the input tensor to the output if possible.
+  std::unique_ptr<Tensor> maybe_output = ctx->forward_input(
+      input_index, output_index, DT_VARIANT, TensorShape{},
+      ctx->input_memory_type(input_index), AllocatorAttributes());
+  Tensor* output_tensor;
+  if (maybe_output != nullptr && maybe_output->dtype() == DT_VARIANT &&
+      maybe_output->NumElements() == 1) {
+    output_tensor = maybe_output.get();
+    TensorMap* tmp_out = output_tensor->scalar<Variant>()().get<TensorMap>();
+    if (tmp_out == nullptr) {
+      return errors::InvalidArgument(
+          "Expected input ", input_index, " to be a TensorMap but saw ",
+          output_tensor->scalar<Variant>()().TypeName());
+    }
+    if (tmp_out->RefCountIsOne()) {
+      // Woohoo, forwarding succeeded!
+      ctx->set_output(output_index, *output_tensor);
+      *output_map = tmp_out;
+      return OkStatus();
+    }
+  }
+
+  // If forwarding is not possible allocate a new output tensor and copy
+  // the `input_map` to it.
+  AllocatorAttributes attr;
+  attr.set_on_host(true);
+  TF_RETURN_IF_ERROR(
+      ctx->allocate_output(output_index, {}, &output_tensor, attr));
+  output_tensor->scalar<Variant>()() = input_map.Copy();
+
+  *output_map = output_tensor->scalar<Variant>()().get<TensorMap>();
+  return OkStatus();
+}
+
+class EmptyTensorMap : public OpKernel {
+ public:
+  explicit EmptyTensorMap(OpKernelConstruction* ctx) : OpKernel(ctx) {}
+
+  void Compute(OpKernelContext* ctx) override {
+    Tensor* result;
+    AllocatorAttributes attr;
+    attr.set_on_host(true);
+    OP_REQUIRES_OK(ctx, ctx->allocate_output(0, TensorShape{}, &result, attr));
+    TensorMap empty;
+    result->scalar<Variant>()() = std::move(empty);
+  }
+};
+
+class TensorMapSize : public OpKernel {
+ public:
+  explicit TensorMapSize(OpKernelConstruction* ctx) : OpKernel(ctx) {}
+  ~TensorMapSize() override {}
+
+  void Compute(OpKernelContext* ctx) override {
+    const TensorMap* map = nullptr;
+    OP_REQUIRES_OK(ctx, GetInputMap(ctx, 0, &map));
+    Tensor* result;
+    OP_REQUIRES_OK(ctx, ctx->allocate_output(0, TensorShape{}, &result));
+    result->scalar<int32>()() = map->tensors().size();
+  }
+};
+
+class TensorMapLookup : public OpKernel {
+ public:
+  explicit TensorMapLookup(OpKernelConstruction* ctx) : OpKernel(ctx) {}
+  ~TensorMapLookup() override {}
+
+  void Compute(OpKernelContext* ctx) override {
+    const TensorKey& key = ctx->input(1);
+    const TensorMap* map = nullptr;
+    OP_REQUIRES_OK(ctx, GetInputMap(ctx, 0, &map));
+
+    OP_REQUIRES(
+        ctx, map->tensors().find(key) != map->tensors().end(),
+        errors::InvalidArgument("Trying to lookup non-existent key. Could not "
+                                "find key \"" +
+                                key.SummarizeValue(100) + "\"."));
+
+    ctx->set_output(0, map->tensors().find(key)->second);
+  }
+};
+
+class TensorMapInsert : public OpKernel {
+ public:
+  explicit TensorMapInsert(OpKernelConstruction* ctx) : OpKernel(ctx) {}
+  ~TensorMapInsert() override {}
+
+  void Compute(OpKernelContext* ctx) override {
+    const TensorKey& key = ctx->input(1);
+    const Tensor& value = ctx->input(2);
+    const TensorMap* map = nullptr;
+    OP_REQUIRES_OK(ctx, GetInputMap(ctx, 0, &map));
+
+    TensorMap* output_map = nullptr;
+    OP_REQUIRES_OK(ctx,
+                   ForwardInputOrCreateNewMap(ctx, 0, 0, *map, &output_map));
+    output_map->replace(key, value);
+  }
+};
+
+class TensorMapErase : public OpKernel {
+ public:
+  explicit TensorMapErase(OpKernelConstruction* ctx) : OpKernel(ctx) {}
+
+  void Compute(OpKernelContext* ctx) override {
+    const TensorKey& key = ctx->input(1);
+    const TensorMap* map = nullptr;
+    OP_REQUIRES_OK(ctx, GetInputMap(ctx, 0, &map));
+
+    OP_REQUIRES(
+        ctx, map->tensors().find(key) != map->tensors().end(),
+        errors::InvalidArgument("Trying to erase non-existent item. Could not "
+                                "find key \"" +
+                                key.SummarizeValue(100) + "\"."));
+
+    TensorMap* output_map = nullptr;
+    OP_REQUIRES_OK(ctx,
+                   ForwardInputOrCreateNewMap(ctx, 0, 0, *map, &output_map));
+    output_map->tensors().erase(key);
+  }
+};
+
+class TensorMapHasKey : public OpKernel {
+ public:
+  explicit TensorMapHasKey(OpKernelConstruction* ctx) : OpKernel(ctx) {}
+  ~TensorMapHasKey() override {}
+
+  void Compute(OpKernelContext* ctx) override {
+    const TensorKey& key = ctx->input(1);
+    const TensorMap* map = nullptr;
+    OP_REQUIRES_OK(ctx, GetInputMap(ctx, 0, &map));
+    Tensor* result;
+    OP_REQUIRES_OK(ctx, ctx->allocate_output(0, TensorShape{}, &result));
+    result->scalar<bool>()() = map->tensors().find(key) != map->tensors().end();
+  }
+};
+
+class TensorMapStackKeys : public OpKernel {
+ public:
+  explicit TensorMapStackKeys(OpKernelConstruction* ctx) : OpKernel(ctx) {
+    OP_REQUIRES_OK(ctx, ctx->GetAttr("key_dtype", &key_dtype_));
+  }
+  ~TensorMapStackKeys() override {}
+
+  void Compute(OpKernelContext* ctx) override {
+    const TensorMap* map = nullptr;
+    OP_REQUIRES_OK(ctx, GetInputMap(ctx, 0, &map));
+
+    OP_REQUIRES(ctx, map->size() != 0,
+                errors::InvalidArgument(
+                    "TensorMapStackKeys cannot be called on empty map."));
+
+    auto it = map->tensors().begin();
+    TensorShape output_shape = it->first.shape();
+    output_shape.InsertDim(0, map->tensors().size());
+    Tensor* result;
+    OP_REQUIRES_OK(ctx, ctx->allocate_output(0, output_shape, &result));
+
+    int i = 0;
+    size_t sz = map->tensors().size();
+    TensorShape key_shape = it->first.shape();
+    while (it != map->tensors().end() && i < sz) {
+      OP_REQUIRES(
+          ctx, it->first.dtype() == key_dtype_,
+          errors::InvalidArgument("Key does not match requested dtype."));
+      OP_REQUIRES(
+          ctx, it->first.shape() == key_shape,
+          errors::InvalidArgument("Keys must all have the same shape."));
+      OP_REQUIRES_OK(ctx, batch_util::CopyElementToSlice(it->first, result, i));
+      i++;
+      it++;
+    }
+  }
+
+ private:
+  DataType key_dtype_;
+};
+
+template <typename Device>
+Status TensorMapBinaryAdd(OpKernelContext* ctx, const TensorMap& a,
+                          const TensorMap& b, TensorMap* out) {
+  // Binary add returns a map containing the union of keys.
+  // Values with keys in the intersection are added.
+  out->tensors() = a.tensors();
+  for (const std::pair<TensorKey, Tensor>& p : b.tensors()) {
+    absl::flat_hash_map<TensorKey, Tensor>::iterator it =
+        out->tensors().find(p.first);
+    if (it != out->tensors().end()) {
+      Tensor out_tensor;
+      TF_RETURN_IF_ERROR(
+          BinaryAddTensors<Device>(ctx, p.second, it->second, &out_tensor));
+      it->second = out_tensor;
+    } else {
+      out->tensors().emplace(p.first, p.second);
+    }
+  }
+  return OkStatus();
+}
+
+template <typename Device>
+Status TensorMapZerosLike(OpKernelContext* ctx, const TensorMap& x,
+                          TensorMap* y) {
+  // Zeros like returns an empty map.
+  return OkStatus();
+}
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_MAP_KERNELS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/matmul_op.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/matmul_op.h
new file mode 100644
index 0000000000000000000000000000000000000000..03d0b640784157314ab1a3cac9c47687a9127c37
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/matmul_op.h
@@ -0,0 +1,124 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_MATMUL_OP_H_
+#define TENSORFLOW_CORE_KERNELS_MATMUL_OP_H_
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/tensor_types.h"
+#include "tensorflow/core/lib/hash/hash.h"
+
+#if defined(TENSORFLOW_USE_CUSTOM_CONTRACTION_KERNEL)
+#include "tsl/framework/contraction/eigen_contraction_kernel.h"
+#endif
+
+namespace tensorflow {
+namespace functor {
+
+// Helpers to define tensor<T> needed by MatMul op.
+template <typename T>
+struct MatMulTypes {
+  typedef Eigen::TensorMap<Eigen::Tensor<T, 2, Eigen::RowMajor>, Eigen::Aligned>
+      out_type;
+  typedef Eigen::TensorMap<Eigen::Tensor<const T, 2, Eigen::RowMajor>,
+                           Eigen::Aligned>
+      in_type;
+};
+
+template <typename Device, typename In0, typename In1, typename Out,
+          typename DimPair>
+void MatMul(const Device& d, Out out, In0 in0, In1 in1,
+            const DimPair& dim_pair) {
+  out.device(d) = in0.contract(in1, dim_pair);
+}
+
+template <typename Device, typename T>
+struct MatMulFunctor {
+  // Computes on device "d": out = in0 * in1, where * is matrix
+  // multiplication.
+  void operator()(
+      const Device& d, typename MatMulTypes<T>::out_type out,
+      typename MatMulTypes<T>::in_type in0,
+      typename MatMulTypes<T>::in_type in1,
+      const Eigen::array<Eigen::IndexPair<Eigen::DenseIndex>, 1>& dim_pair);
+};
+
+}  // end namespace functor
+
+#if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+// Encapsulate all the shape information that is used in matmul operations.
+class MatmulParameters {
+ public:
+  MatmulParameters(bool transa, bool transb, uint64 m, uint64 n, uint64 k,
+                   DataType dtype, int device_id)
+      : transa_(transa),
+        transb_(transb),
+        m_(m),
+        n_(n),
+        k_(k),
+        dtype_(dtype),
+        device_id_(device_id) {
+    hash_code_ = transa;
+    hash_code_ = Hash64Combine(hash_code_, transb);
+    hash_code_ = Hash64Combine(hash_code_, m);
+    hash_code_ = Hash64Combine(hash_code_, n);
+    hash_code_ = Hash64Combine(hash_code_, k);
+    hash_code_ = Hash64Combine(hash_code_, dtype);
+    hash_code_ = Hash64Combine(hash_code_, device_id);
+  }
+  bool operator==(const MatmulParameters& other) const {
+    return this->get_data_as_tuple() == other.get_data_as_tuple();
+  }
+
+  bool operator!=(const MatmulParameters& other) const {
+    return !(*this == other);
+  }
+  uint64 hash() const { return hash_code_; }
+
+  string ToString() const {
+    // clang-format off
+    return strings::StrCat(
+        transa_, ", ", transb_, ", ",
+        m_, ", ", n_, ", ", k_,
+        dtype_, ", ", device_id_);
+    // clang-format on
+  }
+
+ private:
+  typedef std::tuple<bool, bool, int64, int64, int64, DataType, int>
+      ParameterDataType;
+
+  ParameterDataType get_data_as_tuple() const {
+    return std::make_tuple(transa_, transb_, m_, n_, k_, dtype_, device_id_);
+  }
+
+  bool transa_;
+  bool transb_;
+  uint64 m_;
+  uint64 n_;
+  uint64 k_;
+  DataType dtype_;
+  int device_id_;
+  uint64 hash_code_;
+};
+
+typedef Eigen::GpuDevice GPUDevice;
+
+#endif  // GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_MATMUL_OP_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/matmul_op_impl.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/matmul_op_impl.h
new file mode 100644
index 0000000000000000000000000000000000000000..c647780973efe9929a81cce4eac5876e757ef61d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/matmul_op_impl.h
@@ -0,0 +1,1105 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// See docs in ../ops/math_ops.cc.
+
+#ifndef TENSORFLOW_CORE_KERNELS_MATMUL_OP_IMPL_H_
+#define TENSORFLOW_CORE_KERNELS_MATMUL_OP_IMPL_H_
+
+#define EIGEN_USE_THREADS
+
+#include <algorithm>
+#include <functional>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/register_types.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/tensor_shape.h"
+#include "tensorflow/core/framework/type_traits.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/kernels/fill_functor.h"
+#include "tensorflow/core/lib/core/errors.h"
+#include "tensorflow/core/lib/gtl/inlined_vector.h"
+#include "tensorflow/core/platform/logging.h"
+#include "tensorflow/core/platform/types.h"
+#include "tensorflow/core/util/matmul_autotune.h"
+#include "tensorflow/core/util/matmul_bcast.h"
+#include "tensorflow/core/util/work_sharder.h"
+
+#if defined(TENSORFLOW_USE_CUSTOM_CONTRACTION_KERNEL)
+#include "tsl/framework/contraction/eigen_contraction_kernel.h"
+#endif
+
+#if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+#include "xla/stream_executor/host_or_device_scalar.h"
+#include "tensorflow/core/kernels/gpu_utils.h"
+#include "tensorflow/core/kernels/matmul_util.h"
+#include "tensorflow/core/kernels/numeric_options_utils.h"
+#include "tensorflow/core/platform/stream_executor.h"
+#endif  // GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+#if GOOGLE_CUDA
+#include "third_party/gpus/cuda/include/cuda.h"
+#include "xla/stream_executor/cuda/cuda_blas_lt.h"
+#endif  // GOOGLE_CUDA
+#if TENSORFLOW_USE_ROCM
+#include "rocm/rocm_config.h"
+#if TF_HIPBLASLT
+#include "xla/stream_executor/rocm/hip_blas_lt.h"
+#endif
+#endif
+
+namespace tensorflow {
+
+typedef Eigen::ThreadPoolDevice CPUDevice;
+typedef Eigen::GpuDevice GPUDevice;
+
+namespace {
+
+// Returns the pair of dimensions along which to perform Tensor contraction to
+// emulate matrix multiplication.
+// For matrix multiplication of 2D Tensors X and Y, X is contracted along
+// second dimension and Y is contracted along the first dimension (if neither X
+// nor Y is adjointed). The dimension to contract along is switched when any
+// operand is adjointed.
+// See http://en.wikipedia.org/wiki/Tensor_contraction
+inline Eigen::IndexPair<Eigen::DenseIndex> ContractionDims(bool adj_x,
+                                                           bool adj_y) {
+  return Eigen::IndexPair<Eigen::DenseIndex>(adj_x ? 0 : 1, adj_y ? 1 : 0);
+}
+
+// Parallel batch matmul kernel based on the multi-threaded tensor contraction
+// in Eigen.
+template <typename Scalar, bool IsComplex = true>
+struct ParallelMatMulKernel {
+  static void Conjugate(const OpKernelContext* context, Tensor* out) {
+    const Eigen::ThreadPoolDevice d = context->eigen_cpu_device();
+    auto z = out->tensor<Scalar, 3>();
+    z.device(d) = z.conjugate();
+  }
+
+  static void Run(const OpKernelContext* context, const Tensor& in_x,
+                  const Tensor& in_y, bool adj_x, bool adj_y, bool trans_x,
+                  bool trans_y, const MatMulBCast& bcast, Tensor* out,
+                  int batch_size) {
+    static_assert(IsComplex, "Complex type expected.");
+    auto Tx = in_x.tensor<Scalar, 3>();
+    auto Ty = in_y.tensor<Scalar, 3>();
+    auto Tz = out->tensor<Scalar, 3>();
+    // We use the identities
+    //   conj(a) * conj(b) = conj(a * b)
+    //   conj(a) * b = conj(a * conj(b))
+    // to halve the number of cases. The final conjugation of the result is
+    // done at the end of LaunchBatchMatMul<CPUDevice, Scalar>::Launch().
+    Eigen::array<Eigen::IndexPair<Eigen::DenseIndex>, 1> contract_pairs;
+    contract_pairs[0] = ContractionDims(adj_x || trans_x, adj_y || trans_y);
+    const Eigen::ThreadPoolDevice d = context->eigen_cpu_device();
+
+    const bool should_bcast = bcast.IsBroadcastingRequired();
+    const auto& x_batch_indices = bcast.x_batch_indices();
+    const auto& y_batch_indices = bcast.y_batch_indices();
+    // TODO(rmlarsen): Consider launching these contractions asynchronously.
+    for (int64_t i = 0; i < batch_size; ++i) {
+      const int64_t x_batch_index = should_bcast ? x_batch_indices[i] : i;
+      const int64_t y_batch_index = should_bcast ? y_batch_indices[i] : i;
+
+      auto x = Tx.template chip<0>(x_batch_index);
+      auto z = Tz.template chip<0>(i);
+      if (adj_x != adj_y) {
+        auto y = Ty.template chip<0>(y_batch_index).conjugate();
+        z.device(d) = x.contract(y, contract_pairs);
+      } else {
+        auto y = Ty.template chip<0>(y_batch_index);
+        z.device(d) = x.contract(y, contract_pairs);
+      }
+    }
+  }
+};
+
+// The Eigen contraction kernel used here is very large and slow to compile,
+// so we partially specialize ParallelMatMulKernel for real types to avoid all
+// but one of the instantiations.
+template <typename Scalar>
+struct ParallelMatMulKernel<Scalar, false> {
+  static void Conjugate(const OpKernelContext* context, Tensor* out) {}
+
+  static void Run(const OpKernelContext* context, const Tensor& in_x,
+                  const Tensor& in_y, bool adj_x, bool adj_y, bool trans_x,
+                  bool trans_y, const MatMulBCast& bcast, Tensor* out,
+                  int batch_size) {
+    const bool should_bcast = bcast.IsBroadcastingRequired();
+    const Eigen::ThreadPoolDevice d = context->eigen_cpu_device();
+    Eigen::array<Eigen::IndexPair<Eigen::DenseIndex>, 1> contract_pairs;
+    contract_pairs[0] = ContractionDims(adj_x || trans_x, adj_y || trans_y);
+    if (batch_size == 1 && !should_bcast) {
+      auto Tx = in_x.flat_inner_dims<Scalar, 2>();
+      auto Ty = in_y.flat_inner_dims<Scalar, 2>();
+      auto Tz = out->flat_inner_dims<Scalar, 2>();
+      Tz.device(d) = Tx.contract(Ty, contract_pairs);
+    } else {
+      auto Tx = in_x.tensor<Scalar, 3>();
+      auto Ty = in_y.tensor<Scalar, 3>();
+      auto Tz = out->tensor<Scalar, 3>();
+      const auto& x_batch_indices = bcast.x_batch_indices();
+      const auto& y_batch_indices = bcast.y_batch_indices();
+      // TODO(rmlarsen): Consider launching these contractions asynchronously.
+      for (int64_t i = 0; i < batch_size; ++i) {
+        const int64_t x_batch_index = should_bcast ? x_batch_indices[i] : i;
+        const int64_t y_batch_index = should_bcast ? y_batch_indices[i] : i;
+        auto x = Tx.template chip<0>(x_batch_index);
+        auto y = Ty.template chip<0>(y_batch_index);
+        auto z = Tz.template chip<0>(i);
+
+        z.device(d) = x.contract(y, contract_pairs);
+      }
+    }
+  }
+};
+
+// Basic y-combinator implementation.
+template <class Func>
+struct YCombinatorImpl {
+  Func func;
+  template <class... Args>
+  decltype(auto) operator()(Args&&... args) const {
+    return func(*this, std::forward<Args>(args)...);
+  }
+};
+
+template <class Func>
+YCombinatorImpl<std::decay_t<Func>> YCombinator(Func&& func) {
+  return YCombinatorImpl<std::decay_t<Func>>{std::forward<Func>(func)};
+}
+
+// Sequential batch matmul kernel that calls the regular Eigen matmul.
+// We prefer this over the tensor contraction because it performs
+// better on vector-matrix and matrix-vector products.
+template <typename Scalar>
+struct SequentialMatMulKernel {
+  using Matrix =
+      Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>;
+  using ConstMatrixMap = Eigen::Map<const Matrix>;
+  using MatrixMap = Eigen::Map<Matrix>;
+
+  static ConstMatrixMap ConstTensorSliceToEigenMatrix(const Tensor& t,
+                                                      int slice) {
+    return ConstMatrixMap(
+        t.flat<Scalar>().data() + slice * t.dim_size(1) * t.dim_size(2),
+        t.dim_size(1), t.dim_size(2));
+  }
+
+  static MatrixMap TensorSliceToEigenMatrix(Tensor* t, int slice) {
+    return MatrixMap(
+        t->flat<Scalar>().data() + slice * t->dim_size(1) * t->dim_size(2),
+        t->dim_size(1), t->dim_size(2));
+  }
+
+  static void Run(const Tensor& in_x, const Tensor& in_y, bool adj_x,
+                  bool adj_y, bool trans_x, bool trans_y,
+                  const MatMulBCast& bcast, Tensor* out, int start, int limit) {
+    const bool should_bcast = bcast.IsBroadcastingRequired();
+    const auto& x_batch_indices = bcast.x_batch_indices();
+    const auto& y_batch_indices = bcast.y_batch_indices();
+    for (int64_t i = start; i < limit; ++i) {
+      const int64_t x_batch_index = should_bcast ? x_batch_indices[i] : i;
+      const int64_t y_batch_index = should_bcast ? y_batch_indices[i] : i;
+      auto x = ConstTensorSliceToEigenMatrix(in_x, x_batch_index);
+      auto y = ConstTensorSliceToEigenMatrix(in_y, y_batch_index);
+      auto z = TensorSliceToEigenMatrix(out, i);
+      // Assume at most one of adj_x or trans_x is true. Similarly, for adj_y
+      // and trans_y.
+      if (!adj_x && !trans_x) {
+        if (!adj_y && !trans_y) {
+          z.noalias() = x * y;
+        } else if (adj_y) {
+          z.noalias() = x * y.adjoint();
+        } else {  // trans_y == true
+          z.noalias() = x * y.transpose();
+        }
+      } else if (adj_x) {
+        if (!adj_y && !trans_y) {
+          z.noalias() = x.adjoint() * y;
+        } else if (adj_y) {
+          z.noalias() = x.adjoint() * y.adjoint();
+        } else {  // trans_y == true
+          z.noalias() = x.adjoint() * y.transpose();
+        }
+      } else {  // trans_x == true
+        if (!adj_y && !trans_y) {
+          z.noalias() = x.transpose() * y;
+        } else if (adj_y) {
+          z.noalias() = x.transpose() * y.adjoint();
+        } else {  // trans_y == true
+          z.noalias() = x.transpose() * y.transpose();
+        }
+      }
+    }
+  }
+};
+
+// For single-batch multiplications, manually parallize by splitting the output
+// matrix.
+template <typename Scalar>
+struct SingleBatchParallelMatMulKernel {
+  using Matrix =
+      Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>;
+  using ConstMatrixMap = Eigen::Map<const Matrix>;
+  using MatrixMap = Eigen::Map<Matrix>;
+
+  static ConstMatrixMap ConstTensorToEigenMatrix(const Tensor& t) {
+    return ConstMatrixMap(t.flat<Scalar>().data(), t.dim_size(1),
+                          t.dim_size(2));
+  }
+
+  static MatrixMap TensorToEigenMatrix(Tensor* t) {
+    return MatrixMap(t->flat<Scalar>().data(), t->dim_size(1), t->dim_size(2));
+  }
+
+  static void Run(const CPUDevice& device, const Tensor& in_x,
+                  const Tensor& in_y, bool adj_x, bool adj_y, bool trans_x,
+                  bool trans_y, Tensor* out) {
+    using Eigen::Index;
+    Eigen::ThreadPoolInterface* pool = device.getPool();
+
+    Index m = (trans_x || adj_x) ? in_x.dim_size(2) : in_x.dim_size(1);
+    Index k = (trans_x || adj_x) ? in_x.dim_size(1) : in_x.dim_size(2);
+    Index n = (trans_y || adj_y) ? in_y.dim_size(1) : in_y.dim_size(2);
+
+    auto x_mat = ConstTensorToEigenMatrix(in_x);
+    auto y_mat = ConstTensorToEigenMatrix(in_y);
+    auto out_mat = TensorToEigenMatrix(out);
+
+    // Computes a block of the output matrix.
+    auto compute_matmul_block = [&x_mat, &y_mat, &out_mat, adj_x, trans_x,
+                                 adj_y, trans_y](Index row, Index col,
+                                                 Index nrows, Index ncols) {
+      auto z = out_mat.block(row, col, nrows, ncols);
+
+      // Assume at most one of adj_x or trans_x is true. Similarly, for adj_y
+      // and trans_y.
+      if (!adj_x && !trans_x) {
+        auto x = x_mat.middleRows(row, nrows);
+        if (!adj_y && !trans_y) {
+          auto y = y_mat.middleCols(col, ncols);
+          z = x * y;
+        } else if (adj_y) {
+          auto y = y_mat.middleRows(col, ncols);
+          z.noalias() = x * y.adjoint();
+        } else {  // trans_y == true
+          auto y = y_mat.middleRows(col, ncols);
+          z.noalias() = x * y.transpose();
+        }
+      } else if (adj_x) {
+        auto x = x_mat.middleCols(row, nrows);
+        if (!adj_y && !trans_y) {
+          auto y = y_mat.middleCols(col, ncols);
+          z.noalias() = x.adjoint() * y;
+        } else if (adj_y) {
+          auto y = y_mat.middleRows(col, ncols);
+          z.noalias() = x.adjoint() * y.adjoint();
+        } else {  // trans_y == true
+          auto y = y_mat.middleRows(col, ncols);
+          z.noalias() = x.adjoint() * y.transpose();
+        }
+      } else {  // trans_x == true
+        auto x = x_mat.middleCols(row, nrows);
+        if (!adj_y && !trans_y) {
+          auto y = y_mat.middleCols(col, ncols);
+          z.noalias() = x.transpose() * y;
+        } else if (adj_y) {
+          auto y = y_mat.middleRows(col, ncols);
+          z.noalias() = x.transpose() * y.adjoint();
+        } else {  // trans_y == true
+          auto y = y_mat.middleRows(col, ncols);
+          z.noalias() = x.transpose() * y.transpose();
+        }
+      }
+    };
+
+    // Split the work across n threads, unless the total amount of work
+    // is small (e.g. 128 * 128) - in which case use fewer threads.  This is
+    // the same heuristic value used in LaunchBatchMatMul below.
+    const int64_t kMaxCostOuterParallelism = 128 * 128;
+    Index work_limit = std::max<Index>((m * k * n) / pool->NumThreads(),
+                                       kMaxCostOuterParallelism);
+    // Blocks should have a size no smaller than 8 * kPacketSize, except perhaps
+    // for tail blocks.
+    constexpr int kPacketSize = Eigen::internal::packet_traits<Scalar>::size;
+    constexpr Index kBlockMin = 8 * kPacketSize;
+
+    // Precompute how many blocks there will be.
+    auto compute_blocks = YCombinator([k, work_limit, kBlockMin](
+                                          auto& compute_blocks, Index row,
+                                          Index col, Index nrows,
+                                          Index ncols) -> Index {
+      Index work = nrows * k * ncols;
+      Index blocks = 0;
+      while (work > work_limit && (nrows > kBlockMin || ncols > kBlockMin)) {
+        if (nrows > ncols) {
+          Index half = Eigen::divup(nrows / 2, kBlockMin) * kBlockMin;
+          blocks += 1 + compute_blocks(row + half, col, nrows - half, ncols);
+          nrows = half;
+        } else {
+          Index half = Eigen::divup(ncols / 2, kBlockMin) * kBlockMin;
+          blocks += 1 + compute_blocks(row, col + half, nrows, ncols - half);
+          ncols = half;
+        }
+        work = nrows * k * ncols;
+      }
+      return blocks;
+    });
+    Index total_blocks = 1 + compute_blocks(0, 0, m, n);
+
+    // Recursively split work according to the exact same heuristic as above.
+    Eigen::Barrier barrier(total_blocks);
+    auto handle_range = YCombinator(
+        [k, pool, &barrier, work_limit, kBlockMin, &compute_matmul_block](
+            auto& handle_range, Index row, Index col, Index nrows,
+            Index ncols) -> void {
+          Index work = nrows * k * ncols;
+          while (work > work_limit &&
+                 (nrows > kBlockMin || ncols > kBlockMin)) {
+            if (nrows > ncols) {
+              Index half = Eigen::divup(nrows / 2, kBlockMin) * kBlockMin;
+              pool->Schedule([&handle_range, row, half, col, nrows, ncols]() {
+                handle_range(row + half, col, nrows - half, ncols);
+              });
+              nrows = half;
+            } else {
+              Index half = Eigen::divup(ncols / 2, kBlockMin) * kBlockMin;
+              pool->Schedule([&handle_range, row, half, col, nrows, ncols]() {
+                handle_range(row, col + half, nrows, ncols - half);
+              });
+              ncols = half;
+            }
+            work = nrows * k * ncols;
+          }
+
+          if (nrows > 0 && ncols > 0) {
+            // Compute the output block.
+            compute_matmul_block(row, col, nrows, ncols);
+          }
+          barrier.Notify();
+        });
+    handle_range(0, 0, m, n);
+    barrier.Wait();
+  }
+};
+
+}  // namespace
+
+template <typename Device, typename Scalar>
+struct LaunchBatchMatMul;
+
+template <typename Scalar>
+struct LaunchBatchMatMul<CPUDevice, Scalar> {
+  static void Launch(OpKernelContext* context, const Tensor& in_x,
+                     const Tensor& in_y, bool adj_x, bool adj_y, bool trans_x,
+                     bool trans_y, const MatMulBCast& bcast, Tensor* out) {
+    typedef ParallelMatMulKernel<Scalar, Eigen::NumTraits<Scalar>::IsComplex>
+        ParallelMatMulKernel;
+    bool conjugate_result = false;
+
+    // Number of matrix multiplies i.e. size of the batch.
+    const int64_t batch_size = bcast.output_batch_size();
+    const int64_t cost_per_unit =
+        in_x.dim_size(1) * in_x.dim_size(2) * out->dim_size(2);
+    const int64_t small_dim = std::min(
+        std::min(in_x.dim_size(1), in_x.dim_size(2)), out->dim_size(2));
+    // NOTE(nikhilsarda): This heuristic is optimal in benchmarks as of
+    // Jan 21, 2020.
+    const int64_t kMaxCostOuterParallelism = 128 * 128;  // heuristic.
+    auto worker_threads = *(context->device()->tensorflow_cpu_worker_threads());
+    // TODO(rmlarsen): Reconsider the heuristics now that we have asynchronous
+    // evaluation in Eigen Tensor.
+    if (small_dim > 1 &&
+        (batch_size == 1 || cost_per_unit > kMaxCostOuterParallelism)) {
+      // Parallelize over inner dims.
+      // For large matrix products it is counter-productive to parallelize
+      // over the batch dimension.
+      ParallelMatMulKernel::Run(context, in_x, in_y, adj_x, adj_y, trans_x,
+                                trans_y, bcast, out, batch_size);
+      conjugate_result = adj_x;
+    } else if (batch_size > 1) {
+      // Parallelize over outer dims. For small matrices and large batches, it
+      // is counter-productive to parallelize the inner matrix multiplies.
+      Shard(worker_threads.num_threads, worker_threads.workers, batch_size,
+            cost_per_unit,
+            [&in_x, &in_y, adj_x, adj_y, trans_x, trans_y, &bcast, out](
+                int start, int limit) {
+              SequentialMatMulKernel<Scalar>::Run(in_x, in_y, adj_x, adj_y,
+                                                  trans_x, trans_y, bcast, out,
+                                                  start, limit);
+            });
+    } else if (cost_per_unit > kMaxCostOuterParallelism) {
+      // Split along output blocks.
+      SingleBatchParallelMatMulKernel<Scalar>::Run(context->eigen_cpu_device(),
+                                                   in_x, in_y, adj_x, adj_y,
+                                                   trans_x, trans_y, out);
+    } else {
+      // Single small multiplication.
+      SequentialMatMulKernel<Scalar>::Run(in_x, in_y, adj_x, adj_y, trans_x,
+                                          trans_y, bcast, out, 0, batch_size);
+    }
+
+    if (conjugate_result) {
+      // We used one of the identities
+      //   conj(a) * conj(b) = conj(a * b)
+      //   conj(a) * b = conj(a * conj(b))
+      // above, we need to conjugate the final output. This is a
+      // no-op for non-complex types.
+      ParallelMatMulKernel::Conjugate(context, out);
+    }
+  }
+};
+
+#if GOOGLE_CUDA || TF_HIPBLASLT
+
+namespace {
+// A dummy type to group matmul autotune results together.
+struct BlasLtMatmulAutoTuneGroup {
+  static string name() { return "MatmulLt"; }
+};
+
+typedef AutotuneSingleton<BlasLtMatmulAutoTuneGroup, BlasLtMatmulPlanParams,
+                          se::blas::AlgorithmConfig,
+                          absl::Hash<BlasLtMatmulPlanParams>>
+    AutoTuneBatchMatmul;
+
+}  // namespace
+
+#endif  // GOOGLE_CUDA
+#if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+
+class BlasScratchAllocator : public se::ScratchAllocator {
+ public:
+  using Stream = se::Stream;
+  using DeviceMemoryBytes = se::DeviceMemory<uint8>;
+
+  BlasScratchAllocator(OpKernelContext* context)
+      : memory_limit_(0), total_byte_size_(0), context_(context) {}
+
+  BlasScratchAllocator(OpKernelContext* context, int64_t memory_limit)
+      : memory_limit_(memory_limit), total_byte_size_(0), context_(context) {}
+
+  int64_t GetMemoryLimitInBytes() override { return memory_limit_; }
+
+  tsl::StatusOr<DeviceMemoryBytes> AllocateBytes(int64_t byte_size) override {
+    Tensor temporary_memory;
+
+    if (memory_limit_ > 0 && byte_size > memory_limit_) {
+      return tsl::Status{
+          absl::StatusCode::kUnavailable,
+          absl::StrCat("Requested memory size (", byte_size,
+                       ") exceeds the memory limit (", memory_limit_, ").")};
+    }
+    AllocationAttributes allocation_attr;
+    allocation_attr.retry_on_failure = false;
+    Status allocation_status(context_->allocate_temp(
+        DT_UINT8, TensorShape({byte_size}), &temporary_memory));
+    if (!allocation_status.ok()) {
+      return tsl::Status{
+          absl::StatusCode::kUnavailable,
+          absl::StrCat("Failed to allocate requested memory of (", byte_size,
+                       ").")};
+    }
+    // Hold the reference of the allocated tensors until the end of the
+    // allocator.
+    allocated_tensors_.push_back(temporary_memory);
+    total_byte_size_ += byte_size;
+    return tsl::StatusOr<DeviceMemoryBytes>(DeviceMemoryBytes::MakeFromByteSize(
+        temporary_memory.flat<uint8>().data(),
+        temporary_memory.flat<uint8>().size()));
+  }
+  int64 TotalByteSize() { return total_byte_size_; }
+
+ private:
+  int64_t memory_limit_;
+  int64_t total_byte_size_;
+  OpKernelContext* context_;
+  std::vector<Tensor> allocated_tensors_;
+};
+
+template <typename Scalar>
+struct LaunchBatchMatMul<GPUDevice, Scalar> {
+  static void Launch(OpKernelContext* context, const Tensor& in_x,
+                     const Tensor& in_y, bool adj_x, bool adj_y, bool trans_x,
+                     bool trans_y, const MatMulBCast& bcast, Tensor* out) {
+    se::blas::Transpose trans[] = {se::blas::Transpose::kNoTranspose,
+                                   se::blas::Transpose::kTranspose,
+                                   se::blas::Transpose::kConjugateTranspose};
+    const uint64 m = in_x.dim_size(adj_x || trans_x ? 2 : 1);
+    const uint64 k = in_x.dim_size(adj_x || trans_x ? 1 : 2);
+    const uint64 n = in_y.dim_size(adj_y || trans_y ? 1 : 2);
+    const int64_t batch_size = bcast.output_batch_size();
+    auto blas_transpose_a = trans[adj_x ? 2 : (trans_x ? 1 : 0)];
+    auto blas_transpose_b = trans[adj_y ? 2 : (trans_y ? 1 : 0)];
+
+    auto* stream = context->op_device_context()->stream();
+    OP_REQUIRES(context, stream, errors::Internal("No GPU stream available."));
+
+    typedef se::DeviceMemory<Scalar> DeviceMemoryType;
+    std::vector<DeviceMemoryType> a_device_memory;
+    std::vector<DeviceMemoryType> b_device_memory;
+    std::vector<DeviceMemoryType> c_device_memory;
+    std::vector<DeviceMemoryType*> a_ptrs;
+    std::vector<DeviceMemoryType*> b_ptrs;
+    std::vector<DeviceMemoryType*> c_ptrs;
+    a_device_memory.reserve(bcast.x_batch_size());
+    b_device_memory.reserve(bcast.y_batch_size());
+    c_device_memory.reserve(batch_size);
+    a_ptrs.reserve(batch_size);
+    b_ptrs.reserve(batch_size);
+    c_ptrs.reserve(batch_size);
+    auto* a_base_ptr = in_x.template flat<Scalar>().data();
+    auto* b_base_ptr = in_y.template flat<Scalar>().data();
+    auto* c_base_ptr = out->template flat<Scalar>().data();
+    uint64 a_stride;
+    uint64 b_stride;
+    uint64 c_stride;
+
+    bool is_full_broadcast =
+        std::min(bcast.x_batch_size(), bcast.y_batch_size()) == 1;
+
+    // Use float as coefficient type for half and bfloat16 precision inputs,
+    // otherwise use the input type.
+    constexpr bool is_16bit_input = std::is_same_v<Scalar, Eigen::half> ||
+                                    std::is_same_v<Scalar, Eigen::bfloat16>;
+    using Coefficient = std::conditional_t<is_16bit_input, float, Scalar>;
+
+#if GOOGLE_CUDA || TF_HIPBLASLT
+    static const bool use_autotune = MatmulAutotuneEnable();
+    bool bCublasLtSupport = true;
+#if TF_HIPBLASLT
+    if (!std::is_same_v<Scalar, float>) bCublasLtSupport = false;
+    auto cap = stream->GetRocmComputeCapability();
+    // as of ROCm 5.5, hipblaslt only supports MI200.
+    if (cap.gcn_arch_name().substr(0, 6) != "gfx90a") bCublasLtSupport = false;
+#endif
+    if (EnableCublasLtGemm() && bCublasLtSupport) {
+      static const int64_t max_scratch_size =
+          GetWorkspaceLimit(1LL << 32);  // 4GB by default
+
+      bool requires_mixed_broadcasting =
+          bcast.IsBroadcastingRequired() && !is_full_broadcast;
+
+      if (!requires_mixed_broadcasting) {
+        a_device_memory.push_back(AsDeviceMemory(a_base_ptr));
+        b_device_memory.push_back(AsDeviceMemory(b_base_ptr));
+        c_device_memory.push_back(AsDeviceMemory(c_base_ptr));
+        a_ptrs.push_back(&a_device_memory.back());
+        b_ptrs.push_back(&b_device_memory.back());
+        c_ptrs.push_back(&c_device_memory.back());
+
+        BlasLtMatmulPlanParams matmul_params{
+            se::blas::ToDataType<Scalar>::value,
+            static_cast<size_t>(m),
+            static_cast<size_t>(n),
+            static_cast<size_t>(k),
+            blas_transpose_a,
+            blas_transpose_b,
+            static_cast<size_t>(batch_size),
+            /*broadcast_a=*/bcast.x_batch_size() == 1,
+            /*broadcast_b=*/bcast.y_batch_size() == 1};
+
+        std::optional<int> max_algorithm_count;
+        if (!use_autotune) max_algorithm_count = 1;
+        absl::Mutex* pmu = nullptr;
+        auto plan_and_algorithms_or = GetPlanAndAlgorithms(
+            stream, matmul_params, &pmu, max_algorithm_count);
+        OP_REQUIRES_OK(context, plan_and_algorithms_or.status());
+        absl::MutexLock lock(pmu);
+        const auto* plan_and_algorithms =
+            std::move(plan_and_algorithms_or).value();
+        const auto& plan = plan_and_algorithms->plan;
+        const auto& algorithms = plan_and_algorithms->algorithms;
+        se::gpu::BlasLt* blas_lt = se::gpu::GetBlasLt(stream);
+        OP_REQUIRES(context, blas_lt != nullptr,
+                    errors::Internal("blaslt not supported"));
+
+        se::blas::AlgorithmConfig algorithm_config(se::blas::kNoAlgorithm);
+        if (!use_autotune) {
+          algorithm_config.set_algorithm(0);
+        } else if (!AutoTuneBatchMatmul::GetInstance()->Find(
+                       matmul_params, &algorithm_config)) {
+          VLOG(4) << "Autotuning BlasLtMatmul over " << algorithms.size()
+                  << " algorithms.";
+          se::blas::ProfileResult best_result;
+          se::blas::ProfileResult profile_result;
+
+          for (size_t i = 0; i != algorithms.size(); ++i) {
+            const auto& profile_algorithm = algorithms[i];
+            // Create a new scratch allocator with every autotuning run so that
+            // scratch space is deallocated between runs.
+            BlasScratchAllocator scratch_allocator(context, max_scratch_size);
+            Status cublas_launch_status =
+                DoBlasLtMatmul(stream, plan, *a_ptrs[0], *b_ptrs[0], *c_ptrs[0],
+                               profile_algorithm, scratch_allocator,
+                               /*bias = */ {}, &profile_result);
+
+            VLOG(4) << "  Autotune algorithm " << i
+                    << " result: " << profile_result.elapsed_time_in_ms()
+                    << " ms, valid=" << profile_result.is_valid()
+                    << ", workspace_size=" << profile_algorithm.workspace_size;
+
+            if (cublas_launch_status.ok() && profile_result.is_valid() &&
+                profile_result.elapsed_time_in_ms() <
+                    best_result.elapsed_time_in_ms()) {
+              best_result = profile_result;
+              // Use index into algorithms array, instead of cublas internal ID.
+              best_result.set_algorithm(i);
+            }
+          }
+
+          if (best_result.is_valid()) {
+            algorithm_config.set_algorithm(best_result.algorithm());
+          }
+          // Each matmul parameter set gets one pass of
+          // autotune. If no algorithms works, kNoAlgorithm is added to the
+          // autotune map.
+          AutoTuneBatchMatmul::GetInstance()->Insert(matmul_params,
+                                                     algorithm_config);
+        }
+        se::blas::AlgorithmType algorithm_idx = algorithm_config.algorithm();
+        OP_REQUIRES(context,
+                    0 <= algorithm_idx && algorithm_idx < algorithms.size(),
+                    errors::Internal("Missing/invalid BatchMatmul algorithm"));
+        const auto& algorithm = algorithms[algorithm_idx];
+        BlasScratchAllocator scratch_allocator(context, max_scratch_size);
+        VLOG(4) << "Calling BlasLtMatMul: a.shape=(" << bcast.x_batch_size()
+                << ", " << in_x.dim_size(1) << ", " << in_x.dim_size(2)
+                << "), b.shape=(" << bcast.y_batch_size() << ", "
+                << in_y.dim_size(1) << ", " << in_y.dim_size(2) << "), m=" << m
+                << ", n=" << n << ", k=" << k << ", batch_size=" << batch_size
+                << "trans_x = " << trans_x << "trans_y = " << trans_y
+                << "adj_x = " << adj_x << "adj_y = " << adj_y;
+
+        OP_REQUIRES_OK(
+            context, DoBlasLtMatmul(stream, plan, *a_ptrs[0], *b_ptrs[0],
+                                    *c_ptrs[0], algorithm, scratch_allocator));
+      } else {  // requires mixed broadcasting
+        const std::vector<int64_t>& a_batch_indices = bcast.x_batch_indices();
+        const std::vector<int64_t>& b_batch_indices = bcast.y_batch_indices();
+        for (int64_t i = 0; i < bcast.x_batch_size(); ++i) {
+          a_device_memory.push_back(AsDeviceMemory(a_base_ptr + i * m * k));
+        }
+        for (int64_t i = 0; i < bcast.y_batch_size(); ++i) {
+          b_device_memory.push_back(AsDeviceMemory(b_base_ptr + i * k * n));
+        }
+        for (int64_t i = 0; i < batch_size; ++i) {
+          c_device_memory.push_back(AsDeviceMemory(c_base_ptr + i * m * n));
+          a_ptrs.push_back(&a_device_memory[a_batch_indices[i]]);
+          b_ptrs.push_back(&b_device_memory[b_batch_indices[i]]);
+          c_ptrs.push_back(&c_device_memory.back());
+        }
+
+        BlasScratchAllocator scratch_allocator(context, max_scratch_size);
+        bool blas_launch_status =
+            stream
+                ->ThenBlasGemmBatchedWithScratch(
+                    blas_transpose_b, blas_transpose_a, n, m, k,
+                    static_cast<Coefficient>(1.0), b_ptrs,
+                    adj_y || trans_y ? k : n, a_ptrs, adj_x || trans_x ? m : k,
+                    static_cast<Coefficient>(0.0), c_ptrs, n, batch_size,
+                    GetNumericOptions(), &scratch_allocator)
+                .ok();
+        if (!blas_launch_status) {
+          context->SetStatus(errors::Internal(
+              "Blas xGEMMBatched launch failed: a.shape=",
+              in_x.shape().DebugString(),
+              ", b.shape=", in_y.shape().DebugString(), ", m=", m, ", n=", n,
+              ", k=", k, ", batch_size=", batch_size));
+        }
+      }
+    } else {
+#endif  // GOOGLE_CUDA
+      bool use_strided_batched =
+          (!bcast.IsBroadcastingRequired() || is_full_broadcast) &&
+          batch_size > 1;
+      if (use_strided_batched) {
+        a_stride = bcast.x_batch_size() != 1 ? m * k : 0;
+        b_stride = bcast.y_batch_size() != 1 ? k * n : 0;
+        c_stride = m * n;
+        a_device_memory.push_back(AsDeviceMemory(a_base_ptr));
+        b_device_memory.push_back(AsDeviceMemory(b_base_ptr));
+        c_device_memory.push_back(AsDeviceMemory(c_base_ptr));
+        a_ptrs.push_back(&a_device_memory.back());
+        b_ptrs.push_back(&b_device_memory.back());
+        c_ptrs.push_back(&c_device_memory.back());
+      } else if (!bcast.IsBroadcastingRequired()) {
+        for (int64_t i = 0; i < batch_size; ++i) {
+          a_device_memory.push_back(AsDeviceMemory(a_base_ptr + i * m * k));
+          b_device_memory.push_back(AsDeviceMemory(b_base_ptr + i * k * n));
+          c_device_memory.push_back(AsDeviceMemory(c_base_ptr + i * m * n));
+          a_ptrs.push_back(&a_device_memory.back());
+          b_ptrs.push_back(&b_device_memory.back());
+          c_ptrs.push_back(&c_device_memory.back());
+        }
+      } else {
+        const std::vector<int64_t>& a_batch_indices = bcast.x_batch_indices();
+        const std::vector<int64_t>& b_batch_indices = bcast.y_batch_indices();
+        for (int64_t i = 0; i < bcast.x_batch_size(); ++i) {
+          a_device_memory.push_back(AsDeviceMemory(a_base_ptr + i * m * k));
+        }
+        for (int64_t i = 0; i < bcast.y_batch_size(); ++i) {
+          b_device_memory.push_back(AsDeviceMemory(b_base_ptr + i * k * n));
+        }
+        for (int64_t i = 0; i < batch_size; ++i) {
+          c_device_memory.push_back(AsDeviceMemory(c_base_ptr + i * m * n));
+          a_ptrs.push_back(&a_device_memory[a_batch_indices[i]]);
+          b_ptrs.push_back(&b_device_memory[b_batch_indices[i]]);
+          c_ptrs.push_back(&c_device_memory.back());
+        }
+      }
+
+      // Blas does
+      // C = A x B
+      // where A, B and C are assumed to be in column major.
+      // We want the output to be in row-major, so we can compute
+      // C' = B' x A', where ' stands for transpose (not adjoint).
+      // TODO(yangzihao): Choose the best of the three strategies using
+      // autotune.
+      if (batch_size == 1) {
+        // This is a regular matrix*matrix or matrix*vector multiply. Avoid the
+        // overhead of the scratch allocator and the batch interface.
+        // TODO(benbarsdell): Use fp16 Gemv if it becomes supported by CUBLAS
+        if constexpr (!std::is_same_v<Scalar, Eigen::half> &&
+                      !std::is_same_v<Scalar, Eigen::bfloat16>) {
+          if (n == 1 &&
+              blas_transpose_b != se::blas::Transpose::kConjugateTranspose &&
+              blas_transpose_a != se::blas::Transpose::kConjugateTranspose) {
+            // This is a matrix*vector multiply so use GEMV to compute A * b.
+            // Here we are multiplying in the natural order, so we have to flip
+            // the transposition flag to compensate for the tensor being stored
+            // row-major. Since GEMV doesn't provide a way to just conjugate an
+            // argument, we have to defer those cases to GEMM below.
+            auto gemv_trans_a =
+                blas_transpose_a == se::blas::Transpose::kTranspose
+                    ? se::blas::Transpose::kNoTranspose
+                    : se::blas::Transpose::kTranspose;
+            bool blas_launch_status =
+                stream
+                    ->ThenBlasGemv(gemv_trans_a, adj_x || trans_x ? m : k,
+                                   adj_x || trans_x ? k : m,
+                                   static_cast<Coefficient>(1.0), *(a_ptrs[0]),
+                                   adj_x || trans_x ? m : k, *(b_ptrs[0]), 1,
+                                   static_cast<Coefficient>(0.0), c_ptrs[0], 1)
+                    .ok();
+            if (!blas_launch_status) {
+              context->SetStatus(errors::Internal(
+                  "Blas xGEMV launch failed : a.shape=",
+                  in_x.shape().DebugString(), ", b.shape=",
+                  in_y.shape().DebugString(), ", m=", m, ", n=", n, ", k=", k));
+            }
+            return;
+          }
+        }
+
+        OP_REQUIRES_OK(context, stream->ThenBlasGemm(
+                                    blas_transpose_b, blas_transpose_a, n, m, k,
+                                    *(b_ptrs[0]), adj_y || trans_y ? k : n,
+                                    *(a_ptrs[0]), adj_x || trans_x ? m : k,
+                                    c_ptrs[0], n, GetNumericOptions()));
+      } else if (use_strided_batched) {
+        OP_REQUIRES_OK(
+            context, stream->ThenBlasGemmStridedBatched(
+                         blas_transpose_b, blas_transpose_a, n, m, k,
+                         static_cast<Coefficient>(1.0), *b_ptrs[0],
+                         adj_y || trans_y ? k : n, b_stride, *a_ptrs[0],
+                         adj_x || trans_x ? m : k, a_stride,
+                         static_cast<Coefficient>(0.0), c_ptrs[0], n, c_stride,
+                         batch_size, GetNumericOptions()));
+      } else {
+        BlasScratchAllocator scratch_allocator(context);
+        bool blas_launch_status =
+            stream
+                ->ThenBlasGemmBatchedWithScratch(
+                    blas_transpose_b, blas_transpose_a, n, m, k,
+                    static_cast<Coefficient>(1.0), b_ptrs,
+                    adj_y || trans_y ? k : n, a_ptrs, adj_x || trans_x ? m : k,
+                    static_cast<Coefficient>(0.0), c_ptrs, n, batch_size,
+                    GetNumericOptions(), &scratch_allocator)
+                .ok();
+        if (!blas_launch_status) {
+          context->SetStatus(errors::Internal(
+              "Blas xGEMMBatched launch failed : a.shape=",
+              in_x.shape().DebugString(),
+              ", b.shape=", in_y.shape().DebugString(), ", m=", m, ", n=", n,
+              ", k=", k, ", batch_size=", batch_size));
+        }
+      }
+#if GOOGLE_CUDA || TF_HIPBLASLT
+    }
+#endif  // GOOGLE_CUDA
+  }
+};
+
+#endif  // GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+
+template <typename Device, typename Ta, typename Tb, typename Tout>
+class BaseBatchMatMulOp : public OpKernel {
+ public:
+  explicit BaseBatchMatMulOp(OpKernelConstruction* context,
+                             bool is_legacy_matmul)
+      : OpKernel(context) {
+    if (is_legacy_matmul) {
+      // The old MatMul kernel has "transpose_a/transpose_b" attributes.
+      OP_REQUIRES_OK(context, context->GetAttr("transpose_a", &trans_x_));
+      OP_REQUIRES_OK(context, context->GetAttr("transpose_b", &trans_y_));
+      adj_x_ = false;
+      adj_y_ = false;
+    } else {
+      OP_REQUIRES_OK(context, context->GetAttr("adj_x", &adj_x_));
+      OP_REQUIRES_OK(context, context->GetAttr("adj_y", &adj_y_));
+      trans_x_ = false;
+      trans_y_ = false;
+    }
+  }
+
+  ~BaseBatchMatMulOp() override {}
+
+  void Compute(OpKernelContext* ctx) override {
+    const Tensor& in0 = ctx->input(0);
+    const Tensor& in1 = ctx->input(1);
+
+    const Status s = ValidateInputTensors(ctx, in0, in1);
+    if (!s.ok()) {
+      ctx->SetStatus(s);
+      return;
+    }
+
+    MatMulBCast bcast(in0.shape().dim_sizes(), in1.shape().dim_sizes());
+    OP_REQUIRES(
+        ctx, bcast.IsValid(),
+        errors::InvalidArgument(
+            "In[0] and In[1] must have compatible batch dimensions: ",
+            in0.shape().DebugString(), " vs. ", in1.shape().DebugString()));
+
+    TensorShape out_shape = bcast.output_batch_shape();
+    auto batch_size = bcast.output_batch_size();
+    auto d0 = in0.dim_size(in0.dims() - 2);
+    auto d1 = in0.dim_size(in0.dims() - 1);
+    Tensor in0_reshaped;
+    OP_REQUIRES(
+        ctx,
+        in0_reshaped.CopyFrom(in0, TensorShape({bcast.x_batch_size(), d0, d1})),
+        errors::Internal("Failed to reshape In[0] from ",
+                         in0.shape().DebugString()));
+    auto d2 = in1.dim_size(in1.dims() - 2);
+    auto d3 = in1.dim_size(in1.dims() - 1);
+    Tensor in1_reshaped;
+    OP_REQUIRES(
+        ctx,
+        in1_reshaped.CopyFrom(in1, TensorShape({bcast.y_batch_size(), d2, d3})),
+        errors::Internal("Failed to reshape In[1] from ",
+                         in1.shape().DebugString()));
+    if (adj_x_ || trans_x_) std::swap(d0, d1);
+    if (adj_y_ || trans_y_) std::swap(d2, d3);
+    OP_REQUIRES(
+        ctx, d1 == d2,
+        errors::InvalidArgument(
+            "Matrix size-incompatible: In[0]: ", in0.shape().DebugString(),
+            ", In[1]: ", in1.shape().DebugString()));
+    OP_REQUIRES_OK(ctx, out_shape.AddDimWithStatus(d0));
+    OP_REQUIRES_OK(ctx, out_shape.AddDimWithStatus(d3));
+    Tensor* out = nullptr;
+    OP_REQUIRES_OK(ctx, ctx->allocate_output(0, out_shape, &out));
+    if (out->NumElements() == 0) {
+      return;
+    }
+    if (in0.NumElements() == 0 || in1.NumElements() == 0) {
+      functor::SetZeroFunctor<Device, Tout> f;
+      f(ctx->eigen_device<Device>(), out->flat<Tout>());
+      return;
+    }
+    Tensor out_reshaped;
+    OP_REQUIRES(ctx,
+                out_reshaped.CopyFrom(*out, TensorShape({batch_size, d0, d3})),
+                errors::Internal("Failed to reshape output from ",
+                                 out->shape().DebugString()));
+    if (std::is_same_v<Device, CPUDevice> && std::is_same_v<Ta, bfloat16> &&
+        std::is_same_v<Tb, bfloat16>) {
+      Tensor in0_reshaped_float, in1_reshaped_float, out_reshaped_float;
+      OP_REQUIRES_OK(ctx, ctx->allocate_temp(DT_FLOAT, in0_reshaped.shape(),
+                                             &in0_reshaped_float));
+      OP_REQUIRES_OK(ctx, ctx->allocate_temp(DT_FLOAT, in1_reshaped.shape(),
+                                             &in1_reshaped_float));
+      OP_REQUIRES_OK(ctx, ctx->allocate_temp(DT_FLOAT, out_reshaped.shape(),
+                                             &out_reshaped_float));
+
+      // TODO: Avoid extra copy to make bfloat16 matmul efficient on CPU.
+      BFloat16ToFloat(in0_reshaped.flat<bfloat16>().data(),
+                      in0_reshaped_float.flat<float>().data(),
+                      in0_reshaped.NumElements());
+      BFloat16ToFloat(in1_reshaped.flat<bfloat16>().data(),
+                      in1_reshaped_float.flat<float>().data(),
+                      in1_reshaped.NumElements());
+
+      LaunchBatchMatMul<Device, float>::Launch(
+          ctx, in0_reshaped_float, in1_reshaped_float, adj_x_, adj_y_, trans_x_,
+          trans_y_, bcast, &out_reshaped_float);
+      FloatToBFloat16(out_reshaped_float.flat<float>().data(),
+                      out_reshaped.flat<bfloat16>().data(), out->NumElements());
+    } else {
+      // Cast tensor to desired type to reuse Eigen.
+      // TODO(b/178749687): remove this cast if Eigen supports this natively.
+      if (!std::is_same<Ta, Tout>::value) {
+        in0_reshaped = CastTensor<Ta, Tout>(in0_reshaped);
+      }
+      if (!std::is_same<Tb, Tout>::value) {
+        in1_reshaped = CastTensor<Tb, Tout>(in1_reshaped);
+      }
+      LaunchBatchMatMul<Device, Tout>::Launch(ctx, in0_reshaped, in1_reshaped,
+                                              adj_x_, adj_y_, trans_x_,
+                                              trans_y_, bcast, &out_reshaped);
+    }
+  }
+
+ protected:
+  virtual Status ValidateInputTensors(OpKernelContext* ctx, const Tensor& in0,
+                                      const Tensor& in1) = 0;
+
+ private:
+  // TODO(171979567) Make the ops take both adj and transpose attributes.
+  bool adj_x_ = false;
+  bool adj_y_ = false;
+  bool trans_x_ = false;
+  bool trans_y_ = false;
+
+  // Cast `t` from `SrcT` to `DstT`.
+  template <typename SrcT, typename DstT>
+  Tensor CastTensor(const Tensor& t) {
+    Tensor res = Tensor(DataTypeToEnum<DstT>::v(), t.shape());
+    res.flat<DstT>() = t.flat<SrcT>().template cast<DstT>();
+    return res;
+  }
+};
+
+// BatchMatMul Op implementation which disallows broadcasting.
+template <typename Device, typename Ta, typename Tb, typename Tout,
+          bool is_legacy_matmul = false>
+class BatchMatMulOp : public BaseBatchMatMulOp<Device, Ta, Tb, Tout> {
+ public:
+  explicit BatchMatMulOp(OpKernelConstruction* context)
+      : BaseBatchMatMulOp<Device, Ta, Tb, Tout>(context, is_legacy_matmul) {}
+
+  ~BatchMatMulOp() override {}
+
+ private:
+  Status ValidateInputTensors(OpKernelContext* ctx, const Tensor& in0,
+                              const Tensor& in1) override {
+    // Disallow broadcasting support. Ensure that all batch dimensions of the
+    // input tensors match.
+    if (in0.dims() != in1.dims()) {
+      return errors::InvalidArgument(
+          "In[0] and In[1] has different ndims: ", in0.shape().DebugString(),
+          " vs. ", in1.shape().DebugString());
+    }
+    const int ndims = in0.dims();
+    if (is_legacy_matmul) {
+      if (ndims != 2) {
+        return errors::InvalidArgument("In[0] and In[1] ndims must be == 2: ",
+                                       ndims);
+      }
+    } else {
+      if (ndims < 2) {
+        return errors::InvalidArgument("In[0] and In[1] ndims must be >= 2: ",
+                                       ndims);
+      }
+      for (int i = 0; i < ndims - 2; ++i) {
+        if (in0.dim_size(i) != in1.dim_size(i)) {
+          return errors::InvalidArgument(
+              "In[0].dim(", i, ") and In[1].dim(", i,
+              ") must be the same: ", in0.shape().DebugString(), " vs ",
+              in1.shape().DebugString());
+        }
+      }
+    }
+    return OkStatus();
+  }
+};
+
+// BatchMatMul Op implementation with broadcasting support.
+template <typename Device, typename Ta, typename Tb, typename Tout>
+class BatchMatMulV2Op : public BaseBatchMatMulOp<Device, Ta, Tb, Tout> {
+ public:
+  explicit BatchMatMulV2Op(OpKernelConstruction* context)
+      : BaseBatchMatMulOp<Device, Ta, Tb, Tout>(context,
+                                                /* is_legacy_matmul= */ false) {
+  }
+
+  ~BatchMatMulV2Op() override {}
+
+ private:
+  Status ValidateInputTensors(OpKernelContext* ctx, const Tensor& in0,
+                              const Tensor& in1) override {
+    // Enable broadcasting support. Validity of broadcasting is checked in
+    // BaseBatchMatMulOp.
+    if (in0.dims() < 2) {
+      return errors::InvalidArgument("In[0] ndims must be >= 2: ", in0.dims());
+    }
+    if (in1.dims() < 2) {
+      return errors::InvalidArgument("In[1] ndims must be >= 2: ", in1.dims());
+    }
+    return OkStatus();
+  }
+};
+
+// Register for MatMul, BatchMatMul, BatchMatMulv2 where Tin = Tout.
+#define REGISTER_BATCH_MATMUL_CPU(TYPE)                                   \
+  REGISTER_KERNEL_BUILDER(                                                \
+      Name("BatchMatMul").Device(DEVICE_CPU).TypeConstraint<TYPE>("T"),   \
+      BatchMatMulOp<CPUDevice, TYPE, TYPE, TYPE>);                        \
+  REGISTER_KERNEL_BUILDER(                                                \
+      Name("BatchMatMulV2").Device(DEVICE_CPU).TypeConstraint<TYPE>("T"), \
+      BatchMatMulV2Op<CPUDevice, TYPE, TYPE, TYPE>);                      \
+  REGISTER_KERNEL_BUILDER(                                                \
+      Name("MatMul").Device(DEVICE_CPU).TypeConstraint<TYPE>("T"),        \
+      BatchMatMulOp<CPUDevice, TYPE, TYPE, TYPE, /* is_legacy_matmul=*/true>)
+
+#define REGISTER_BATCH_MATMUL_GPU(TYPE)                                   \
+  REGISTER_KERNEL_BUILDER(                                                \
+      Name("BatchMatMul").Device(DEVICE_GPU).TypeConstraint<TYPE>("T"),   \
+      BatchMatMulOp<GPUDevice, TYPE, TYPE, TYPE>);                        \
+  REGISTER_KERNEL_BUILDER(                                                \
+      Name("BatchMatMulV2").Device(DEVICE_GPU).TypeConstraint<TYPE>("T"), \
+      BatchMatMulV2Op<GPUDevice, TYPE, TYPE, TYPE>);                      \
+  REGISTER_KERNEL_BUILDER(                                                \
+      Name("MatMul").Device(DEVICE_GPU).TypeConstraint<TYPE>("T"),        \
+      BatchMatMulOp<GPUDevice, TYPE, TYPE, TYPE, /* is_legacy_matmul=*/true>)
+
+// Register for BatchMatMulv3 where Ta, Tb and Tout are not the same.
+#define REGISTER_BATCH_MATMUL_TOUT_CPU(Ta, Tb, Tout)         \
+  REGISTER_KERNEL_BUILDER(Name("BatchMatMulV3")              \
+                              .Device(DEVICE_CPU)            \
+                              .TypeConstraint<Ta>("Ta")      \
+                              .TypeConstraint<Tb>("Tb")      \
+                              .TypeConstraint<Tout>("Tout"), \
+                          BatchMatMulV2Op<CPUDevice, Ta, Tb, Tout>)
+
+#define REGISTER_BATCH_MATMUL_TOUT_GPU(Ta, Tb, Tout)         \
+  REGISTER_KERNEL_BUILDER(Name("BatchMatMulV3")              \
+                              .Device(DEVICE_GPU)            \
+                              .TypeConstraint<Ta>("Ta")      \
+                              .TypeConstraint<Tb>("Tb")      \
+                              .TypeConstraint<Tout>("Tout"), \
+                          BatchMatMulV2Op<GPUDevice, Ta, Tb, Tout>)
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_MATMUL_OP_IMPL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/matmul_util.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/matmul_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..b422df8aa15b95532c5de6b22f4f94df8a442c4b
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/matmul_util.h
@@ -0,0 +1,137 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_KERNELS_MATMUL_UTIL_H_
+#define TENSORFLOW_CORE_KERNELS_MATMUL_UTIL_H_
+
+#include <optional>
+#include <vector>
+
+#if TENSORFLOW_USE_ROCM
+#include "rocm/rocm_config.h"
+#endif
+
+#if GOOGLE_CUDA || TF_HIPBLASLT
+
+#include "absl/container/flat_hash_map.h"
+#include "xla/stream_executor/device_memory.h"
+#include "tensorflow/core/framework/types.h"
+#include "tsl/platform/types.h"
+
+#if GOOGLE_CUDA
+#include "xla/stream_executor/cuda/cuda_blas_lt.h"
+#endif
+
+#if TF_HIPBLASLT
+#include "xla/stream_executor/rocm/hip_blas_lt.h"
+#define CUDA_R_32F HIPBLAS_R_32F
+#endif
+
+namespace tensorflow {
+
+// Get a workspace limit from the environment variable, which is in MB.
+// Return the workspace memory limit in bytes. If no value is set, return the
+// default value.
+int64_t GetWorkspaceLimit(int64_t default_value_in_bytes);
+
+struct BlasLtMatmulPlanParams {
+  std::string ToString() const;
+  bool operator==(const BlasLtMatmulPlanParams& other) const;
+
+  se::blas::DataType dtype;
+  size_t m;
+  size_t n;
+  size_t k;
+  se::blas::Transpose trans_a;
+  se::blas::Transpose trans_b;
+  size_t batch_count = 1;
+  bool broadcast_a = false;
+  bool broadcast_b = false;
+  se::gpu::BlasLt::Epilogue epilogue = se::gpu::BlasLt::Epilogue::kDefault;
+};
+
+namespace internal {
+
+inline auto AsTuple(const BlasLtMatmulPlanParams& p) {
+  return std::make_tuple(p.dtype, p.m, p.n, p.k, p.trans_a, p.trans_b,
+                         p.batch_count, p.broadcast_a, p.broadcast_b,
+                         p.epilogue);
+}
+
+}  // namespace internal
+
+template <typename H>
+H AbslHashValue(H h, const BlasLtMatmulPlanParams& params) {
+  return H::combine(std::move(h), internal::AsTuple(params));
+}
+
+struct PlanAndAlgorithms {
+  se::gpu::BlasLt::MatmulPlan plan;
+  std::vector<se::gpu::BlasLt::MatmulAlgorithm> algorithms;
+};
+
+// Thread-safe map from matmul parameters to their corresponding plan and
+// algorithms.
+class BlasLtMatmulPlanMap {
+ public:
+  const PlanAndAlgorithms* Find(const BlasLtMatmulPlanParams& params) const;
+  const PlanAndAlgorithms* Insert(const BlasLtMatmulPlanParams& params,
+                                  PlanAndAlgorithms value);
+
+  mutable absl::Mutex mu_;
+
+ private:
+  absl::flat_hash_map<BlasLtMatmulPlanParams, PlanAndAlgorithms>
+      params_plan_map_ ABSL_GUARDED_BY(mu_);
+};
+
+StatusOr<se::blas::ComputationType> GetBlasComputationType(
+    const DataType& dtype);
+
+StatusOr<const PlanAndAlgorithms*> GetPlanAndAlgorithms(
+    se::Stream* stream, const BlasLtMatmulPlanParams& params, absl::Mutex** pmu,
+    std::optional<int> max_algorithm_count = std::nullopt);
+
+template <typename T>
+Status DoBlasLtMatmul(se::Stream* stream,
+                      const se::gpu::BlasLt::MatmulPlan& plan,
+                      const se::DeviceMemory<T>& a,
+                      const se::DeviceMemory<T>& b, se::DeviceMemory<T>& c,
+                      const se::gpu::BlasLt::MatmulAlgorithm& algorithm,
+                      se::ScratchAllocator& scratch_allocator,
+                      const se::DeviceMemory<T>& bias = {},
+                      se::blas::ProfileResult* profile_result = nullptr) {
+  se::gpu::BlasLt* blas_lt = se::gpu::GetBlasLt(stream);
+  // TF_RET_CHECK(blas_lt != nullptr);
+
+  se::DeviceMemory<T> aux{};  // We don't use the auxilary buffers.
+
+  // The scale type may be f32 if the data type is f16 and bf16.
+  if constexpr (std::is_same_v<T, Eigen::half> ||
+                std::is_same_v<T, Eigen::bfloat16>) {
+    if (plan.op_desc.scale_type() == CUDA_R_32F) {
+      return blas_lt->DoMatmul(stream, plan, se::HostOrDeviceScalar<float>(1.0),
+                               b, a, se::HostOrDeviceScalar<float>(0.0), c, c,
+                               algorithm, scratch_allocator, bias, aux,
+                               profile_result);
+    }
+  }
+  return blas_lt->DoMatmul(stream, plan, se::HostOrDeviceScalar<T>(T(1.0)), b,
+                           a, se::HostOrDeviceScalar<T>(T(0.0)), c, c,
+                           algorithm, scratch_allocator, bias, aux,
+                           profile_result);
+}
+
+}  // namespace tensorflow
+
+#endif
+
+#endif  // TENSORFLOW_CORE_KERNELS_MATMUL_UTIL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/maxpooling_op.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/maxpooling_op.h
new file mode 100644
index 0000000000000000000000000000000000000000..64f999e85d62f2b32aae1583e83b55fed5f74482
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/maxpooling_op.h
@@ -0,0 +1,55 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_MAXPOOLING_OP_H_
+#define TENSORFLOW_CORE_KERNELS_MAXPOOLING_OP_H_
+// Functor definition for MaxPoolingOp, must be compilable by nvcc.
+
+#include "tensorflow/core/framework/numeric_types.h"
+#include "tensorflow/core/framework/tensor_types.h"
+#include "tensorflow/core/framework/type_traits.h"
+#include "tensorflow/core/kernels/eigen_pooling.h"
+#include "tensorflow/core/platform/types.h"
+#include "tsl/framework/fixedpoint/FixedPoint.h"
+
+namespace tensorflow {
+namespace functor {
+
+template <typename Device, typename T>
+struct SpatialMaxPooling {
+  void operator()(const Device& d, typename TTypes<T, 4>::Tensor output,
+                  typename TTypes<T, 4>::ConstTensor input, int window_rows,
+                  int window_cols, int row_stride, int col_stride,
+                  const Eigen::PaddingType& padding) {
+    // Because we swap the layout, we swap the row/cols as well
+    output.swap_layout().device(d) =
+        Eigen::SpatialMaxPooling(input.swap_layout(), window_cols, window_rows,
+                                 col_stride, row_stride, padding);
+  }
+};
+
+template <typename Device>
+struct SpatialMaxPooling<Device, qint8> {
+  void operator()(const Device& d, typename TTypes<qint8, 4>::Tensor output,
+                  typename TTypes<qint8, 4>::ConstTensor input, int window_rows,
+                  int window_cols, int row_stride, int col_stride,
+                  const Eigen::PaddingType& padding) {}
+};
+
+}  // namespace functor
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_MAXPOOLING_OP_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/maxpooling_op_gpu.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/maxpooling_op_gpu.h
new file mode 100644
index 0000000000000000000000000000000000000000..650a01e3ff0dc1ad21901460fe11d9551f5610eb
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/maxpooling_op_gpu.h
@@ -0,0 +1,86 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#if !GOOGLE_CUDA && !TENSORFLOW_USE_ROCM
+#error This file must only be included when building with Cuda or ROCm support
+#endif
+
+#ifndef TENSORFLOW_CORE_KERNELS_MAXPOOLING_OP_GPU_H_
+#define TENSORFLOW_CORE_KERNELS_MAXPOOLING_OP_GPU_H_
+
+#define EIGEN_USE_GPU
+
+#include "tensorflow/core/framework/tensor_types.h"
+#include "tensorflow/core/platform/types.h"
+#include "tensorflow/core/util/tensor_format.h"
+
+namespace tensorflow {
+
+namespace functor {
+// Run the forward pass of max pooling, optionally writing the argmax indices to
+// the mask array, if it is not nullptr. If mask is passed in as nullptr, the
+// argmax indices are not written.
+template <typename T>
+struct MaxPoolForwardWithOptionalArgmax {
+  bool operator()(const T* bottom_data, const int batch, const int height,
+                  const int width, const int channels, const int pooled_height,
+                  const int pooled_width, const int kernel_h,
+                  const int kernel_w, const int stride_h, const int stride_w,
+                  const int pad_t, const int pad_l, T* top_data, int64_t* mask,
+                  const Eigen::GpuDevice& d, bool propagate_nans,
+                  const bool include_batch_in_index);
+};
+
+struct MaxPoolForwardNoMask_NCHW_VECT_C {
+  bool operator()(const int32* bottom_data, const int batch, const int height,
+                  const int width, int channels, const int pooled_height,
+                  const int pooled_width, const int kernel_h,
+                  const int kernel_w, const int stride_h, const int stride_w,
+                  const int pad_t, const int pad_l, int32* top_data,
+                  const Eigen::GpuDevice& d);
+};
+
+template <typename T>
+struct MaxPoolBackwardWithArgmax {
+  bool operator()(const int output_size, const int input_size,
+                  const T* top_diff, const int64_t* mask, const int top_offset,
+                  const int bottom_offset, T* bottom_diff,
+                  const Eigen::GpuDevice& d, const bool include_batch_in_index);
+};
+
+template <typename T>
+struct MaxPoolGradBackwardWithArgmax {
+  bool operator()(const int output_size, const int input_size,
+                  const T* top_diff, const int64_t* mask, const int top_offset,
+                  const int bottom_offset, T* bottom_diff,
+                  const Eigen::GpuDevice& d, const bool include_batch_in_index);
+};
+
+template <typename T>
+struct MaxPoolGradBackwardNoMask {
+  bool operator()(TensorFormat data_format, const T* bottom_data,
+                  const T* output_data, const int batch,
+                  const int pooled_height, const int pooled_width,
+                  const int channels, const int height, const int width,
+                  const int kernel_h, const int kernel_w, const int stride_h,
+                  const int stride_w, const int pad_t, const int pad_l,
+                  const T* top_diff, T* bottom_diff, const Eigen::GpuDevice& d);
+};
+
+}  // namespace functor
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_MAXPOOLING_OP_GPU_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/meta_support.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/meta_support.h
new file mode 100644
index 0000000000000000000000000000000000000000..b1e81b4f1d26d379428db268081fc4895995f6f7
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/meta_support.h
@@ -0,0 +1,112 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_META_SUPPORT_H_
+#define TENSORFLOW_CORE_KERNELS_META_SUPPORT_H_
+
+#include "meta/multi_thread_gemm.h"
+#include "meta/multi_thread_transform.h"
+#include "meta/quantized_mul_kernels.h"
+#include "meta/streams.h"
+#include "meta/transform_kernels.h"
+
+#include "tensorflow/core/framework/numeric_types.h"
+
+namespace tensorflow {
+
+class OpKernelContext;
+
+namespace meta {
+
+// Gemmlowp/meta is a small library of optimized Arm32/64 kernels for quantized
+// matrix multiplication and other quantized computations.
+
+// Set the maximum number of threads of computation that the internal workers
+// pool can use. If num_threads is 0, then use intra_op_parallelism_threads.
+void SetNumThreads(int num_threads);
+
+int GetNumThreads();
+
+// Toggle the internal workers pool. If set to false, the computations will
+// use the worker pool passed each time in the OpKernelContext. If set to true
+// then the OpKernelContext will be ignored, and the internal optimized workers
+// pool will be used.
+//
+// The internal workers pool is disabled by default (false).
+void SetUseLocalContext(bool use_local_context);
+
+bool GetUseLocalContext();
+
+// Toggles the codepath. Enabled by default (true) on supported platforms.
+void SetEnabled(bool enabled);
+
+// Returns true if the codepath is supported and is enabled. Use this call
+// before calling the compute functions. If the codepath is not supported, and
+// any of the compute function is called, the library will log a FATAL error.
+bool IsSupportedAndEnabled();
+
+// Calculate the quantized matrix multiplication:
+//
+// for (i, j) in [0, m) x [0, n) do
+//   c_data[i, j] :=
+//     sum((a_data[i, l] + offset_a) * (b_data[l, j] + offset_b)) : l in [0, k)
+//
+// If transpose_a is false the lhs operand has row major layout, otherwise
+// column major. Similarly transpose_b describes the layout of the rhs operand.
+// lda, ldb, and ldc are the strides of the lhs operand, rhs operand and the
+// result arrays.
+void QuantizedGemm(OpKernelContext* context, bool transpose_a, bool transpose_b,
+                   const quint8* a_data, const quint8* b_data, qint32* c_data,
+                   int m, int n, int k, int offset_a, int offset_b, int lda,
+                   int ldb, int ldc);
+
+// Take an array of numbers from the range [input_min, input_max] quantized
+// uniformly to int32 values, recover their float values, and then quantize
+// them back uniformly to the range [output_min, output_max] as uint8.
+// Saturate the uint8 values.
+void Requantize(OpKernelContext* context, const qint32* input, int count,
+                float input_min, float input_max, float output_min,
+                float output_max, quint8* output);
+
+// Take an array of numbers from the range [range_min, range_max] quantized
+// uniformly to uint8 values and recover their float values.
+void Dequantize(OpKernelContext* context, const quint8* input, int count,
+                float range_min, float range_max, float* output);
+
+// Take an array of float values and quantize them uniformly to the range
+// [range_min, range_max] expressed as uint8. Saturate the uint8 values.
+void Quantize(OpKernelContext*, const float* input, int count, float range_min,
+              float range_max, quint8* output);
+
+// Take two arrays: the inputs and the bias quantized uniformly in the ranges
+// [input_min, input_max], and [bias_min, bias_max] accordingly, as uint8
+// values. Recover their float values. Add the values. Quantize them back
+// uniformly to the range [output_min, output_max] as int32. Saturate the
+// int32 values.
+void QuantizedBiasAdd(OpKernelContext* context, const quint8* input,
+                      int input_count, const quint8* bias, int bias_count,
+                      float input_min, float input_max, float bias_min,
+                      float bias_max, float output_min, float output_max,
+                      qint32* output);
+
+// Take an array of uint8 values and clamp them to the range [clamp_min,
+// clamp_max].
+void Clamp(OpKernelContext* context, const quint8* input, int input_count,
+           quint8 clamp_min, quint8 clamp_max, quint8* output);
+
+}  // namespace meta
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_META_SUPPORT_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/mfcc.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/mfcc.h
new file mode 100644
index 0000000000000000000000000000000000000000..790b5f7b1518bd0fe36af56d3016e1382eb9dec3
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/mfcc.h
@@ -0,0 +1,77 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// Basic class for computing MFCCs from spectrogram slices.
+
+#ifndef TENSORFLOW_CORE_KERNELS_MFCC_H_
+#define TENSORFLOW_CORE_KERNELS_MFCC_H_
+
+#include <vector>
+
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/kernels/mfcc_dct.h"
+#include "tensorflow/core/kernels/mfcc_mel_filterbank.h"
+#include "tensorflow/core/platform/logging.h"
+
+namespace tensorflow {
+
+class Mfcc {
+ public:
+  Mfcc();
+  bool Initialize(int input_length, double input_sample_rate);
+
+  // Input is a single squared-magnitude spectrogram frame. The input spectrum
+  // is converted to linear magnitude and weighted into bands using a
+  // triangular mel filterbank, and a discrete cosine transform (DCT) of the
+  // values is taken. Output is populated with the lowest dct_coefficient_count
+  // of these values.
+  void Compute(const std::vector<double>& spectrogram_frame,
+               std::vector<double>* output) const;
+
+  void set_upper_frequency_limit(double upper_frequency_limit) {
+    CHECK(!initialized_) << "Set frequency limits before calling Initialize.";
+    upper_frequency_limit_ = upper_frequency_limit;
+  }
+
+  void set_lower_frequency_limit(double lower_frequency_limit) {
+    CHECK(!initialized_) << "Set frequency limits before calling Initialize.";
+    lower_frequency_limit_ = lower_frequency_limit;
+  }
+
+  void set_filterbank_channel_count(int filterbank_channel_count) {
+    CHECK(!initialized_) << "Set channel count before calling Initialize.";
+    filterbank_channel_count_ = filterbank_channel_count;
+  }
+
+  void set_dct_coefficient_count(int dct_coefficient_count) {
+    CHECK(!initialized_) << "Set coefficient count before calling Initialize.";
+    dct_coefficient_count_ = dct_coefficient_count;
+  }
+
+ private:
+  MfccMelFilterbank mel_filterbank_;
+  MfccDct dct_;
+  bool initialized_;
+  double lower_frequency_limit_;
+  double upper_frequency_limit_;
+  int filterbank_channel_count_;
+  int dct_coefficient_count_;
+  Mfcc(const Mfcc&) = delete;
+  void operator=(const Mfcc&) = delete;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_MFCC_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/mfcc_dct.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/mfcc_dct.h
new file mode 100644
index 0000000000000000000000000000000000000000..e7982d6ac88403e6663444385c2a06e4786fefd4
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/mfcc_dct.h
@@ -0,0 +1,45 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// Basic minimal DCT class for MFCC speech processing.
+
+#ifndef TENSORFLOW_CORE_KERNELS_MFCC_DCT_H_
+#define TENSORFLOW_CORE_KERNELS_MFCC_DCT_H_
+
+#include <vector>
+
+#include "tensorflow/core/framework/op_kernel.h"
+
+namespace tensorflow {
+
+class MfccDct {
+ public:
+  MfccDct();
+  bool Initialize(int input_length, int coefficient_count);
+  void Compute(const std::vector<double>& input,
+               std::vector<double>* output) const;
+
+ private:
+  bool initialized_;
+  int coefficient_count_;
+  int input_length_;
+  std::vector<std::vector<double> > cosines_;
+  MfccDct(const MfccDct&) = delete;
+  void operator=(const MfccDct&) = delete;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_MFCC_DCT_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/mfcc_mel_filterbank.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/mfcc_mel_filterbank.h
new file mode 100644
index 0000000000000000000000000000000000000000..293d77457872cd752156e7d280763b19ad7b27bc
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/mfcc_mel_filterbank.h
@@ -0,0 +1,65 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// Basic class for applying a mel-scale mapping to a power spectrum.
+
+#ifndef TENSORFLOW_CORE_KERNELS_MFCC_MEL_FILTERBANK_H_
+#define TENSORFLOW_CORE_KERNELS_MFCC_MEL_FILTERBANK_H_
+
+#include <vector>
+#include "tensorflow/core/framework/op_kernel.h"
+
+namespace tensorflow {
+
+class MfccMelFilterbank {
+ public:
+  MfccMelFilterbank();
+  bool Initialize(int input_length,  // Number of unique FFT bins fftsize/2+1.
+                  double input_sample_rate, int output_channel_count,
+                  double lower_frequency_limit, double upper_frequency_limit);
+
+  // Takes a squared-magnitude spectrogram slice as input, computes a
+  // triangular-mel-weighted linear-magnitude filterbank, and places the result
+  // in output.
+  void Compute(const std::vector<double>& input,
+               std::vector<double>* output) const;
+
+ private:
+  double FreqToMel(double freq) const;
+  bool initialized_;
+  int num_channels_;
+  double sample_rate_;
+  int input_length_;
+  std::vector<double> center_frequencies_;  // In mel, for each mel channel.
+
+  // Each FFT bin b contributes to two triangular mel channels, with
+  // proportion weights_[b] going into mel channel band_mapper_[b], and
+  // proportion (1 - weights_[b]) going into channel band_mapper_[b] + 1.
+  // Thus, weights_ contains the weighting applied to each FFT bin for the
+  // upper-half of the triangular band.
+  std::vector<double> weights_;  // Right-side weight for this fft  bin.
+
+  // FFT bin i contributes to the upper side of mel channel band_mapper_[i]
+  std::vector<int> band_mapper_;
+  int start_index_;  // Lowest FFT bin used to calculate mel spectrum.
+  int end_index_;    // Highest FFT bin used to calculate mel spectrum.
+
+  MfccMelFilterbank(const MfccMelFilterbank&) = delete;
+  void operator=(const MfccMelFilterbank&) = delete;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_MFCC_MEL_FILTERBANK_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/multinomial_op.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/multinomial_op.h
new file mode 100644
index 0000000000000000000000000000000000000000..34e21236132ae950c8baacdd479618916ebd0751
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/multinomial_op.h
@@ -0,0 +1,30 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_MULTINOMIAL_OP_H_
+#define TENSORFLOW_CORE_KERNELS_MULTINOMIAL_OP_H_
+
+namespace tensorflow {
+
+namespace functor {
+
+// Generic helper functor for the Multinomial Op.
+template <typename Device, typename T, typename OutputType>
+struct MultinomialFunctor;
+
+}  // namespace functor
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_MULTINOMIAL_OP_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/nextafter_op.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/nextafter_op.h
new file mode 100644
index 0000000000000000000000000000000000000000..89a39f498c49ac2e1f90518f279711cd69b9da80
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/nextafter_op.h
@@ -0,0 +1,39 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_NEXTAFTER_OP_H_
+#define TENSORFLOW_CORE_KERNELS_NEXTAFTER_OP_H_
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/kernels/cwise_ops.h"
+
+namespace tensorflow {
+namespace functor {
+
+template <typename T>
+struct nextafter_op {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const T operator()(const T& x1,
+                                                           const T& x2) const {
+    return std::nextafter(x1, x2);
+  }
+};
+
+template <typename T>
+struct nextafter : base<T, nextafter_op<T>> {};
+
+}  // namespace functor
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_NEXTAFTER_OP_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/no_op.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/no_op.h
new file mode 100644
index 0000000000000000000000000000000000000000..9e16d069787ed5c630a5184636f65eb1903ebd76
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/no_op.h
@@ -0,0 +1,32 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_NO_OP_H_
+#define TENSORFLOW_CORE_KERNELS_NO_OP_H_
+
+#include "tensorflow/core/framework/op_kernel.h"
+
+namespace tensorflow {
+
+class NoOp : public OpKernel {
+ public:
+  explicit NoOp(OpKernelConstruction* context) : OpKernel(context) {}
+  void Compute(OpKernelContext* context) override {}
+  bool IsExpensive() override { return false; }
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_NO_OP_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/nth_element_op.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/nth_element_op.h
new file mode 100644
index 0000000000000000000000000000000000000000..7a5ec3d0b58a54f821b965e17b2a2280b52c75eb
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/nth_element_op.h
@@ -0,0 +1,37 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_NTH_ELEMENT_OP_H_
+#define TENSORFLOW_CORE_KERNELS_NTH_ELEMENT_OP_H_
+
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/tensor_types.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+
+namespace functor {
+
+template <typename Device, typename T>
+struct NthElementFunctor {
+  void operator()(OpKernelContext* context, const Tensor& input_tensor,
+                  Tensor& output_tensor, int n);
+};
+
+}  // namespace functor
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_NTH_ELEMENT_OP_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/numeric_options_utils.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/numeric_options_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..d9ea889b443a870ad95457e7408a557b65c9e8d4
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/numeric_options_utils.h
@@ -0,0 +1,33 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_NUMERIC_OPTIONS_UTILS_H_
+#define TENSORFLOW_CORE_KERNELS_NUMERIC_OPTIONS_UTILS_H_
+
+#include "xla/stream_executor/numeric_options.h"
+#include "tsl/platform/tensor_float_32_utils.h"
+#include "tsl/util/determinism.h"
+
+namespace tensorflow {
+
+inline stream_executor::NumericOptions GetNumericOptions() {
+  return stream_executor::NumericOptions{
+      /*require_determinism=*/tsl::OpDeterminismRequired(),
+      /*allow_tf32=*/tsl::tensor_float_32_execution_enabled()};
+}
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_NUMERIC_OPTIONS_UTILS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/one_hot_op.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/one_hot_op.h
new file mode 100644
index 0000000000000000000000000000000000000000..afcf287a55bb1abab86529c77f5cddff58959e15
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/one_hot_op.h
@@ -0,0 +1,125 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// See docs in ../ops/array_ops.cc
+
+#ifndef TENSORFLOW_CORE_KERNELS_ONE_HOT_OP_H_
+#define TENSORFLOW_CORE_KERNELS_ONE_HOT_OP_H_
+// Generator definition for OneHotOp, must be compilable by nvcc.
+
+#define EIGEN_USE_THREADS
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/framework/bounds_check.h"
+#include "tensorflow/core/framework/tensor_types.h"
+#include "tensorflow/core/platform/macros.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+
+typedef Eigen::ThreadPoolDevice CPUDevice;
+
+namespace generator {
+
+template <typename T, typename TI>
+class OneGenerator {
+ public:
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
+  OneGenerator(const typename TTypes<TI>::ConstMatrix& indices,
+               const typename TTypes<T>::ConstScalar& on_value,
+               const typename TTypes<T>::ConstScalar& off_value)
+      : indices_(indices), on_value_(on_value), off_value_(off_value) {}
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T
+  operator()(const Eigen::array<Eigen::DenseIndex, 3>& pre_depth_suff) const {
+    return (indices_(pre_depth_suff[0], pre_depth_suff[2]) == pre_depth_suff[1])
+               ? on_value_()
+               : off_value_();
+  }
+
+ private:
+  const typename TTypes<TI>::ConstMatrix indices_;
+  const typename TTypes<T>::ConstScalar on_value_;
+  const typename TTypes<T>::ConstScalar off_value_;
+};
+
+}  // namespace generator
+
+namespace functor {
+
+template <typename Device, typename T, typename TI>
+struct OneHot {
+  EIGEN_ALWAYS_INLINE static void Compute(
+      const Device& d, const typename TTypes<TI>::ConstMatrix& indices,
+      const typename TTypes<T>::ConstScalar& on_value,
+      const typename TTypes<T>::ConstScalar& off_value,
+      typename TTypes<T, 3>::Tensor* output) {
+    generator::OneGenerator<T, TI> generator(indices, on_value, off_value);
+    output->device(d) = output->generate(generator);
+  }
+};
+
+template <typename T, typename TI>
+struct OneHot<CPUDevice, T, TI> {
+  EIGEN_ALWAYS_INLINE static void Compute(
+      const CPUDevice& d, const typename TTypes<TI>::ConstMatrix& indices,
+      const typename TTypes<T>::ConstScalar& on_value,
+      const typename TTypes<T>::ConstScalar& off_value,
+      typename TTypes<T, 3>::Tensor* output) {
+    // Pre-fill output with `off_value`.
+    output->device(d) = output->constant(off_value());
+
+    // Iterate through indices and update on_value elements in the output.
+    Eigen::Index prefix_size = output->dimensions()[0];
+    Eigen::Index depth_size = output->dimensions()[1];
+    Eigen::Index suffix_size = output->dimensions()[2];
+
+    // Cost of setting one `on_value` coefficient.
+    double bytes_loaded = sizeof(T);
+    double bytes_stored = sizeof(T);
+    double cycles = 0.0;
+    const Eigen::TensorOpCost cost(bytes_loaded, bytes_stored, cycles);
+
+    if (suffix_size == 1) {
+      const auto func = [&](Eigen::Index start, Eigen::Index end) -> void {
+        for (Eigen::Index i = start; i < end; ++i) {
+          const TI depth = internal::SubtleMustCopy(indices(i, 0));
+          if (FastBoundsCheck(depth, depth_size)) {
+            (*output)(i, depth, 0) = on_value();
+          }
+        }
+      };
+      d.parallelFor(prefix_size, cost, func);
+    } else {
+      const auto func = [&](Eigen::Index start, Eigen::Index end) -> void {
+        for (Eigen::Index i = start; i < end; ++i) {
+          const Eigen::Index d0 = i / suffix_size;
+          const Eigen::Index d1 = i - (d0 * suffix_size);
+          const TI depth = internal::SubtleMustCopy(indices(d0, d1));
+          if (FastBoundsCheck(depth, depth_size)) {
+            (*output)(d0, depth, d1) = on_value();
+          }
+        }
+      };
+      d.parallelFor(prefix_size * suffix_size, cost * suffix_size, func);
+    }
+  }
+};
+
+}  // namespace functor
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_ONE_HOT_OP_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/ops_testutil.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/ops_testutil.h
new file mode 100644
index 0000000000000000000000000000000000000000..0a94bc4291920cd26c32054a1f5f216d68d47710
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/ops_testutil.h
@@ -0,0 +1,212 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_OPS_TESTUTIL_H_
+#define TENSORFLOW_CORE_KERNELS_OPS_TESTUTIL_H_
+
+#include <functional>
+#include <initializer_list>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "tensorflow/core/common_runtime/device.h"
+#include "tensorflow/core/common_runtime/device_factory.h"
+#include "tensorflow/core/common_runtime/device_mgr.h"
+#include "tensorflow/core/common_runtime/process_function_library_runtime.h"
+#include "tensorflow/core/framework/allocator.h"
+#include "tensorflow/core/framework/device_base.h"
+#include "tensorflow/core/framework/function.h"
+#include "tensorflow/core/framework/graph.pb.h"
+#include "tensorflow/core/framework/node_def.pb.h"
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/resource_mgr.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/tensor_shape.h"
+#include "tensorflow/core/framework/tensor_testutil.h"
+#include "tensorflow/core/framework/type_index.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/framework/types.pb.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/lib/core/status_test_util.h"
+#include "tensorflow/core/lib/gtl/array_slice.h"
+#include "tensorflow/core/lib/gtl/inlined_vector.h"
+#include "tensorflow/core/platform/env.h"
+#include "tensorflow/core/platform/logging.h"
+#include "tensorflow/core/platform/macros.h"
+#include "tensorflow/core/platform/mutex.h"
+#include "tensorflow/core/platform/status.h"
+#include "tensorflow/core/platform/test.h"
+#include "tensorflow/core/platform/threadpool.h"
+#include "tensorflow/core/platform/types.h"
+#include "tensorflow/core/public/session_options.h"
+#include "tensorflow/core/public/version.h"
+#include "tensorflow/core/util/tensor_slice_reader_cache.h"
+
+namespace tensorflow {
+namespace test {
+
+void SetOutputAttrs(OpKernelContext::Params* params,
+                    std::vector<AllocatorAttributes>* attrs);
+
+}  // namespace test
+
+// Helpful functions to test operators.
+//
+// This class will eventually be replaced / heavily modified
+// to use the BrainClient interface.
+class OpsTestBase : public ::testing::Test {
+ public:
+  OpsTestBase();
+
+  ~OpsTestBase() override;
+
+  // Allow kernel unit tests to run on GPU
+  void SetDevice(const DeviceType& device_type, std::unique_ptr<Device> device);
+
+  void set_node_def(const NodeDef& node_def);
+
+  // Clients can manipulate the underlying NodeDef via this accessor.
+  NodeDef* node_def();
+
+  // Initializes an operator that takes in 'input_types' as input
+  // and output types as output.
+  //
+  // Returns the status of initialization.
+  Status InitOp();
+
+  // Only use this directly if you have a deprecated op that you need to test.
+  Status InitOpWithGraphVersion(int graph_def_version);
+
+  // Adds an input for every element described by the shape.
+  // 'input_mapping' maps an index (0...NumElements(shape)) to a
+  // value.
+  //
+  // TODO(vrv): Replace with something like a BrainClient Feed.
+  template <typename T>
+  void AddInput(const TensorShape& shape, std::function<T(int)> input_mapping) {
+    test::FillFn(AddInput(DataTypeToEnum<T>::v(), shape), input_mapping);
+  }
+
+  // Like AddInput but takes in an explicit arrayslice of data.
+  template <typename T>
+  void AddInputFromArray(const TensorShape& shape,
+                         const gtl::ArraySlice<T> data) {
+    test::FillValues<T>(AddInput(DataTypeToEnum<T>::v(), shape), data);
+  }
+
+  // Convenience function to add an input and populate it with the elements from
+  // an initializer list converting the types as needed.
+  template <typename T, typename SrcType>
+  void AddInputFromList(const TensorShape& shape,
+                        std::initializer_list<SrcType> data) {
+    test::FillValues<T>(AddInput(DataTypeToEnum<T>::v(), shape), data);
+  }
+
+  // Adds a Resource type as input. If <container> is empty, uses the default
+  // container name.
+  template <typename T>
+  void AddResourceInput(const string& container, const string& name,
+                        T* resource) {
+    CHECK_GT(input_types_.size(), inputs_.size())
+        << "Adding more inputs than types; perhaps you need to call MakeOp";
+    ResourceMgr* rm = device_->resource_manager();
+    std::string container_name =
+        container.empty() ? rm->default_container() : container;
+    EXPECT_TRUE(rm->Create(container_name, name, resource).ok());
+    AddResourceInputInternal(container_name, name, TypeIndex::Make<T>());
+  }
+
+  // Runs an operation producing 'num_outputs' outputs.
+  //
+  // Returns the context's status after running the operation.
+  Status RunOpKernel();
+
+  // Returns the tensor input for 'input_index'.
+  //
+  // REQUIRES: 0 <= input_index < context_->num_inputs()
+  const Tensor& GetInput(int input_index) const;
+
+  TensorValue mutable_input(int input_index);
+
+  // Returns the tensor output for 'output_index'.
+  //
+  // REQUIRES: 0 <= output_index < context_->num_outputs()
+  Tensor* GetOutput(int output_index);
+
+  Allocator* allocator();
+
+  OpKernel* op_kernel();
+
+  const DataTypeVector& output_types() const;
+
+  void set_session_metadata(SessionMetadata session_metadata) {
+    session_metadata_ = std::move(session_metadata);
+  }
+
+  const SessionMetadata& session_metadata() const { return session_metadata_; }
+
+ protected:
+  void CreateContext();
+  Tensor* AddInput(DataType dtype, const TensorShape& shape);
+  void AddResourceInputInternal(const std::string& container_name,
+                                const std::string& name,
+                                const TypeIndex& type_index);
+
+  // device_mgr_ owns device_.
+  std::unique_ptr<DeviceMgr> device_mgr_;
+  Device* device_;
+
+  // The device allocator, or the managed_allocator_ below if running on GPU.
+  Allocator* allocator_;
+
+  std::unique_ptr<OpKernel> kernel_;
+  std::unique_ptr<ScopedStepContainer> step_container_;
+  NodeDef node_def_;
+  DataTypeVector input_types_;
+  DeviceType device_type_;
+
+  mutex lock_for_refs_;  // Used as the Mutex for inputs added as refs
+
+  gtl::InlinedVector<TensorValue, 4> inputs_;
+  // Owns Tensors.
+  std::vector<Tensor*> tensors_;
+  // Copies of the outputs in unified memory (host and device accessible).
+  std::vector<Tensor*> managed_outputs_;
+
+  // AllocatorAttributes for the allocators of the outputs.
+  std::vector<AllocatorAttributes> out_alloc_attrs_;
+  checkpoint::TensorSliceReaderCacheWrapper slice_reader_cache_wrapper_;
+  CancellationManager default_cancellation_manager_;
+  std::unique_ptr<OpKernelContext::Params> params_;
+  std::unique_ptr<OpKernelContext> context_;
+  // Unified memory allocator, only used when running on GPU.
+  std::unique_ptr<Allocator> managed_allocator_;
+
+  std::unique_ptr<FunctionLibraryDefinition> flib_def_;
+  std::unique_ptr<ProcessFunctionLibraryRuntime> pflr_;
+  std::unique_ptr<thread::ThreadPool> thread_pool_;
+
+  SessionMetadata session_metadata_;
+
+ private:
+  OpsTestBase(const OpsTestBase&) = delete;
+  void operator=(const OpsTestBase&) = delete;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_OPS_TESTUTIL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/ops_util.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/ops_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..842dd7984b34effa1d015af00f4a5caa7e90b3ef
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/ops_util.h
@@ -0,0 +1,22 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_OPS_UTIL_H_
+#define TENSORFLOW_CORE_KERNELS_OPS_UTIL_H_
+
+// Placeholder for the ops_util library that is moved under core/framework.
+#include "tensorflow/core/framework/ops_util.h"
+
+#endif  // TENSORFLOW_CORE_KERNELS_OPS_UTIL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/pad_op.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/pad_op.h
new file mode 100644
index 0000000000000000000000000000000000000000..34a19dfc80f65368841ba1e854d3b0e2ae843059
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/pad_op.h
@@ -0,0 +1,56 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_PAD_OP_H_
+#define TENSORFLOW_CORE_KERNELS_PAD_OP_H_
+// Functor definition for PadOp, must be compilable by nvcc.
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/framework/tensor_types.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+namespace functor {
+
+// Functor used by PadOp to do the computations.
+template <typename Device, typename T, typename Tpadding, int Dims>
+struct Pad {
+  // Pad "input" into "output", as specified by "paddings" and "pad_value".
+  // See pad_op.cc for details.
+  void operator()(const Device& d, typename TTypes<T, Dims>::Tensor output,
+                  typename TTypes<T, Dims>::ConstTensor input,
+                  Eigen::array<Eigen::IndexPair<Tpadding>, Dims> paddings,
+                  T pad_value) {
+    MaybeWith32BitIndexing<Device>(
+        [&](auto output32, auto input32) {
+          output32.device(d) = input32.pad(paddings, pad_value);
+        },
+        output, input);
+  }
+};
+
+template <typename Device, typename T, typename Tpadding>
+struct Pad<Device, T, Tpadding, 0> {
+  // In the scalar case we simply copy the input.
+  void operator()(const Device& d, typename TTypes<T, 0>::Tensor output,
+                  typename TTypes<T, 0>::ConstTensor input,
+                  Eigen::array<Eigen::IndexPair<Tpadding>, 0>, T) {
+    output.device(d) = input;
+  }
+};
+}  // namespace functor
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_PAD_OP_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/padding_fifo_queue.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/padding_fifo_queue.h
new file mode 100644
index 0000000000000000000000000000000000000000..939e04dd5e769b96258dfc840e733ecec5e4b873
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/padding_fifo_queue.h
@@ -0,0 +1,90 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_PADDING_FIFO_QUEUE_H_
+#define TENSORFLOW_CORE_KERNELS_PADDING_FIFO_QUEUE_H_
+
+#include <deque>
+#include <vector>
+
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/partial_tensor_shape.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/tensor_shape.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/kernels/fifo_queue.h"
+#include "tensorflow/core/kernels/typed_queue.h"
+#include "tensorflow/core/platform/macros.h"
+#include "tensorflow/core/platform/mutex.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+
+class PaddingFIFOQueue : public FIFOQueue {
+ public:
+  PaddingFIFOQueue(int32_t capacity, const DataTypeVector& component_dtypes,
+                   const std::vector<PartialTensorShape>& component_shapes,
+                   const string& name);
+
+  Status Initialize() override;
+
+  // Implementations of QueueInterface methods --------------------------------
+
+  void TryDequeueMany(int num_elements, OpKernelContext* ctx,
+                      bool allow_small_batch,
+                      CallbackWithTuple callback) override;
+  Status MatchesNodeDef(const NodeDef& node_def) override;
+
+ protected:
+  Status ValidateManyTuple(const Tuple& tuple) override;
+  Status ValidateTuple(const Tuple& tuple) override;
+  Status CompatibleNodeDefShapes(const NodeDef& node_def) const;
+
+  // Convert a list of PartialTensorShape to a list of
+  // TensorShape.
+  // Any unknown dimension sizes are converted to 0.
+  // REQUIRED: All the input shapes have well defined rank.
+  static std::vector<TensorShape> ConvertShapesPartialDimensionsToZero(
+      const gtl::ArraySlice<PartialTensorShape>& partial_shapes);
+
+  // Sets the values in the given element to zero.
+  static Status SetElementZero(Tensor* element);
+
+  // Copies element into the index^th slice (in the first dimension)
+  // of parent.  Allows for the parent's slice to have a larger size
+  // than the element, and copies the element into the upper left hand
+  // corner of the slice.
+  static Status CopyElementToLargerSlice(const Tensor& element, Tensor* parent,
+                                         int index);
+
+  std::vector<PartialTensorShape> partial_shapes_;
+
+ private:
+  ~PaddingFIFOQueue() override {}
+
+  static Status GetElementComponent(const PaddingFIFOQueue::Tuple& tuple,
+                                    int component, OpKernelContext* ctx,
+                                    Tensor* out_tensor);
+
+  static Status IsSameSizeExceptZerosInFirst(const TensorShape& first,
+                                             const TensorShape& second);
+
+  PaddingFIFOQueue(const PaddingFIFOQueue&) = delete;
+  void operator=(const PaddingFIFOQueue&) = delete;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_PADDING_FIFO_QUEUE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/parameterized_truncated_normal_op.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/parameterized_truncated_normal_op.h
new file mode 100644
index 0000000000000000000000000000000000000000..4df75c783694ec71dd732f1409f991c11643d4c3
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/parameterized_truncated_normal_op.h
@@ -0,0 +1,66 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_PARAMETERIZED_TRUNCATED_NORMAL_OP_H_
+#define TENSORFLOW_CORE_KERNELS_PARAMETERIZED_TRUNCATED_NORMAL_OP_H_
+
+#include "tensorflow/core/framework/tensor_types.h"
+#include "tensorflow/core/lib/random/random_distributions.h"
+#include "tensorflow/core/util/bcast.h"
+
+namespace tensorflow {
+
+class OpKernelContext;
+
+namespace functor {
+
+// Sample a truncated normal random variable, with mean, stddev, minval, and
+// maxval parameters for each batch. Uses two rejection sampling algorithms
+// described in http://rd.springer.com/article/10.1007/BF00143942 and a randn
+// rejection sampler when most of the normal is inside the bounds.
+//
+// Either minval may be -infinity, or maxval may be +infinity. If the interval
+// (minval, maxval) is empty, the result is NaN.
+template <typename Device, typename T>
+struct TruncatedNormalFunctor {
+  void operator()(OpKernelContext* ctx, const Device& d, int64_t num_batches,
+                  int64_t samples_per_batch, int64_t num_elements,
+                  typename TTypes<T>::ConstFlat means,
+                  typename TTypes<T>::ConstFlat stddevs,
+                  typename TTypes<T>::ConstFlat minvals,
+                  typename TTypes<T>::ConstFlat maxvals,
+                  const random::PhiloxRandom& gen,
+                  typename TTypes<T>::Flat output);
+};
+
+// This version supports broadcasting of the arguments, as well as puts
+// the sample dimension on the left.
+template <typename Device, typename T>
+struct TruncatedNormalFunctorV2 {
+  void operator()(OpKernelContext* ctx, const Device& d, int64_t num_batches,
+                  int64_t samples_per_batch, int64_t num_elements,
+                  const BCastList<4>& bcast,
+                  typename TTypes<T>::ConstFlat means,
+                  typename TTypes<T>::ConstFlat stddevs,
+                  typename TTypes<T>::ConstFlat minvals,
+                  typename TTypes<T>::ConstFlat maxvals,
+                  const random::PhiloxRandom& gen,
+                  typename TTypes<T>::Flat output);
+};
+
+}  // namespace functor
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_PARAMETERIZED_TRUNCATED_NORMAL_OP_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/partitioned_function_ops.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/partitioned_function_ops.h
new file mode 100644
index 0000000000000000000000000000000000000000..6ae267b90a9414619afb0ba34f2102c8c881f632
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/partitioned_function_ops.h
@@ -0,0 +1,73 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_PARTITIONED_FUNCTION_OPS_H_
+#define TENSORFLOW_CORE_KERNELS_PARTITIONED_FUNCTION_OPS_H_
+
+#include "tensorflow/core/common_runtime/function.h"
+#include "tensorflow/core/framework/function.h"
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/tensor.h"
+
+namespace tensorflow {
+
+class NameAttrList;
+class ConfigProto;
+
+// A `PartitionedCallOp` asynchronously executes a function, potentially across
+// multiple devices but within a single process. The kernel places and
+// partitions a given function's underlying graph, and executes each of the
+// partitioned subgraphs as a function.
+//
+// TODO(akshayka): Support distributed execution.
+class PartitionedCallOp : public AsyncOpKernel {
+ public:
+  explicit PartitionedCallOp(OpKernelConstruction* ctx);
+
+  ~PartitionedCallOp() override;
+
+  void ComputeAsync(OpKernelContext* ctx, DoneCallback done) override;
+
+ protected:
+  Status FillOutputDevices(const FunctionLibraryRuntime& lib,
+                           const Device& cpu_device, AttrSlice attrs,
+                           FunctionLibraryRuntime::InstantiateOptions* opts);
+
+  Status Instantiate(FunctionLibraryRuntime* lib, OpKernelContext* ctx,
+                     std::vector<Tensor>* inputs,
+                     FunctionLibraryRuntime::Handle* handle);
+
+  void RunFunction(FunctionLibraryRuntime::Handle handle,
+                   const std::vector<Tensor>& inputs,
+                   FunctionLibraryRuntime* lib, OpKernelContext* ctx,
+                   DoneCallback done);
+
+  // Using unique pointers to avoid including proto headers in kernel headers
+  std::unique_ptr<NameAttrList> func_;
+  std::unique_ptr<ConfigProto> config_proto_;
+  string executor_type_;
+  bool shared_rendezvous_;
+  mutex mu_;
+  // Cache the handle per FLR because this kernel may be instantiated for
+  // a stateful op, different invocations of it may use different FLRs.
+  // Different device placements of PartitionedCallOp also use
+  // different FLRs.
+  gtl::FlatMap<FunctionLibraryRuntime*, FunctionLibraryRuntime::Handle> handles_
+      TF_GUARDED_BY(mu_);
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_PARTITIONED_FUNCTION_OPS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/poisson-loss.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/poisson-loss.h
new file mode 100644
index 0000000000000000000000000000000000000000..12888bda3135aaae78aaa57ce4f3b7363bfa55b8
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/poisson-loss.h
@@ -0,0 +1,109 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_POISSON_LOSS_H_
+#define TENSORFLOW_CORE_KERNELS_POISSON_LOSS_H_
+
+#include <cmath>
+
+#include "tensorflow/core/kernels/loss.h"
+#include "tensorflow/core/lib/core/errors.h"
+
+namespace tensorflow {
+
+class PoissonLossUpdater : public DualLossUpdater {
+ public:
+  // Update is found by a Newton algorithm (see readme.md).
+  double ComputeUpdatedDual(const int num_loss_partitions, const double label,
+                            const double example_weight,
+                            const double current_dual, const double wx,
+                            const double weighted_example_norm) const final {
+    // Newton algorithm converges quadratically so 10 steps will be largely
+    // enough to achieve a very good precision
+    static const int newton_total_steps = 10;
+    // Initialize the Newton optimization at x such that
+    // exp(x) = label - current_dual
+    const double y_minus_a = label - current_dual;
+    double x = (y_minus_a > 0) ? log(y_minus_a) : 0;
+    for (int i = 0; i < newton_total_steps; ++i) {
+      x = NewtonStep(x, num_loss_partitions, label, wx, example_weight,
+                     weighted_example_norm, current_dual);
+    }
+    return label - exp(x);
+  }
+
+  // Dual of poisson loss function.
+  // https://en.wikipedia.org/wiki/Convex_conjugate
+  double ComputeDualLoss(const double current_dual, const double example_label,
+                         const double example_weight) const final {
+    // Dual of the poisson loss function is
+    // (y-a)*(log(y-a)-1), where a is the dual variable.
+    // It is defined only for a<y.
+    const double y_minus_a = example_label - current_dual;
+    if (y_minus_a == 0.0) {
+      // (y-a)*(log(y-a)-1) approaches 0 as y-a approaches 0.
+      return 0.0;
+    }
+    if (y_minus_a < 0.0) {
+      return std::numeric_limits<double>::max();
+    }
+    return y_minus_a * (log(y_minus_a) - 1) * example_weight;
+  }
+
+  double ComputePrimalLoss(const double wx, const double example_label,
+                           const double example_weight) const final {
+    return (exp(wx) - wx * example_label) * example_weight;
+  }
+
+  double PrimalLossDerivative(const double wx, const double label,
+                              const double example_weight) const final {
+    return (exp(wx) - label) * example_weight;
+  }
+
+  // TODO(chapelle): We need to introduce a maximum_prediction parameter,
+  // expose that parameter to the user and have this method return
+  // 1.0/maximum_prediction.
+  // Setting this at 1 for now, it only impacts the adaptive sampling.
+  double SmoothnessConstant() const final { return 1; }
+
+  Status ConvertLabel(float* const example_label) const final {
+    if (*example_label < 0.0) {
+      return errors::InvalidArgument(
+          "Only non-negative labels can be used with the Poisson log loss. "
+          "Found example with label: ", *example_label);
+    }
+    return OkStatus();
+  }
+
+ private:
+  // One Newton step (see readme.md).
+  double NewtonStep(const double x, const int num_loss_partitions,
+                    const double label, const double wx,
+                    const double example_weight,
+                    const double weighted_example_norm,
+                    const double current_dual) const {
+    const double expx = exp(x);
+    const double numerator =
+        x - wx - num_loss_partitions * weighted_example_norm *
+        example_weight * (label - current_dual - expx);
+    const double denominator =
+       1 + num_loss_partitions * weighted_example_norm * example_weight * expx;
+    return x - numerator / denominator;
+  }
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_LOGISTIC_LOSS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/pooling_ops_3d.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/pooling_ops_3d.h
new file mode 100644
index 0000000000000000000000000000000000000000..eab41a60d694fc45719bac0fd484974d552892fa
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/pooling_ops_3d.h
@@ -0,0 +1,80 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_POOLING_OPS_3D_H_
+#define TENSORFLOW_CORE_KERNELS_POOLING_OPS_3D_H_
+
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/util/padding.h"
+#include "tensorflow/core/util/tensor_format.h"
+
+namespace tensorflow {
+
+enum PoolingType { MAX, AVG };
+
+template <typename Device, typename T, PoolingType Type>
+struct LaunchPoolingOp;
+
+template <typename Device, typename T>
+struct LaunchAvgPooling3dGradOp;
+
+template <typename Device, typename T>
+struct LaunchMaxPooling3dGradOp;
+
+template <typename Device, typename T>
+struct LaunchMaxPooling3dGradGradOp;
+
+// A helper class to manage sizes and shapes for 3d pooling operations.
+struct Pool3dParameters {
+  // Updates context->status if there is an invalid input.
+  Pool3dParameters(OpKernelContext* context, const std::vector<int32>& ksize,
+                   const std::vector<int32>& stride, Padding padding,
+                   TensorFormat data_format,
+                   const TensorShape& tensor_in_shape);
+
+  // Returns the shape of the output for "forward" pooling operations.
+  Status forward_output_shape(TensorShape* shape);
+
+  int depth;
+
+  int tensor_in_planes;
+  int tensor_in_cols;
+  int tensor_in_rows;
+  int tensor_in_batch;
+
+  int window_planes;
+  int window_cols;
+  int window_rows;
+  int depth_window;
+
+  int plane_stride;
+  int col_stride;
+  int row_stride;
+  int depth_stride;
+
+  int64_t out_plane;
+  int64_t out_height;
+  int64_t out_width;
+
+  int64_t pad_planes;
+  int64_t pad_cols;
+  int64_t pad_rows;
+
+  TensorFormat data_format;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_POOLING_OPS_3D_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/pooling_ops_3d_gpu.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/pooling_ops_3d_gpu.h
new file mode 100644
index 0000000000000000000000000000000000000000..002964a3aa1cf30327591ea7330601979a72c85d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/pooling_ops_3d_gpu.h
@@ -0,0 +1,48 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#if !GOOGLE_CUDA && !TENSORFLOW_USE_ROCM
+#error This file must only be included when building with Cuda or ROCm support
+#endif
+
+#ifndef TENSORFLOW_CORE_KERNELS_POOLING_OPS_3D_GPU_H_
+#define TENSORFLOW_CORE_KERNELS_POOLING_OPS_3D_GPU_H_
+
+#define EIGEN_USE_GPU
+
+#include "tensorflow/core/framework/tensor_types.h"
+#include "tensorflow/core/platform/types.h"
+#include "tensorflow/core/util/tensor_format.h"
+
+namespace tensorflow {
+
+namespace functor {
+template <typename T>
+struct MaxPool3dGradBackward {
+  bool operator()(TensorFormat data_format, const T* bottom_data,
+                  const T* output_data, const int batch, const int pooled_plane,
+                  const int pooled_height, const int pooled_width,
+                  const int channels, const int plane, const int height,
+                  const int width, const int kernel_p, const int kernel_h,
+                  const int kernel_w, const int stride_p, const int stride_h,
+                  const int stride_w, const int pad_p, const int pad_t,
+                  const int pad_l, const T* top_diff, T* bottom_diff,
+                  const Eigen::GpuDevice& d);
+};
+}  // namespace functor
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_POOLING_OPS_3D_GPU_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/pooling_ops_common.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/pooling_ops_common.h
new file mode 100644
index 0000000000000000000000000000000000000000..8513ea1644d19962fe7416bb5c5818fe4dcc7f1c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/pooling_ops_common.h
@@ -0,0 +1,679 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_POOLING_OPS_COMMON_H_
+#define TENSORFLOW_CORE_KERNELS_POOLING_OPS_COMMON_H_
+
+#include <vector>
+
+#if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+#define EIGEN_USE_GPU
+#endif  // GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/framework/bounds_check.h"
+#include "tensorflow/core/framework/numeric_op.h"
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/tensor_shape.h"
+#include "tensorflow/core/kernels/avgpooling_op.h"
+#include "tensorflow/core/kernels/maxpooling_op.h"
+#include "tensorflow/core/kernels/ops_util.h"
+#include "tensorflow/core/util/padding.h"
+#include "tensorflow/core/util/tensor_format.h"
+#include "tensorflow/core/util/work_sharder.h"
+
+#if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+#include "tensorflow/core/kernels/maxpooling_op_gpu.h"
+#endif  // GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+
+namespace tensorflow {
+
+typedef Eigen::GpuDevice GPUDevice;
+
+// A helper class to manage sizes and shapes for pooling operations.
+struct PoolParameters {
+  // Updates context->status if there is an invalid input.
+  // explicit_paddings has eight elements if padding==EXPLIICT, and zero
+  // elements otherwise.
+  PoolParameters(OpKernelContext* context, const std::vector<int32>& ksize,
+                 const std::vector<int32>& stride, Padding padding,
+                 std::vector<int64_t> explicit_paddings,
+                 TensorFormat data_format, const TensorShape& tensor_in_shape);
+
+  // Returns the shape of the output for "forward" pooling operations.
+  Status forward_output_shape(TensorShape* shape);
+
+  int depth;
+
+  int tensor_in_cols;
+  int tensor_in_rows;
+  int tensor_in_batch;
+
+  int window_rows;
+  int window_cols;
+  int depth_window;
+
+  int row_stride;
+  int col_stride;
+  int depth_stride;
+
+  int64_t out_height;
+  int64_t out_width;
+  int out_depth;
+
+  int64_t pad_top;
+  int64_t pad_bottom;
+  int64_t pad_left;
+  int64_t pad_right;
+
+  int pad_depth;
+
+  TensorFormat data_format;
+};
+
+// An implementation of MaxPooling (forward).
+// TODO (yongtang): Remove MaxPoolingOp and use MaxPoolingV2Op,
+//     QuantizedMaxPoolingOp depends on MaxPoolingOp so keep intact for now
+template <typename Device, typename T>
+class MaxPoolingOp : public OpKernel {
+ public:
+  explicit MaxPoolingOp(OpKernelConstruction* context) : OpKernel(context) {
+    string data_format;
+    auto status = context->GetAttr("data_format", &data_format);
+    if (status.ok()) {
+      OP_REQUIRES(context, FormatFromString(data_format, &data_format_),
+                  errors::InvalidArgument("Invalid data format"));
+      OP_REQUIRES(
+          context, data_format_ == FORMAT_NHWC,
+          errors::InvalidArgument("Default MaxPoolingOp only supports NHWC ",
+                                  "on device type ",
+                                  DeviceTypeString(context->device_type())));
+    } else {
+      data_format_ = FORMAT_NHWC;
+    }
+    OP_REQUIRES_OK(context, context->GetAttr("ksize", &ksize_));
+    OP_REQUIRES(context, ksize_.size() == 4,
+                errors::InvalidArgument("Sliding window ksize field must "
+                                        "specify 4 dimensions"));
+    for (int i = 0; i < ksize_.size(); ++i) {
+      OP_REQUIRES(context, ksize_[i] > 0,
+                  errors::InvalidArgument("Sliding window ksize for dimension ",
+                                          i, " was zero."));
+    }
+    OP_REQUIRES_OK(context, context->GetAttr("strides", &stride_));
+    OP_REQUIRES(context, stride_.size() == 4,
+                errors::InvalidArgument("Sliding window stride field must "
+                                        "specify 4 dimensions"));
+    OP_REQUIRES_OK(context, context->GetAttr("padding", &padding_));
+    if (padding_ == Padding::EXPLICIT) {
+      OP_REQUIRES_OK(
+          context, context->GetAttr("explicit_paddings", &explicit_paddings_));
+    }
+    OP_REQUIRES(context, ksize_[0] == 1 && stride_[0] == 1,
+                errors::Unimplemented(
+                    "Pooling is not yet supported on the batch dimension."));
+  }
+
+  void Compute(OpKernelContext* context) override {
+    const Tensor& tensor_in = context->input(0);
+    PoolParameters params{
+        context,     ksize_,           stride_, padding_, explicit_paddings_,
+        FORMAT_NHWC, tensor_in.shape()};
+    if (!context->status().ok()) {
+      return;
+    }
+
+    Tensor* output = nullptr;
+    TensorShape params_forward_output_shape;
+    OP_REQUIRES_OK(context,
+                   params.forward_output_shape(&params_forward_output_shape));
+    OP_REQUIRES_OK(context, context->allocate_output(
+                                0, params_forward_output_shape, &output));
+
+    if (params.depth_window > 1) {
+      // Validate spec against the current implementation.  A
+      // relaxation of these requirements would be ideal.
+      OP_REQUIRES(context, params.depth % params.depth_window == 0,
+                  errors::Unimplemented(
+                      "Depthwise max pooling requires "
+                      "the depth window to evenly divide the input depth."));
+      OP_REQUIRES(
+          context, params.depth_window == params.depth_stride,
+          errors::Unimplemented("Depthwise max pooling requires "
+                                "the depth window to equal the depth stride."));
+      OP_REQUIRES(
+          context, padding_ != EXPLICIT,
+          errors::Unimplemented("Depthwise max pooling does not support "
+                                "explicit padding."));
+
+      DepthwiseMaxPool(context, output, tensor_in, params);
+    } else {
+      // MaxPoolingOp is only called on the GPU when the eigen_tensor label
+      // is used. In this case, explicit padding is not supported
+      if (std::is_same<Device, GPUDevice>::value &&
+          padding_ == Padding::EXPLICIT) {
+        context->SetStatus(errors::Unimplemented(
+            "MaxPoolingOp does not support explicit padding."));
+        return;
+      }
+      SpatialMaxPool(context, output, tensor_in, params, padding_);
+    }
+  }
+
+ private:
+  // Single-threaded implementation of DepthwiseMaxPool which
+  // does not handle all of the same options as SpatialMaxPool
+  // (strict assumptions on no padding, stride).
+  //
+  // TODO(vrv): implement a more general depthwise-max pool that works
+  // on GPU as well.
+  void DepthwiseMaxPool(OpKernelContext* context, Tensor* output,
+                        const Tensor& tensor_in, const PoolParameters& params) {
+    Eigen::Map<const Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>>
+        in_by_pool(tensor_in.flat<T>().data(), params.depth_window,
+                   tensor_in.NumElements() / params.depth_window);
+    Eigen::Map<Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>> out_by_pool(
+        output->flat<T>().data(), 1, output->NumElements());
+    out_by_pool = in_by_pool.colwise().maxCoeff();
+  }
+
+  void SpatialMaxPool(OpKernelContext* context, Tensor* output,
+                      const Tensor& tensor_in, const PoolParameters& params,
+                      const Padding& padding) {
+    if (output->NumElements() == 0) {
+      return;
+    }
+    // On GPU, use Eigen's Spatial Max Pooling.  On CPU, use an
+    // EigenMatrix version that is currently faster than Eigen's
+    // Spatial MaxPooling implementation.
+    //
+    // TODO(vrv): Remove this once we no longer need it.
+    if (std::is_same<Device, GPUDevice>::value) {
+      Eigen::PaddingType pt = BrainPadding2EigenPadding(padding);
+      functor::SpatialMaxPooling<Device, T>()(
+          context->eigen_device<Device>(), output->tensor<T, 4>(),
+          tensor_in.tensor<T, 4>(), params.window_rows, params.window_cols,
+          params.row_stride, params.col_stride, pt);
+    } else {
+      typedef Eigen::Map<const Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>>
+          ConstEigenMatrixMap;
+      typedef Eigen::Map<Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>>
+          EigenMatrixMap;
+
+      ConstEigenMatrixMap in_mat(tensor_in.flat<T>().data(), params.depth,
+                                 params.tensor_in_cols * params.tensor_in_rows *
+                                     params.tensor_in_batch);
+      EigenMatrixMap out_mat(
+          output->flat<T>().data(), params.depth,
+          params.out_width * params.out_height * params.tensor_in_batch);
+
+      const DeviceBase::CpuWorkerThreads& worker_threads =
+          *(context->device()->tensorflow_cpu_worker_threads());
+
+      // The following code basically does the following:
+      // 1. Flattens the input and output tensors into two dimensional arrays.
+      //    tensor_in_as_matrix:
+      //      depth by (tensor_in_cols * tensor_in_rows * tensor_in_batch)
+      //    output_as_matrix:
+      //      depth by (out_width * out_height * tensor_in_batch)
+      //
+      // 2. Walks through the set of columns in the flattened
+      // tensor_in_as_matrix,
+      //    and updates the corresponding column(s) in output_as_matrix with the
+      //    max value.
+      auto shard = [&params, &in_mat, &out_mat](int64_t start, int64_t limit) {
+        const int32_t in_rows = params.tensor_in_rows;
+        const int32_t in_cols = params.tensor_in_cols;
+        const int32_t pad_top = params.pad_top;
+        const int32_t pad_left = params.pad_left;
+        const int32_t window_rows = params.window_rows;
+        const int32_t window_cols = params.window_cols;
+        const int32_t row_stride = params.row_stride;
+        const int32_t col_stride = params.col_stride;
+        const int32_t out_height = params.out_height;
+        const int32_t out_width = params.out_width;
+
+        {
+          // Initializes the output tensor with MIN<T>.
+          const int32_t output_image_size =
+              out_height * out_width * params.depth;
+          EigenMatrixMap out_shard(out_mat.data() + start * output_image_size,
+                                   1, (limit - start) * output_image_size);
+          out_shard.setConstant(Eigen::NumTraits<T>::lowest());
+        }
+
+        for (int32_t b = start; b < limit; ++b) {
+          const int32_t out_offset_batch = b * out_height;
+          for (int32_t h = 0; h < in_rows; ++h) {
+            for (int32_t w = 0; w < in_cols; ++w) {
+              // (h_start, h_end) * (w_start, w_end) is the range that the input
+              // vector projects to.
+              const int32_t hpad = h + pad_top;
+              const int32_t wpad = w + pad_left;
+              const int32_t h_start =
+                  (hpad < window_rows) ? 0
+                                       : (hpad - window_rows) / row_stride + 1;
+              const int32_t h_end = std::min(hpad / row_stride + 1, out_height);
+              const int32_t w_start =
+                  (wpad < window_cols) ? 0
+                                       : (wpad - window_cols) / col_stride + 1;
+              const int32_t w_end = std::min(wpad / col_stride + 1, out_width);
+              // compute elementwise max
+              const int32_t in_offset = (b * in_rows + h) * in_cols + w;
+              for (int32_t ph = h_start; ph < h_end; ++ph) {
+                const int32_t out_offset_base =
+                    (out_offset_batch + ph) * out_width;
+                for (int32_t pw = w_start; pw < w_end; ++pw) {
+                  const int32_t out_offset = out_offset_base + pw;
+                  out_mat.col(out_offset) =
+                      out_mat.col(out_offset).cwiseMax(in_mat.col(in_offset));
+                }
+              }
+            }
+          }
+        }
+      };
+
+      // TODO(andydavis) Consider sharding across batch x rows x cols.
+      // TODO(andydavis) Consider a higher resolution shard cost model.
+      const int64_t shard_cost =
+          params.tensor_in_rows * params.tensor_in_cols * params.depth;
+      Shard(worker_threads.num_threads, worker_threads.workers,
+            params.tensor_in_batch, shard_cost, shard);
+    }
+  }
+
+  std::vector<int32> ksize_;
+  std::vector<int32> stride_;
+  Padding padding_;
+  std::vector<int64_t> explicit_paddings_;
+  TensorFormat data_format_;
+};
+
+template <typename Device>
+struct LaunchMaxPoolingNoMask_NCHW_VECT_C;
+
+#if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+template <>
+struct LaunchMaxPoolingNoMask_NCHW_VECT_C<Eigen::GpuDevice> {
+  static void launch(OpKernelContext* context, const PoolParameters& params,
+                     const Tensor& input, Tensor* output) {
+#if GOOGLE_CUDA
+    bool status = functor::MaxPoolForwardNoMask_NCHW_VECT_C()(
+        reinterpret_cast<const int32*>(input.flat<qint8>().data()),
+        params.tensor_in_batch, params.tensor_in_rows, params.tensor_in_cols,
+        params.depth, params.out_height, params.out_width, params.window_rows,
+        params.window_cols, params.row_stride, params.col_stride,
+        params.pad_top, params.pad_left,
+        reinterpret_cast<int32*>(output->flat<qint8>().data()),
+        context->eigen_gpu_device());
+    if (!status) {
+      context->SetStatus(errors::Internal(
+          "Failed launching LaunchMaxPoolingNoMask_NCHW_VECT_C"));
+    }
+#else
+    // ROCm TODO: add support __vmaxs4 on ROCm
+    context->SetStatus(errors::Internal(
+        "Failed launching LaunchMaxPoolingNoMask_NCHW_VECT_C"));
+#endif  // GOOGLE_CUDA
+  }
+};
+#endif  // GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+
+template <typename Device, typename T>
+class MaxPoolingV2Op : public OpKernel {
+ public:
+  explicit MaxPoolingV2Op(OpKernelConstruction* context) : OpKernel(context) {
+    string data_format;
+    auto status = context->GetAttr("data_format", &data_format);
+    if (status.ok()) {
+      OP_REQUIRES(context, FormatFromString(data_format, &data_format_),
+                  errors::InvalidArgument("Invalid data format"));
+      OP_REQUIRES(
+          context,
+          data_format_ == FORMAT_NHWC || data_format_ == FORMAT_NCHW_VECT_C,
+          errors::InvalidArgument(
+              "MaxPoolingV2Op only supports NHWC or NCHW_VECT_C. Got: ",
+              data_format));
+    } else {
+      data_format_ = FORMAT_NHWC;
+    }
+    if (context->num_inputs() == 1) {
+      OP_REQUIRES_OK(context, context->GetAttr("ksize", &ksize_));
+      OP_REQUIRES(context, ksize_.size() == 4,
+                  errors::InvalidArgument("Sliding window ksize field must "
+                                          "specify 4 dimensions"));
+      OP_REQUIRES(
+          context,
+          ksize_[0] > 0 && ksize_[1] > 0 && ksize_[2] > 0 && ksize_[3] > 0,
+          errors::InvalidArgument("Sliding window ksize must be positive."));
+      OP_REQUIRES_OK(context, context->GetAttr("strides", &stride_));
+      OP_REQUIRES(context, stride_.size() == 4,
+                  errors::InvalidArgument("Sliding window stride field must "
+                                          "specify 4 dimensions"));
+      OP_REQUIRES(context, ksize_[0] == 1 && stride_[0] == 1,
+                  errors::Unimplemented(
+                      "Pooling is not yet supported on the batch dimension."));
+    }
+    OP_REQUIRES_OK(context, context->GetAttr("padding", &padding_));
+  }
+
+  void Compute(OpKernelContext* context) override {
+    const Tensor& tensor_in = context->input(0);
+
+    std::vector<int32> ksize = ksize_;
+    std::vector<int32> stride = stride_;
+
+    if (context->num_inputs() != 1) {
+      const Tensor& tensor_ksize = context->input(1);
+      auto value_ksize = tensor_ksize.flat<int32>();
+      ksize.resize(tensor_ksize.shape().num_elements());
+      std::copy_n(&value_ksize(0), ksize.size(), ksize.begin());
+
+      const Tensor& tensor_stride = context->input(2);
+      auto value_stride = tensor_stride.flat<int32>();
+      stride.resize(tensor_stride.shape().num_elements());
+      std::copy_n(&value_stride(0), stride.size(), stride.begin());
+    }
+
+    OP_REQUIRES(context, ksize.size() == 4,
+                errors::InvalidArgument("Sliding window ksize field must "
+                                        "specify 4 dimensions"));
+    OP_REQUIRES(
+        context, ksize[0] > 0 && ksize[1] > 0 && ksize[2] > 0 && ksize[3] > 0,
+        errors::InvalidArgument("Sliding window ksize must be positive."));
+    OP_REQUIRES(context, stride.size() == 4,
+                errors::InvalidArgument("Sliding window stride field must "
+                                        "specify 4 dimensions"));
+    OP_REQUIRES(context, ksize[0] == 1 && stride[0] == 1,
+                errors::Unimplemented(
+                    "Pooling is not yet supported on the batch dimension."));
+
+    PoolParameters params{
+        context,
+        ksize,
+        stride,
+        padding_,
+        /*explicit_paddings=*/{},
+        data_format_,
+        tensor_in.shape(),
+    };
+    if (!context->status().ok()) {
+      return;
+    }
+
+    Tensor* output = nullptr;
+    TensorShape params_forward_output_shape;
+    OP_REQUIRES_OK(context,
+                   params.forward_output_shape(&params_forward_output_shape));
+    OP_REQUIRES_OK(context, context->allocate_output(
+                                0, params_forward_output_shape, &output));
+
+    if (params.depth_window > 1) {
+      // Validate spec against the current implementation.  A
+      // relaxation of these requirements would be ideal.
+      OP_REQUIRES(context, params.depth % params.depth_window == 0,
+                  errors::Unimplemented(
+                      "Depthwise max pooling requires "
+                      "the depth window to evenly divide the input depth."));
+      OP_REQUIRES(
+          context, params.depth_window == params.depth_stride,
+          errors::Unimplemented("Depthwise max pooling requires "
+                                "the depth window to equal the depth stride."));
+
+      DepthwiseMaxPool(context, output, tensor_in, params);
+    } else {
+      SpatialMaxPool(context, output, tensor_in, params, padding_);
+    }
+  }
+
+ private:
+  // Single-threaded implementation of DepthwiseMaxPool which
+  // does not handle all of the same options as SpatialMaxPool
+  // (strict assumptions on no padding, stride).
+  //
+  // TODO(vrv): implement a more general depthwise-max pool that works
+  // on GPU as well.
+  void DepthwiseMaxPool(OpKernelContext* context, Tensor* output,
+                        const Tensor& tensor_in, const PoolParameters& params) {
+    Eigen::Map<const Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>>
+        in_by_pool(tensor_in.flat<T>().data(), params.depth_window,
+                   tensor_in.NumElements() / params.depth_window);
+    Eigen::Map<Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>> out_by_pool(
+        output->flat<T>().data(), 1, output->NumElements());
+    out_by_pool = in_by_pool.colwise().maxCoeff();
+  }
+
+  void SpatialMaxPool(OpKernelContext* context, Tensor* output,
+                      const Tensor& tensor_in, const PoolParameters& params,
+                      const Padding& padding) {
+    if (output->NumElements() == 0) {
+      return;
+    }
+    // On GPU, use Eigen's Spatial Max Pooling.  On CPU, use an
+    // EigenMatrix version that is currently faster than Eigen's
+    // Spatial MaxPooling implementation.
+    //
+    // TODO(vrv): Remove this once we no longer need it.
+#if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+    if (std::is_same<Device, GPUDevice>::value) {
+      Eigen::PaddingType pt = BrainPadding2EigenPadding(padding);
+      if (std::is_same<T, qint8>::value) {
+        LaunchMaxPoolingNoMask_NCHW_VECT_C<GPUDevice>::launch(
+            context, params, tensor_in, output);
+      } else {
+        functor::SpatialMaxPooling<Device, T>()(
+            context->eigen_device<Device>(), output->tensor<T, 4>(),
+            tensor_in.tensor<T, 4>(), params.window_rows, params.window_cols,
+            params.row_stride, params.col_stride, pt);
+      }
+    } else
+#endif
+    {
+      typedef Eigen::Map<const Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>>
+          ConstEigenMatrixMap;
+      typedef Eigen::Map<Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>>
+          EigenMatrixMap;
+
+      ConstEigenMatrixMap in_mat(tensor_in.flat<T>().data(), params.depth,
+                                 params.tensor_in_cols * params.tensor_in_rows *
+                                     params.tensor_in_batch);
+      EigenMatrixMap out_mat(
+          output->flat<T>().data(), params.depth,
+          params.out_width * params.out_height * params.tensor_in_batch);
+
+      const DeviceBase::CpuWorkerThreads& worker_threads =
+          *(context->device()->tensorflow_cpu_worker_threads());
+
+      // The following code basically does the following:
+      // 1. Flattens the input and output tensors into two dimensional arrays.
+      //    tensor_in_as_matrix:
+      //      depth by (tensor_in_cols * tensor_in_rows * tensor_in_batch)
+      //    output_as_matrix:
+      //      depth by (out_width * out_height * tensor_in_batch)
+      //
+      // 2. Walks through the set of columns in the flattened
+      // tensor_in_as_matrix,
+      //    and updates the corresponding column(s) in output_as_matrix with the
+      //    max value.
+      auto shard = [&params, &in_mat, &out_mat](int64_t start, int64_t limit) {
+        const int32_t in_rows = params.tensor_in_rows;
+        const int32_t in_cols = params.tensor_in_cols;
+        const int32_t pad_top = params.pad_top;
+        const int32_t pad_left = params.pad_left;
+        const int32_t window_rows = params.window_rows;
+        const int32_t window_cols = params.window_cols;
+        const int32_t row_stride = params.row_stride;
+        const int32_t col_stride = params.col_stride;
+        const int32_t out_height = params.out_height;
+        const int32_t out_width = params.out_width;
+
+        {
+          // Initializes the output tensor with MIN<T>.
+          const int32_t output_image_size =
+              out_height * out_width * params.depth;
+          EigenMatrixMap out_shard(out_mat.data() + start * output_image_size,
+                                   1, (limit - start) * output_image_size);
+          out_shard.setConstant(Eigen::NumTraits<T>::lowest());
+        }
+
+        for (int32_t b = start; b < limit; ++b) {
+          const int32_t out_offset_batch = b * out_height;
+          for (int32_t h = 0; h < in_rows; ++h) {
+            for (int32_t w = 0; w < in_cols; ++w) {
+              // (h_start, h_end) * (w_start, w_end) is the range that the input
+              // vector projects to.
+              const int32_t hpad = h + pad_top;
+              const int32_t wpad = w + pad_left;
+              const int32_t h_start =
+                  (hpad < window_rows) ? 0
+                                       : (hpad - window_rows) / row_stride + 1;
+              const int32_t h_end = std::min(hpad / row_stride + 1, out_height);
+              const int32_t w_start =
+                  (wpad < window_cols) ? 0
+                                       : (wpad - window_cols) / col_stride + 1;
+              const int32_t w_end = std::min(wpad / col_stride + 1, out_width);
+              // compute elementwise max
+              const int32_t in_offset = (b * in_rows + h) * in_cols + w;
+              for (int32_t ph = h_start; ph < h_end; ++ph) {
+                const int32_t out_offset_base =
+                    (out_offset_batch + ph) * out_width;
+                for (int32_t pw = w_start; pw < w_end; ++pw) {
+                  const int32_t out_offset = out_offset_base + pw;
+                  out_mat.col(out_offset) =
+                      out_mat.col(out_offset).cwiseMax(in_mat.col(in_offset));
+                }
+              }
+            }
+          }
+        }
+      };
+
+      // TODO(andydavis) Consider sharding across batch x rows x cols.
+      // TODO(andydavis) Consider a higher resolution shard cost model.
+      const int64_t shard_cost =
+          params.tensor_in_rows * params.tensor_in_cols * params.depth;
+      Shard(worker_threads.num_threads, worker_threads.workers,
+            params.tensor_in_batch, shard_cost, shard);
+    }
+  }
+
+  std::vector<int32> ksize_;
+  std::vector<int32> stride_;
+  Padding padding_;
+  TensorFormat data_format_;
+};
+
+template <typename Device, typename T>
+void SpatialAvgPool(OpKernelContext* context, Tensor* output,
+                    const Tensor& input, const PoolParameters& params,
+                    const Padding& padding) {
+  if (output->NumElements() == 0) {
+    return;
+  }
+  typedef Eigen::Map<const Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>>
+      ConstEigenMatrixMap;
+  typedef Eigen::Map<Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>>
+      EigenMatrixMap;
+
+  auto in_flat = input.flat<T>();
+  auto out_flat = output->flat<T>();
+
+  auto shard = [&params, &in_flat, &out_flat](int64_t start, int64_t limit) {
+    // Calculate indices for this shards chunk of work.
+    const int64_t input_image_size =
+        params.tensor_in_rows * params.tensor_in_cols * params.depth;
+    const int64_t output_image_size =
+        params.out_width * params.out_height * params.depth;
+    const int64_t shard_batch_size = limit - start;
+
+    ConstEigenMatrixMap in_mat(
+        in_flat.data() + start * input_image_size, params.depth,
+        params.tensor_in_cols * params.tensor_in_rows * shard_batch_size);
+    EigenMatrixMap out_mat(
+        out_flat.data() + start * output_image_size, params.depth,
+        params.out_width * params.out_height * shard_batch_size);
+    Eigen::Matrix<T, Eigen::Dynamic, 1> out_count(out_mat.cols());
+    out_count.setZero();
+
+    // Initializes output to zero.
+    out_mat.setZero();
+
+    // The following code basically does the following:
+    // 1. Flattens the input and output tensors into two dimensional arrays.
+    //    tensor_in_as_matrix:
+    //      depth by (tensor_in_cols * tensor_in_rows * tensor_in_batch)
+    //    output_as_matrix:
+    //      depth by (out_width * out_height * tensor_in_batch)
+    //
+    // 2. Walks through the set of columns in the flattened
+    // tensor_in_as_matrix,
+    //    and updates the corresponding column(s) in output_as_matrix with the
+    //    average value.
+    for (int b = 0; b < shard_batch_size; ++b) {
+      for (int h = 0; h < params.tensor_in_rows; ++h) {
+        for (int w = 0; w < params.tensor_in_cols; ++w) {
+          // (h_start, h_end) * (w_start, w_end) is the range that the input
+          // vector projects to.
+          const int hpad = h + params.pad_top;
+          const int wpad = w + params.pad_left;
+          const int h_start =
+              (hpad < params.window_rows)
+                  ? 0
+                  : (hpad - params.window_rows) / params.row_stride + 1;
+          const int h_end =
+              std::min<int>(hpad / params.row_stride + 1, params.out_height);
+          const int w_start =
+              (wpad < params.window_cols)
+                  ? 0
+                  : (wpad - params.window_cols) / params.col_stride + 1;
+          const int w_end =
+              std::min<int>(wpad / params.col_stride + 1, params.out_width);
+          const int in_offset =
+              (b * params.tensor_in_rows + h) * params.tensor_in_cols + w;
+          Eigen::DSizes<Eigen::DenseIndex, 2> in_indices(0, in_offset);
+          for (int ph = h_start; ph < h_end; ++ph) {
+            for (int pw = w_start; pw < w_end; ++pw) {
+              const int out_offset =
+                  (b * params.out_height + ph) * params.out_width + pw;
+              out_mat.col(out_offset) += in_mat.col(in_offset);
+              out_count(out_offset) += T(1);
+            }
+          }
+        }
+      }
+    }
+
+    DCHECK_GT(out_count.minCoeff(), T(0));
+    out_mat.array().rowwise() /= out_count.transpose().array();
+  };
+
+  const int64_t work_unit_size =
+      params.tensor_in_rows * params.tensor_in_cols * params.depth;
+  // NOTE: Constants in calculation below were estimated based on benchmarking.
+  // Nanoseconds/work_unit for benchmarks ranged from 0.01 to 0.001, and
+  // so the factor 0.01 (i.e. 1/100) with a max of 10000, was chosen to limit
+  // the work unit cost to an operating range in which it empirically performed
+  // best.
+  const int64_t work_unit_cost = std::max(int64_t{10000}, work_unit_size / 100);
+  const DeviceBase::CpuWorkerThreads& worker_threads =
+      *(context->device()->tensorflow_cpu_worker_threads());
+  Shard(worker_threads.num_threads, worker_threads.workers,
+        params.tensor_in_batch, work_unit_cost, shard);
+}
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_POOLING_OPS_COMMON_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/pooling_ops_common_gpu.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/pooling_ops_common_gpu.h
new file mode 100644
index 0000000000000000000000000000000000000000..c5d51e5935677a857d9c0f3dfeb7a7682cea8d0e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/pooling_ops_common_gpu.h
@@ -0,0 +1,70 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#if !GOOGLE_CUDA && !TENSORFLOW_USE_ROCM
+#error This file must only be included when building with Cuda or ROCm support
+#endif
+
+#ifndef TENSORFLOW_CORE_KERNELS_POOLING_OPS_COMMON_GPU_H_
+#define TENSORFLOW_CORE_KERNELS_POOLING_OPS_COMMON_GPU_H_
+
+#include <vector>
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/framework/numeric_op.h"
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/tensor_shape.h"
+#include "tensorflow/core/kernels/avgpooling_op.h"
+#include "tensorflow/core/kernels/maxpooling_op.h"
+#include "tensorflow/core/kernels/ops_util.h"
+#include "tensorflow/core/platform/stream_executor.h"
+#include "tensorflow/core/util/padding.h"
+#include "tensorflow/core/util/tensor_format.h"
+
+namespace tensorflow {
+
+// A helper class that launch the cudnn pooling forward operations.
+template <typename T>
+class DnnPoolingOp {
+ public:
+  typedef GPUDevice Device;
+  static void Compute(OpKernelContext* context,
+                      se::dnn::PoolingMode pooling_mode,
+                      const std::vector<int32>& size,
+                      const std::vector<int32>& stride, Padding padding,
+                      std::vector<int64_t> explicit_paddings,
+                      TensorFormat data_format, const Tensor& tensor_in,
+                      const TensorShape& tensor_out_shape, bool propagate_nans);
+};
+
+// A helper class that launch the cudnn pooling backward operations.
+// The original input and output tensors are optional for AvgPoolGrad, but
+// mandatory for MaxPoolGrad.
+template <typename T>
+class DnnPoolingGradOp {
+ public:
+  typedef GPUDevice Device;
+  static void Compute(OpKernelContext* context,
+                      se::dnn::PoolingMode pooling_mode,
+                      const std::vector<int32>& size,
+                      const std::vector<int32>& stride, Padding padding,
+                      std::vector<int64_t> explicit_paddings,
+                      TensorFormat data_format, const Tensor* tensor_in,
+                      const Tensor* tensor_out, const Tensor& out_backprop,
+                      const TensorShape& tensor_in_shape, bool propagate_nans);
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_POOLING_OPS_COMMON_GPU_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/population_count_op.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/population_count_op.h
new file mode 100644
index 0000000000000000000000000000000000000000..2c9812967366d8b943715f08caf07ce5804877ca
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/population_count_op.h
@@ -0,0 +1,38 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_POPULATION_COUNT_OP_H_
+#define TENSORFLOW_CORE_KERNELS_POPULATION_COUNT_OP_H_
+
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/tensor_types.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+
+namespace functor {
+
+template <typename Device, typename T>
+struct PopulationCount {
+  void operator()(OpKernelContext* c, typename TTypes<T>::ConstFlat input,
+                  TTypes<uint8>::Flat output);
+};
+
+}  // namespace functor
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_POPULATION_COUNT_OP_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/priority_queue.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/priority_queue.h
new file mode 100644
index 0000000000000000000000000000000000000000..c571846a37d1184b77f55a00e0abcc0d170f772d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/priority_queue.h
@@ -0,0 +1,94 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_PRIORITY_QUEUE_H_
+#define TENSORFLOW_CORE_KERNELS_PRIORITY_QUEUE_H_
+
+#include <deque>
+#include <queue>
+#include <vector>
+
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/tensor_shape.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/kernels/typed_queue.h"
+#include "tensorflow/core/platform/macros.h"
+#include "tensorflow/core/platform/mutex.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+
+using PriorityTensorPair = std::pair<int64_t, Tensor>;
+
+struct ComparePriorityTensorPair {
+  // 0 is a higher priority than 1, -MAX_LONG is a higher priority
+  // than MAX_LONG, etc.  Values coming in with a smaller
+  // priority number will bubble to the front of the queue.
+  bool operator()(const PriorityTensorPair& lhs,
+                  const PriorityTensorPair& rhs) const {
+    return lhs.first > rhs.first;
+  }
+};
+
+class PriorityQueue
+    : public TypedQueue<std::priority_queue<PriorityTensorPair,
+                                            std::vector<PriorityTensorPair>,
+                                            ComparePriorityTensorPair> > {
+ public:
+  PriorityQueue(int32_t capacity, const DataTypeVector& component_dtypes,
+                const std::vector<TensorShape>& component_shapes,
+                const string& name);
+
+  Status Initialize() override;  // Must be called before any other method.
+
+  // Implementations of QueueInterface methods --------------------------------
+
+  void TryEnqueue(const Tuple& tuple, OpKernelContext* ctx,
+                  DoneCallback callback) override;
+  void TryEnqueueMany(const Tuple& tuple, OpKernelContext* ctx,
+                      DoneCallback callback) override;
+  void TryDequeue(OpKernelContext* ctx, CallbackWithTuple callback) override;
+  void TryDequeueMany(int num_elements, OpKernelContext* ctx,
+                      bool allow_small_batch,
+                      CallbackWithTuple callback) override;
+  Status MatchesNodeDef(const NodeDef& node_def) override;
+  Status MatchesPriorityNodeDefTypes(const NodeDef& node_def) const;
+  Status MatchesPriorityNodeDefShapes(const NodeDef& node_def) const;
+
+  int32 size() const override {
+    mutex_lock lock(mu_);
+    return queues_[0].size();
+  }
+
+ private:
+  ~PriorityQueue() override {}
+
+  // Helper for dequeuing a single element from queues_.
+  void DequeueLocked(OpKernelContext* ctx, Tuple* tuple)
+      TF_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+
+  static Status GetElementComponentFromBatch(const Tuple& tuple, int index,
+                                             int component,
+                                             OpKernelContext* ctx,
+                                             Tensor* out_element);
+
+  PriorityQueue(const PriorityQueue&) = delete;
+  void operator=(const PriorityQueue&) = delete;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_PRIORITY_QUEUE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/quantization_utils.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/quantization_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..88bee91121641a20049b96426b6db5307757a230
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/quantization_utils.h
@@ -0,0 +1,968 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_QUANTIZATION_UTILS_H_
+#define TENSORFLOW_CORE_KERNELS_QUANTIZATION_UTILS_H_
+
+#include <cmath>
+#define EIGEN_USE_THREADS
+
+// This is a set of functions that standardizes how quantized values are
+// interpreted as float numbers.
+// All of the current implementations are for reference and have not been
+// optimized. They should be implementable using fixed point representations
+// to avoid a dependency on floating-point hardware.
+
+#if defined(__ARM_NEON__) || defined(__ARM_NEON)
+#define QUANTIZATION_UTILS_USE_NEON
+#include <arm_neon.h>
+#endif
+
+#include <array>
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#define GEMMLOWP_ALLOW_SLOW_SCALAR_FALLBACK
+#include "public/gemmlowp.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/lib/core/threadpool.h"
+
+namespace tensorflow {
+
+// We have to be able to detect and handle overflows in int32, so this function
+// uses doubles and int64's to make sure we have enough room.
+template <class T>
+inline int64_t FloatToQuantizedUnclamped(float input, float range_min,
+                                         float range_max) {
+  const int64_t lowest_quantized =
+      static_cast<double>(Eigen::NumTraits<T>::lowest());
+  if (range_min == range_max) {
+    return lowest_quantized;
+  }
+  const int number_of_bits = sizeof(T) * 8;
+  const int64_t number_of_steps = static_cast<int64_t>(1) << number_of_bits;
+  const double range_adjust = (number_of_steps / (number_of_steps - 1.0));
+  const double range = ((range_max - range_min) * range_adjust);
+  const double range_scale = (number_of_steps / range);
+  int64_t quantized =
+      (round(input * range_scale) - round(range_min * range_scale));
+  quantized += lowest_quantized;
+  return quantized;
+}
+
+template <>
+inline int64_t FloatToQuantizedUnclamped<float>(float input, float range_min,
+                                                float range_max) {
+  return -1;
+}
+
+// This converts the float into the final quantized type, clamping/saturating
+// any over or underflows.
+template <class T>
+T FloatToQuantized(float input, float range_min, float range_max) {
+  if (std::is_same<T, float>::value) {
+    // Specialization for float. This is used in reference implementation
+    // for float which is useful to compare performance between float
+    // and quantized type.
+    return input;
+  }
+  int64_t quantized = FloatToQuantizedUnclamped<T>(input, range_min, range_max);
+  const int64_t lowest_quantized =
+      static_cast<int64_t>(Eigen::NumTraits<T>::lowest());
+  const int64_t highest_quantized =
+      static_cast<int64_t>(Eigen::NumTraits<T>::highest());
+  quantized = std::max(quantized, lowest_quantized);
+  quantized = std::min(quantized, highest_quantized);
+  return static_cast<T>(static_cast<int32>(quantized));
+}
+
+template <class T>
+float QuantizedToFloat(T input, float range_min, float range_max) {
+  if (std::is_same<T, float>::value) {
+    // Specialization for float. This is used in reference implementation
+    // for float which is useful to compare performance between float
+    // and quantized type.
+    return input;
+  }
+  if (range_min == range_max) {
+    return range_min;
+  }
+  const int number_of_bits = sizeof(T) * 8;
+  const int64_t number_of_steps = static_cast<int64_t>(1) << number_of_bits;
+  const double range_adjust = (number_of_steps / (number_of_steps - 1.0));
+  const double range = ((range_max - range_min) * range_adjust);
+  const double range_scale = (range / number_of_steps);
+  const int64_t lowest_quantized =
+      static_cast<int64_t>(Eigen::NumTraits<T>::lowest());
+  const double offset_input = static_cast<double>(input) - lowest_quantized;
+  // For compatibility with DEQUANTIZE_WITH_EIGEN, we should convert
+  // range_scale to a float, otherwise range_min_rounded might be slightly
+  // different.
+  const double range_min_rounded =
+      std::round(range_min / static_cast<float>(range_scale)) *
+      static_cast<float>(range_scale);
+  const double result = range_min_rounded + (offset_input * range_scale);
+  return static_cast<float>(result);
+}
+
+template <class T>
+float FloatForOneQuantizedLevel(float range_min, float range_max) {
+  const int64_t highest = static_cast<int64_t>(Eigen::NumTraits<T>::highest());
+  const int64_t lowest = static_cast<int64_t>(Eigen::NumTraits<T>::lowest());
+  const float float_for_one_quantized_level =
+      (range_max - range_min) / (highest - lowest);
+  return float_for_one_quantized_level;
+}
+
+template <class T1, class T2, class T3>
+void QuantizationRangeForMultiplication(float min_a, float max_a, float min_b,
+                                        float max_b, float* min_c,
+                                        float* max_c) {
+  const float a_float_for_one_quant_level =
+      FloatForOneQuantizedLevel<T1>(min_a, max_a);
+  const float b_float_for_one_quant_level =
+      FloatForOneQuantizedLevel<T2>(min_b, max_b);
+
+  const int64_t c_highest =
+      static_cast<int64_t>(Eigen::NumTraits<T3>::highest());
+  const int64_t c_lowest = static_cast<int64_t>(Eigen::NumTraits<T3>::lowest());
+  const float c_float_for_one_quant_level =
+      a_float_for_one_quant_level * b_float_for_one_quant_level;
+
+  *min_c = c_float_for_one_quant_level * c_lowest;
+  *max_c = c_float_for_one_quant_level * c_highest;
+}
+
+// input_array is an eigen Tensor.  q2f is a QuantizedToFloatStruct.
+// This evaluates to an eigen tensor expression, to be used like:
+// auto tensor = DEQUANTIZE_WITH_EIGEN(input_tensor, q2f);
+#define DEQUANTIZE_WITH_EIGEN(input_array, q2f)                         \
+  ((q2f.range_min_rounded - q2f.lowest_quantized() * q2f.range_scale) + \
+   input_array.template cast<float>() * q2f.range_scale)
+
+// input_array is an eigen Tensor.  f2q is a FloatToQuantizedStruct.
+// OutputType is the type of output (e.g. quint8).
+// This evaluates to an eigen tensor expression, to be used like:
+// auto tensor = QUANTIZE_WITH_EIGEN(input_tensor, f2q, T);
+#define QUANTIZE_WITH_EIGEN(input_array, f2q, OutputType) \
+  ((input_array * f2q.range_scale).round() -              \
+   (f2q.range_min_scaled - f2q.lowest_quantized()))       \
+      .cwiseMax(f2q.lower_bound_float())                  \
+      .cwiseMin(f2q.upper_bound_float())                  \
+      .template cast<int32>()                             \
+      .template cast<OutputType>()
+
+// For use with DEQUANTIZE_WITH_EIGEN.
+template <typename T>
+struct QuantizedToFloatStruct {
+  static constexpr int number_of_bits = sizeof(T) * 8;
+  static constexpr int64_t number_of_steps = static_cast<int64_t>(1)
+                                             << number_of_bits;
+
+  static float lowest_quantized() {
+    return static_cast<float>(Eigen::NumTraits<T>::lowest());
+  }
+
+  QuantizedToFloatStruct(float range_min, float range_max)
+      : range_min(range_min),
+        range_scale((range_max - range_min) / (number_of_steps - 1.0)),
+        range_min_rounded(range_max == range_min
+                              ? range_min
+                              : std::round(range_min / range_scale) *
+                                    range_scale) {}
+
+  const float range_min;
+  const float range_scale;
+  const float range_min_rounded;
+};
+
+// For use with QUANTIZE_WITH_EIGEN.
+template <typename T>
+struct FloatToQuantizedStruct {
+  static constexpr int number_of_bits = sizeof(T) * 8;
+  static constexpr int64_t number_of_steps = static_cast<int64_t>(1)
+                                             << number_of_bits;
+  static constexpr double range_adjust =
+      (number_of_steps / (number_of_steps - 1.0));
+
+  // Casting QInt32's lowest or highest to a float gives a float that can't be
+  // cast back to int32 or QInt32.  Instead, use bounds that can be converted
+  // back to int32 without going outside the range of an int32.
+  static float lower_bound_float() {
+    return Eigen::numext::maxi(
+        static_cast<float>(Eigen::NumTraits<T>::lowest()), -2.147483648e+09f);
+  }
+  static float upper_bound_float() {
+    return Eigen::numext::mini(
+        static_cast<float>(Eigen::NumTraits<T>::highest()), +2.147483520e+09f);
+  }
+
+  static float lowest_quantized() {
+    return static_cast<float>(Eigen::NumTraits<T>::lowest());
+  }
+
+  FloatToQuantizedStruct(float range_min, float range_max)
+      : range_min(range_min),
+        range_scale(range_max == range_min
+                        ? 0.0
+                        : (number_of_steps - 1.0) / (range_max - range_min)),
+        range_min_scaled(std::round(range_min * range_scale)) {}
+
+  const float range_min;
+  const float range_scale;
+  const float range_min_scaled;
+};
+
+template <class T1, class T2>
+inline T2 RequantizeInNewRange(T1 input, float min_input, float max_input,
+                               float min_new, float max_new) {
+  const float input_float = QuantizedToFloat<T1>(input, min_input, max_input);
+  return FloatToQuantized<T2>(input_float, min_new, max_new);
+}
+
+template <class T1, class T2>
+inline void RequantizeManyInNewRange(const T1* input, int64_t count,
+                                     float min_input, float max_input,
+                                     float min_output, float max_output,
+                                     T2* output) {
+  for (size_t index = 0; index < count; ++index) {
+    const float input_float =
+        QuantizedToFloat<T1>(input[index], min_input, max_input);
+    output[index] = FloatToQuantized<T2>(input_float, min_output, max_output);
+  }
+}
+
+// Because converting 32-bit accumulated results down to eight bit is a common
+// case, we have a specialized code path to handle it as efficiently as
+// possible using only fixed-point math for the inner loop.
+inline void RequantizeManyInNewRangeReference(const qint32* input,
+                                              int64_t count, float min_input,
+                                              float max_input, float min_output,
+                                              float max_output,
+                                              quint8* output) {
+  // Initially we calculate all the constants we need once, before we go into
+  // the inner loop.  If this is updated, also update the Eigen version.
+  const int fp_shift = 16;
+  const float input_range = max_input - min_input;
+  const float output_range = max_output - min_output;
+  const float recip_output_range =
+      output_range == 0.0 ? 0.0 : (255.0 / output_range);
+  const float input_rezero = (min_input + max_input) / 2.0;
+  const int64_t range_scale_fp =
+      output_range == 0.0 ? 0.0
+                          : static_cast<int64_t>(255.0 * (1 << fp_shift) *
+                                                 input_range / output_range);
+  const int64_t input_offset_fp =
+      static_cast<int64_t>(input_rezero * recip_output_range * (1 << fp_shift));
+  const int64_t output_offset_fp =
+      output_range == 0.0
+          ? 0
+          : std::lround((1 << fp_shift) * (min_output * 255.0) / output_range);
+  const int64_t rounding_delta = 1 << (fp_shift - 1);
+
+  // Inside this loop we just do minimal adds, multiplies, and shifts, in a way
+  // that could be easily adapted for a SIMD implementation. It should also be
+  // possible to perform all the calculations in 32-bit rather than 64, but
+  // that's not been implemented yet.
+  for (int64_t index = 0; index < count; ++index) {
+    const int64_t input_value = static_cast<int64_t>(input[index]);
+    const int64_t fp_value =
+        ((input_value * range_scale_fp) >> 32) + input_offset_fp;
+    const int64_t offset_intermediate = fp_value - output_offset_fp;
+    const int64_t round_intermediate = offset_intermediate + rounding_delta;
+    int64_t quantized_int64 = round_intermediate >> fp_shift;
+    quantized_int64 = std::max(quantized_int64, int64_t{0});
+    quantized_int64 = std::min(quantized_int64, int64_t{255});
+    output[index] = static_cast<quint8>(static_cast<int32>(quantized_int64));
+  }
+}
+
+// Another common case is converting eight bit inputs up to thirty two bits, so
+// we have specialized fixed-point code to accelerate that. There is also a NEON
+// version for ARM devices below.
+inline void RequantizeManyInNewRange8To32BitReference(
+    const quint8* input, int64_t count, float min_input, float max_input,
+    float min_output, float max_output, qint32* output) {
+  const float code_0_float = QuantizedToFloat<quint8>(0, min_input, max_input);
+  const float code_1_float = QuantizedToFloat<quint8>(1, min_input, max_input);
+  const int64_t code_0_int64 =
+      FloatToQuantizedUnclamped<qint32>(code_0_float, min_output, max_output);
+  const int64_t code_1_int64 =
+      FloatToQuantizedUnclamped<qint32>(code_1_float, min_output, max_output);
+  const int32_t mult_int32 = code_1_int64 - code_0_int64;
+  const int64_t lowest_quantized =
+      static_cast<int64_t>(Eigen::NumTraits<qint32>::lowest());
+  const int64_t highest_quantized =
+      static_cast<int64_t>(Eigen::NumTraits<qint32>::highest());
+  for (int64_t i = 0; i < count; ++i) {
+    const int64_t input_value = static_cast<int64_t>(input[i]);
+    int64_t output_value = code_0_int64 + (input_value * mult_int32);
+    output_value = std::max(output_value, lowest_quantized);
+    output_value = std::min(output_value, highest_quantized);
+    output[i] = static_cast<int32>(output_value);
+  }
+}
+
+#ifdef QUANTIZATION_UTILS_USE_NEON
+// Speeds up the 32->8bit conversion using fixed-point arithmetic and NEON SIMD
+// intrinsics for ARM platforms.
+inline void RequantizeManyInNewRangeNeon(const qint32* input, int64 count,
+                                         float min_input, float max_input,
+                                         float min_output, float max_output,
+                                         quint8* output) {
+  // Initially we calculate all the constants we need once, before we go into
+  // the inner loop.  If this is updated, also update the Eigen version.
+  const int fp_shift = 16;
+
+  // Calculate range variables in advance.
+  // Input range.
+  const float input_range = max_input - min_input;
+  // Output range.
+  const float output_range = max_output - min_output;
+  // Ratio of output range.
+  const float recip_output_range =
+      output_range == 0.0 ? 0.0 : (255.0 / output_range);
+  // Average of input range as zero position of input.
+  const float input_rezero = (min_input + max_input) / 2.0;
+  // In-out range scale.
+  const int32 range_scale_fp =
+      output_range == 0.0 ? 0.0
+                          : static_cast<int32>(255.0 * (1 << (fp_shift - 16)) *
+                                               input_range / output_range);
+  // Input zero position offset to output.
+  const int32 input_offset_fp =
+      static_cast<int32>(input_rezero * recip_output_range * (1 << fp_shift));
+  // Output min offset.
+  const int32 output_offset_fp =
+      output_range == 0.0
+          ? 0
+          : static_cast<int32>((1 << fp_shift) * (min_output * 255.0) /
+                               output_range);
+  const int32 rounding_delta = 1 << (fp_shift - 1);
+
+  // broadcast range to each lane
+  const int32x4_t range_scale_fp_32x4 = vmovq_n_s32(range_scale_fp);
+  const int32x4_t input_offset_fp_32x4 = vmovq_n_s32(input_offset_fp);
+  const int32x4_t output_offset_fp_32x4 = vmovq_n_s32(output_offset_fp);
+  const int32x4_t rounding_delta_32x4 = vmovq_n_s32(rounding_delta);
+
+  int64 index = 0;
+  // Use SIMD to requantize.
+  for (; index < (count - 7); index += 8) {
+    const int32* input_ptr = &(input->value) + index;
+    const int32x4_t input_value_low_32x4 = vld1q_s32(input_ptr);
+    const int32x4_t input_value_high_32x4 = vld1q_s32(input_ptr + 4);
+    const int32x4_t fp_value_low_32x4 = vaddq_s32(
+        input_offset_fp_32x4,
+        vmulq_s32(vshrq_n_s32(input_value_low_32x4, 16), range_scale_fp_32x4));
+    const int32x4_t fp_value_high_32x4 = vaddq_s32(
+        input_offset_fp_32x4,
+        vmulq_s32(vshrq_n_s32(input_value_high_32x4, 16), range_scale_fp_32x4));
+    const int32x4_t offset_intermediate_low_32x4 =
+        vsubq_s32(fp_value_low_32x4, output_offset_fp_32x4);
+    const int32x4_t offset_intermediate_high_32x4 =
+        vsubq_s32(fp_value_high_32x4, output_offset_fp_32x4);
+    const int32x4_t round_intermediate_low_32x4 =
+        vaddq_s32(offset_intermediate_low_32x4, rounding_delta_32x4);
+    const int32x4_t round_intermediate_high_32x4 =
+        vaddq_s32(offset_intermediate_high_32x4, rounding_delta_32x4);
+    const int16x4_t quantized_low_16x4 =
+        vqmovn_s32(vshrq_n_s32(round_intermediate_low_32x4, fp_shift));
+    const int16x4_t quantized_high_16x4 =
+        vqmovn_s32(vshrq_n_s32(round_intermediate_high_32x4, fp_shift));
+    const uint8x8_t quantized_8x8 =
+        vqmovun_s16(vcombine_s16(quantized_low_16x4, quantized_high_16x4));
+    uint8* output_ptr = &(output->value) + index;
+    vst1_u8(output_ptr, quantized_8x8);
+  }
+
+  // Requantize remaining elements in array without SIMD.
+  for (; index < count; ++index) {
+    const int32 input_value = static_cast<int32>(input[index]);
+    const int32 fp_value =
+        static_cast<int32>(
+            (static_cast<int32>(input_value >> 16) * (range_scale_fp))) +
+        input_offset_fp;
+    const int32 offset_intermediate = fp_value - output_offset_fp;
+    const int32 round_intermediate = offset_intermediate + rounding_delta;
+    int32 quantized_int32 = round_intermediate >> fp_shift;
+    quantized_int32 = std::max(quantized_int32, 0);
+    quantized_int32 = std::min(quantized_int32, 255);
+    output[index] = static_cast<quint8>(static_cast<int32>(quantized_int32));
+  }
+}
+
+template <>
+inline void RequantizeManyInNewRange<qint32, quint8>(
+    const qint32* input, int64 count, float min_input, float max_input,
+    float min_output, float max_output, quint8* output) {
+  const float input_range = max_input - min_input;
+  const float output_range = max_output - min_output;
+  if ((input_range / output_range) > 16384.0f) {
+    // Our NEON implementation uses 32-bit math and can't handle very
+    // large ranges, so fall back to the reference implementation. We don't
+    // expect these to be common in models, so this shouldn't be a performance
+    // problem in practice.
+    RequantizeManyInNewRangeReference(input, count, min_input, max_input,
+                                      min_output, max_output, output);
+  } else {
+    RequantizeManyInNewRangeNeon(input, count, min_input, max_input, min_output,
+                                 max_output, output);
+  }
+}
+
+// NEON accelerated 16bit rounded division by 2^n.
+template <int POW>
+inline int16x8_t Divide16x8PowRound(const int16x8_t val) {
+  const int16x8_t val_sign = vshrq_n_s16(val, 15);
+  const int16x8_t val_xor = veorq_s16(val, val_sign);
+  const int16x8_t val_pos = vsubq_s16(val_xor, val_sign);
+  const int16x8_t shifted_val_pos = vrshrq_n_s16(val_pos, POW);
+  const int16x8_t shifted_val_pos_xor = veorq_s16(shifted_val_pos, val_sign);
+  const int16x8_t shifted_val = vsubq_s16(shifted_val_pos_xor, val_sign);
+  return shifted_val;
+}
+
+// NEON accelerated 64bit rounded division by 2^n.
+template <int POW>
+inline int64x2_t Divide64x2PowRound(const int64x2_t val) {
+  const int64x2_t val_sign = vshrq_n_s64(val, 63);
+  const int64x2_t val_xor = veorq_s64(val, val_sign);
+  const int64x2_t val_pos = vsubq_s64(val_xor, val_sign);
+  const int64x2_t shifted_val_pos = vrshrq_n_s64(val_pos, POW);
+  const int64x2_t shifted_val_pos_xor = veorq_s64(shifted_val_pos, val_sign);
+  const int64x2_t shifted_val = vsubq_s64(shifted_val_pos_xor, val_sign);
+  return shifted_val;
+}
+
+// NEON accelerated 16bit division by 2^n.
+// CAVEAT: The input must be greater than min-int16 to avoid underflow.
+template <int POW>
+inline int16x8_t Divide16x8Pow(const int16x8_t val) {
+  static constexpr int16 FIRST_BIT_VAL = 0x0000000000000001;
+  static const int16x8_t FIRST_BIT = vmovq_n_s16(FIRST_BIT_VAL);
+  const int16x8_t val_sign = vshrq_n_s16(val, 15);
+  const int16x8_t neg_offset = vandq_s16(val_sign, FIRST_BIT);
+  const int16x8_t val_with_offset = vsubq_s16(val, neg_offset);
+  const int16x8_t shifted_wo_offset =
+      vsraq_n_s16(neg_offset, val_with_offset, POW);
+  return shifted_wo_offset;
+}
+
+// NEON accelerated 64bit division by 2^n.
+// CAVEAT: The input must be greater than min-int64 to avoid underflow.
+template <int POW>
+inline int64x2_t Divide64x2Pow(const int64x2_t val) {
+  static constexpr int64 FIRST_BIT_VAL = 0x0000000000000001;
+  static const int64x2_t FIRST_BIT = vmovq_n_s64(FIRST_BIT_VAL);
+  const int64x2_t val_sign = vshrq_n_s64(val, 63);
+  const int64x2_t neg_offset = vandq_s64(val_sign, FIRST_BIT);
+  const int64x2_t val_with_offset = vsubq_s64(val, neg_offset);
+  const int64x2_t shifted_wo_offset =
+      vsraq_n_s64(neg_offset, val_with_offset, POW);
+  return shifted_wo_offset;
+}
+
+// 32bit x 2 NEON accelerated lerp computation.
+template <int RESOLUTION>
+inline int32x2_t ComputeLerp32x2(const int32x2_t top_left,
+                                 const int32x2_t top_right,
+                                 const int32x2_t bottom_left,
+                                 const int32x2_t bottom_right,
+                                 const int32x2_t x_lerp,
+                                 const int32x2_t y_lerp) {
+  static_assert(RESOLUTION < 31, "RESOLUTION must be less than 31");
+  constexpr int32 RESOLUTION_MULT32 = (1 << RESOLUTION);
+  static const int32x2_t RESOLUTION_MULT32x2 = vmov_n_s32(RESOLUTION_MULT32);
+
+  const int64x2_t top_left_x_res = vmull_s32(top_left, RESOLUTION_MULT32x2);
+  const int64x2_t bottom_left_x_res =
+      vmull_s32(bottom_left, RESOLUTION_MULT32x2);
+
+  const int32x2_t top_right_sub_top_left = vsub_s32(top_right, top_left);
+  const int64x2_t top_x_res =
+      vmlal_s32(top_left_x_res, top_right_sub_top_left, x_lerp);
+  const int32x2_t bottom_right_sub_bottom_left =
+      vsub_s32(bottom_right, bottom_left);
+  const int64x2_t bottom_x_res =
+      vmlal_s32(bottom_left_x_res, bottom_right_sub_bottom_left, x_lerp);
+
+  const int64x2_t bottom_sub_top_x_res = vsubq_s64(bottom_x_res, top_x_res);
+  const int64x2_t bottom_sub_top =
+      Divide64x2Pow<RESOLUTION>(bottom_sub_top_x_res);
+  const int32x2_t bottom_sub_top_32 = vqmovn_s64(bottom_sub_top);
+  const int64x2_t top_add_bottom_sub_top_mul_ylerp_x_res =
+      vmlal_s32(top_x_res, bottom_sub_top_32, y_lerp);
+  const int64x2_t retval =
+      Divide64x2PowRound<RESOLUTION>(top_add_bottom_sub_top_mul_ylerp_x_res);
+  const int32x2_t retval32 = vqmovn_s64(retval);
+  return retval32;
+}
+
+// 8bit x 8 NEON accelerated lerp computation.
+template <int RESOLUTION>
+inline uint8x8_t ComputeLerp8x8(const uint8x8_t top_left8x8,
+                                const uint8x8_t top_right8x8,
+                                const uint8x8_t bottom_left8x8,
+                                const uint8x8_t bottom_right8x8,
+                                const int16x8_t x_lerp,
+                                const int16x8_t y_lerp) {
+  static_assert(RESOLUTION < 8, "RESOLUTION must be less than 8");
+  constexpr uint8 RESOLUTION_MULT_VAL = (1 << RESOLUTION);
+  static const uint8x8_t RESOLUTION_MULT = vdup_n_u8(RESOLUTION_MULT_VAL);
+
+  const int16x8_t top_left_x_res =
+      vreinterpretq_s16_u16(vmull_u8(top_left8x8, RESOLUTION_MULT));
+  const int16x8_t bottom_left_x_res =
+      vreinterpretq_s16_u16(vmull_u8(bottom_left8x8, RESOLUTION_MULT));
+
+  const int16x8_t top_right_sub_top_left =
+      vreinterpretq_s16_u16(vsubl_u8(top_right8x8, top_left8x8));
+  const int16x8_t top_x_res =
+      vmlaq_s16(top_left_x_res, top_right_sub_top_left, x_lerp);
+
+  const int16x8_t bottom_right_sub_bottom_left =
+      vreinterpretq_s16_u16(vsubl_u8(bottom_right8x8, bottom_left8x8));
+  const int16x8_t bottom_x_res =
+      vmlaq_s16(bottom_left_x_res, bottom_right_sub_bottom_left, x_lerp);
+
+  const int16x8_t bottom_sub_top_x_res = vsubq_s16(bottom_x_res, top_x_res);
+  const int16x8_t bottom_sub_top =
+      Divide16x8Pow<RESOLUTION>(bottom_sub_top_x_res);
+  const int16x8_t top_add_bottom_sub_top_mul_ylerp_x_res =
+      vmlaq_s16(top_x_res, bottom_sub_top, y_lerp);
+  const int16x8_t retval16 =
+      Divide16x8PowRound<RESOLUTION>(top_add_bottom_sub_top_mul_ylerp_x_res);
+  const uint8x8_t retval = vmovn_u16(vreinterpretq_u16_s16(retval16));
+  return retval;
+}
+
+// Requantize 8 x 8 quints to 8 x 32 qints in parallel by neon
+// Return std::array instead of pointer to leverage return value optimization
+inline std::array<int32x4_t, 2> Requantize8x8To32Neon(
+    const uint8* input_ptr, const int64x2_t input_0_64x2,
+    const int32x2_t input_mult_32x2) {
+  const uint8x8_t input_value_8x8 = vld1_u8(input_ptr);
+  const int16x8_t input_value_16x8 =
+      vreinterpretq_s16_u16(vmovl_u8(input_value_8x8));
+  const int16x4_t input_value_low_16x4 = vget_low_s16(input_value_16x8);
+  const int16x4_t input_value_high_16x4 = vget_high_s16(input_value_16x8);
+  const int32x4_t input_value_low_32x4 = vmovl_s16(input_value_low_16x4);
+  const int32x4_t input_value_high_32x4 = vmovl_s16(input_value_high_16x4);
+  const int32x2_t input_value_low_low_32x2 = vget_low_s32(input_value_low_32x4);
+  const int32x2_t input_value_low_high_32x2 =
+      vget_high_s32(input_value_low_32x4);
+  const int32x2_t input_value_high_low_32x2 =
+      vget_low_s32(input_value_high_32x4);
+  const int32x2_t input_value_high_high_32x2 =
+      vget_high_s32(input_value_high_32x4);
+  const int64x2_t mult_result_low_low_64x2 =
+      vmlal_s32(input_0_64x2, input_value_low_low_32x2, input_mult_32x2);
+  const int64x2_t mult_result_low_high_64x2 =
+      vmlal_s32(input_0_64x2, input_value_low_high_32x2, input_mult_32x2);
+  const int64x2_t mult_result_high_low_64x2 =
+      vmlal_s32(input_0_64x2, input_value_high_low_32x2, input_mult_32x2);
+  const int64x2_t mult_result_high_high_64x2 =
+      vmlal_s32(input_0_64x2, input_value_high_high_32x2, input_mult_32x2);
+  const int32x2_t output_value_low_low_32x2 =
+      vqmovn_s64(mult_result_low_low_64x2);
+  const int32x2_t output_value_low_high_32x2 =
+      vqmovn_s64(mult_result_low_high_64x2);
+  const int32x2_t output_value_high_low_32x2 =
+      vqmovn_s64(mult_result_high_low_64x2);
+  const int32x2_t output_value_high_high_32x2 =
+      vqmovn_s64(mult_result_high_high_64x2);
+  const int32x4_t output_value_low_32x4 =
+      vcombine_s32(output_value_low_low_32x2, output_value_low_high_32x2);
+  const int32x4_t output_value_high_32x4 =
+      vcombine_s32(output_value_high_low_32x2, output_value_high_high_32x2);
+  return std::array<int32x4_t, 2>{
+      {output_value_low_32x4, output_value_high_32x4}};
+}
+
+// Speeds up the 8->32bit conversion using fixed-point arithmetic and NEON SIMD
+// intrinsics for ARM platforms.
+template <>
+inline void RequantizeManyInNewRange<quint8, qint32>(
+    const quint8* input, int64 count, float min_input, float max_input,
+    float min_output, float max_output, qint32* output) {
+  // Pre-calculate zero position and multiplier.
+  // Calculate 0 and 1 value in float.
+  const float code_0_float = QuantizedToFloat<quint8>(0, min_input, max_input);
+  const float code_1_float = QuantizedToFloat<quint8>(1, min_input, max_input);
+
+  // Cast 0 and 1 value in int64.
+  const int64 code_0_int64 =
+      FloatToQuantizedUnclamped<qint32>(code_0_float, min_output, max_output);
+  const int64 code_1_int64 =
+      FloatToQuantizedUnclamped<qint32>(code_1_float, min_output, max_output);
+
+  // Calculate multiplier.
+  const int32 mult_int32 = static_cast<int32>(code_1_int64 - code_0_int64);
+
+  // Broadcast 0 position and multiplier to lanes
+  const int64x2_t code_0_64x2 = vmovq_n_s64(code_0_int64);
+  const int32x2_t mult_32x2 = vmov_n_s32(mult_int32);
+
+  int64 i = 0;
+
+  // Use SIMD to requantize array.
+  for (; i < (count - 7); i += 8) {
+    const uint8* input_ptr = &(input->value) + i;
+    int32* output_ptr = &(output->value) + i;
+    const std::array<int32x4_t, 2> output_value =
+        Requantize8x8To32Neon(input_ptr, code_0_64x2, mult_32x2);
+    vst1q_s32(output_ptr + 0, output_value[0]);
+    vst1q_s32(output_ptr + 4, output_value[1]);
+  }
+
+  // Requantize remaining elements in array without SIMD.
+  const int64 lowest_quantized =
+      static_cast<int64_t>(Eigen::NumTraits<qint32>::lowest());
+  const int64 highest_quantized =
+      static_cast<int64_t>(Eigen::NumTraits<qint32>::highest());
+
+  for (; i < count; ++i) {
+    const int64 input_value = static_cast<int64_t>(input[i]);
+    int64 output_value = code_0_int64 + (input_value * mult_int32);
+    output_value = std::max(output_value, lowest_quantized);
+    output_value = std::min(output_value, highest_quantized);
+    output[i] = static_cast<int32>(output_value);
+  }
+}
+
+#else
+
+// If SIMD implementations aren't available, then use these default reference
+// versions.
+template <>
+inline void RequantizeManyInNewRange<qint32, quint8>(
+    const qint32* input, int64_t count, float min_input, float max_input,
+    float min_output, float max_output, quint8* output) {
+  RequantizeManyInNewRangeReference(input, count, min_input, max_input,
+                                    min_output, max_output, output);
+}
+
+template <>
+inline void RequantizeManyInNewRange<quint8, qint32>(
+    const quint8* input, int64_t count, float min_input, float max_input,
+    float min_output, float max_output, qint32* output) {
+  RequantizeManyInNewRange8To32BitReference(input, count, min_input, max_input,
+                                            min_output, max_output, output);
+}
+
+#endif
+
+template <int shift>
+struct int64_right_shift_op {
+  EIGEN_DEVICE_FUNC
+  EIGEN_STRONG_INLINE const int64_t operator()(const int64_t a) const {
+    return a >> shift;
+  }
+};
+
+// See RequantizeManyInNewRange() for a non-eigen reference implementation.
+template <class T1, class T2>
+inline void RequantizeManyInNewRangeUsingEigen(
+    const Eigen::ThreadPoolDevice& device, const Tensor& input, float min_input,
+    float max_input, float min_output, float max_output, Tensor* output) {
+  auto input_array = input.flat<T1>();
+  QuantizedToFloatStruct<T1> q2f(min_input, max_input);
+  auto input_float = DEQUANTIZE_WITH_EIGEN(input_array, q2f);
+  FloatToQuantizedStruct<T2> f2q(min_output, max_output);
+  auto input_requantized = QUANTIZE_WITH_EIGEN(input_float, f2q, T2);
+
+  output->flat<T2>().device(device) = input_requantized;
+}
+
+// See RequantizeManyInNewRange() for a non-eigen reference implementation.
+//
+// Because converting 32-bit accumulated results down to eight bit is a common
+// case, we have a specialized code path to handle it as efficiently as
+// possible using only fixed-point math for the inner loop.
+template <>
+inline void RequantizeManyInNewRangeUsingEigen<qint32, quint8>(
+    const Eigen::ThreadPoolDevice& device, const Tensor& input, float min_input,
+    float max_input, float min_output, float max_output, Tensor* output) {
+  // Initially we calculate all the constants we need once, before we go into
+  // the inner loop.  If this is updated, also update the non-Eigen version.
+  const int fp_shift = 16;
+  const float input_range = max_input - min_input;
+  const float output_range = max_output - min_output;
+  const float recip_output_range =
+      output_range == 0.0 ? 0.0 : (255.0 / output_range);
+  const float input_rezero = (min_input + max_input) / 2.0;
+  const int64_t range_scale_fp =
+      output_range == 0.0 ? 0.0
+                          : static_cast<int64_t>(255.0 * (1 << fp_shift) *
+                                                 input_range / output_range);
+  const int64_t input_offset_fp =
+      static_cast<int64_t>(input_rezero * recip_output_range * (1 << fp_shift));
+  const int64_t output_offset_fp =
+      output_range == 0.0
+          ? 0
+          : std::lround((1 << fp_shift) * (min_output * 255.0) / output_range);
+  const int64_t rounding_delta = 1 << (fp_shift - 1);
+
+  // Inside this eigen expression we just do minimal adds, multiplies, and
+  // shifts. It should be possible to perform all the calculations in 32-bit
+  // rather than 64, but that's not been implemented yet.
+  auto input_array = input.flat<qint32>();
+  auto fp_value = ((input_array.template cast<int64_t>() * range_scale_fp)
+                       .unaryExpr(int64_right_shift_op<32>())) +
+                  (input_offset_fp - output_offset_fp + rounding_delta);
+  auto intermediate = fp_value.unaryExpr(int64_right_shift_op<fp_shift>());
+  auto input_requantized = intermediate.cwiseMax(int64_t{0})
+                               .cwiseMin(int64_t{255})
+                               .template cast<int32>()
+                               .template cast<quint8>();
+  output->flat<quint8>().device(device) = input_requantized;
+}
+
+// REQUIRES: 'result->NumElements() == input.NumElements()'
+template <class T>
+void FloatTensorToQuantizedInPlaceUsingEigen(
+    const Eigen::ThreadPoolDevice& device, const Tensor& input, float min,
+    float max, Tensor* result) {
+  DCHECK_EQ(DataTypeToEnum<T>::v(), result->dtype());
+  auto flat_input = input.flat<float>();
+  auto flat_result = result->flat<T>();
+  DCHECK_EQ(flat_input.size(), flat_result.size());
+
+  FloatToQuantizedStruct<T> f2q(min, max);
+  flat_result.device(device) = QUANTIZE_WITH_EIGEN(flat_input, f2q, T);
+}
+
+template <class T>
+void FloatTensorToQuantizedInPlace(const Tensor& input, float min, float max,
+                                   Tensor* result) {
+  DCHECK_EQ(DataTypeToEnum<T>::v(), result->dtype());
+  auto flat_input = input.flat<float>();
+  auto flat_result = result->flat<T>();
+  const int data_size = flat_input.size();
+  DCHECK(data_size == flat_result.size());
+  for (int i = 0; i < data_size; ++i) {
+    flat_result(i) = FloatToQuantized<T>(flat_input(i), min, max);
+  }
+}
+
+template <class T>
+Tensor FloatTensorToQuantized(const Tensor& input, float min, float max) {
+  Tensor result(DataTypeToEnum<T>::v(), input.shape());
+  FloatTensorToQuantizedInPlace<T>(input, min, max, &result);
+  return result;
+}
+
+// REQUIRES: 'result->NumElements() == input.NumElements()'
+template <class T>
+void QuantizedTensorToFloatInPlaceUsingEigen(
+    const Eigen::ThreadPoolDevice& device, const Tensor& input, float min,
+    float max, Tensor* result) {
+  DCHECK_EQ(DataTypeToEnum<T>::v(), input.dtype());
+  auto flat_input = input.flat<T>();
+  auto flat_result = result->flat<float>();
+  const int data_size = flat_input.size();
+  DCHECK(data_size == flat_result.size());
+
+  QuantizedToFloatStruct<T> q2f(min, max);
+  flat_result.device(device) = DEQUANTIZE_WITH_EIGEN(flat_input, q2f);
+}
+
+// REQUIRES: 'result->NumElements() == input.NumElements()'
+template <class T>
+void QuantizedTensorToFloatInPlace(const Tensor& input, float min, float max,
+                                   Tensor* result) {
+  DCHECK_EQ(DataTypeToEnum<T>::v(), input.dtype());
+  auto flat_input = input.flat<T>();
+  auto flat_result = result->flat<float>();
+  const int data_size = flat_input.size();
+  DCHECK(data_size == flat_result.size());
+  for (int i = 0; i < data_size; ++i) {
+    flat_result(i) = QuantizedToFloat<T>(flat_input(i), min, max);
+  }
+}
+
+template <class T>
+Tensor QuantizedTensorToFloat(const Tensor& input, float min, float max) {
+  Tensor result(DT_FLOAT, input.shape());
+  QuantizedTensorToFloatInPlace<T>(input, min, max, &result);
+  return result;
+}
+
+void GetOutputMinAndMaxForQuantizedAdd(float input_min, float input_max,
+                                       float smaller_input_min,
+                                       float smaller_input_max,
+                                       float* output_min, float* output_max);
+
+// Add <input> and <smaller_input>.  If <smaller_input> has fewer elements than
+// <input>, then it is broadcast onto <input>.
+template <typename T1, typename T2, typename T3>
+void QuantizedAddUsingEigen(const Eigen::ThreadPoolDevice& device,
+                            const Tensor& input, float input_min,
+                            float input_max, const Tensor& smaller_input,
+                            float smaller_input_min, float smaller_input_max,
+                            Tensor* output, float* output_min,
+                            float* output_max) {
+  const auto& input_flat = input.flat<T1>();
+  const auto& smaller_input_flat = smaller_input.flat<T2>();
+  auto output_flat = output->flat<T3>();
+
+  GetOutputMinAndMaxForQuantizedAdd(input_min, input_max, smaller_input_min,
+                                    smaller_input_max, output_min, output_max);
+  // To do addition properly, we need to compensate for a possibly unbalanced
+  // zero point in the total representation. The quantized value that
+  // represents the real number zero needs to be subtracted before addition to
+  // make sure that the identity of zero + zero = zero holds.
+  const T3 zero_in_total_space =
+      FloatToQuantized<T3>(0.0f, *output_min, *output_max);
+
+  const int64_t input_element_count = input.NumElements();
+  const int64_t smaller_input_element_count = smaller_input.NumElements();
+
+  QuantizedToFloatStruct<T1> input_q2f(input_min, input_max);
+  QuantizedToFloatStruct<T2> smaller_input_q2f(smaller_input_min,
+                                               smaller_input_max);
+  FloatToQuantizedStruct<T3> f2q(*output_min, *output_max);
+
+  auto smaller_input_float =
+      DEQUANTIZE_WITH_EIGEN(smaller_input_flat, smaller_input_q2f);
+  auto smaller_input_in_total_space =
+      QUANTIZE_WITH_EIGEN(smaller_input_float, f2q, T3);
+
+  auto input_float = DEQUANTIZE_WITH_EIGEN(input_flat, input_q2f);
+  auto input_in_total_space = QUANTIZE_WITH_EIGEN(input_float, f2q, T3);
+
+  Eigen::array<Eigen::DenseIndex, 1> bcast;
+  bcast[0] = input_element_count / smaller_input_element_count;
+  output_flat.device(device) =
+      input_in_total_space +
+      (smaller_input_in_total_space.broadcast(bcast) + zero_in_total_space);
+}
+
+// This is a reference implementation of the bias addition for quantized
+// buffers, designed to provide a clear specification for the result we
+// want. We'll want to specialize this for particular hardware, and
+// probably even fuse it with matrix multiplications in a lot of cases. It's
+// important to show the clamping behavior we want in particular.
+template <typename T1, typename T2, typename T3>
+void QuantizedAdd(const Eigen::ThreadPoolDevice& device, const Tensor& input,
+                  float input_min, float input_max, const Tensor& smaller_input,
+                  float smaller_input_min, float smaller_input_max,
+                  Tensor* output, float* output_min, float* output_max) {
+  const auto& input_flat = input.flat<T1>();
+  const auto& smaller_input_flat = smaller_input.flat<T2>();
+  auto output_flat = output->flat<T3>();
+
+  GetOutputMinAndMaxForQuantizedAdd(input_min, input_max, smaller_input_min,
+                                    smaller_input_max, output_min, output_max);
+  // To do addition properly, we need to compensate for a possibly unbalanced
+  // zero point in the total representation. The quantized value that
+  // represents the real number zero needs to be subtracted before addition to
+  // make sure that the identity of zero + zero = zero holds.
+  const T3 zero_in_total_space =
+      FloatToQuantized<T3>(0.0f, *output_min, *output_max);
+
+  const int64_t input_element_count = input.NumElements();
+  const int64_t smaller_input_element_count = smaller_input.NumElements();
+
+  float total_min = *output_min;
+  float total_max = *output_max;
+  const size_t how_many_iterations =
+      (input_element_count / smaller_input_element_count);
+  for (size_t iteration = 0; iteration < how_many_iterations; ++iteration) {
+    const size_t offset = iteration * smaller_input_element_count;
+    for (int c = 0; c < smaller_input_element_count; ++c) {
+      const int index = (offset + c);
+      // The two numbers we're going to add can each be in very different
+      // ranges (e.g. the quantized value '127' may represent very different
+      // real numbers in both) so we need to convert them to a common range
+      // before we sum them.
+      const T1 input_value = input_flat(index);
+      const T3 input_in_total_space = RequantizeInNewRange<T1, T3>(
+          input_value, input_min, input_max, total_min, total_max);
+      const T2 smaller_input_value = smaller_input_flat(c);
+      const T3 smaller_input_in_total_space =
+          RequantizeInNewRange<T2, T3>(smaller_input_value, smaller_input_min,
+                                       smaller_input_max, total_min, total_max);
+      const T3 total_pre = input_in_total_space + smaller_input_in_total_space;
+      // As noted above, we need to compensate for the offset of the actual
+      // zero point in the space we're operating in.
+      const T3 total = total_pre + zero_in_total_space;
+      output_flat(index) = total;
+    }
+  }
+}
+
+// See gemmlowp/internal/multi_thread_gemm.h for the semantics of Execute.
+class TensorflowGemmlowpWorkersPool {
+ public:
+  TensorflowGemmlowpWorkersPool(thread::ThreadPool* workers)
+      : workers_(workers) {}
+
+  ~TensorflowGemmlowpWorkersPool() {
+    // This workaround ensures that all worker tasks have exited methods in the
+    // BlockingCounter. Without this, there is a race where the context is torn
+    // down while the counter is in use.
+    counter_to_decrement_when_ready_.Reset(0);
+  }
+
+  void Execute(const std::vector<gemmlowp::Task*>& tasks) {
+    assert(!tasks.empty());
+    assert(workers_ != nullptr);
+    counter_to_decrement_when_ready_.Reset(tasks.size());
+    for (gemmlowp::Task* task : tasks) {
+      workers_->Schedule([this, task]() {
+        // TODO(cwhipkey): get a local_allocator from a thread local storage.
+        gemmlowp::Allocator local_allocator;
+        CHECK(task != nullptr);
+        task->local_allocator = &local_allocator;
+        task->Run();
+        counter_to_decrement_when_ready_.DecrementCount();
+      });
+    }
+    counter_to_decrement_when_ready_.Wait();
+    for (gemmlowp::Task* task : tasks) {
+      delete task;
+    }
+  }
+
+ private:
+  thread::ThreadPool* const workers_;
+
+  // The BlockingCounter used to wait for the workers.
+  gemmlowp::BlockingCounter counter_to_decrement_when_ready_;
+
+  TensorflowGemmlowpWorkersPool(const TensorflowGemmlowpWorkersPool&) = delete;
+  void operator=(const TensorflowGemmlowpWorkersPool&) = delete;
+};
+
+class TensorflowGemmContext : public gemmlowp::MultiThreadGemmContextBase {
+ public:
+  TensorflowGemmContext(int num_threads, thread::ThreadPool* workers)
+      : workers_pool_(workers) {
+    set_max_num_threads(num_threads);
+  }
+
+  TensorflowGemmlowpWorkersPool* workers_pool() { return &workers_pool_; }
+
+ private:
+  TensorflowGemmlowpWorkersPool workers_pool_;
+
+  TensorflowGemmContext(const TensorflowGemmContext&) = delete;
+  void operator=(const TensorflowGemmContext&) = delete;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_QUANTIZATION_UTILS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/quantize_and_dequantize_op.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/quantize_and_dequantize_op.h
new file mode 100644
index 0000000000000000000000000000000000000000..253d667a91ddb659dee39ba210bb9f4d2245127d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/quantize_and_dequantize_op.h
@@ -0,0 +1,322 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_QUANTIZE_AND_DEQUANTIZE_OP_H_
+#define TENSORFLOW_CORE_KERNELS_QUANTIZE_AND_DEQUANTIZE_OP_H_
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/tensor_types.h"
+#include "tensorflow/core/kernels/cwise_ops.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+
+enum QuantizerRoundMode {
+  // Round half up: if the fraction of y is exactly 0.5, then
+  // round(y) = y + 0.5
+  // E.g., -5.5 gets rounded to -5, -5.4 goes to -5,
+  // 5.4 goes to 5, and 5.5 goes to 6.
+  ROUND_HALF_UP,
+  // Round half to even: if the fraction of y is exactly 0.5, then round(y) is
+  // the nearest even integer to y.
+  // E.g., 23.5 gets rounded to 24, 24.5 gets rounded to 24, while -23.5 becomes
+  // -24, and -24.5 gets rounded to 24.
+  ROUND_HALF_TO_EVEN,
+};
+
+namespace functor {
+
+// TODO(pauldonnelly): 'signed_input' should really be called 'signed_output'.
+
+template <typename Device, typename T>
+struct QuantizeAndDequantizeOneScaleFunctor {
+  void operator()(const Device& d, typename TTypes<T>::ConstVec input,
+                  bool signed_input, int num_bits, bool range_given,
+                  Tensor* input_min_tensor, Tensor* input_max_tensor,
+                  QuantizerRoundMode round_mode, bool narrow_range,
+                  typename TTypes<T>::Vec output);
+};
+
+template <typename Device, typename T>
+struct QuantizeAndDequantizePerChannelFunctor {
+  void operator()(const Device& d, typename TTypes<T, 3>::ConstTensor input,
+                  bool signed_input, int num_bits, bool range_given,
+                  Tensor* input_min_tensor, Tensor* input_max_tensor,
+                  QuantizerRoundMode round_mode, bool narrow_range,
+                  typename TTypes<T, 3>::Tensor output);
+};
+
+template <typename Device, typename T>
+struct QuantizeAndDequantizeOneScaleGradientFunctor {
+  void operator()(const Device& d, typename TTypes<T>::ConstFlat gradient,
+                  typename TTypes<T>::ConstFlat input,
+                  typename TTypes<T>::ConstScalar input_min,
+                  typename TTypes<T>::ConstScalar input_max,
+                  typename TTypes<T>::Flat input_backprop,
+                  typename TTypes<T>::Scalar input_min_backprop,
+                  typename TTypes<T>::Scalar input_max_backprop);
+};
+
+template <typename Device, typename T>
+struct QuantizeAndDequantizePerChannelGradientFunctor {
+  void operator()(const Device& d, typename TTypes<T, 3>::ConstTensor gradient,
+                  typename TTypes<T, 3>::ConstTensor input,
+                  const Tensor* input_min_tensor,
+                  const Tensor* input_max_tensor,
+                  typename TTypes<T, 3>::Tensor input_backprop,
+                  typename TTypes<T>::Flat input_min_backprop,
+                  typename TTypes<T>::Flat input_max_backprop);
+};
+
+// The implementation below runs on both CPU and GPU.
+template <typename Device, typename T, typename Func,
+          typename Vec = typename TTypes<T>::Vec,
+          typename ConstVec = typename TTypes<T>::ConstVec>
+void ClampScaleAndRound(const Device& d, ConstVec input, T min_range,
+                        T max_range, T scale, T inverse_scale, Func round_func,
+                        Vec output) {
+  output.device(d) = (input.cwiseMin(max_range).cwiseMax(min_range) * scale)
+                         .unaryExpr(round_func) *
+                     inverse_scale;
+}
+
+// The implementation below runs on both CPU and GPU.
+template <typename Device, typename T, typename Vec = typename TTypes<T>::Vec,
+          typename ConstVec = typename TTypes<T>::ConstVec>
+void ClampScaleAndRound(const Device& d, ConstVec input, T min_range,
+                        T max_range, T scale, T inverse_scale,
+                        QuantizerRoundMode round_mode, Vec output) {
+  switch (round_mode) {
+    case ROUND_HALF_TO_EVEN:
+      ClampScaleAndRound(d, input, min_range, max_range, scale, inverse_scale,
+                         Eigen::internal::scalar_round_half_to_even_op<T>(),
+                         output);
+      break;
+    case ROUND_HALF_UP:
+      ClampScaleAndRound(d, input, min_range, max_range, scale, inverse_scale,
+                         Eigen::internal::scalar_round_up_op<T>(), output);
+      break;
+  }
+}
+
+// The implementation below runs on both CPU and GPU.
+template <typename Device, typename T, typename Func,
+          typename Vec = typename TTypes<T>::Vec,
+          typename ConstVec = typename TTypes<T>::ConstVec>
+void ScaleAndRound(const Device& d, ConstVec input, T scale, T inverse_scale,
+                   Func round_func, Vec output) {
+  output.device(d) = (input * scale).unaryExpr(round_func) * inverse_scale;
+}
+
+// The implementation below runs on both CPU and GPU.
+template <typename Device, typename T, typename Vec = typename TTypes<T>::Vec,
+          typename ConstVec = typename TTypes<T>::ConstVec>
+void ScaleAndRound(const Device& d, ConstVec input, T scale, T inverse_scale,
+                   QuantizerRoundMode round_mode, Vec output) {
+  switch (round_mode) {
+    case ROUND_HALF_TO_EVEN:
+      ScaleAndRound(d, input, scale, inverse_scale,
+                    Eigen::internal::scalar_round_half_to_even_op<T>(), output);
+      break;
+    case ROUND_HALF_UP:
+      ScaleAndRound(d, input, scale, inverse_scale,
+                    Eigen::internal::scalar_round_up_op<T>(), output);
+      break;
+  }
+}
+
+template <typename T>
+void ComputeQuantizationRange(bool signed_input, int num_bits,
+                              QuantizerRoundMode round_mode, bool narrow_range,
+                              T* min_range, T* max_range, T* scale,
+                              T* inverse_scale) {
+  // Calculate the range for the simulated integer quantization:
+  // e.g. [-127,127] for signed = true, narrow_range = true, num_bits = 8,
+  // or [-128,127] for signed = true, narrow_range = false, num_bits = 8,
+  // or [0, 255] for signed = false, num_bits = 8.
+  const int64_t min_quantized =
+      signed_input ? narrow_range ? -(1ULL << (num_bits - 1)) + 1
+                                  : -(1ULL << (num_bits - 1))
+                   : 0;
+  const int64_t max_quantized =
+      signed_input ? (1ULL << (num_bits - 1)) - 1 : (1ULL << num_bits) - 1;
+  // Determine the maximum scaling factor that would scale
+  // [min_range, max_range] to not exceed [min_quantized, max_quantized],
+  // while keeping 0 unchanged.
+  const T scale_from_min_side = (min_quantized * *min_range > 0)
+                                    ? min_quantized / *min_range
+                                    : std::numeric_limits<T>::max();
+  const T scale_from_max_side = (max_quantized * *max_range > 0)
+                                    ? max_quantized / *max_range
+                                    : std::numeric_limits<T>::max();
+
+  // Note: Avoids changing the side of the range that determines scale.
+  if (scale_from_min_side < scale_from_max_side) {
+    *scale = scale_from_min_side;
+    *inverse_scale = *min_range / min_quantized;
+    *max_range = max_quantized * *inverse_scale;
+  } else {
+    *scale = scale_from_max_side;
+    *inverse_scale = *max_range / max_quantized;
+    *min_range = min_quantized * *inverse_scale;
+  }
+}
+
+// The implementation below runs on both CPU and GPU.
+template <typename Device, typename T>
+struct QuantizeAndDequantizeOneScaleImpl {
+  static void Compute(const Device& d, typename TTypes<T>::ConstVec input,
+                      bool signed_input, int num_bits, bool range_given,
+                      Tensor* input_min_tensor, Tensor* input_max_tensor,
+                      QuantizerRoundMode round_mode, bool narrow_range,
+                      typename TTypes<T>::Vec output) {
+    T min_range;
+    T max_range;
+    auto input_min = input_min_tensor->scalar<T>();
+    auto input_max = input_max_tensor->scalar<T>();
+    if (!range_given) {
+      input_min.device(d) = input.minimum();
+      input_max.device(d) = input.maximum();
+      d.memcpyDeviceToHost(&min_range, input_min.data(), sizeof(T));
+      d.memcpyDeviceToHost(&max_range, input_max.data(), sizeof(T));
+    } else {
+      // Copy the range values from their respective tensors on the host.
+      min_range = input_min_tensor->scalar<T>()();
+      max_range = input_max_tensor->scalar<T>()();
+    }
+
+    T scale, inverse_scale;
+    ComputeQuantizationRange(signed_input, num_bits, round_mode, narrow_range,
+                             &min_range, &max_range, &scale, &inverse_scale);
+
+    if (range_given) {
+      // Note: The clamping here is to avoid overflow in the quantized type.
+      // The semantics of the op does not guarantee to clamp to the specified
+      // min_range and max_range - because we may have changed either min_range
+      // or max_range.
+      ClampScaleAndRound(d, input, min_range, max_range, scale, inverse_scale,
+                         round_mode, output);
+    } else {
+      ScaleAndRound(d, input, scale, inverse_scale, round_mode, output);
+    }
+  }
+};
+
+// The implementation below runs on both CPU and GPU.
+
+template <typename Device, typename T>
+struct QuantizeAndDequantizePerChannelImpl {
+  static void Compute(const Device& d, typename TTypes<T, 3>::ConstTensor input,
+                      bool signed_input, int num_bits, bool range_given,
+                      Tensor* input_min_tensor, Tensor* input_max_tensor,
+                      QuantizerRoundMode round_mode, bool narrow_range,
+                      typename TTypes<T, 3>::Tensor output) {
+    using Index = typename tensorflow::TTypes<T>::ConstTensor::Index;
+    int num_channels = input.dimension(1);
+    auto input_min = input_min_tensor->vec<T>();
+    auto input_max = input_max_tensor->vec<T>();
+    std::vector<T> min_range(num_channels);
+    std::vector<T> max_range(num_channels);
+
+    if (!range_given) {
+      Eigen::IndexList<Eigen::type2index<0>, Eigen::type2index<2> > reduce_dims;
+      input_min.device(d) = input.minimum(reduce_dims);
+      input_max.device(d) = input.maximum(reduce_dims);
+      d.memcpyDeviceToHost(min_range.data(), input_min.data(),
+                           num_channels * sizeof(T));
+      d.memcpyDeviceToHost(max_range.data(), input_max.data(),
+                           num_channels * sizeof(T));
+    } else {
+      // Copy the range values from their respective tensors on the host.
+      std::memcpy(min_range.data(), input_min_tensor->vec<T>().data(),
+                  num_channels * sizeof(T));
+      std::memcpy(max_range.data(), input_max_tensor->vec<T>().data(),
+                  num_channels * sizeof(T));
+    }
+
+    for (Index i = 0; i < num_channels; ++i) {
+      const auto input_chip = input.template chip<1>(i);
+      auto output_chip = output.template chip<1>(i);
+
+      T scale, inverse_scale;
+      ComputeQuantizationRange(signed_input, num_bits, round_mode, narrow_range,
+                               &min_range[i], &max_range[i], &scale,
+                               &inverse_scale);
+      if (range_given) {
+        ClampScaleAndRound(d, input_chip, min_range[i], max_range[i], scale,
+                           inverse_scale, round_mode, output_chip);
+      } else {
+        ScaleAndRound(d, input_chip, scale, inverse_scale, round_mode,
+                      output_chip);
+      }
+    }
+  }
+};
+
+template <typename Device, typename T>
+struct QuantizeAndDequantizeOneScaleGradientImpl {
+  static void Compute(const Device& d, typename TTypes<T>::ConstFlat gradient,
+                      typename TTypes<T>::ConstFlat input,
+                      typename TTypes<T>::ConstScalar input_min,
+                      typename TTypes<T>::ConstScalar input_max,
+                      typename TTypes<T>::Flat input_backprop,
+                      typename TTypes<T>::Scalar input_min_backprop,
+                      typename TTypes<T>::Scalar input_max_backprop) {
+    const T min_val = input_min();
+    const T max_val = input_max();
+    const auto in_range =
+        (input >= min_val && input <= max_val)
+            .select(input.constant(1.0f), input.constant(0.0f));
+    input_backprop.device(d) = gradient * in_range;
+    input_min_backprop.device(d) = input_min_backprop.constant(0.0f);
+    input_max_backprop.device(d) = input_max_backprop.constant(0.0f);
+  }
+};
+
+template <typename Device, typename T>
+struct QuantizeAndDequantizePerChannelGradientImpl {
+  static void Compute(const Device& d,
+                      typename TTypes<T, 3>::ConstTensor gradient,
+                      typename TTypes<T, 3>::ConstTensor input,
+                      const Tensor* input_min_tensor,
+                      const Tensor* input_max_tensor,
+                      typename TTypes<T, 3>::Tensor input_backprop,
+                      typename TTypes<T>::Flat input_min_backprop,
+                      typename TTypes<T>::Flat input_max_backprop) {
+    using Index = typename tensorflow::TTypes<T>::ConstTensor::Index;
+    auto input_min = input_min_tensor->vec<T>();
+    auto input_max = input_max_tensor->vec<T>();
+    int num_channels = input.dimension(1);
+    for (Index i = 0; i < num_channels; ++i) {
+      const auto gradient_chip = gradient.template chip<1>(i);
+      const auto input_chip = input.template chip<1>(i);
+      const T min_val = input_min(i);
+      const T max_val = input_max(i);
+      const auto in_range =
+          (input_chip >= min_val && input_chip <= max_val)
+              .select(input_chip.constant(1.0f), input_chip.constant(0.0f));
+      input_backprop.template chip<1>(i).device(d) = gradient_chip * in_range;
+    }
+    input_min_backprop.device(d) = input_min_backprop.constant(0.0f);
+    input_max_backprop.device(d) = input_max_backprop.constant(0.0f);
+  }
+};
+
+}  // end of namespace functor
+}  // end of namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_QUANTIZE_AND_DEQUANTIZE_OP_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/queue_base.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/queue_base.h
new file mode 100644
index 0000000000000000000000000000000000000000..71884a9dff0af96bc72cd47ee3f4aa046075de86
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/queue_base.h
@@ -0,0 +1,187 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_QUEUE_BASE_H_
+#define TENSORFLOW_CORE_KERNELS_QUEUE_BASE_H_
+
+#include <deque>
+#include <vector>
+
+#include "absl/base/macros.h"
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/queue_interface.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/tensor_shape.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/lib/gtl/array_slice.h"
+#include "tensorflow/core/platform/macros.h"
+#include "tensorflow/core/platform/mutex.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+
+// Functionality common to asynchronous QueueInterface implementations.
+class QueueBase : public QueueInterface {
+ public:
+  // As a possible value of 'capacity'.
+  static constexpr int32_t kUnbounded = INT_MAX;
+
+  // Args:
+  //   component_dtypes: The types of each component in a queue-element tuple.
+  //   component_shapes: The shapes of each component in a queue-element tuple,
+  //     which must either be empty (if the shapes are not specified) or
+  //     or have the same size as component_dtypes.
+  //   name: A name to use for the queue.
+  QueueBase(int32_t capacity, const DataTypeVector& component_dtypes,
+            const std::vector<TensorShape>& component_shapes,
+            const string& name);
+
+  // Implementations of QueueInterface methods --------------------------------
+  const DataTypeVector& component_dtypes() const override {
+    return component_dtypes_;
+  }
+
+  Status ValidateTuple(const Tuple& tuple) override;
+  Status ValidateManyTuple(const Tuple& tuple) override;
+
+  void Close(OpKernelContext* ctx, bool cancel_pending_enqueues,
+             DoneCallback callback) override;
+
+  // Other public methods -----------------------------------------------------
+  const std::vector<TensorShape>& component_shapes() const {
+    return component_shapes_;
+  }
+
+  int32 capacity() const { return capacity_; }
+
+  bool is_closed() const override {
+    mutex_lock lock(mu_);
+    return closed_;
+  }
+
+  // Copies the index^th slice (in the first dimension) of parent into element.
+  static Status CopySliceToElement(const Tensor& parent, Tensor* element,
+                                   int64_t index);
+
+  // Copies element into the index^th slice (in the first dimension) of parent.
+  // NOTE(mrry): This method is deprecated. Use
+  // `tensorflow::batch_util::CopySliceToElement()` defined in
+  // "./batch_util.h" instead.
+  ABSL_DEPRECATED(
+      "Use `tensorflow::batch_util::CopySliceToElement()` defined in "
+      "\"./batch_util.h\" instead.")
+  static Status CopyElementToSlice(const Tensor& element, Tensor* parent,
+                                   int64_t index);
+
+ protected:
+  enum Action { kEnqueue, kDequeue };
+  enum RunResult { kNoProgress, kProgress, kComplete };
+
+  // Tries to enqueue/dequeue (or close) based on whatever is at the
+  // front of enqueue_attempts_/dequeue_attempts_.  Appends to
+  // *finished the callback for any finished attempt (so it may be
+  // called once mu_ is released).  Returns true if any progress was
+  // made.
+  struct CleanUp {
+    CleanUp(DoneCallback&& f, CancellationToken ct, CancellationManager* cm)
+        : finished(f), to_deregister(ct), cm(cm) {}
+    DoneCallback finished;
+    CancellationToken to_deregister;
+    CancellationManager* cm;
+  };
+
+  // Returns the number of components in a queue-element tuple.
+  int32 num_components() const { return component_dtypes_.size(); }
+
+  // True if shapes were specified.  If so, inputs will be validated
+  // against them, etc.
+  bool specified_shapes() const { return component_shapes_.size() > 0; }
+
+  // Code common to Validate*Tuple().
+  Status ValidateTupleCommon(const Tuple& tuple) const;
+
+  TensorShape ManyOutShape(int i, int64_t batch_size) {
+    TensorShape shape({batch_size});
+    shape.AppendShape(component_shapes_[i]);
+    return shape;
+  }
+
+  void Cancel(Action action, CancellationManager* cancellation_manager,
+              CancellationToken token);
+
+  // Helper for cancelling all pending Enqueue(Many) operations when
+  // Close is called with cancel_pending_enqueues.
+  void CloseAndCancel();
+
+  bool TryAttemptLocked(Action action, std::vector<CleanUp>* clean_up)
+      TF_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+
+  // Tries to make progress on the enqueues or dequeues at the front
+  // of the *_attempts_ queues.
+  void FlushUnlocked();
+
+  ~QueueBase() override;
+
+  // Helpers for implementing MatchesNodeDef().
+  static string ShapeListString(const gtl::ArraySlice<TensorShape>& shapes);
+  Status MatchesNodeDefOp(const NodeDef& node_def, const string& op) const;
+  Status MatchesNodeDefCapacity(const NodeDef& node_def,
+                                int32_t capacity) const;
+  Status MatchesNodeDefTypes(const NodeDef& node_def) const;
+  Status MatchesNodeDefShapes(const NodeDef& node_def) const;
+
+ protected:
+  const int32 capacity_;
+  const DataTypeVector component_dtypes_;
+  const std::vector<TensorShape> component_shapes_;
+  const string name_;
+  mutable mutex mu_;
+  bool closed_ TF_GUARDED_BY(mu_);
+
+  struct Attempt;
+  typedef std::function<RunResult(Attempt*)> RunCallback;
+  struct Attempt {
+    int32 elements_requested;
+    DoneCallback done_callback;  // must be run outside mu_
+    OpKernelContext* context;
+    CancellationManager* cancellation_manager;  // not owned
+    CancellationToken cancellation_token;
+    RunCallback run_callback;  // must be run while holding mu_
+    bool is_cancelled;
+    Tuple tuple;
+    // tuples is used by some implementations allowing dynamic shapes.
+    std::vector<Tuple> tuples;
+
+    Attempt(int32_t elements_requested, DoneCallback done_callback,
+            OpKernelContext* context, CancellationManager* cancellation_manager,
+            CancellationToken cancellation_token, RunCallback run_callback)
+        : elements_requested(elements_requested),
+          done_callback(done_callback),
+          context(context),
+          cancellation_manager(cancellation_manager),
+          cancellation_token(cancellation_token),
+          run_callback(run_callback),
+          is_cancelled(false) {}
+  };
+  std::deque<Attempt> enqueue_attempts_ TF_GUARDED_BY(mu_);
+  std::deque<Attempt> dequeue_attempts_ TF_GUARDED_BY(mu_);
+
+  QueueBase(const QueueBase&) = delete;
+  void operator=(const QueueBase&) = delete;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_QUEUE_BASE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/queue_op.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/queue_op.h
new file mode 100644
index 0000000000000000000000000000000000000000..5583b79c786e95e90e1d9e6974191ae5a0e05782
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/queue_op.h
@@ -0,0 +1,279 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_QUEUE_OP_H_
+#define TENSORFLOW_CORE_KERNELS_QUEUE_OP_H_
+
+#include <deque>
+
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/queue_interface.h"
+#include "tensorflow/core/framework/resource_op_kernel.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/kernels/queue_base.h"
+#include "tensorflow/core/lib/core/errors.h"
+#include "tensorflow/core/platform/macros.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+
+// Defines a QueueOp, an abstract class for Queue construction ops.
+class QueueOp : public ResourceOpKernel<QueueInterface> {
+ public:
+  QueueOp(OpKernelConstruction* context);
+
+  void Compute(OpKernelContext* context) override;
+
+ protected:
+  // Variables accessible by subclasses
+  int32 capacity_;
+  DataTypeVector component_types_;
+
+ private:
+  Status VerifyResource(QueueInterface* queue) override;
+};
+
+class TypedQueueOp : public QueueOp {
+ public:
+  using QueueOp::QueueOp;
+
+ protected:
+  template <typename TypedQueue>
+  Status CreateTypedQueue(TypedQueue* queue, QueueInterface** ret) {
+    if (queue == nullptr) {
+      return errors::ResourceExhausted("Failed to allocate queue.");
+    }
+    *ret = queue;
+    return queue->Initialize();
+  }
+};
+
+// Queue manipulator kernels
+
+class QueueOpKernel : public AsyncOpKernel {
+ public:
+  explicit QueueOpKernel(OpKernelConstruction* context);
+
+  void ComputeAsync(OpKernelContext* ctx, DoneCallback callback) final;
+
+ protected:
+  virtual void ComputeAsync(OpKernelContext* ctx, QueueInterface* queue,
+                            DoneCallback callback) = 0;
+};
+
+class QueueAccessOpKernel : public QueueOpKernel {
+ public:
+  explicit QueueAccessOpKernel(OpKernelConstruction* context);
+
+ protected:
+  int64_t timeout_;
+};
+
+// Defines an EnqueueOp, the execution of which enqueues a tuple of
+// tensors in the given Queue.
+//
+// The op has 1 + k inputs, where k is the number of components in the
+// tuples stored in the given Queue:
+// - Input 0: queue handle.
+// - Input 1: 0th element of the tuple.
+// - ...
+// - Input (1+k): kth element of the tuple.
+class EnqueueOp : public QueueAccessOpKernel {
+ public:
+  explicit EnqueueOp(OpKernelConstruction* context);
+
+ protected:
+  void ComputeAsync(OpKernelContext* ctx, QueueInterface* queue,
+                    DoneCallback callback) override;
+
+ private:
+  EnqueueOp(const EnqueueOp&) = delete;
+  void operator=(const EnqueueOp&) = delete;
+};
+
+// Defines an EnqueueManyOp, the execution of which slices each
+// component of a tuple of tensors along the 0th dimension, and
+// enqueues tuples of slices in the given Queue.
+//
+// The op has 1 + k inputs, where k is the number of components in the
+// tuples stored in the given Queue:
+// - Input 0: queue handle.
+// - Input 1: 0th element of the tuple.
+// - ...
+// - Input (1+k): kth element of the tuple.
+//
+// N.B. All tuple components must have the same size in the 0th
+// dimension.
+class EnqueueManyOp : public QueueAccessOpKernel {
+ public:
+  explicit EnqueueManyOp(OpKernelConstruction* context);
+
+ protected:
+  void ComputeAsync(OpKernelContext* ctx, QueueInterface* queue,
+                    DoneCallback callback) override;
+
+  ~EnqueueManyOp() override;
+
+ private:
+  EnqueueManyOp(const EnqueueManyOp&) = delete;
+  void operator=(const EnqueueManyOp&) = delete;
+};
+
+// Defines a DequeueOp, the execution of which dequeues a tuple of
+// tensors from the given Queue.
+//
+// The op has one input, which is the handle of the appropriate
+// Queue. The op has k outputs, where k is the number of components in
+// the tuples stored in the given Queue, and output i is the ith
+// component of the dequeued tuple.
+class DequeueOp : public QueueAccessOpKernel {
+ public:
+  explicit DequeueOp(OpKernelConstruction* context);
+
+ protected:
+  void ComputeAsync(OpKernelContext* ctx, QueueInterface* queue,
+                    DoneCallback callback) override;
+
+  ~DequeueOp() override;
+
+ private:
+  DequeueOp(const DequeueOp&) = delete;
+  void operator=(const DequeueOp&) = delete;
+};
+
+// Defines a DequeueManyOp, the execution of which concatenates the
+// requested number of elements from the given Queue along the 0th
+// dimension, and emits the result as a single tuple of tensors.
+//
+// The op has two inputs:
+// - Input 0: the handle to a queue.
+// - Input 1: the number of elements to dequeue.
+//
+// The op has k outputs, where k is the number of components in the
+// tuples stored in the given Queue, and output i is the ith component
+// of the dequeued tuple.
+class DequeueManyOp : public QueueAccessOpKernel {
+ public:
+  explicit DequeueManyOp(OpKernelConstruction* context);
+
+ protected:
+  void ComputeAsync(OpKernelContext* ctx, QueueInterface* queue,
+                    DoneCallback callback) override;
+
+  ~DequeueManyOp() override;
+
+ private:
+  DequeueManyOp(const DequeueManyOp&) = delete;
+  void operator=(const DequeueManyOp&) = delete;
+};
+
+// Defines a DequeueUpToOp, the execution of which concatenates the
+// requested number of elements from the given Queue along the 0th
+// dimension, and emits the result as a single tuple of tensors.
+//
+// The difference between this op and DequeueMany is the handling when
+// the Queue is closed.  While the DequeueMany op will return if there
+// an error when there are less than num_elements elements left in the
+// closed queue, this op will return between 1 and
+// min(num_elements, elements_remaining_in_queue), and will not block.
+// If there are no elements left, then the standard DequeueMany error
+// is returned.
+//
+// This op only works if the underlying Queue implementation accepts
+// the allow_small_batch = true parameter to TryDequeueMany.
+// If it does not, an errors::Unimplemented exception is returned.
+//
+// The op has two inputs:
+// - Input 0: the handle to a queue.
+// - Input 1: the number of elements to dequeue.
+//
+// The op has k outputs, where k is the number of components in the
+// tuples stored in the given Queue, and output i is the ith component
+// of the dequeued tuple.
+//
+// The op has one attribute: allow_small_batch.  If the Queue supports
+// it, setting this to true causes the queue to return smaller
+// (possibly zero length) batches when it is closed, up to however
+// many elements are available when the op executes.  In this case,
+// the Queue does not block when closed.
+class DequeueUpToOp : public QueueAccessOpKernel {
+ public:
+  explicit DequeueUpToOp(OpKernelConstruction* context);
+
+ protected:
+  void ComputeAsync(OpKernelContext* ctx, QueueInterface* queue,
+                    DoneCallback callback) override;
+
+  ~DequeueUpToOp() override;
+
+ private:
+  DequeueUpToOp(const DequeueUpToOp&) = delete;
+  void operator=(const DequeueUpToOp&) = delete;
+};
+
+// Defines a QueueCloseOp, which closes the given Queue. Closing a
+// Queue signals that no more elements will be enqueued in it.
+//
+// The op has one input, which is the handle of the appropriate Queue.
+class QueueCloseOp : public QueueOpKernel {
+ public:
+  explicit QueueCloseOp(OpKernelConstruction* context);
+
+ protected:
+  void ComputeAsync(OpKernelContext* ctx, QueueInterface* queue,
+                    DoneCallback callback) override;
+
+ private:
+  bool cancel_pending_enqueues_;
+  QueueCloseOp(const QueueCloseOp&) = delete;
+  void operator=(const QueueCloseOp&) = delete;
+};
+
+// Defines a QueueSizeOp, which computes the number of elements in the
+// given Queue, and emits it as an output tensor.
+//
+// The op has one input, which is the handle of the appropriate Queue;
+// and one output, which is a single-element tensor containing the current
+// size of that Queue.
+class QueueSizeOp : public QueueOpKernel {
+ public:
+  explicit QueueSizeOp(OpKernelConstruction* context);
+
+ protected:
+  void ComputeAsync(OpKernelContext* ctx, QueueInterface* queue,
+                    DoneCallback callback) override;
+
+ private:
+  QueueSizeOp(const QueueSizeOp&) = delete;
+  void operator=(const QueueSizeOp&) = delete;
+};
+
+class QueueIsClosedOp : public QueueOpKernel {
+ public:
+  explicit QueueIsClosedOp(OpKernelConstruction* context);
+
+ protected:
+  void ComputeAsync(OpKernelContext* ctx, QueueInterface* queue,
+                    DoneCallback callback) override;
+
+ private:
+  QueueIsClosedOp(const QueueIsClosedOp&) = delete;
+  void operator=(const QueueIsClosedOp&) = delete;
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_QUEUE_OP_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/ragged_tensor_to_variant_op_test.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/ragged_tensor_to_variant_op_test.h
new file mode 100644
index 0000000000000000000000000000000000000000..0b71a308b2c5030cbbf7bfa0fa2755e28332d241
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/ragged_tensor_to_variant_op_test.h
@@ -0,0 +1,134 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#include <vector>
+
+#include <gtest/gtest.h>
+#include "absl/strings/match.h"
+#include "tensorflow/core/framework/fake_input.h"
+#include "tensorflow/core/framework/node_def_builder.h"
+#include "tensorflow/core/framework/shape_inference.h"
+#include "tensorflow/core/framework/shape_inference_testutil.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/tensor_shape.h"
+#include "tensorflow/core/framework/tensor_testutil.h"
+#include "tensorflow/core/framework/variant.h"
+#include "tensorflow/core/framework/variant_encode_decode.h"
+#include "tensorflow/core/kernels/ops_testutil.h"
+#include "tensorflow/core/kernels/ragged_tensor_variant.h"
+#include "tensorflow/core/lib/core/status_test_util.h"
+#include "tensorflow/core/platform/test.h"
+
+#ifndef TENSORFLOW_CORE_KERNELS_RAGGED_TENSOR_TO_VARIANT_OP_TEST_H_
+#define TENSORFLOW_CORE_KERNELS_RAGGED_TENSOR_TO_VARIANT_OP_TEST_H_
+
+namespace tensorflow {
+
+class RaggedTensorToVariantKernelTest : public ::tensorflow::OpsTestBase {
+ protected:
+  // Builds the tensorflow test graph for the RaggedTensorToVariant op, and
+  // populates the `splits` input with the given values.
+  template <typename VALUE_TYPE, typename SPLIT_TYPE>
+  void BuildEncodeRaggedTensorGraph(
+      const std::vector<std::vector<SPLIT_TYPE>>& ragged_splits,
+      const TensorShape& ragged_values_shape,
+      const std::vector<VALUE_TYPE>& ragged_values, const bool batched) {
+    const auto values_dtype = DataTypeToEnum<VALUE_TYPE>::v();
+    const auto splits_dtype = DataTypeToEnum<SPLIT_TYPE>::v();
+    int64_t num_splits = ragged_splits.size();
+    TF_ASSERT_OK(
+        NodeDefBuilder("tested_op", "RaggedTensorToVariant")
+            .Input(FakeInput(num_splits, splits_dtype))  // ragged_splits
+            .Input(FakeInput(values_dtype))              // ragged_values
+            .Attr("RAGGED_RANK", num_splits)
+            .Attr("Tvalues", values_dtype)
+            .Attr("Tsplits", splits_dtype)
+            .Attr("batched_input", batched)
+            .Finalize(node_def()));
+    TF_ASSERT_OK(InitOp());
+    for (const auto& splits : ragged_splits) {
+      int64_t splits_size = splits.size();
+      AddInputFromArray<SPLIT_TYPE>(TensorShape({splits_size}), splits);
+    }
+    AddInputFromArray<VALUE_TYPE>(ragged_values_shape, ragged_values);
+  }
+
+  template <typename VALUE_TYPE, typename SPLIT_TYPE>
+  void BuildEncodeRaggedTensorGraph(
+      const std::vector<std::vector<SPLIT_TYPE>>& ragged_splits,
+      const TensorShape& ragged_values_shape, const VALUE_TYPE& ragged_values,
+      const bool batched) {
+    const auto values_dtype = DataTypeToEnum<VALUE_TYPE>::v();
+    const auto splits_dtype = DataTypeToEnum<SPLIT_TYPE>::v();
+    int64_t num_splits = ragged_splits.size();
+    TF_ASSERT_OK(
+        NodeDefBuilder("tested_op", "RaggedTensorToVariant")
+            .Input(FakeInput(num_splits, splits_dtype))  // ragged_splits
+            .Input(FakeInput(values_dtype))              // ragged_values
+            .Attr("RAGGED_RANK", num_splits)
+            .Attr("Tvalues", values_dtype)
+            .Attr("Tsplits", splits_dtype)
+            .Attr("batched_input", batched)
+            .Finalize(node_def()));
+    TF_ASSERT_OK(InitOp());
+    for (const auto& splits : ragged_splits) {
+      int64_t splits_size = splits.size();
+      AddInputFromArray<SPLIT_TYPE>(TensorShape({splits_size}), splits);
+    }
+    AddInput<VALUE_TYPE>(ragged_values_shape,
+                         [&ragged_values](int i) { return ragged_values; });
+  }
+
+  template <typename VALUE_TYPE, typename SPLIT_TYPE>
+  RaggedTensorVariant CreateVariantFromRagged(
+      const std::vector<std::vector<SPLIT_TYPE>>& ragged_splits,
+      const TensorShape& ragged_values_shape,
+      const std::vector<VALUE_TYPE>& ragged_values) {
+    RaggedTensorVariant encoded;
+    for (auto ragged_split : ragged_splits) {
+      int splits_size = ragged_split.size();
+      Tensor splits(DataTypeToEnum<SPLIT_TYPE>::v(),
+                    TensorShape({splits_size}));
+      test::FillValues<SPLIT_TYPE>(&splits, ragged_split);
+      encoded.append_splits(splits);
+    }
+    Tensor values(DataTypeToEnum<VALUE_TYPE>::v(), ragged_values_shape);
+    test::FillValues<VALUE_TYPE>(&values, ragged_values);
+    encoded.set_values(values);
+    return encoded;
+  }
+
+  template <typename VALUE_TYPE, typename SPLIT_TYPE>
+  RaggedTensorVariant CreateVariantFromRagged(
+      const std::vector<std::vector<SPLIT_TYPE>>& ragged_splits,
+      const std::vector<VALUE_TYPE>& ragged_values) {
+    int num_values = ragged_values.size();
+    return CreateVariantFromRagged(ragged_splits, {num_values}, ragged_values);
+  }
+
+  template <typename VALUE_TYPE, typename SPLIT_TYPE>
+  void ExpectRaggedTensorVariantEqual(const RaggedTensorVariant& expected,
+                                      const RaggedTensorVariant& actual) {
+    test::ExpectTensorEqual<VALUE_TYPE>(actual.values(), expected.values());
+    EXPECT_EQ(actual.ragged_rank(), expected.ragged_rank());
+    for (int i = 0; i < actual.ragged_rank(); ++i) {
+      test::ExpectTensorEqual<SPLIT_TYPE>(actual.splits(i), expected.splits(i));
+    }
+  }
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_RAGGED_TENSOR_TO_VARIANT_OP_TEST_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/ragged_tensor_variant.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/ragged_tensor_variant.h
new file mode 100644
index 0000000000000000000000000000000000000000..4bef66a9e745b3defe26855ccaa7b733dd81c48e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/ragged_tensor_variant.h
@@ -0,0 +1,110 @@
+#include "tensorflow/core/framework/tensor_key.h"
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_RAGGED_TENSOR_VARIANT_H_
+#define TENSORFLOW_CORE_KERNELS_RAGGED_TENSOR_VARIANT_H_
+
+#define EIGEN_USE_THREADS
+#if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+#define EIGEN_USE_GPU
+#endif  // GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+
+#include <vector>
+
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/framework/variant_op_registry.h"
+#include "tensorflow/core/framework/variant_tensor_data.h"
+#include "tensorflow/core/kernels/cwise_ops_common.h"
+#include "tensorflow/core/util/tensor_ops_util.h"
+
+namespace tensorflow {
+
+// Class used to store a RaggedTensor as a Variant scalar.
+class RaggedTensorVariant {
+ public:
+  RaggedTensorVariant() {}
+  RaggedTensorVariant(Tensor values, const std::vector<Tensor>& nested_splits)
+      : values_(std::move(values)), nested_splits_(nested_splits) {}
+
+  // Variant support methods.
+  string TypeName() const;
+  string DebugString() const;
+  void Encode(VariantTensorData* data) const;
+  bool Decode(const VariantTensorData& data);
+
+  // The flat_values of the RaggedTensor.
+  const Tensor& values() const { return values_; }
+  Tensor* mutable_values() { return &values_; }
+  void set_values(const Tensor& new_values) { values_ = new_values; }
+
+  // The nested row_splits of the RaggedTensor.
+  int ragged_rank() const { return nested_splits_.size(); }
+  const std::vector<Tensor>& nested_splits() const { return nested_splits_; }
+  std::vector<Tensor>* mutable_nested_splits() { return &nested_splits_; }
+  const Tensor& splits(int i) const { return nested_splits_[i]; }
+  Tensor* mutable_splits(int i) { return &nested_splits_[i]; }
+  void set_nested_splits(const std::vector<Tensor>& nested_splits) {
+    nested_splits_ = nested_splits;
+  }
+  void append_splits(const Tensor& splits) { nested_splits_.push_back(splits); }
+
+ private:
+  Tensor values_;
+  std::vector<Tensor> nested_splits_;
+};
+
+template <typename Device>
+Status RaggedTensorVariantZerosLike(OpKernelContext* c,
+                                    const RaggedTensorVariant& x,
+                                    RaggedTensorVariant* y) {
+  y->set_nested_splits(x.nested_splits());
+  TF_RETURN_IF_ERROR(
+      ZerosLikeTensor<Device>(c, x.values(), y->mutable_values()));
+  return OkStatus();
+}
+
+template <typename Device>
+Status RaggedTensorVariantBinaryAdd(OpKernelContext* c,
+                                    const RaggedTensorVariant& x,
+                                    const RaggedTensorVariant& y,
+                                    RaggedTensorVariant* out) {
+  if (x.values().dtype() != y.values().dtype()) {
+    return errors::InvalidArgument(
+        "Can't add RaggedTensorVariants of different dtypes. One is ",
+        DataTypeString(x.values().dtype()), " and the other is ",
+        DataTypeString(y.values().dtype()));
+  }
+  if (x.ragged_rank() != y.ragged_rank()) {
+    return errors::InvalidArgument(
+        "Can't add RaggedTensorVariants of different ragged rank. ", "One is ",
+        x.ragged_rank(), " and the other is ", y.ragged_rank());
+  }
+  for (int i = 0; i < x.ragged_rank(); ++i) {
+    if (TensorKey(x.splits(i)) != TensorKey(y.splits(i))) {
+      return errors::InvalidArgument(
+          "Can't add RaggedTensorVariants with different row_splits.");
+    }
+  }
+  out->set_nested_splits(x.nested_splits());
+  TF_RETURN_IF_ERROR(BinaryAddTensors<Device>(c, x.values(), y.values(),
+                                              out->mutable_values()));
+  return OkStatus();
+}
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_RAGGED_TENSOR_VARIANT_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/random_binomial_op.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/random_binomial_op.h
new file mode 100644
index 0000000000000000000000000000000000000000..e701e5ff7625edae37bfa5610110f0e2e004dc3c
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/random_binomial_op.h
@@ -0,0 +1,61 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_RANDOM_BINOMIAL_OP_H_
+#define TENSORFLOW_CORE_KERNELS_RANDOM_BINOMIAL_OP_H_
+
+#include "tensorflow/core/framework/tensor_types.h"
+#include "tensorflow/core/lib/random/random_distributions.h"
+
+namespace tensorflow {
+
+class OpKernelContext;
+
+namespace functor {
+
+// Sample a binomial random variable, with probs and counts for each batch.
+// Uses binomial inversion and a transformed rejection sampling method as
+// described in
+// https://pdfs.semanticscholar.org/471b/c2726e25bbf8801ef781630a2c13f654268e.pdf.
+// Two different algorithms are employed, depending on the size of
+// counts * probs (or counts * (1 - probs) if probs > 0.5.
+// If counts * probs < 10, we simply sum up Geometric random variables until
+// they exceed count, and the number we used is binomially distributed.
+// In expectation, this will take O(counts * probs) time, and requiring in
+// expectation the same number of random variates.
+// This can be much cheaper than summing bernoulli random variates, as we
+// will always need O(counts) bernoulli random variates (so this requires fewer
+// uniform r.v.s as well as can be faster).
+//
+// If counts * probs > 10, we use a transformed-rejection algorithm based on
+// pairs of uniform random variates due to Hormann.
+// https://pdfs.semanticscholar.org/471b/c2726e25bbf8801ef781630a2c13f654268e.pdf
+// This algorithm has higher acceptance rates for counts * probs large, as the
+// proposal distribution becomes quite tight, requiring approximately two
+// uniform random variates as counts * probs becomes large.
+template <typename Device, typename T, typename U>
+struct RandomBinomialFunctor {
+  void operator()(OpKernelContext* ctx, const Device& d, int64_t num_batches,
+                  int64_t samples_per_batch, int64_t num_elements,
+                  typename TTypes<T>::ConstFlat counts,
+                  typename TTypes<T>::ConstFlat probs,
+                  const random::PhiloxRandom& gen,
+                  typename TTypes<U>::Flat output);
+};
+
+}  // namespace functor
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_RANDOM_BINOMIAL_OP_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/random_index_shuffle.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/random_index_shuffle.h
new file mode 100644
index 0000000000000000000000000000000000000000..68b52ad6e3052bc532dd0f2d83e41bacf1c554d3
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/random_index_shuffle.h
@@ -0,0 +1,45 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_RANDOM_INDEX_SHUFFLE_H_
+#define TENSORFLOW_CORE_KERNELS_RANDOM_INDEX_SHUFFLE_H_
+
+#include <array>
+
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+namespace random {
+
+// Returns the position of `index` in a permutation of [0, ..., max_index].
+//
+// Index must be number in [0, ..., max_index].
+// Key is the random key for the permutation.
+// The returned index will also be in [0, ..., max_index]. For a fixed `key`
+// and `max_index` the all possible `index` values and the returned values
+// form a bijection.
+// Rounds must be a positive even integer >= 4. Larger values increase improve
+// 'randomness' of permutations for small `max_index` values. The time to
+// compute the result scales linear with the number of rounds. We recommend 8
+// rounds for a good treat off.
+//
+// For more details on the algorithm see the top of the cc file.
+uint64_t index_shuffle(const uint64_t index, const std::array<uint32_t, 3>& key,
+                       const uint64_t max_index, const int32_t rounds);
+
+}  // namespace random
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_RANDOM_INDEX_SHUFFLE_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/random_op.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/random_op.h
new file mode 100644
index 0000000000000000000000000000000000000000..ea16f54ec9acb4db6f25674173a1e048cc419a24
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/random_op.h
@@ -0,0 +1,64 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_RANDOM_OP_H_
+#define TENSORFLOW_CORE_KERNELS_RANDOM_OP_H_
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/lib/random/random_distributions.h"
+
+namespace tensorflow {
+
+class OpKernelContext;
+
+namespace functor {
+
+template <typename Device, class Distribution>
+struct FillPhiloxRandom;
+
+typedef Eigen::ThreadPoolDevice CPUDevice;
+// Declares the partially CPU-specialized functor struct.
+//
+// NOTE: Due to inlining done by the compiler, you may need to add
+// explicit instantiation of the functor in random_op.cc.  See example
+// functor::FillPhiloxRandom<CPUDevice, random::UniformDistribution>.
+//
+// This functor can take the PhiloxRandom input from either device memory `key`
+// and `counter` or a stack value `gen`. If both `key` and `counter` are not
+// nullptr, they provide the input; otherwise `gen` provides the input.
+template <class Distribution>
+struct FillPhiloxRandom<CPUDevice, Distribution> {
+  void operator()(OpKernelContext* ctx, const CPUDevice& d, const uint64* key,
+                  const uint64* counter, random::PhiloxRandom gen,
+                  typename Distribution::ResultElementType* data, int64_t size,
+                  Distribution dist);
+};
+
+#if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+typedef Eigen::GpuDevice GPUDevice;
+// Declares the partially GPU-specialized functor struct.
+template <class Distribution>
+struct FillPhiloxRandom<GPUDevice, Distribution> {
+  void operator()(OpKernelContext* ctx, const GPUDevice& d, const uint64* key,
+                  const uint64* counter, random::PhiloxRandom gen,
+                  typename Distribution::ResultElementType* data, int64_t size,
+                  Distribution dist);
+};
+#endif  // GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+
+}  // namespace functor
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_RANDOM_OP_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/random_op_cpu.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/random_op_cpu.h
new file mode 100644
index 0000000000000000000000000000000000000000..cfa927c1e539ea7de8a3acdf0f2b8312f546ba39
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/random_op_cpu.h
@@ -0,0 +1,193 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_RANDOM_OP_CPU_H_
+#define TENSORFLOW_CORE_KERNELS_RANDOM_OP_CPU_H_
+
+#define EIGEN_USE_THREADS
+
+#include <algorithm>
+#include <cmath>
+#include <memory>
+
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/register_types.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/tensor_shape.h"
+#include "tensorflow/core/kernels/random_op.h"
+#include "tensorflow/core/kernels/random_ops_util.h"
+#include "tensorflow/core/lib/hash/crc32c.h"
+#include "tensorflow/core/lib/random/random_distributions.h"
+#include "tensorflow/core/lib/random/simple_philox.h"
+#include "tensorflow/core/platform/logging.h"
+#include "tensorflow/core/util/guarded_philox_random.h"
+#include "tensorflow/core/util/work_sharder.h"
+
+#if EIGEN_COMP_GNUC && __cplusplus > 199711L
+#define DISABLE_FLOAT_EQUALITY_WARNING \
+  _Pragma("GCC diagnostic push")       \
+      _Pragma("GCC diagnostic ignored \"-Wfloat-equal\"")
+#define ENABLE_FLOAT_EQUALITY_WARNING _Pragma("GCC diagnostic pop")
+#else
+#define DISABLE_FLOAT_EQUALITY_WARNING
+#define ENABLE_FLOAT_EQUALITY_WARNING
+#endif
+
+namespace tensorflow {
+
+typedef Eigen::ThreadPoolDevice CPUDevice;
+typedef Eigen::GpuDevice GPUDevice;
+
+namespace functor {
+using random::PhiloxRandom;
+using random::SingleSampleAdapter;
+
+// The default implementation of the functor, which should never be invoked
+// But we still need to provide implementation for now for the linker to work,
+// since we do not support all the distributions yet.
+template <typename Device, class Distribution>
+struct FillPhiloxRandom {
+  typedef typename Distribution::ResultElementType T;
+  void operator()(OpKernelContext* ctx, const Device&, const uint64* key,
+                  const uint64* counter, random::PhiloxRandom gen, T* data,
+                  int64_t size, Distribution dist) {
+    OP_REQUIRES(
+        ctx, false,
+        errors::Internal(
+            "Default `FillPhiloxRandom` implementation should not be executed. "
+            "The cause of this error is probably that `FillPhiloxRandom` does "
+            "not support this device or random distribution yet."));
+  }
+};
+
+// A class to fill a specified range of random groups
+template <class Distribution, bool VariableSamplesPerOutput>
+struct FillPhiloxRandomTask;
+
+// Specialization for distribution that takes a fixed number of samples for
+// each output.
+template <class Distribution>
+struct FillPhiloxRandomTask<Distribution, false> {
+  typedef typename Distribution::ResultElementType T;
+  static void Run(random::PhiloxRandom gen, T* data, int64_t size,
+                  int64_t start_group, int64_t limit_group, Distribution dist) {
+    const int kGroupSize = Distribution::kResultElementCount;
+
+    gen.Skip(start_group);
+    int64_t offset = start_group * kGroupSize;
+
+    // First fill all the full-size groups
+    int64_t limit_group_full = std::min(limit_group, size / kGroupSize);
+    for (int64_t index = start_group; index < limit_group_full; ++index) {
+      auto samples = dist(&gen);
+      std::copy(&samples[0], &samples[0] + kGroupSize, data + offset);
+      offset += kGroupSize;
+    }
+
+    // If there are any remaining elements that need to be filled, process them
+    if (limit_group_full < limit_group) {
+      int64_t remaining_size = size - limit_group_full * kGroupSize;
+      auto samples = dist(&gen);
+      std::copy(&samples[0], &samples[0] + remaining_size, data + offset);
+    }
+  }
+};
+
+// Specialization for distribution that takes a variable number of samples for
+// each output. This will be slower due to the generality.
+template <class Distribution>
+struct FillPhiloxRandomTask<Distribution, true> {
+  typedef typename Distribution::ResultElementType T;
+  static constexpr int64_t kReservedSamplesPerOutput = 256;
+
+  static void Run(random::PhiloxRandom base_gen, T* data, int64_t size,
+                  int64_t start_group, int64_t limit_group, Distribution dist) {
+    const int kGroupSize = Distribution::kResultElementCount;
+
+    static const int kGeneratorSkipPerOutputGroup =
+        kGroupSize * kReservedSamplesPerOutput /
+        PhiloxRandom::kResultElementCount;
+
+    int64_t offset = start_group * kGroupSize;
+
+    // First fill all the full-size groups
+    int64_t limit_group_full = std::min(limit_group, size / kGroupSize);
+    int64_t group_index;
+    for (group_index = start_group; group_index < limit_group_full;
+         ++group_index) {
+      // Reset the generator to the beginning of the output group region
+      // This is necessary if we want the results to be independent of order
+      // of work
+      PhiloxRandom gen = base_gen;
+      gen.Skip(group_index * kGeneratorSkipPerOutputGroup);
+      SingleSampleAdapter<PhiloxRandom> single_samples(&gen);
+
+      auto samples = dist(&single_samples);
+      std::copy(&samples[0], &samples[0] + kGroupSize, data + offset);
+      offset += kGroupSize;
+    }
+
+    // If there are any remaining elements that need to be filled, process them
+    if (limit_group_full < limit_group) {
+      PhiloxRandom gen = base_gen;
+      gen.Skip(group_index * kGeneratorSkipPerOutputGroup);
+      SingleSampleAdapter<PhiloxRandom> single_samples(&gen);
+
+      int64_t remaining_size = size - limit_group_full * kGroupSize;
+      auto samples = dist(&single_samples);
+      std::copy(&samples[0], &samples[0] + remaining_size, data + offset);
+    }
+  }
+};
+
+// Partial specialization for CPU to fill the entire region with randoms
+// It splits the work into several tasks and run them in parallel
+template <class Distribution>
+void FillPhiloxRandom<CPUDevice, Distribution>::operator()(
+    OpKernelContext* ctx, const CPUDevice&, const uint64* key,
+    const uint64* counter, random::PhiloxRandom gen,
+    typename Distribution::ResultElementType* data, int64_t size,
+    Distribution dist) {
+  if (key != nullptr && counter != nullptr) {
+    gen = GetPhiloxRandomFromCounterKeyMem(counter, key);
+  }
+
+  const int kGroupSize = Distribution::kResultElementCount;
+
+  auto worker_threads = *(ctx->device()->tensorflow_cpu_worker_threads());
+
+  int64_t total_group_count = (size + kGroupSize - 1) / kGroupSize;
+
+  const int kGroupCost =
+      random::PhiloxRandom::kResultElementCount *
+      (random::PhiloxRandom::kElementCost + Distribution::kElementCost);
+
+  Shard(worker_threads.num_threads, worker_threads.workers, total_group_count,
+        kGroupCost,
+        [&gen, data, size, dist](int64_t start_group, int64_t limit_group) {
+          FillPhiloxRandomTask<
+              Distribution,
+              Distribution::kVariableSamplesPerOutput>::Run(gen, data, size,
+                                                            start_group,
+                                                            limit_group, dist);
+        });
+}
+
+}  // namespace functor
+
+
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_RANDOM_OP_CPU_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/random_op_gpu.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/random_op_gpu.h
new file mode 100644
index 0000000000000000000000000000000000000000..f8efa21daba8ffef16571166375ab07ce72e6980
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/random_op_gpu.h
@@ -0,0 +1,255 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_RANDOM_OP_GPU_H_
+#define TENSORFLOW_CORE_KERNELS_RANDOM_OP_GPU_H_
+
+#if defined(__CUDACC__) || TENSORFLOW_USE_ROCM
+
+#include "tensorflow/core/kernels/random_op.h"
+#include "tensorflow/core/kernels/random_ops_util.h"
+#include "tensorflow/core/lib/random/philox_random.h"
+#include "tensorflow/core/lib/random/random_distributions.h"
+#include "tensorflow/core/util/gpu_kernel_helper.h"
+
+namespace tensorflow {
+
+namespace functor {
+
+template <class Distribution, bool VariableSamplesPerOutput>
+struct FillPhiloxRandomKernel;
+
+template <class Distribution>
+struct FillPhiloxRandomKernel<Distribution, false> {
+  typedef typename Distribution::ResultElementType T;
+  PHILOX_DEVICE_INLINE void Run(const uint64* key, const uint64* counter,
+                                random::PhiloxRandom gen, T* data, int64 size,
+                                Distribution dist);
+};
+
+template <class Distribution>
+struct FillPhiloxRandomKernel<Distribution, true> {
+  typedef typename Distribution::ResultElementType T;
+  PHILOX_DEVICE_INLINE void Run(const uint64* key, const uint64* counter,
+                                random::PhiloxRandom base_gen, T* data,
+                                int64 size, Distribution dist);
+};
+
+template <typename T, int ElementCount>
+class SampleCopier {
+ public:
+  inline __device__ void operator()(
+      T* __restrict__ buf,
+      const tensorflow::random::Array<T, ElementCount>& array) const {
+#pragma unroll
+    for (int i = 0; i < ElementCount; i++) {
+      buf[i] = array[i];
+    }
+  }
+};
+
+template <>
+class SampleCopier<float, 4> {
+ public:
+  // Copies the elements from the array to buf. buf must be 128-bit aligned,
+  // which is true for tensor data, and all offsets that are a multiple of the
+  // vector size (because the vectors are 128 bits long).
+  inline __device__ void operator()(
+      float* __restrict__ buf,
+      const tensorflow::random::Array<float, 4>& array) const {
+    // NOTE(ringwalt): It's not safe to cast &array[0] to a float4, because they
+    // have 32-bit alignment vs 128-bit alignment. There seems to be no
+    // performance loss when assigning each element to a vector.
+    float4 vec;
+    vec.x = array[0];
+    vec.y = array[1];
+    vec.z = array[2];
+    vec.w = array[3];
+    float4* buf_vector = reinterpret_cast<float4*>(buf);
+    *buf_vector = vec;
+  }
+};
+
+template <>
+class SampleCopier<int32, 4> {
+ public:
+  // Copies the elements from the array to buf. buf must be 128-bit aligned,
+  // which is true for tensor data, and all offsets that are a multiple of the
+  // vector size (because the vectors are 128 bits long).
+  inline __device__ void operator()(
+      int32* __restrict__ buf,
+      const tensorflow::random::Array<int32, 4>& array) const {
+    ::int4 vec;
+    vec.x = array[0];
+    vec.y = array[1];
+    vec.z = array[2];
+    vec.w = array[3];
+    ::int4* buf_vector = reinterpret_cast<::int4*>(buf);
+    *buf_vector = vec;
+  }
+};
+
+template <>
+class SampleCopier<double, 2> {
+ public:
+  // Copies the elements from the array to buf. buf must be 128-bit aligned,
+  // which is true for tensor data, and all offsets that are a multiple of the
+  // vector size (because the vectors are 128 bits long).
+  inline __device__ void operator()(
+      double* __restrict__ buf,
+      const tensorflow::random::Array<double, 2>& array) const {
+    double2 vec;
+    vec.x = array[0];
+    vec.y = array[1];
+    double2* buf_vector = reinterpret_cast<double2*>(buf);
+    *buf_vector = vec;
+  }
+};
+
+template <>
+class SampleCopier<int64, 2> {
+ public:
+  // Copies the elements from the array to buf. buf must be 128-bit aligned,
+  // which is true for tensor data, and all offsets that are a multiple of the
+  // vector size (because the vectors are 128 bits long).
+  inline __device__ void operator()(
+      int64* __restrict__ buf,
+      const tensorflow::random::Array<int64, 2>& array) const {
+    longlong2 vec;
+    vec.x = array[0];
+    vec.y = array[1];
+    longlong2* buf_vector = reinterpret_cast<longlong2*>(buf);
+    *buf_vector = vec;
+  }
+};
+
+// A cuda kernel to fill the data with random numbers from the specified
+// distribution. Each output takes a fixed number of samples.
+template <class Distribution>
+PHILOX_DEVICE_INLINE void FillPhiloxRandomKernel<Distribution, false>::Run(
+    const uint64* key, const uint64* counter, random::PhiloxRandom gen, T* data,
+    int64 size, Distribution dist) {
+  const int kGroupSize = Distribution::kResultElementCount;
+
+  const int32 thread_id = blockIdx.x * blockDim.x + threadIdx.x;
+  const int32 total_thread_count = gridDim.x * blockDim.x;
+  int64 offset = thread_id * kGroupSize;
+  if (key != nullptr && counter != nullptr) {
+    gen = GetPhiloxRandomFromCounterKeyMem(counter, key);
+  }
+  gen.Skip(thread_id);
+
+  const SampleCopier<T, kGroupSize> copier;
+  while (offset + kGroupSize <= size) {
+    const typename Distribution::ResultType samples = dist(&gen);
+    copier(&data[offset], samples);
+
+    offset += total_thread_count * kGroupSize;
+    gen.Skip(total_thread_count - 1);
+  }
+
+  typename Distribution::ResultType samples = dist(&gen);
+  for (int i = 0; i < kGroupSize; ++i) {
+    if (offset >= size) {
+      return;
+    }
+    data[offset] = samples[i];
+    ++offset;
+  }
+}
+
+// A cuda kernel to fill the data with random numbers from the specified
+// distribution. Each output takes a variable number of samples.
+template <class Distribution>
+PHILOX_DEVICE_INLINE void FillPhiloxRandomKernel<Distribution, true>::Run(
+    const uint64* key, const uint64* counter, random::PhiloxRandom base_gen,
+    T* data, int64 size, Distribution dist) {
+  if (key != nullptr && counter != nullptr) {
+    base_gen = GetPhiloxRandomFromCounterKeyMem(counter, key);
+  }
+
+  using random::PhiloxRandom;
+  using random::SingleSampleAdapter;
+
+  const int kReservedSamplesPerOutput = 256;
+  const int kGroupSize = Distribution::kResultElementCount;
+  const int kGeneratorSkipPerOutputGroup = kGroupSize *
+                                           kReservedSamplesPerOutput /
+                                           PhiloxRandom::kResultElementCount;
+
+  const int32 thread_id = blockIdx.x * blockDim.x + threadIdx.x;
+  const int32 total_thread_count = gridDim.x * blockDim.x;
+  int64 group_index = thread_id;
+  int64 offset = group_index * kGroupSize;
+
+  while (offset < size) {
+    // Since each output takes a variable number of samples, we need to
+    // realign the generator to the beginning for the current output group
+    PhiloxRandom gen = base_gen;
+    gen.Skip(group_index * kGeneratorSkipPerOutputGroup);
+    SingleSampleAdapter<PhiloxRandom> single_samples(&gen);
+
+    typename Distribution::ResultType samples = dist(&single_samples);
+
+    for (int i = 0; i < kGroupSize; ++i) {
+      if (offset >= size) {
+        return;
+      }
+      data[offset] = samples[i];
+      ++offset;
+    }
+
+    offset += (total_thread_count - 1) * kGroupSize;
+    group_index += total_thread_count;
+  }
+}
+
+// A simple launch pad to call the correct function templates to fill the data
+template <class Distribution>
+__global__ void __launch_bounds__(1024)
+    FillPhiloxRandomKernelLaunch(const uint64* key, const uint64* counter,
+                                 random::PhiloxRandom base_gen,
+                                 typename Distribution::ResultElementType* data,
+                                 int64 size, Distribution dist) {
+  FillPhiloxRandomKernel<Distribution,
+                         Distribution::kVariableSamplesPerOutput>()
+      .Run(key, counter, base_gen, data, size, dist);
+}
+
+// Partial specialization for GPU
+template <class Distribution>
+void FillPhiloxRandom<GPUDevice, Distribution>::operator()(
+    OpKernelContext*, const GPUDevice& d, const uint64* key,
+    const uint64* counter, random::PhiloxRandom gen,
+    typename Distribution::ResultElementType* data, int64 size,
+    Distribution dist) {
+  if (size == 0) return;
+  const int32 block_size = d.maxGpuThreadsPerBlock();
+  const int32 num_blocks =
+      std::min<int64_t>(
+          d.getNumGpuMultiProcessors() * d.maxGpuThreadsPerMultiProcessor(),
+          size + block_size - 1) /
+      block_size;
+  TF_CHECK_OK(GpuLaunchKernel(FillPhiloxRandomKernelLaunch<Distribution>,
+                              num_blocks, block_size, 0, d.stream(), key,
+                              counter, gen, data, size, dist));
+}
+
+}  // namespace functor
+}  // namespace tensorflow
+
+#endif  // defined(__CUDACC__) || TENSORFLOW_USE_ROCM
+
+#endif  // TENSORFLOW_CORE_KERNELS_RANDOM_OP_GPU_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/random_ops_util.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/random_ops_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..b990456965ff596e4146c6cc511c1efd292217eb
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/random_ops_util.h
@@ -0,0 +1,73 @@
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_RANDOM_OPS_UTIL_H_
+#define TENSORFLOW_CORE_KERNELS_RANDOM_OPS_UTIL_H_
+
+#include "tensorflow/core/lib/random/philox_random.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+
+using random::PhiloxRandom;
+
+// The following 2 functions use the contract "lower 32 bits for the first
+// uint32, higher 32 bits for the second". Note that this is endian-neutral,
+// unlike a direct memory copy `memcpy(output, &input, 8)`.
+PHILOX_DEVICE_INLINE void Uint64ToUint32s(uint64 input, uint32* output1,
+                                          uint32* output2) {
+  *output1 = static_cast<uint32>(input);
+  *output2 = static_cast<uint32>(input >> 32);
+}
+
+PHILOX_DEVICE_INLINE uint64 Uint32sToUint64(uint32 input1, uint32 input2) {
+  auto u64_1 = static_cast<uint64>(input1);
+  auto u64_2 = static_cast<uint64>(input2);
+  return u64_1 | (u64_2 << 32);
+}
+
+PHILOX_DEVICE_INLINE PhiloxRandom::ResultType GetCounterFromMem(
+    uint64 const* ptr) {
+  PhiloxRandom::ResultType counter;
+  Uint64ToUint32s(ptr[0], &counter[0], &counter[1]);
+  Uint64ToUint32s(ptr[1], &counter[2], &counter[3]);
+  return counter;
+}
+
+PHILOX_DEVICE_INLINE void WriteCounterToMem(
+    PhiloxRandom::ResultType const& counter, uint64* ptr) {
+  ptr[0] = Uint32sToUint64(counter[0], counter[1]);
+  ptr[1] = Uint32sToUint64(counter[2], counter[3]);
+}
+
+PHILOX_DEVICE_INLINE PhiloxRandom::Key GetKeyFromMem(uint64 const* ptr) {
+  PhiloxRandom::Key key;
+  Uint64ToUint32s(ptr[0], &key[0], &key[1]);
+  return key;
+}
+
+PHILOX_DEVICE_INLINE void WriteKeyToMem(PhiloxRandom::Key const& key,
+                                        uint64* ptr) {
+  *ptr = Uint32sToUint64(key[0], key[1]);
+}
+
+PHILOX_DEVICE_INLINE PhiloxRandom GetPhiloxRandomFromCounterKeyMem(
+    uint64 const* counter_ptr, uint64 const* key_ptr) {
+  return PhiloxRandom(GetCounterFromMem(counter_ptr), GetKeyFromMem(key_ptr));
+}
+
+}  // end namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_RANDOM_OPS_UTIL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/random_poisson_op.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/random_poisson_op.h
new file mode 100644
index 0000000000000000000000000000000000000000..ca0dad4bf8345245a081d33ac1102a5385c9870e
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/random_poisson_op.h
@@ -0,0 +1,38 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_RANDOM_POISSON_OP_H_
+#define TENSORFLOW_CORE_KERNELS_RANDOM_POISSON_OP_H_
+
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/lib/random/simple_philox.h"
+
+namespace tensorflow {
+
+namespace functor {
+
+// Generic helper functor for the Random Poisson Op.
+template <typename Device, typename T /* rate */, typename U /* output */>
+struct PoissonFunctor {
+  void operator()(OpKernelContext* ctx, const Device& d, const T* rate_flat,
+                  int64_t num_rate, int64_t num_samples,
+                  const random::PhiloxRandom& rng, U* samples_flat);
+};
+
+}  // namespace functor
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_RANDOM_POISSON_OP_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/range_sampler.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/range_sampler.h
new file mode 100644
index 0000000000000000000000000000000000000000..8710e10977300c3f2beb79447df2784cc5dede61
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/range_sampler.h
@@ -0,0 +1,250 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_RANGE_SAMPLER_H_
+#define TENSORFLOW_CORE_KERNELS_RANGE_SAMPLER_H_
+
+#include <vector>
+
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/lib/gtl/array_slice.h"
+#include "tensorflow/core/lib/random/distribution_sampler.h"
+#include "tensorflow/core/lib/random/random_distributions.h"
+#include "tensorflow/core/lib/random/weighted_picker.h"
+#include "tensorflow/core/platform/logging.h"
+#include "tensorflow/core/platform/mutex.h"
+#include "tensorflow/core/platform/thread_annotations.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tsl {
+class Env;
+}  // namespace tsl
+namespace tensorflow {
+using Env = tsl::Env;
+
+// Abstract subclass for sampling from the set of non-negative integers
+// [0, range)
+class RangeSampler {
+ public:
+  explicit RangeSampler(int64_t range) : range_(range) { CHECK_GT(range_, 0); }
+  virtual ~RangeSampler();
+
+  // Sample a single value
+  virtual int64_t Sample(random::SimplePhilox* rnd) const = 0;
+
+  // The probability that a single call to Sample() returns the given value.
+  // Assumes that value is in [0, range).  No range checking is done.
+  virtual float Probability(int64_t value) const = 0;
+
+  // Fill "batch" with samples from the distribution.
+  // If unique=true, then we re-pick each element until we get a
+  // value distinct from all previously picked values in the batch.
+  void SampleBatch(random::SimplePhilox* rnd, bool unique,
+                   gtl::MutableArraySlice<int64_t> batch) const;
+
+  // Fill "batch" with samples from the distribution, and report
+  // "expected counts".
+  //
+  // The "expected count" of a value is an estimate of the expected
+  // number of occurrences of the value in the batch returned by a
+  // call to this function with the given parameters.  If unique=true,
+  // the expected count is an inclusion probability.  For details on
+  // this estimation, see the comment to "ExpectedCountHelper" in the
+  // .cc file.
+  //
+  // Expected counts for the elements of the returned "batch" are reported
+  // in the aligned array "batch_expected_count".
+  //
+  // The user can optionally provide "extras", containing values in the range.
+  // The expected counts for the extras are reported in the aligned array
+  // "extras_expected_count".
+  //
+  // "batch_expected_count" must have size equal to 0 or to the size of "batch".
+  // "extras" and "extras_expected_count" must have equal size.
+  void SampleBatchGetExpectedCount(
+      random::SimplePhilox* rnd, bool unique,
+      gtl::MutableArraySlice<int64_t> batch,
+      gtl::MutableArraySlice<float> batch_expected_count,
+      gtl::ArraySlice<int64_t> extras,
+      gtl::MutableArraySlice<float> extras_expected_count) const;
+
+  // Same as SampleBatchGetExpectedCount (see above), but with avoided values.
+  // We repick to avoid all of the values in "avoided_values".
+  // "avoided_values" is only supported with unique=true.  If
+  // unique=false, then avoided_values must be empty.
+  virtual void SampleBatchGetExpectedCountAvoid(
+      random::SimplePhilox* rnd, bool unique,
+      gtl::MutableArraySlice<int64_t> batch,
+      gtl::MutableArraySlice<float> batch_expected_count,
+      gtl::ArraySlice<int64_t> extras,
+      gtl::MutableArraySlice<float> extras_expected_count,
+      gtl::ArraySlice<int64_t> avoided_values) const;
+
+  // Does this sampler need to be updated with values, e.g. UnigramSampler
+  virtual bool NeedsUpdates() const { return false; }
+
+  // Updates the underlying distribution
+  virtual void Update(gtl::ArraySlice<int64_t> values) {
+    LOG(FATAL) << "Update not supported for this sampler type.";
+  }
+
+  int64_t range() { return range_; }
+
+ protected:
+  const int64_t range_;
+};
+
+// An AllSampler only samples batches of size equal to range.
+// It returns the entire range.
+// It cannot sample single values.
+class AllSampler : public RangeSampler {
+ public:
+  explicit AllSampler(int64_t range);
+
+  ~AllSampler() override {}
+
+  int64_t Sample(random::SimplePhilox* rnd) const override {
+    LOG(FATAL) << "Should not be called";
+    return 0;
+  }
+
+  float Probability(int64_t value) const override {
+    LOG(FATAL) << "Should not be called";
+    return 0;
+  }
+
+  void SampleBatchGetExpectedCountAvoid(
+      random::SimplePhilox* rnd, bool unique,
+      gtl::MutableArraySlice<int64_t> batch,
+      gtl::MutableArraySlice<float> batch_expected_count,
+      gtl::ArraySlice<int64_t> extras,
+      gtl::MutableArraySlice<float> extras_expected_count,
+      gtl::ArraySlice<int64_t> avoided_values) const override;
+};
+
+class UniformSampler : public RangeSampler {
+ public:
+  explicit UniformSampler(int64_t range);
+
+  ~UniformSampler() override {}
+
+  int64_t Sample(random::SimplePhilox* rnd) const override;
+
+  float Probability(int64_t value) const override;
+
+ private:
+  const float inv_range_;
+};
+
+class LogUniformSampler : public RangeSampler {
+ public:
+  explicit LogUniformSampler(int64_t range);
+
+  ~LogUniformSampler() override {}
+
+  int64_t Sample(random::SimplePhilox* rnd) const override;
+
+  float Probability(int64_t value) const override;
+
+ private:
+  const double log_range_;
+};
+
+// Thread-unsafe unigram sampler
+class ThreadUnsafeUnigramSampler : public RangeSampler {
+ public:
+  explicit ThreadUnsafeUnigramSampler(int64_t range);
+  ~ThreadUnsafeUnigramSampler() override {}
+
+  int64_t Sample(random::SimplePhilox* rnd) const override;
+
+  float Probability(int64_t value) const override;
+
+  bool NeedsUpdates() const override { return true; }
+  void Update(gtl::ArraySlice<int64_t> values) override;
+
+ private:
+  random::WeightedPicker picker_;
+};
+
+// Thread-safe unigram sampler
+class UnigramSampler : public RangeSampler {
+ public:
+  explicit UnigramSampler(int64_t range);
+  ~UnigramSampler() override {}
+
+  int64_t Sample(random::SimplePhilox* rnd) const override;
+
+  float Probability(int64_t value) const override;
+
+  // Overriding at a high level results in far fewer lock acquisitions.
+  void SampleBatchGetExpectedCountAvoid(
+      random::SimplePhilox* rnd, bool unique,
+      gtl::MutableArraySlice<int64_t> batch,
+      gtl::MutableArraySlice<float> batch_expected_count,
+      gtl::ArraySlice<int64_t> extras,
+      gtl::MutableArraySlice<float> extras_expected_count,
+      gtl::ArraySlice<int64_t> avoided_values) const override;
+
+  bool NeedsUpdates() const override { return true; }
+  void Update(gtl::ArraySlice<int64_t> values) override;
+
+ private:
+  ThreadUnsafeUnigramSampler unsafe_sampler_ TF_GUARDED_BY(mu_);
+  mutable mutex mu_;
+};
+
+// A unigram sampler that uses a fixed unigram distribution read from a
+// file or passed in as an in-memory array instead of building up the
+// distribution from data on the fly. There is also an option to skew the
+// distribution by applying a distortion power to the weights.
+class FixedUnigramSampler : public RangeSampler {
+ public:
+  FixedUnigramSampler(int64_t range, float distortion, int32_t num_reserved_ids,
+                      int32_t num_shards, int32_t shard);
+  // The vocab_file is assumed to be a CSV, with the last entry of each row a
+  // value representing the counts or probabilities for the corresponding ID.
+  Status SetDistributionSampler(Env* env, const string& vocab_file);
+  Status SetDistributionSampler(const std::vector<float>& unigrams);
+  float Probability(int64_t value) const override;
+
+  int64_t Sample(random::SimplePhilox* rnd) const override;
+
+ private:
+  // Underlying distribution sampler.
+  std::unique_ptr<random::DistributionSampler> dist_sampler_;
+  // Weights for individual samples. The probability of a sample i is defined
+  // as weights_.at(i) / total_weight_.
+  std::vector<float> weights_;
+  // The total weights of all samples.
+  float total_weight_;
+  // Sharding information of the sampler. The whole vocabulary is sharded
+  // into num_shards_ smaller ranges and each sampler is responsible for one
+  // such smaller range, identified by the shard number.
+  int32 num_shards_;
+  int32 shard_;
+  float distortion_;
+  // Fill the sampler with the appropriate number of reserved IDs.
+  void FillReservedIds(int32_t num_reserved_ids);
+  // Load IDs to sample from a CSV file. It is assumed that the last item of
+  // each row contains a count or probability for the corresponding ID.
+  Status LoadFromFile(Env* env, const string& vocab_file, float distortion);
+  // Load from an in-memory array.
+  void LoadFromUnigrams(const std::vector<float>& unigrams, float distortion);
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_RANGE_SAMPLER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/record_yielder.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/record_yielder.h
new file mode 100644
index 0000000000000000000000000000000000000000..adb975a5a3e0951bedc517cbd844aa8173554134
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/record_yielder.h
@@ -0,0 +1,160 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_RECORD_YIELDER_H_
+#define TENSORFLOW_CORE_KERNELS_RECORD_YIELDER_H_
+
+#include <atomic>
+#include <random>
+#include <string>
+#include <vector>
+
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/lib/core/errors.h"
+#include "tensorflow/core/lib/core/notification.h"
+#include "tensorflow/core/lib/core/threadpool.h"
+#include "tensorflow/core/platform/macros.h"
+#include "tensorflow/core/platform/thread_annotations.h"
+
+namespace tensorflow {
+
+// RecordYielder produces value records from a set of tfrecord files
+// in a random order.
+//
+// It guarantees that:
+//   1) all records in tfrecords are yielded within every epoch;
+//   2) each record is yielded only once within every epoch;
+//   3) the order in which records are yielded is highly randomized.
+//   4) the peak memory usage is roughly avg record size *
+//      (opts.bufsize + opts.parallelism * 16).
+//
+// Usage example:
+//   RecordYielder::Options opts;
+//   opts.file_pattern = "input-*";
+//   opts.seed = 301;
+//   opts.bufsize = 1000000;    // A randomized buffer with 1M records.
+//   opts.parallelism = 8;      // Uses 8 tfrecord iterators to iterate
+//                              // through all files.
+//   RecordYielder yielder(opts);
+//   string val;
+//   while (true) {
+//     yielder.YieldOne(&val);
+//     // process val
+//   }
+//
+// RecordYielder can be accessed by multiple threads concurrently.
+class RecordYielder {
+ public:
+  struct Options {
+    // Glob pattern for tfrecords.
+    string file_pattern;
+
+    // Random seed. It determines how data files are shuffled and how
+    // records are shuffled.
+    int64_t seed = 0;
+
+    // Each epoch, all files are first shuffled according to the
+    // random seed and the epoch number, and then all files are
+    // left-shifted by file_shuffle_shift_ratio * num_files slots.  If
+    // file_shuffle_shift_ratio is not within [0, 1), the
+    // implementation clip it to [0, 1).
+    float file_shuffle_shift_ratio = 0;
+
+    // Randomization buffer keeps these many records.
+    uint64 bufsize = 1;
+
+    // Uses these many concurrent tfrecord iterators to iterate through
+    // tfrecords.
+    int32 parallelism = 1;
+
+    string compression_type;
+  };
+
+  explicit RecordYielder(OpKernelConstruction* context,
+                         const RecordYielder::Options& opts);
+  ~RecordYielder();
+
+  RecordYielder(const RecordYielder&) = delete;
+  RecordYielder& operator=(const RecordYielder&) = delete;
+
+  // Yields one 'value'.
+  Status YieldOne(tstring* value);
+
+  // Returns the current epoch number.
+  int64_t current_epoch() const { return epoch_; }
+
+ private:
+  typedef RecordYielder ME;
+
+  Options opts_;
+
+  // Backgrounds threads. Owned.
+  thread::ThreadPool* thread_;
+
+  // Epoch number.
+  std::atomic<int64_t> epoch_;
+
+  mutex mu_;
+
+  // Turned to true when this is deleted.
+  bool stop_ TF_GUARDED_BY(mu_) = false;
+  Status status_ TF_GUARDED_BY(mu_);
+
+  // PRG used for randomization.
+  std::mt19937_64 rnd_ TF_GUARDED_BY(mu_);
+
+  // Randomization buffer.
+  std::vector<string> buf_ TF_GUARDED_BY(mu_);
+
+  // True iff we are draining an epoch.
+  bool epoch_end_ = false;
+
+  int64_t num_records_added_in_epoch_ = 0;
+  int64_t num_records_yielded_in_epoch_ = 0;
+
+  // Trigger when the main loop has exited.
+  Notification main_loop_done_;
+
+  // condition_variables.
+  condition_variable buf_empty_;
+  bool BufEmpty() const TF_SHARED_LOCKS_REQUIRED(mu_) {
+    return stop_ || buf_.empty();
+  }
+
+  condition_variable buf_not_full_;
+  bool BufNotFull() const TF_SHARED_LOCKS_REQUIRED(mu_) {
+    return stop_ || buf_.size() < opts_.bufsize;
+  }
+
+  condition_variable buf_enough_;
+  bool BufEnough() const TF_SHARED_LOCKS_REQUIRED(mu_) {
+    // NOTE: Unless we are finishing an epoch, we want to make sure
+    // the buf_ contains enough randomized elements before yielding
+    // any.
+    return stop_ || !status_.ok() || (epoch_end_ && !buf_.empty()) ||
+           (!epoch_end_ &&
+            buf_.size() >= std::max<uint64>(1, opts_.bufsize / 2));
+  }
+
+  void MainLoop();
+  struct Shard;
+  void ShardLoop(Shard* shard);
+  bool ShouldFinish(const Status& s);
+  bool Add(std::vector<string>* values);
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_RECORD_YIELDER_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/reduction_gpu_kernels.cu.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/reduction_gpu_kernels.cu.h
new file mode 100644
index 0000000000000000000000000000000000000000..a82e6c4706110457c69b2283374c206694158f04
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/reduction_gpu_kernels.cu.h
@@ -0,0 +1,1412 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_REDUCTION_GPU_KERNELS_CU_H_
+#define TENSORFLOW_CORE_KERNELS_REDUCTION_GPU_KERNELS_CU_H_
+
+#if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+
+#define EIGEN_USE_GPU
+
+#include <sstream>
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/kernels/gpu_prim.h"
+#include "tensorflow/core/kernels/reduction_ops.h"
+#include "tensorflow/core/lib/core/bits.h"
+#include "tensorflow/core/util/gpu_device_functions.h"
+#include "tensorflow/core/util/gpu_kernel_helper.h"
+#include "tensorflow/core/util/permutation_input_iterator.h"
+#include "tensorflow/core/util/transform_output_iterator.h"
+
+namespace tensorflow {
+namespace functor {
+
+typedef Eigen::GpuDevice GPUDevice;
+
+template <typename T>
+struct SqrtOfReal {
+  __host__ __device__ T operator()(const T& a) const {
+    return T(Eigen::numext::sqrt(Eigen::numext::real(a)));
+  }
+};
+
+template <typename T>
+struct Sum {
+  __host__ __device__ T operator()(const T& a, const T& b) const {
+    return a + b;
+  }
+};
+
+template <typename T>
+struct Prod {
+  __host__ __device__ T operator()(const T& a, const T& b) const {
+    return a * b;
+  }
+};
+
+template <typename T>
+struct Square {
+  __host__ __device__ T operator()(const T& a) const {
+    return Prod<T>()(a, Eigen::numext::conj(a));
+  }
+};
+
+template <typename T, typename OUT_T = T>
+struct DividesBy {
+  T divisor;
+
+  __host__ __device__ explicit DividesBy(T divisor) : divisor(divisor) {}
+
+  __host__ __device__ OUT_T operator()(const T& x) const { return x / divisor; }
+};
+
+struct MaxPropagateNaN {
+  template <typename T>
+  __host__ __device__ inline T operator()(const T& a, const T& b) const {
+    return (a != a ? a : (a > b ? a : b));
+  }
+};
+
+struct MinPropagateNaN {
+  template <typename T>
+  __host__ __device__ inline T operator()(const T& a, const T& b) const {
+    return (a != a ? a : (a < b ? a : b));
+  }
+};
+
+#if GOOGLE_CUDA
+// TODO(rocm) : enable this once ROCm platform has support for complex datatypes
+//
+// needed to work around a compiler bug in nvcc - it doesn't seem to like
+// the overloaded ops for std::complex
+template <>
+struct DividesBy<std::complex<float>> {
+  cuFloatComplex divisor;
+
+  __host__ __device__ explicit DividesBy(std::complex<float> divisor)
+      : divisor(make_cuComplex(divisor.real(), divisor.imag())) {}
+
+  // implements
+  __host__ __device__ std::complex<float> operator()(
+      const std::complex<float>& x) const {
+    auto result = cuCdivf(make_cuComplex(x.real(), x.imag()), divisor);
+    return std::complex<float>(result.x, result.y);
+  }
+};
+
+template <>
+struct DividesBy<std::complex<double>> {
+  cuDoubleComplex divisor;
+
+  __host__ __device__ explicit DividesBy(std::complex<double> divisor)
+      : divisor(make_cuDoubleComplex(divisor.real(), divisor.imag())) {}
+
+  // implements
+  __host__ __device__ std::complex<double> operator()(
+      const std::complex<double>& x) const {
+    auto result = cuCdiv(make_cuDoubleComplex(x.real(), x.imag()), divisor);
+    return std::complex<double>(result.x, result.y);
+  }
+};
+#endif  // GOOGLE_CUDA
+
+template <typename T>
+struct DividesBy<float, T> {
+  float divisor;
+
+  __host__ __device__ explicit DividesBy(float divisor) : divisor(divisor) {}
+
+  __host__ __device__ T operator()(const float& x) const {
+    return T(x / divisor);
+  }
+};
+
+template <typename T>
+struct HalfToFloat {
+  __host__ __device__ float operator()(const T& x) const {
+    return static_cast<float>(x);
+  }
+};
+
+template <typename T>
+struct FloatToHalf {
+  __host__ __device__ T operator()(const float& x) const {
+    return static_cast<T>(x);
+  }
+};
+
+struct And {
+  __host__ __device__ bool operator()(const bool& a, const bool& b) const {
+    return a && b;
+  }
+};
+
+struct Or {
+  __host__ __device__ bool operator()(const bool& a, const bool& b) const {
+    return a || b;
+  }
+};
+
+// each block does a grid strided loop and reduces its values locally
+// the case of one block is used for low latency small reductions to scalars
+template <typename T, typename OUT_T, int num_threads, typename Op>
+__global__ __launch_bounds__(1024) void BlockReduceKernel(
+    T in, OUT_T out, int num_elems, Op op,
+    typename std::iterator_traits<T>::value_type initVal) {
+  const int bid = blockIdx.x;
+  const int tid = threadIdx.x;
+
+  const int gid = bid * blockDim.x + tid;
+  const int stride = blockDim.x * gridDim.x;
+
+  typedef typename std::iterator_traits<T>::value_type value_type;
+
+  value_type sum = initVal;
+  if (gid < num_elems) {
+    sum = in[gid];
+    for (int pos = gid + stride; pos < num_elems; pos += stride) {
+      sum = op(sum, in[pos]);
+    }
+  }
+
+  typedef gpuprim::BlockReduce<value_type, num_threads> BlockReduce;
+
+  __shared__ typename BlockReduce::TempStorage temp_storage;
+
+  // only include input values in the reduction
+  //
+  // elements: -----------------
+  // grid:     |====|====|====|====|====|
+  const int num_elements_to_reduce =
+      max(min(static_cast<int>(num_elems - bid * blockDim.x), num_threads), 0);
+
+  sum = BlockReduce(temp_storage).Reduce(sum, op, num_elements_to_reduce);
+
+  if (tid == 0) out[bid] = sum;
+}
+
+// maps a warp to each row
+template <typename T, typename OUT_T, typename Op>
+__global__ __launch_bounds__(1024) void RowReduceKernel(
+    T in, OUT_T out, int num_rows, int num_cols, Op op,
+    typename std::iterator_traits<T>::value_type initVal) {
+  typedef typename std::iterator_traits<T>::value_type value_type;
+  // Defensive index computation to avoid integer overflow.
+  assert(blockDim.x % TF_RED_WARPSIZE == 0);
+  int warps_per_block = blockDim.x / TF_RED_WARPSIZE;
+  int warp_index = threadIdx.x / TF_RED_WARPSIZE;
+  const int row = blockIdx.x * warps_per_block + warp_index;
+  const int lane = threadIdx.x % TF_RED_WARPSIZE;
+
+  if (num_cols == 1) {
+    int gid = threadIdx.x + blockIdx.x * blockDim.x;
+    if (gid < num_rows) out[gid] = in[gid];
+    return;
+  }
+
+  value_type sum = initVal;
+  int col = lane;
+
+  if (row < num_rows && col < num_cols) {
+    sum = in[row * num_cols + col];
+    col += TF_RED_WARPSIZE;
+    for (; col < num_cols; col += TF_RED_WARPSIZE) {
+      sum = op(sum, in[row * num_cols + col]);
+    }
+  }
+
+  typedef gpuprim::WarpReduce<value_type> WarpReduce;
+
+  __shared__ typename WarpReduce::TempStorage temp_storage;
+
+  sum =
+      WarpReduce(temp_storage).Reduce(sum, op, min(num_cols, TF_RED_WARPSIZE));
+
+  if (row < num_rows && lane == 0) out[row] = sum;
+}
+
+template <typename T1>
+struct storage_type {
+  T1 val;
+  __host__ __device__ storage_type() {}
+  __host__ __device__ operator T1() { return val; }
+  __host__ __device__ storage_type<T1>& operator=(const T1& in) {
+    val = in;
+    return *this;
+  }
+};
+
+template <typename T2>
+struct storage_type<std::complex<T2>> {
+  T2 real;
+  T2 imag;
+  __host__ __device__ storage_type() {}
+  __host__ __device__ operator std::complex<T2>() {
+    return std::complex<T2>(real, imag);
+  }
+  __host__ __device__ storage_type<std::complex<T2>>& operator=(
+      const std::complex<T2>& in) {
+    real = in.real();
+    imag = in.imag();
+    return *this;
+  }
+};
+
+// Works only if there are <= 16 columns
+// each warps sums over multiple rows at once
+template <typename T, typename OUT_T, typename Op>
+__global__ __launch_bounds__(1024) void ColumnReduceMax16ColumnsKernel(
+    T in, OUT_T out, int num_rows, int num_cols, Op op,
+    typename std::iterator_traits<T>::value_type initVal) {
+  typedef typename std::iterator_traits<T>::value_type value_type;
+  int rows_per_warp = TF_RED_WARPSIZE / num_cols;
+
+  const int lane = threadIdx.x % TF_RED_WARPSIZE;
+  const int lane_row = lane / num_cols;
+
+  const int start_row_warp =
+      rows_per_warp * (blockIdx.y * blockDim.y + threadIdx.y);
+  const int start_row_lane = start_row_warp + lane_row;
+  int row = start_row_lane;
+  int col = lane % num_cols;
+
+  value_type sum = initVal;
+  if (row * num_cols + col < num_rows * num_cols)
+    sum = in[row * num_cols + col];
+
+    // 1D array necessary due to bug in CUDA 9 compiler.
+    // TODO(nluehr) revert to 2D array when compiler is ready.
+    // This is to mimic the following, but without any constructors:
+    //   __shared__ storage_type<value_type> partial_sums[TF_RED_WARPSIZE *
+    //   (TF_RED_WARPSIZE+1)];
+#if GOOGLE_CUDA
+  __shared__ __align__(alignof(value_type)) char
+      partial_sums_raw[TF_RED_WARPSIZE * (TF_RED_WARPSIZE + 1) *
+                       sizeof(value_type)];
+  value_type* partial_sums = reinterpret_cast<value_type*>(partial_sums_raw);
+#elif TENSORFLOW_USE_ROCM
+  __shared__ storage_type<value_type>
+      partial_sums[TF_RED_WARPSIZE * (TF_RED_WARPSIZE + 1)];
+#endif
+
+  row += rows_per_warp * gridDim.y * blockDim.y;
+  for (; row < num_rows; row += rows_per_warp * gridDim.y * blockDim.y) {
+    int global_pos = row * num_cols + col;
+    if (global_pos < (num_rows * num_cols))
+      sum = op(sum, in[row * num_cols + col]);
+  }
+
+  const int rows_in_this_warp = min(rows_per_warp, num_rows - start_row_warp);
+  // not the most efficient way to do this sum
+  for (int i = 1; i < rows_in_this_warp; ++i) {
+    value_type tmp = gpuprim::ShuffleIndex<TF_RED_WARPSIZE, value_type>(
+        sum, static_cast<int>(threadIdx.x + i * num_cols), 0xffffffff);
+    if (lane < num_cols) sum = op(sum, tmp);
+  }
+
+  if (lane < num_cols)
+    partial_sums[lane * (TF_RED_WARPSIZE + 1) + threadIdx.y] = sum;
+
+  __syncthreads();
+
+  if (threadIdx.y == 0 && threadIdx.x < num_cols) {
+    value_type s = partial_sums[threadIdx.x * (TF_RED_WARPSIZE + 1)];
+
+    if (blockDim.y > 1) {
+      for (int row = 1; row < blockDim.y; ++row) {
+        value_type t = partial_sums[threadIdx.x * (TF_RED_WARPSIZE + 1) + row];
+        s = op(s, t);
+      }
+    }
+
+    out[col * gridDim.y + blockIdx.y] = s;
+  }
+}
+
+// Maps each block to a column range TF_RED_WARPSIZE wide
+template <typename T, typename OUT_T, typename Op>
+__global__ __launch_bounds__(1024) void ColumnReduceKernel(
+    T in, OUT_T out, int num_rows, int num_cols, Op op,
+    typename std::iterator_traits<T>::value_type initVal) {
+  typedef typename std::iterator_traits<T>::value_type value_type;
+  int row = blockIdx.y * blockDim.y + threadIdx.y;
+  int col = blockIdx.x * TF_RED_WARPSIZE + threadIdx.x;
+
+  value_type sum = initVal;
+  if (row < num_rows && col < num_cols) sum = in[row * num_cols + col];
+
+    // 1D array necessary due to bug in CUDA 9 compiler.
+    // TODO(nluehr) revert to 2D array when compiler is ready.
+    // This is to mimic the following, but without constructors:
+    //     __shared__ storage_type<value_type> partial_sums[TF_RED_WARPSIZE *
+    //     (TF_RED_WARPSIZE + 1)];
+#if GOOGLE_CUDA
+  __shared__ __align__(alignof(value_type)) char
+      partial_sums_raw[TF_RED_WARPSIZE * (TF_RED_WARPSIZE + 1) *
+                       sizeof(value_type)];
+  value_type* partial_sums = reinterpret_cast<value_type*>(partial_sums_raw);
+#elif TENSORFLOW_USE_ROCM
+  __shared__ storage_type<value_type>
+      partial_sums[TF_RED_WARPSIZE * (TF_RED_WARPSIZE + 1)];
+#endif
+
+  row += gridDim.y * blockDim.y;
+
+  if (col < num_cols) {
+    for (; row < num_rows; row += gridDim.y * blockDim.y) {
+      sum = op(sum, in[row * num_cols + col]);
+    }
+  }
+
+  partial_sums[threadIdx.x * (TF_RED_WARPSIZE + 1) + threadIdx.y] = sum;
+
+  __syncthreads();
+
+  if (threadIdx.y == 0 && col < num_cols) {
+    value_type s = partial_sums[threadIdx.x * (TF_RED_WARPSIZE + 1)];
+
+    // only include input values in the reduction
+    // elem   block_rows
+    //  -         =
+    //  -         =
+    //  #         #  block boundary
+    //  -         =
+    //  -         =
+    //  #         #  block boundary
+    //  -         =
+    //            =
+    const int numRowsThisBlock =
+        min(static_cast<int>(blockDim.y), num_rows - blockIdx.y * blockDim.y);
+
+    for (int row = 1; row < numRowsThisBlock; ++row) {
+      value_type t = partial_sums[threadIdx.x * (TF_RED_WARPSIZE + 1) + row];
+      s = op(s, t);
+    }
+
+    out[col * gridDim.y + blockIdx.y] = s;
+  }
+}
+
+// does multiple warp size segmented reductions in parallel
+// segments cannot cross warp boundaries (mainly used for reducing the segments
+// that come from the Max16Columns column reduction kernel)
+template <typename T, typename OUT_T, typename Op>
+__global__ __launch_bounds__(1024) void CleanupSegments(
+    T partial_sums, OUT_T out, int num_rows, int num_cols, int segment_size,
+    Op op, typename std::iterator_traits<T>::value_type initVal) {
+  typedef typename std::iterator_traits<T>::value_type value_type;
+  const int tid = threadIdx.x + blockIdx.x * blockDim.x;
+
+  value_type val = initVal;
+  if (tid < segment_size * num_cols) val = partial_sums[tid];
+
+  typedef gpuprim::WarpReduce<value_type> WarpReduce;
+
+  __shared__ typename WarpReduce::TempStorage temp_storage;
+
+  const bool head_flag = (threadIdx.x % segment_size) == 0;
+  value_type sum =
+      WarpReduce(temp_storage).HeadSegmentedReduce(val, head_flag, op);
+
+  if (head_flag && tid < segment_size * num_cols) {
+    out[tid / segment_size] = sum;
+  }
+}
+
+// assigns one thread to a column
+template <typename T, typename OUT_T, typename Op>
+__global__ __launch_bounds__(1024) void ColumnReduceSimpleKernel(
+    T in, OUT_T out, int num_planes, int num_rows, int num_cols, Op op) {
+  typedef typename std::iterator_traits<T>::value_type value_type;
+  const int gid = threadIdx.x + blockIdx.x * blockDim.x;
+  const int elems_per_plane = num_rows * num_cols;
+
+  const int plane = gid / num_cols;
+  const int col = gid % num_cols;
+
+  if (plane >= num_planes) return;
+
+  if (num_rows == 1) {
+    out[plane * elems_per_plane + col] = in[plane * elems_per_plane + col];
+    return;
+  }
+
+  value_type sum = op(in[plane * elems_per_plane + col],
+                      in[plane * elems_per_plane + num_cols + col]);
+  for (int row = 2; row < num_rows; ++row) {
+    sum = op(sum, in[plane * elems_per_plane + row * num_cols + col]);
+  }
+
+  out[plane * num_cols + col] = sum;
+}
+
+namespace {
+constexpr int kUnroll = 8;
+}
+
+template <typename T, typename IN_T, typename Op>
+__device__ __inline__ T ComputeSum(IN_T in_, const int plane,
+                                   const int num_out_rows, int num_rows,
+                                   int num_cols, const int col, Op op) {
+  const int out_rows = num_rows / (2 * kUnroll);
+  const int num_rem_rows = num_rows % (2 * kUnroll);
+  const int elems_per_plane = num_rows * num_cols;
+  T reg[2 * kUnroll];
+  T sum;
+  int offset = 0;
+  if (out_rows != 0) {
+    for (int i = 0; i < 2 * kUnroll; i++) {
+      reg[i] =
+          in_[plane * elems_per_plane + i * (num_out_rows * num_cols) + col];
+    }
+    sum = reg[0];
+    for (int i = 1; i < 2 * kUnroll; i++) {
+      sum = op(sum, reg[i]);
+    }
+    offset = 2 * kUnroll * (num_out_rows * num_cols);
+  }
+
+  if (col < num_cols && num_rem_rows > 0) {
+    reg[0] = in_[plane * elems_per_plane + offset + 0 * num_cols + col];
+    if (out_rows != 0) {
+      sum = op(sum, reg[0]);
+    } else {
+      sum = reg[0];
+    }
+    for (int i = 1; i < num_rem_rows; i++) {
+      reg[0] = in_[plane * elems_per_plane + offset + i * num_cols + col];
+      sum = op(sum, reg[0]);
+    }
+  }
+  return sum;
+}
+
+template <typename IN_T, typename Op>
+__global__ __launch_bounds__(1024) void ColumnReduceInToTempKernel(
+    void* __restrict__ temp, int temp_in_offset, int temp_out_offset, IN_T in,
+    int num_planes, int num_rows, int num_cols, Op op) {
+  typedef typename std::iterator_traits<IN_T>::value_type value_type;
+
+  value_type* t = (value_type*)temp;
+  value_type* out_ = t + temp_out_offset;
+
+  const int gid = threadIdx.x + blockIdx.x * blockDim.x;
+  const int num_out_rows = max(1, num_rows / (2 * kUnroll));
+  const int plane = gid / (num_out_rows * num_cols);
+  const int col = gid % (num_out_rows * num_cols);
+
+  if (plane >= num_planes) return;
+
+  value_type sum;
+  if (temp_in_offset == -1) {
+    auto in_ = in;
+    sum = ComputeSum<value_type, IN_T, Op>(in_, plane, num_out_rows, num_rows,
+                                           num_cols, col, op);
+  } else {
+    auto in_ = t + temp_in_offset;
+    sum = ComputeSum<value_type, value_type*, Op>(in_, plane, num_out_rows,
+                                                  num_rows, num_cols, col, op);
+  }
+  out_[plane * num_out_rows * num_cols + col] = sum;
+}
+
+template <typename T, typename OUT_T, typename Op>
+__global__ __launch_bounds__(1024) void ColumnReduceTempToOutKernel(
+    void* __restrict__ temp, int temp_in_offset, T in, OUT_T out,
+    int num_planes, int num_rows, int num_cols, Op op) {
+  typedef typename std::iterator_traits<T>::value_type value_type;
+  value_type* t = (value_type*)temp;
+  const int tid = threadIdx.x;
+  const int gid = threadIdx.x + blockIdx.x * blockDim.x;
+  int elems_per_plane = num_rows * num_cols;
+
+  if (num_rows == 1) {
+    if (gid >= num_planes * num_cols) return;
+    if (temp_in_offset == -1) {
+      auto in_ = in;
+      out[gid] = in_[gid];
+    } else {
+      auto in_ = t + temp_in_offset;
+      out[gid] = in_[gid];
+    }
+    return;
+  }
+
+  const int planes_per_block = 1;
+  const int plane = blockIdx.x * planes_per_block + tid / elems_per_plane;
+  // A thread block contains one or multiple plane(s),
+  // i.e. num_rows * num_cols <= blockDim.x
+  const int col = tid % elems_per_plane;
+  const int local_plane = plane % planes_per_block;
+
+  if (tid >= planes_per_block * elems_per_plane || plane >= num_planes) return;
+
+  GPU_DYNAMIC_SHARED_MEM_DECL(8, char, ss);
+  value_type* const smem = reinterpret_cast<value_type*>(ss);
+
+  if (temp_in_offset == -1) {
+    auto in_ = in;
+    smem[local_plane * elems_per_plane + col] =
+        in_[plane * elems_per_plane + col];
+  } else {
+    auto in_ = t + temp_in_offset;
+    smem[local_plane * elems_per_plane + col] =
+        in_[plane * elems_per_plane + col];
+  }
+  __syncthreads();
+
+  int num_in_rows = num_rows;
+  int num_out_rows;
+  int num_rem_rows;
+
+  int in_offset = 0;
+  int out_offset = blockDim.x;
+
+  int in_elems_per_plane = elems_per_plane;
+  int out_elems_per_plane;
+
+  while (num_in_rows > 1) {
+    num_out_rows = num_in_rows / 2;
+    num_rem_rows = num_in_rows % 2;
+    out_elems_per_plane = num_out_rows * num_cols;
+
+    if (col < out_elems_per_plane) {
+      value_type sum;
+      sum = op(smem[in_offset + local_plane * in_elems_per_plane + col],
+               smem[in_offset + local_plane * in_elems_per_plane +
+                    out_elems_per_plane + col]);
+      if (num_rem_rows == 1 && col < num_cols) {
+        sum = op(sum, smem[in_offset + local_plane * in_elems_per_plane +
+                           2 * out_elems_per_plane + col]);
+      }
+      smem[out_offset + local_plane * out_elems_per_plane + col] = sum;
+    }
+
+    num_in_rows = num_out_rows;
+    in_elems_per_plane = out_elems_per_plane;
+    int t_offset = in_offset;
+    in_offset = out_offset;
+    out_offset = t_offset;
+    __syncthreads();
+  }
+
+  if (col < num_cols) {
+    out[plane * num_cols + col] =
+        smem[in_offset + local_plane * out_elems_per_plane + col];
+  }
+}
+
+struct RowOffset {
+  __host__ __device__ explicit RowOffset(const int& cols) : cols_(cols) {}
+
+  __host__ __device__ int operator()(const int& x) const { return cols_ * x; }
+
+  int cols_;
+};
+
+struct GatherOp {
+  __host__ __device__ GatherOp(const int& extent_x, const int& extent_y,
+                               const int& extent_z, bool kOne)
+      : extent_x_(extent_x),
+        extent_y_(extent_y),
+        extent_z_(extent_z),
+        kOne_(kOne) {
+    if (kOne_)
+      group_size_ = extent_y_;
+    else
+      group_size_ = extent_x_ * extent_z_;
+  }
+
+  __host__ __device__ int operator()(const int& ind) const {
+    const int group = kOne_ ? ind / group_size_ : ind % group_size_;
+    const int offset = kOne_ ? ind % group_size_ : ind / group_size_;
+
+    const int x = group / extent_z_;
+    const int z = group % extent_z_;
+
+    return x * extent_y_ * extent_z_ + z + offset * extent_z_;
+  }
+
+  int extent_x_;
+  int extent_y_;
+  int extent_z_;
+  bool kOne_;
+  int group_size_;
+};
+
+template <typename T, typename Op, typename OUT_T, typename IN_T>
+void LaunchScalarReduction(OpKernelContext* ctx, OUT_T out, IN_T in,
+                           int in_size, Op op, T init,
+                           const gpuStream_t& cu_stream) {
+  // handle situations where low latency is important better than CUB
+  if (in_size <= 4096) {
+    const int num_blocks = 1;
+    const int num_threads = 256;
+    TF_CHECK_OK(GpuLaunchKernel(BlockReduceKernel<IN_T, OUT_T, num_threads, Op>,
+                                num_blocks, num_threads, 0, cu_stream, in, out,
+                                in_size, op, init));
+    return;
+  } else if (in_size <= 1 << 18) {
+    const int num_threads = 256;
+    const int num_blocks =
+        std::min(TF_RED_WARPSIZE, Eigen::divup(in_size, num_threads));
+    // it seems like tailoring this to the GPU
+    // would be more effective, but all attempts
+    // at making this a multiple of the number of
+    // multiprocessors have lead to lower perf
+    // in general
+    // TODO(eriche) investigate this more
+
+    Tensor temp_storage;
+    OP_REQUIRES_OK(
+        ctx, ctx->allocate_temp(
+                 DT_INT8,
+                 TensorShape({static_cast<int64_t>(num_blocks * sizeof(T))}),
+                 &temp_storage));
+
+    TF_CHECK_OK(GpuLaunchKernel(BlockReduceKernel<IN_T, T*, num_threads, Op>,
+                                num_blocks, num_threads, 0, cu_stream, in,
+                                (T*)temp_storage.flat<int8_t>().data(), in_size,
+                                op, init));
+
+    // take care that we only reduce blocks that had some valid elements in them
+    // TODO(eriche): CUB currently has a bug in HeadSegmentedReduce that
+    // requires it to be used with a full warp.  Can reduce TF_RED_WARPSIZE ->
+    // num_blocks when this is fixed.
+    TF_CHECK_OK(GpuLaunchKernel(CleanupSegments<T*, OUT_T, Op>, 1,
+                                TF_RED_WARPSIZE, 0, cu_stream,
+                                (T*)temp_storage.flat<int8_t>().data(), out, 1,
+                                1, num_blocks, op, init));
+    return;
+  }
+
+  size_t temp_storage_bytes = 0;
+  auto reduce = [&](void* temp_storage_ptr) {
+    auto success =
+        gpuprim::DeviceReduce::Reduce(temp_storage_ptr, temp_storage_bytes, in,
+                                      out, in_size, op, init, cu_stream);
+
+    OP_REQUIRES(
+        ctx, success == 0,
+        errors::Internal("CUB reduce error ", GpuGetErrorString(success)));
+  };
+
+  reduce(nullptr);  // Get required amount of temp storage.
+
+  Tensor temp_storage;
+  OP_REQUIRES_OK(
+      ctx, ctx->allocate_temp(
+               DT_INT8, TensorShape({static_cast<int64_t>(temp_storage_bytes)}),
+               &temp_storage));
+
+  reduce(temp_storage.flat<int8_t>().data());  // Do reduction.
+}
+
+template <typename T, typename Op, typename OUT_T, typename IN_T>
+void LaunchRowReduction(OpKernelContext* ctx, OUT_T out, IN_T in, int num_rows,
+                        int num_cols, Op op, T init,
+                        const gpuStream_t& cu_stream) {
+  if (num_cols < 1024) {
+    const int threads_per_block = 128;
+    const int warps_per_block = threads_per_block / TF_RED_WARPSIZE;
+    int num_blocks = (num_rows + warps_per_block - 1) / warps_per_block;
+
+    TF_CHECK_OK(GpuLaunchKernel(RowReduceKernel<IN_T, OUT_T, Op>, num_blocks,
+                                threads_per_block, 0, cu_stream, in, out,
+                                num_rows, num_cols, op, init));
+    return;
+  }
+
+  // setup segment offsets with counting and transform iterator
+  RowOffset row_offset_op(num_cols);
+  gpuprim::CountingInputIterator<int> counting_iter(0);
+  gpuprim::TransformInputIterator<int, RowOffset,
+                                  gpuprim::CountingInputIterator<int>>
+      transform_iter(counting_iter, row_offset_op);
+
+  size_t temp_storage_bytes = 0;
+  auto reduce = [&](void* temp_storage_ptr) {
+    auto success = gpuprim::DeviceSegmentedReduce::Reduce(
+        temp_storage_ptr, temp_storage_bytes, in, out, num_rows, transform_iter,
+        transform_iter + 1, op, init, cu_stream);
+
+    OP_REQUIRES(ctx, success == 0,
+                errors::Internal("CUB segmented reduce error",
+                                 GpuGetErrorString(success)));
+  };
+
+  reduce(nullptr);  // Get required amount of temp storage.
+
+  Tensor temp_storage;
+  OP_REQUIRES_OK(
+      ctx, ctx->allocate_temp(
+               DT_INT8, TensorShape({static_cast<int64_t>(temp_storage_bytes)}),
+               &temp_storage));
+
+  reduce(temp_storage.flat<int8_t>().data());  // Do reduction.
+}
+
+template <typename T, typename Op, typename OUT_T, typename IN_T>
+void LaunchColumnReduction_LTE16Cols(OpKernelContext* ctx, OUT_T out, IN_T in,
+                                     int extent_x, int extent_y, Op op, T init,
+                                     const gpuStream_t& cu_stream) {
+  int rows_per_warp = TF_RED_WARPSIZE / extent_y;
+  dim3 block_dim(
+      TF_RED_WARPSIZE,
+      std::min(Eigen::divup(extent_x, rows_per_warp), (1024 / TF_RED_WARPSIZE)),
+      1);
+  dim3 grid_dim(1,
+                Eigen::divup(static_cast<unsigned int>(extent_x),
+                             rows_per_warp * block_dim.y),
+                1);
+
+  grid_dim.y = std::min((int)grid_dim.y, TF_RED_WARPSIZE);
+
+  if (grid_dim.y > 2 && grid_dim.y < TF_RED_WARPSIZE) {
+    int log2 = Log2Floor(grid_dim.y);
+    grid_dim.y = 1 << log2;
+  }
+
+  if (grid_dim.y == 1) {
+    TF_CHECK_OK(GpuLaunchKernel(ColumnReduceMax16ColumnsKernel<IN_T, OUT_T, Op>,
+                                grid_dim, block_dim, 0, cu_stream, in, out,
+                                extent_x, extent_y, op, init));
+  } else {
+    Tensor temp_storage;
+    OP_REQUIRES_OK(ctx,
+                   ctx->allocate_temp(DT_INT8,
+                                      TensorShape({static_cast<int64_t>(
+                                          sizeof(T) * extent_y * grid_dim.y)}),
+                                      &temp_storage));
+    TF_CHECK_OK(GpuLaunchKernel(ColumnReduceMax16ColumnsKernel<IN_T, T*, Op>,
+                                grid_dim, block_dim, 0, cu_stream, in,
+                                (T*)temp_storage.flat<int8_t>().data(),
+                                extent_x, extent_y, op, init));
+
+    dim3 new_grid_dim(
+        (grid_dim.y * extent_y + (TF_RED_WARPSIZE - 1)) / TF_RED_WARPSIZE, 1,
+        1);
+    dim3 num_threads(128, 1, 1);
+    TF_CHECK_OK(GpuLaunchKernel(CleanupSegments<T*, OUT_T, Op>, new_grid_dim,
+                                num_threads, 0, cu_stream,
+                                (T*)temp_storage.flat<int8_t>().data(), out,
+                                extent_x, extent_y, grid_dim.y, op, init));
+  }
+}
+
+template <typename T, typename Op, typename OUT_T, typename IN_T>
+void LaunchColumnReduction_LTE4096Cols(OpKernelContext* ctx, OUT_T out, IN_T in,
+                                       int extent_x, int extent_y, Op op,
+                                       T init, const gpuStream_t& cu_stream) {
+  dim3 block_dim(TF_RED_WARPSIZE, std::min(extent_x, (1024 / TF_RED_WARPSIZE)),
+                 1);
+  dim3 grid_dim((extent_y + (TF_RED_WARPSIZE - 1)) / TF_RED_WARPSIZE, 1, 1);
+
+  if (grid_dim.x < 16)
+    grid_dim.y = std::min((extent_x + (TF_RED_WARPSIZE - 1)) / TF_RED_WARPSIZE,
+                          TF_RED_WARPSIZE);
+
+  if (grid_dim.y > 2 && grid_dim.y < TF_RED_WARPSIZE) {
+    int log2 = Log2Floor(grid_dim.y);
+    grid_dim.y = 1 << log2;
+  }
+
+  if (grid_dim.y == 1) {
+    TF_CHECK_OK(GpuLaunchKernel(ColumnReduceKernel<IN_T, OUT_T, Op>, grid_dim,
+                                block_dim, 0, cu_stream, in, out, extent_x,
+                                extent_y, op, init));
+  } else {
+    Tensor temp_storage;
+    OP_REQUIRES_OK(ctx,
+                   ctx->allocate_temp(DT_INT8,
+                                      TensorShape({static_cast<int64_t>(
+                                          sizeof(T) * extent_y * grid_dim.y)}),
+                                      &temp_storage));
+
+    TF_CHECK_OK(GpuLaunchKernel(
+        ColumnReduceKernel<IN_T, T*, Op>, grid_dim, block_dim, 0, cu_stream, in,
+        (T*)temp_storage.flat<int8_t>().data(), extent_x, extent_y, op, init));
+
+    dim3 new_grid_dim(
+        (grid_dim.y * extent_y + (TF_RED_WARPSIZE - 1)) / TF_RED_WARPSIZE, 1,
+        1);
+    TF_CHECK_OK(GpuLaunchKernel(CleanupSegments<T*, OUT_T, Op>, new_grid_dim,
+                                block_dim, 0, cu_stream,
+                                (T*)temp_storage.flat<int8_t>().data(), out,
+                                extent_x, extent_y, grid_dim.y, op, init));
+  }
+}
+
+template <typename T, typename Op, typename OUT_T, typename IN_T>
+void LaunchColumnReduction(OpKernelContext* ctx, OUT_T out, IN_T in,
+                           int extent_x, int extent_y, Op op, T init,
+                           const gpuStream_t& cu_stream) {
+  if (extent_y <= 16) {
+    LaunchColumnReduction_LTE16Cols(ctx, out, in, extent_x, extent_y, op, init,
+                                    cu_stream);
+  } else if (extent_y <= 4096) {
+    LaunchColumnReduction_LTE4096Cols(ctx, out, in, extent_x, extent_y, op,
+                                      init, cu_stream);
+  } else {
+    int threads_per_block = 128;
+    int num_blocks = Eigen::divup(extent_y, threads_per_block);
+
+    TF_CHECK_OK(GpuLaunchKernel(ColumnReduceSimpleKernel<IN_T, OUT_T, Op>,
+                                num_blocks, threads_per_block, 0, cu_stream, in,
+                                out, 1, extent_x, extent_y, op));
+  }
+}
+
+template <typename T, typename Op, typename OUT_T, typename IN_T>
+void Launch3DYReductionSimple(OpKernelContext* ctx, OUT_T out, IN_T in,
+                              int extent_x, int extent_y, int extent_z, Op op,
+                              T init, const gpuStream_t& cu_stream) {
+  int threads_per_block = 128;
+  int num_blocks =
+      (extent_x * extent_z + threads_per_block - 1) / threads_per_block;
+
+  // TODO(eriche): this won't be very good in the case of small x
+  //                small z and large y.
+  TF_CHECK_OK(GpuLaunchKernel(ColumnReduceSimpleKernel<IN_T, OUT_T, Op>,
+                              num_blocks, threads_per_block, 0, cu_stream, in,
+                              out, extent_x, extent_y, extent_z, op));
+}
+
+template <typename T, typename Op, typename OUT_T, typename IN_T>
+void Launch3DYReduction(OpKernelContext* ctx, OUT_T out, IN_T in, int extent_x,
+                        int extent_y, int extent_z, Op op, T init,
+                        const gpuStream_t& cu_stream) {
+  int threads_per_block = 128;
+
+  int n_group_in = extent_y;
+  int n_size = extent_z;
+
+  // Calculate and allocate temporary space
+  std::size_t temp_storage_bytes = 0;
+  // A plane's size is n_group_in * n_size. We make sure no single plane crosses
+  // more than one thread block, meaning a thread block will handle one whole
+  // plane or multiple planes in the second stage. Also, It may handle a partial
+  // plane when n_size is too large and the while-loop will stop at
+  // n_group_in = 1, where we directly copy the temp to output in the next
+  // stage.
+  while (n_group_in >= 2 && n_group_in * n_size > threads_per_block) {
+    int n_group_out = std::max(1, n_group_in / (2 * kUnroll));
+    temp_storage_bytes += n_group_out * n_size;
+    n_group_in = n_group_out;
+  }
+  temp_storage_bytes *= extent_x * sizeof(T);
+  Tensor temp_storage;
+  OP_REQUIRES_OK(
+      ctx, ctx->allocate_temp(
+               DT_INT8, TensorShape({static_cast<int64_t>(temp_storage_bytes)}),
+               &temp_storage));
+
+  // Reduction
+  n_group_in = extent_y;
+  int temp_in_offset = -1;
+  int temp_out_offset = 0;
+  int num_blocks;
+  while (n_group_in >= 2 && n_group_in * n_size > threads_per_block) {
+    int n_group_out = std::max(1, n_group_in / (2 * kUnroll));
+    num_blocks =
+        Eigen::divup(extent_x * n_group_out * n_size, threads_per_block);
+    TF_CHECK_OK(GpuLaunchKernel(
+        ColumnReduceInToTempKernel<IN_T, Op>, num_blocks, threads_per_block, 0,
+        cu_stream, (void*)(temp_storage.flat<int8_t>().data()), temp_in_offset,
+        temp_out_offset, in, extent_x, n_group_in, extent_z, op));
+
+    n_group_in = n_group_out;
+    temp_in_offset = temp_out_offset;
+    temp_out_offset = temp_in_offset + extent_x * n_group_out * n_size;
+  }
+
+  if (n_group_in * n_size <= threads_per_block) {
+    num_blocks = extent_x;
+  } else {
+    DCHECK_EQ(1, n_group_in);
+    num_blocks = Eigen::divup(extent_x * n_size, threads_per_block);
+  }
+
+  TF_CHECK_OK(GpuLaunchKernel(
+      ColumnReduceTempToOutKernel<IN_T, OUT_T, Op>, num_blocks,
+      threads_per_block, 2 * sizeof(T) * threads_per_block, cu_stream,
+      (void*)(temp_storage.flat<int8_t>().data()), temp_in_offset, in, out,
+      extent_x, n_group_in, extent_z, op));
+}
+
+template <typename T, typename Op, typename OUT_T, typename IN_T>
+void Launch3DXZReduction(OpKernelContext* ctx, OUT_T out, IN_T in, int extent_x,
+                         int extent_y, int extent_z, Op op, T init,
+                         const gpuStream_t& cu_stream) {
+  // setup segment offsets with counting and transform iterator
+  RowOffset row_offset_op(extent_x * extent_z);
+  gpuprim::CountingInputIterator<int> counting_iter(0);
+  gpuprim::TransformInputIterator<int, RowOffset,
+                                  gpuprim::CountingInputIterator<int>>
+      transform_iter(counting_iter, row_offset_op);
+
+  GatherOp gather_op(extent_x, extent_y, extent_z, false);
+  typedef gpuprim::TransformInputIterator<int, GatherOp,
+                                          gpuprim::CountingInputIterator<int>>
+      gatherIterType;
+  gatherIterType gather_iter(counting_iter, gather_op);
+
+  PermutationInputIterator<T, IN_T, gatherIterType> permute_iter(in,
+                                                                 gather_iter);
+
+  std::size_t temp_storage_bytes = 0;
+  auto reduce = [&](void* temp_storage_ptr) {
+    auto success = gpuprim::DeviceSegmentedReduce::Reduce(
+        temp_storage_ptr, temp_storage_bytes, permute_iter, out, extent_y,
+        transform_iter, transform_iter + 1, op, init, cu_stream);
+
+    OP_REQUIRES(ctx, success == 0,
+                errors::Internal("CUB segmented reduce error",
+                                 GpuGetErrorString(success)));
+  };
+
+  reduce(nullptr);  // Get required amount of temp storage.
+
+  Tensor temp_storage;
+  OP_REQUIRES_OK(
+      ctx, ctx->allocate_temp(
+               DT_INT8, TensorShape({static_cast<int64_t>(temp_storage_bytes)}),
+               &temp_storage));
+
+  reduce(temp_storage.flat<int8_t>().data());  // Do reduction.
+}
+
+namespace reduction_op_helper {
+
+template <typename T, typename Op>
+struct IsSum {
+  constexpr static bool value =
+      (std::is_same<Op, gpuprim::Sum>::value ||
+       std::is_same<Op, Eigen::internal::SumReducer<T>>::value ||
+       std::is_same<Op, Sum<T>>::value);
+};
+
+template <typename T, typename Op>
+struct IsMax {
+  constexpr static bool value =
+      (std::is_same<Op, MaxPropagateNaN>::value ||
+       std::is_same<Op, gpuprim::Max>::value ||
+       std::is_same<
+           Op, Eigen::internal::MaxReducer<T, Eigen::PropagateNaN>>::value);
+};
+
+template <typename T, typename Op>
+struct IsMin {
+  constexpr static bool value =
+      (std::is_same<Op, MinPropagateNaN>::value ||
+       std::is_same<Op, gpuprim::Min>::value ||
+       std::is_same<
+           Op, Eigen::internal::MinReducer<T, Eigen::PropagateNaN>>::value);
+};
+
+template <typename T, typename Op>
+struct IsProd {
+  constexpr static bool value =
+      (std::is_same<Op, Prod<T>>::value ||
+       std::is_same<Op, Eigen::internal::ProdReducer<T>>::value);
+};
+
+template <typename T, typename Op>
+struct IdentityValue {
+  static_assert(IsSum<T, Op>::value || IsMax<T, Op>::value ||
+                    IsMin<T, Op>::value || IsProd<T, Op>::value ||
+                    std::is_same<Op, And>::value || std::is_same<Op, Or>::value,
+                "IdentityValue not yet defined for this type");
+
+  template <typename U = T, typename OpCopy = Op>
+  U operator()(
+      typename std::enable_if<IsSum<U, OpCopy>::value, U>::type t = U(0)) {
+    return t;
+  }
+
+  template <typename U = T, typename OpCopy = Op>
+  U operator()(typename std::enable_if<IsMax<U, OpCopy>::value, U>::type t =
+                   Eigen::NumTraits<U>::lowest()) {
+    return t;
+  }
+
+  template <typename U = T, typename OpCopy = Op>
+  U operator()(typename std::enable_if<IsMin<U, OpCopy>::value, U>::type t =
+                   Eigen::NumTraits<U>::highest()) {
+    return t;
+  }
+
+  template <typename U = T, typename OpCopy = Op>
+  U operator()(
+      typename std::enable_if<IsProd<U, OpCopy>::value, U>::type t = U(1)) {
+    return t;
+  }
+
+  template <typename U = T, typename OpCopy = Op>
+  U operator()(typename std::enable_if<std::is_same<OpCopy, And>::value,
+                                       bool>::type t = true) {
+    return t;
+  }
+
+  template <typename U = T, typename OpCopy = Op>
+  U operator()(typename std::enable_if<std::is_same<OpCopy, Or>::value,
+                                       bool>::type t = false) {
+    return t;
+  }
+};
+
+}  // namespace reduction_op_helper
+
+template <typename T, typename Op, typename OUT_T, typename IN_T,
+          typename ReductionAxes>
+void ReduceImpl(OpKernelContext* ctx, OUT_T out, IN_T in, int in_rank,
+                int in_dim0, int in_dim1, int in_dim2, int out_rank,
+                const ReductionAxes& reduction_axes, Op op) {
+  T init = reduction_op_helper::IdentityValue<T, Op>()();
+  const gpuStream_t& cu_stream = GetGpuStream(ctx);
+  if (out_rank == 0) {
+    const int in_size = in_dim0 * in_dim1 * in_dim2;
+    LaunchScalarReduction(ctx, out, in, in_size, op, init, cu_stream);
+  } else if (in_rank == 2 && out_rank == 1 &&
+             reduction_axes[0] == 1) {  // row reduction
+    LaunchRowReduction(ctx, out, in, in_dim0, in_dim1, op, init, cu_stream);
+  } else if (in_rank == 2 && out_rank == 1 &&
+             reduction_axes[0] == 0) {  // column reduction
+    LaunchColumnReduction(ctx, out, in, in_dim0, in_dim1, op, init, cu_stream);
+  } else if (in_rank == 3 && out_rank == 2 && reduction_axes[0] == 1) {
+    int elems_per_thread = in_dim1 / (in_dim0 * in_dim2);
+    if (elems_per_thread >= 16) {
+      Launch3DYReduction(ctx, out, in, in_dim0, in_dim1, in_dim2, op, init,
+                         cu_stream);
+    } else {
+      Launch3DYReductionSimple(ctx, out, in, in_dim0, in_dim1, in_dim2, op,
+                               init, cu_stream);
+    }
+  } else if (in_rank == 3 && out_rank == 1 && reduction_axes[0] == 0 &&
+             reduction_axes[1] == 2) {
+    Launch3DXZReduction(ctx, out, in, in_dim0, in_dim1, in_dim2, op, init,
+                        cu_stream);
+  } else {
+    std::stringstream ss;
+    ss << "Invalid reduction requested: in_rank, out_rank, axes " << in_rank
+       << " " << out_rank;
+    if (out_rank == 1) ss << " " << reduction_axes[0];
+    if (out_rank == 2) ss << " " << reduction_axes[1];
+    LOG(FATAL) << ss.str();
+  }
+}
+
+template <typename Reducer>
+struct ReduceFunctor<GPUDevice, Reducer> {
+  template <typename OUT_T, typename IN_T, typename ReductionAxes>
+  static void Reduce(OpKernelContext* ctx, OUT_T out, IN_T in,
+                     const ReductionAxes& reduction_axes,
+                     const Reducer& reducer);
+};
+
+template <typename T>
+struct ReduceFunctor<GPUDevice, Eigen::internal::SumReducer<T>> {
+  template <typename OUT_T, typename IN_T, typename ReductionAxes>
+  static void Reduce(OpKernelContext* ctx, OUT_T out, IN_T in,
+                     const ReductionAxes& reduction_axes,
+                     const Eigen::internal::SumReducer<T>& reducer) {
+    ReduceImpl<T, Sum<T>, T*, T*, ReductionAxes>(
+        ctx, (T*)out.data(), (T*)in.data(), in.rank(), in.dimension(0),
+        in.rank() >= 2 ? in.dimension(1) : 1,
+        in.rank() >= 3 ? in.dimension(2) : 1, out.rank(), reduction_axes,
+        Sum<T>());
+  }
+
+  template <typename OUT_T>
+  static void FillIdentity(const GPUDevice& d, OUT_T out,
+                           const Eigen::internal::SumReducer<T>& reducer) {
+    FillIdentityEigenImpl(d, out, reducer);
+  }
+};
+
+// Specialization for bfloat16 with fp32 accumulation.
+template <>
+struct ReduceFunctor<GPUDevice, Eigen::internal::SumReducer<Eigen::bfloat16>> {
+  template <typename OUT_T, typename IN_T, typename ReductionAxes>
+  static void Reduce(
+      OpKernelContext* ctx, OUT_T out, IN_T in,
+      const ReductionAxes& reduction_axes,
+      const Eigen::internal::SumReducer<Eigen::bfloat16>& reducer) {
+    typedef gpuprim::TransformInputIterator<float, HalfToFloat<Eigen::bfloat16>,
+                                            Eigen::bfloat16*>
+        inputIterType;
+    inputIterType input_itr((Eigen::bfloat16*)in.data(),
+                            HalfToFloat<Eigen::bfloat16>());
+
+    typedef TransformOutputIterator<Eigen::bfloat16, float,
+                                    FloatToHalf<Eigen::bfloat16>>
+        outputIterType;
+    outputIterType itr((Eigen::bfloat16*)out.data(),
+                       FloatToHalf<Eigen::bfloat16>());
+
+    ReduceImpl<float, gpuprim::Sum, outputIterType, inputIterType,
+               ReductionAxes>(ctx, itr, input_itr, in.rank(), in.dimension(0),
+                              in.rank() >= 2 ? in.dimension(1) : 1,
+                              in.rank() >= 3 ? in.dimension(2) : 1, out.rank(),
+                              reduction_axes, gpuprim::Sum());
+  }
+
+  template <typename OUT_T>
+  static void FillIdentity(
+      const GPUDevice& d, OUT_T out,
+      const Eigen::internal::SumReducer<Eigen::bfloat16>& reducer) {
+    FillIdentityEigenImpl(d, out, reducer);
+  }
+};
+
+// TODO(rmlarsen): Specialize for float16.
+template <typename T>
+struct ReduceFunctor<GPUDevice, functor::EuclideanNormReducer<T>> {
+  template <typename OUT_T, typename IN_T, typename ReductionAxes>
+  static void Reduce(OpKernelContext* ctx, OUT_T out, IN_T in,
+                     const ReductionAxes& reduction_axes,
+                     const functor::EuclideanNormReducer<T>& reducer) {
+    typedef gpuprim::TransformInputIterator<T, Square<T>, T*> inputIterType;
+    inputIterType input_itr((T*)in.data(), Square<T>());
+    typedef TransformOutputIterator<T, T, SqrtOfReal<T>> outputIterType;
+    outputIterType output_itr((T*)out.data(), SqrtOfReal<T>());
+    ReduceImpl<T, Sum<T>, outputIterType, inputIterType, ReductionAxes>(
+        ctx, output_itr, input_itr, in.rank(), in.dimension(0),
+        in.rank() >= 2 ? in.dimension(1) : 1,
+        in.rank() >= 3 ? in.dimension(2) : 1, out.rank(), reduction_axes,
+        Sum<T>());
+  }
+
+  template <typename OUT_T>
+  static void FillIdentity(const GPUDevice& d, OUT_T out,
+                           const functor::EuclideanNormReducer<T>& reducer) {
+    FillIdentityEigenImpl(d, out, reducer);
+  }
+};
+
+template <typename T>
+struct ReduceFunctor<GPUDevice, functor::MeanReducer<T>> {
+  template <typename OUT_T, typename IN_T, typename ReductionAxes>
+  static void Reduce(OpKernelContext* ctx, OUT_T out, IN_T in,
+                     const ReductionAxes& reduction_axes,
+                     const functor::MeanReducer<T>& reducer) {
+    int divisor = 1;
+    if (out.rank() == 0)
+      divisor = in.size();
+    else if (out.rank() == 1 && in.rank() == 2 && reduction_axes[0] == 0)
+      divisor = in.dimension(0);
+    else if (out.rank() == 1 && in.rank() == 2 && reduction_axes[0] == 1)
+      divisor = in.dimension(1);
+    else if (out.rank() == 1 && in.rank() == 3 && reduction_axes[0] == 0 &&
+             reduction_axes[1] == 2)
+      divisor = in.dimension(0) * in.dimension(2);
+    else if (out.rank() == 2 && in.rank() == 3 && reduction_axes[0] == 1)
+      divisor = in.dimension(1);
+
+    DividesBy<T> div_op(static_cast<T>(divisor));
+    TransformOutputIterator<T, T, DividesBy<T>> itr((T*)out.data(), div_op);
+    ReduceImpl<T, Sum<T>, TransformOutputIterator<T, T, DividesBy<T>>, T*,
+               ReductionAxes>(ctx, itr, (T*)in.data(), in.rank(),
+                              in.dimension(0),
+                              in.rank() >= 2 ? in.dimension(1) : 1,
+                              in.rank() >= 3 ? in.dimension(2) : 1, out.rank(),
+                              reduction_axes, Sum<T>());
+  }
+
+  template <typename OUT_T>
+  static void FillIdentity(const GPUDevice& d, OUT_T out,
+                           const functor::MeanReducer<T>& reducer) {
+    FillIdentityEigenImpl(d, out, reducer);
+  }
+};
+
+template <typename T, typename OUT_T, typename IN_T, typename ReductionAxes>
+void ReduceMeanWithFloatAccumulationImpl(
+    OpKernelContext* ctx, OUT_T out, IN_T in,
+    const ReductionAxes& reduction_axes,
+    const functor::MeanReducer<T>& reducer) {
+  float divisor = 1.f;
+  if (out.rank() == 0)
+    divisor = in.size();
+  else if (out.rank() == 1 && in.rank() == 2 && reduction_axes[0] == 0)
+    divisor = in.dimension(0);
+  else if (out.rank() == 1 && in.rank() == 2 && reduction_axes[0] == 1)
+    divisor = in.dimension(1);
+  else if (out.rank() == 1 && in.rank() == 3 && reduction_axes[0] == 0 &&
+           reduction_axes[1] == 2)
+    divisor = in.dimension(0) * in.dimension(2);
+  else if (out.rank() == 2 && in.rank() == 3 && reduction_axes[0] == 1)
+    divisor = in.dimension(1);
+  DividesBy<float, T> div_op(divisor);
+
+  typedef gpuprim::TransformInputIterator<float, HalfToFloat<T>, T*>
+      inputIterType;
+  inputIterType input_itr((T*)in.data(), HalfToFloat<T>());
+
+  typedef TransformOutputIterator<T, float, DividesBy<float, T>> outputIterType;
+  outputIterType itr((T*)out.data(), div_op);
+
+  ReduceImpl<float, gpuprim::Sum, outputIterType, inputIterType, ReductionAxes>(
+      ctx, itr, input_itr, in.rank(), in.dimension(0),
+      in.rank() >= 2 ? in.dimension(1) : 1,
+      in.rank() >= 3 ? in.dimension(2) : 1, out.rank(), reduction_axes,
+      gpuprim::Sum());
+}
+
+template <>
+struct ReduceFunctor<GPUDevice, functor::MeanReducer<Eigen::half>> {
+  template <typename OUT_T, typename IN_T, typename ReductionAxes>
+  static void Reduce(OpKernelContext* ctx, OUT_T out, IN_T in,
+                     const ReductionAxes& reduction_axes,
+                     const functor::MeanReducer<Eigen::half>& reducer) {
+    ReduceMeanWithFloatAccumulationImpl(ctx, out, in, reduction_axes, reducer);
+  }
+
+  template <typename OUT_T>
+  static void FillIdentity(const GPUDevice& d, OUT_T out,
+                           const functor::MeanReducer<Eigen::half>& reducer) {
+    FillIdentityEigenImpl(d, out, reducer);
+  }
+};
+
+template <>
+struct ReduceFunctor<GPUDevice, functor::MeanReducer<Eigen::bfloat16>> {
+  template <typename OUT_T, typename IN_T, typename ReductionAxes>
+  static void Reduce(OpKernelContext* ctx, OUT_T out, IN_T in,
+                     const ReductionAxes& reduction_axes,
+                     const functor::MeanReducer<Eigen::bfloat16>& reducer) {
+    ReduceMeanWithFloatAccumulationImpl(ctx, out, in, reduction_axes, reducer);
+  }
+
+  template <typename OUT_T>
+  static void FillIdentity(
+      const GPUDevice& d, OUT_T out,
+      const functor::MeanReducer<Eigen::bfloat16>& reducer) {
+    FillIdentityEigenImpl(d, out, reducer);
+  }
+};
+
+template <typename T>
+struct ReduceFunctor<GPUDevice,
+                     Eigen::internal::MaxReducer<T, Eigen::PropagateNaN>> {
+  template <typename OUT_T, typename IN_T, typename ReductionAxes>
+  static void Reduce(
+      OpKernelContext* ctx, OUT_T out, IN_T in,
+      const ReductionAxes& reduction_axes,
+      const Eigen::internal::MaxReducer<T, Eigen::PropagateNaN>& reducer) {
+    ReduceImpl<T, MaxPropagateNaN, T*, T*, ReductionAxes>(
+        ctx, (T*)out.data(), (T*)in.data(), in.rank(), in.dimension(0),
+        in.rank() >= 2 ? in.dimension(1) : 1,
+        in.rank() >= 3 ? in.dimension(2) : 1, out.rank(), reduction_axes,
+        MaxPropagateNaN());
+  }
+
+  template <typename OUT_T>
+  static void FillIdentity(
+      const GPUDevice& d, OUT_T out,
+      const Eigen::internal::MaxReducer<T, Eigen::PropagateNaN>& reducer) {
+    FillIdentityEigenImpl(d, out, reducer);
+  }
+};
+
+template <typename T>
+struct ReduceFunctor<GPUDevice,
+                     Eigen::internal::MinReducer<T, Eigen::PropagateNaN>> {
+  template <typename OUT_T, typename IN_T, typename ReductionAxes>
+  static void Reduce(
+      OpKernelContext* ctx, OUT_T out, IN_T in,
+      const ReductionAxes& reduction_axes,
+      const Eigen::internal::MinReducer<T, Eigen::PropagateNaN>& reducer) {
+    ReduceImpl<T, MinPropagateNaN, T*, T*, ReductionAxes>(
+        ctx, (T*)out.data(), (T*)in.data(), in.rank(), in.dimension(0),
+        in.rank() >= 2 ? in.dimension(1) : 1,
+        in.rank() >= 3 ? in.dimension(2) : 1, out.rank(), reduction_axes,
+        MinPropagateNaN());
+  }
+
+  template <typename OUT_T>
+  static void FillIdentity(
+      const GPUDevice& d, OUT_T out,
+      const Eigen::internal::MinReducer<T, Eigen::PropagateNaN>& reducer) {
+    FillIdentityEigenImpl(d, out, reducer);
+  }
+};
+
+template <typename T>
+struct ReduceFunctor<GPUDevice, Eigen::internal::ProdReducer<T>> {
+  template <typename OUT_T, typename IN_T, typename ReductionAxes>
+  static void Reduce(OpKernelContext* ctx, OUT_T out, IN_T in,
+                     const ReductionAxes& reduction_axes,
+                     const Eigen::internal::ProdReducer<T>& reducer) {
+    ReduceImpl<T, Prod<T>, T*, T*, ReductionAxes>(
+        ctx, (T*)out.data(), (T*)in.data(), in.rank(), in.dimension(0),
+        in.rank() >= 2 ? in.dimension(1) : 1,
+        in.rank() >= 3 ? in.dimension(2) : 1, out.rank(), reduction_axes,
+        Prod<T>());
+  }
+
+  template <typename OUT_T>
+  static void FillIdentity(const GPUDevice& d, OUT_T out,
+                           const Eigen::internal::ProdReducer<T>& reducer) {
+    FillIdentityEigenImpl(d, out, reducer);
+  }
+};
+
+template <>
+struct ReduceFunctor<GPUDevice, Eigen::internal::AndReducer> {
+  template <typename OUT_T, typename IN_T, typename ReductionAxes>
+  static void Reduce(OpKernelContext* ctx, OUT_T out, IN_T in,
+                     const ReductionAxes& reduction_axes,
+                     const Eigen::internal::AndReducer& reducer) {
+    ReduceImpl<bool, And, bool*, bool*, ReductionAxes>(
+        ctx, (bool*)out.data(), (bool*)in.data(), in.rank(), in.dimension(0),
+        in.rank() >= 2 ? in.dimension(1) : 1,
+        in.rank() >= 3 ? in.dimension(2) : 1, out.rank(), reduction_axes,
+        And());
+  }
+
+  template <typename OUT_T>
+  static void FillIdentity(const GPUDevice& d, OUT_T out,
+                           const Eigen::internal::AndReducer& reducer) {
+    FillIdentityEigenImpl(d, out, reducer);
+  }
+};
+
+template <>
+struct ReduceFunctor<GPUDevice, Eigen::internal::OrReducer> {
+  template <typename OUT_T, typename IN_T, typename ReductionAxes>
+  static void Reduce(OpKernelContext* ctx, OUT_T out, IN_T in,
+                     const ReductionAxes& reduction_axes,
+                     const Eigen::internal::OrReducer& reducer) {
+    ReduceImpl<bool, Or, bool*, bool*, ReductionAxes>(
+        ctx, (bool*)out.data(), (bool*)in.data(), in.rank(), in.dimension(0),
+        in.rank() >= 2 ? in.dimension(1) : 1,
+        in.rank() >= 3 ? in.dimension(2) : 1, out.rank(), reduction_axes, Or());
+  }
+
+  template <typename OUT_T>
+  static void FillIdentity(const GPUDevice& d, OUT_T out,
+                           const Eigen::internal::OrReducer& reducer) {
+    FillIdentityEigenImpl(d, out, reducer);
+  }
+};
+
+}  // namespace functor
+}  // namespace tensorflow
+
+#endif  // GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+
+#endif  // TENSORFLOW_CORE_KERNELS_REDUCTION_GPU_KERNELS_CU_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/reduction_ops.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/reduction_ops.h
new file mode 100644
index 0000000000000000000000000000000000000000..de32243a013ad6e6c30b0739ece717d1cce6bae5
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/reduction_ops.h
@@ -0,0 +1,206 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_REDUCTION_OPS_H_
+#define TENSORFLOW_CORE_KERNELS_REDUCTION_OPS_H_
+
+// Functor definitions for Reduction ops, must be compilable by nvcc.
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/tensor_types.h"
+
+namespace tensorflow {
+namespace functor {
+
+template <typename Reducer>
+struct ReducerTraits {
+  enum { IsScalarIdentity = true };
+};
+
+// Dummy class used for template specialization for mean reduction, which is
+// accomplished by SumReducer and on-the-fly division by the reduction factor.
+template <typename Scalar>
+struct MeanReducer {
+  Scalar initialize() const { return Scalar(0); }
+};
+
+// Dummy class used for template specialization for l2-norm reduction.
+template <typename Scalar>
+struct EuclideanNormReducer {
+  Scalar initialize() const { return Scalar(0); }
+};
+
+template <typename Scalar>
+struct ReducerTraits<EuclideanNormReducer<Scalar>> {
+  enum { IsScalarIdentity = false };
+};
+
+template <typename Device, typename OUT_T, typename IN_T,
+          typename ReductionAxes, typename Reducer>
+struct ReduceEigenImpl {
+  void operator()(const Device& d, OUT_T out, IN_T in,
+                  const ReductionAxes& reduction_axes, const Reducer& reducer) {
+    out.device(d) = in.reduce(reduction_axes, reducer);
+  }
+};
+
+// Specialization for BF16 Reducer to fix accuracy.
+// TODO: All BF16 reducers should have specializations to fix accuracy.
+#define CASTING_SPECIALIZATION(Reducer, ScalarType, IntermediateType)        \
+  template <typename Device, typename OUT_T, typename IN_T,                  \
+            typename ReductionAxes>                                          \
+  struct ReduceEigenImpl<Device, OUT_T, IN_T, ReductionAxes,                 \
+                         Reducer<ScalarType>> {                              \
+    void operator()(const Device& d, OUT_T out, IN_T in,                     \
+                    const ReductionAxes& reduction_axes,                     \
+                    const Reducer<ScalarType>& reducer) {                    \
+      static_assert(std::is_same<ScalarType, typename OUT_T::Scalar>::value, \
+                    "");                                                     \
+      Reducer<IntermediateType> intermediate_reducer;                        \
+      auto in_as_intermediate = in.template cast<IntermediateType>();        \
+      out.device(d) =                                                        \
+          in_as_intermediate.reduce(reduction_axes, intermediate_reducer)    \
+              .template cast<ScalarType>();                                  \
+    }                                                                        \
+  };
+
+CASTING_SPECIALIZATION(Eigen::internal::SumReducer, bfloat16, float);
+#undef CASTING_SPECIALIZATION
+
+template <typename Device, typename OUT_T, typename IN_T,
+          typename ReductionAxes, typename Scalar>
+struct ReduceEigenImpl<Device, OUT_T, IN_T, ReductionAxes,
+                       functor::MeanReducer<Scalar>> {
+  void operator()(const Device& d, OUT_T out, IN_T in,
+                  const ReductionAxes& reduction_axes,
+                  const functor::MeanReducer<Scalar>& reducer) {
+    static_assert(std::is_same<Scalar, typename OUT_T::Scalar>::value, "");
+    Eigen::internal::SumReducer<Scalar> sum_reducer;
+    out.device(d) = in.reduce(reduction_axes, sum_reducer) /
+                    static_cast<Scalar>(in.size() / out.size());
+  }
+};
+
+// Specialization for which we do the reduction in IntermediateType to
+// avoid integer overflow.
+#define CASTING_SPECIALIZATION(ScalarType, IntermediateType)                  \
+  template <typename Device, typename OUT_T, typename IN_T,                   \
+            typename ReductionAxes>                                           \
+  struct ReduceEigenImpl<Device, OUT_T, IN_T, ReductionAxes,                  \
+                         functor::MeanReducer<ScalarType>> {                  \
+    void operator()(const Device& d, OUT_T out, IN_T in,                      \
+                    const ReductionAxes& reduction_axes,                      \
+                    const functor::MeanReducer<ScalarType>& reducer) {        \
+      static_assert(std::is_same<ScalarType, typename OUT_T::Scalar>::value,  \
+                    "");                                                      \
+      Eigen::internal::SumReducer<IntermediateType> sum_reducer;              \
+      out.device(d) = (in.template cast<IntermediateType>().reduce(           \
+                           reduction_axes, sum_reducer) /                     \
+                       static_cast<IntermediateType>(in.size() / out.size())) \
+                          .template cast<ScalarType>();                       \
+    }                                                                         \
+  }
+
+CASTING_SPECIALIZATION(uint8, uint64);
+CASTING_SPECIALIZATION(uint16, uint64);
+CASTING_SPECIALIZATION(uint32, uint64);
+CASTING_SPECIALIZATION(int8, int64_t);
+CASTING_SPECIALIZATION(int16, int64_t);
+CASTING_SPECIALIZATION(int32, int64_t);
+#undef CASTING_SPECIALIZATION
+
+// TODO(rmlarsen): Refactor this such that taking the sqrt can be optional
+// controlled by an attribute.
+template <typename Device, typename OUT_T, typename IN_T,
+          typename ReductionAxes, typename Scalar>
+struct ReduceEigenImpl<Device, OUT_T, IN_T, ReductionAxes,
+                       functor::EuclideanNormReducer<Scalar>> {
+  void operator()(const Device& d, OUT_T out, IN_T in,
+                  const ReductionAxes& reduction_axes,
+                  const functor::EuclideanNormReducer<Scalar>& reducer) {
+    static_assert(std::is_same<Scalar, typename OUT_T::Scalar>::value, "");
+    Eigen::internal::SumReducer<Scalar> sum_reducer;
+    out.device(d) =
+        (in * in.conjugate()).reduce(reduction_axes, sum_reducer).sqrt();
+  }
+};
+
+template <typename Device, typename OUT_T, typename IN_T,
+          typename ReductionAxes>
+struct ReduceEigenImpl<Device, OUT_T, IN_T, ReductionAxes,
+                       functor::EuclideanNormReducer<bfloat16>> {
+  void operator()(const Device& d, OUT_T out, IN_T in,
+                  const ReductionAxes& reduction_axes,
+                  const functor::EuclideanNormReducer<bfloat16>& reducer) {
+    static_assert(std::is_same<bfloat16, typename OUT_T::Scalar>::value, "");
+    Eigen::internal::SumReducer<float> sum_reducer;
+    auto in_as_float = in.template cast<float>();
+    out.device(d) = (in_as_float * in_as_float.conjugate())
+                        .reduce(reduction_axes, sum_reducer)
+                        .sqrt()
+                        .template cast<bfloat16>();
+  }
+};
+
+// For most reducers, the identity is Reducer::initialize()
+template <typename Reducer>
+struct Identity {
+  static auto identity(const Reducer& reducer)
+      -> decltype(reducer.initialize()) {
+    return reducer.initialize();
+  }
+};
+
+// MeanReducer is a special case, since it doesn't technically have an identity.
+// Thus, ideally we'd return nan.  However, mean is instantiated for integer
+// types as well, so we do the nan override only for floating point types.
+#define FIX_MEAN_IDENTITY(T)                            \
+  template <>                                           \
+  struct Identity<functor::MeanReducer<T>> {            \
+    static T identity(const functor::MeanReducer<T>&) { \
+      return Eigen::NumTraits<T>::quiet_NaN();          \
+    }                                                   \
+  };
+FIX_MEAN_IDENTITY(Eigen::half)
+FIX_MEAN_IDENTITY(Eigen::bfloat16)
+FIX_MEAN_IDENTITY(float)
+FIX_MEAN_IDENTITY(double)
+#undef FIX_MEAN_IDENTITY
+
+template <typename Device, typename OUT_T, typename Reducer>
+void FillIdentityEigenImpl(const Device& d, OUT_T out, const Reducer& reducer) {
+  MaybeWith32BitIndexing<Device>(
+      [&](auto out32) {
+        out32.device(d) = out32.constant(Identity<Reducer>::identity(reducer));
+      },
+      out);
+}
+
+template <typename Device, typename Reducer>
+struct ReduceFunctor {
+  template <typename OUT_T, typename IN_T, typename ReductionAxes>
+  static void Reduce(OpKernelContext* ctx, OUT_T out, IN_T in,
+                     const ReductionAxes& reduction_axes,
+                     const Reducer& reducer);
+
+  template <typename OUT_T>
+  static void FillIdentity(const Device& d, OUT_T out, const Reducer& reducer);
+};
+
+}  // namespace functor
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_REDUCTION_OPS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/reduction_ops_common.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/reduction_ops_common.h
new file mode 100644
index 0000000000000000000000000000000000000000..0ffc638eda175db14b55e427b5f973d853eb5e08
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/reduction_ops_common.h
@@ -0,0 +1,278 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// This is an internal header file intended to only be included as the
+// front-matter in the implementation files of various reduction ops.  It
+// is a header file because we split the various reduction ops into their
+// own compilation units to get more parallelism in compilation.
+
+#ifndef TENSORFLOW_CORE_KERNELS_REDUCTION_OPS_COMMON_H_
+#define TENSORFLOW_CORE_KERNELS_REDUCTION_OPS_COMMON_H_
+
+#define EIGEN_USE_THREADS
+
+#include "Eigen/Core"  // from @eigen_archive
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+
+#include "tensorflow/core/framework/numeric_op.h"
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/register_types.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/kernels/reduction_ops.h"
+#include "tensorflow/core/kernels/transpose_functor.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/lib/gtl/inlined_vector.h"
+#include "tensorflow/core/platform/logging.h"
+
+namespace tensorflow {
+
+typedef Eigen::ThreadPoolDevice CPUDevice;
+typedef Eigen::GpuDevice GPUDevice;
+
+template <typename Device>
+struct Constants {
+  // Derive Index type. int (32-bit) or long (64-bit) depending on the
+  // compile-time configuration. "float" here is not relevant.
+  // TODO(zhifengc): Moves the definition to TTypes.
+  typedef TTypes<float>::Tensor::Index Index;
+  Eigen::array<Index, 1> kZero;
+  Eigen::array<Index, 1> kOne;
+  Eigen::array<Index, 2> kZeroTwo;
+
+  Constants() {
+    kZero[0] = 0;
+    kOne[0] = 1;
+    kZeroTwo[0] = 0;
+    kZeroTwo[1] = 2;
+  }
+};
+
+struct ConstantsBase {
+  const Eigen::IndexList<Eigen::type2index<0>> kZero;
+  const Eigen::IndexList<Eigen::type2index<1>> kOne;
+  const Eigen::IndexList<Eigen::type2index<0>, Eigen::type2index<2>> kZeroTwo;
+};
+template <>
+struct Constants<CPUDevice> : ConstantsBase {};
+
+class ReductionHelper {
+ public:
+  ReductionHelper() : reduce_first_axis_(false) {}
+
+  Status Simplify(const Tensor& data, const Tensor& axis, const bool keep_dims);
+
+  // We need to do roughly:
+  //   tmp_out = allocate(out_reshape())
+  //   tmp_out.reshape(out_reshape) = data.reshape(data_reshape).reduce(axes)
+  //   out = tmp_out.reshape(out_shape)
+
+  // The reduction result must be allocated with this shape.
+  TensorShape out_reshape() const;
+
+  // The final output shape must be allocated with this shape.
+  TensorShape out_shape() const;
+
+  // The reduction is on a reshaped tensor of this rank.
+  int ndims() const { return data_reshape_.size(); }
+
+  // True if need to reduce the 0-th dimension.
+  bool reduce_first_axis() const { return reduce_first_axis_; }
+
+  // The output is reshaped.
+  template <typename T, int N>
+  typename TTypes<T, N>::Tensor out(Tensor* out) {
+    return out->shaped<T, N>(out_reshape_);
+  }
+
+  // The input is reshaped.
+  template <typename T, int N>
+  typename TTypes<T, N>::ConstTensor in(const Tensor& data) {
+    return data.shaped<T, N>(data_reshape_);
+  }
+
+  // Shape of shuffled input
+  TensorShape data_reshape() const {
+    TensorShape shape;
+    for (auto s : data_reshape_) shape.AddDim(s);
+    return shape;
+  }
+
+  // Shape with all reduction dimensions at the end
+  TensorShape shuffled_shape();
+
+  // Permutation of reduced dims needed to put reduction dimensions at the end
+  gtl::InlinedVector<int32, 8> permutation();
+
+ private:
+  bool reduce_first_axis_;  // True if need to reduce the 0-th dimension.
+  gtl::InlinedVector<int64_t, 4>
+      data_reshape_;                          // Reshape data before reduction.
+  gtl::InlinedVector<int64_t, 4> out_shape_;  // The final output shape.
+  gtl::InlinedVector<int64_t, 4> out_reshape_;  // Reshape output for reduction.
+};
+
+// For operations where the output is a reduction function along some
+// dimensions of the input.
+template <typename Device, class T, typename Tperm, typename Reducer>
+class ReductionOp : public OpKernel {
+ public:
+  explicit ReductionOp(OpKernelConstruction* ctx) : OpKernel(ctx) {
+    const DataType dt = DataTypeToEnum<T>::v();
+    const DataType pt = DataTypeToEnum<Tperm>::v();
+    OP_REQUIRES_OK(ctx, ctx->MatchSignature({dt, pt}, {dt}));
+
+    OP_REQUIRES_OK(ctx, ctx->GetAttr("keep_dims", &keep_dims_));
+  }
+
+  void Compute(OpKernelContext* ctx) override {
+    const Tensor& data = ctx->input(0);
+    const Tensor& axes = ctx->input(1);
+    VLOG(1) << "data shape: " << data.shape().DebugString();
+    VLOG(1) << "axes      : " << axes.SummarizeValue(10);
+
+    ReductionHelper helper;
+    OP_REQUIRES_OK(ctx, helper.Simplify(data, axes, keep_dims_));
+    CHECK_GE(helper.ndims(), 0);
+
+    bool is_scalar_identity = functor::ReducerTraits<Reducer>::IsScalarIdentity;
+    bool is_trivial = helper.ndims() == 0 ||
+                      (helper.ndims() == 1 && !helper.reduce_first_axis());
+    if (is_scalar_identity && is_trivial) {
+      Tensor out;
+      // Special case. Reduces nothing and does not alter the input values.
+      if (!out.CopyFrom(data, helper.out_shape())) {
+        ctx->SetStatus(errors::Internal("Error during reduction copy."));
+      }
+      ctx->set_output(0, out);
+      return;
+    }
+
+    // We must allocate temp tensors using the same alloc attr as
+    // output(0) because it is returned as output(0) in the end.
+    const AllocatorAttributes alloc_attr = ctx->output_alloc_attr(0);
+
+    Tensor tmp_out;
+    typedef functor::ReduceFunctor<Device, Reducer> Functor;
+    Constants<Device> constants;
+    const Device& d = ctx->eigen_device<Device>();
+    Reducer reducer;
+
+    if (data.NumElements() > 0 && is_trivial && !is_scalar_identity) {
+      OP_REQUIRES_OK(ctx, ctx->allocate_temp(ctx->expected_output_dtype(0),
+                                             TensorShape({data.NumElements()}),
+                                             &tmp_out, alloc_attr));
+      Functor::Reduce(ctx, tmp_out.flat<T>(),
+                      data.shaped<T, 2>({1, data.NumElements()}),
+                      constants.kZero, reducer);
+    } else {
+      // A temporary tensor whose size matches the size of the reduced
+      // output.
+      OP_REQUIRES_OK(
+          ctx, ctx->allocate_temp(ctx->expected_output_dtype(0),
+                                  helper.out_reshape(), &tmp_out, alloc_attr));
+
+      if (tmp_out.NumElements() == 0) {
+        // Nothing to do, fall through to final reshaping.
+      } else if (data.NumElements() == 0) {
+        // Degenerate reduction where the input is empty but the output is
+        // nonempty (thus tmp_out.NumElements() > 0), and we must fill the
+        // output with identity elements.  Example: tf.reduce_sum(tf.zeros((0,
+        // 3)), [0]). Eigen sometimes crashes in this case, so we do it
+        // manually.
+        Functor::FillIdentity(d, tmp_out.flat<T>(), reducer);
+      } else if ((helper.ndims() == 1) && helper.reduce_first_axis()) {
+        // Reduce to a scalar.
+        Functor::Reduce(ctx, helper.out<T, 0>(&tmp_out), helper.in<T, 1>(data),
+                        constants.kZero, reducer);
+      } else if ((helper.ndims() == 2) && helper.reduce_first_axis()) {
+        // Can be viewed as a reduction of a matrix along 1st dimension.
+        Functor::Reduce(ctx, helper.out<T, 1>(&tmp_out), helper.in<T, 2>(data),
+                        constants.kZero, reducer);
+      } else if ((helper.ndims() == 2) && !helper.reduce_first_axis()) {
+        // Can be viewed as a reduction of a matrix along 2nd dimension.
+        Functor::Reduce(ctx, helper.out<T, 1>(&tmp_out), helper.in<T, 2>(data),
+                        constants.kOne, reducer);
+      } else if ((helper.ndims() == 3) && helper.reduce_first_axis()) {
+        // Can be viewed as a reduction of a 3D tensor along 1st and 3rd
+        // dimensions.
+        Functor::Reduce(ctx, helper.out<T, 1>(&tmp_out), helper.in<T, 3>(data),
+                        constants.kZeroTwo, reducer);
+      } else if ((helper.ndims() == 3) && !helper.reduce_first_axis()) {
+        // Can be viewed as a reduction of a 3D tensor along 2nd dimension.
+        Functor::Reduce(ctx, helper.out<T, 2>(&tmp_out), helper.in<T, 3>(data),
+                        constants.kOne, reducer);
+      } else {
+        // If we don't hit one of the cases above, transpose the data so that
+        // all reduced dimensions are last and reuse the 2-D -> 1-D case.
+        Tensor data_reshaped;
+        OP_REQUIRES(ctx, data_reshaped.CopyFrom(data, helper.data_reshape()),
+                    errors::Internal("Error during reduction copy."));
+        Tensor shuffled;
+        OP_REQUIRES_OK(ctx, ctx->allocate_temp(DataTypeToEnum<T>::value,
+                                               helper.shuffled_shape(),
+                                               &shuffled, alloc_attr));
+        OP_REQUIRES_OK(ctx, DoTranspose(d, data_reshaped, helper.permutation(),
+                                        &shuffled));
+        const int64_t unreduced = tmp_out.NumElements();
+        const int64_t reduced = shuffled.NumElements() / unreduced;
+        const Tensor& const_shuffled = shuffled;
+        Functor::Reduce(ctx, tmp_out.flat<T>(),
+                        const_shuffled.shaped<T, 2>({unreduced, reduced}),
+                        constants.kOne, reducer);
+      }
+    }
+
+    // Set the real output using the contents of the reduction but the
+    // real expected output shape.  The number of elements should
+    // match between the two shapes.
+    Tensor out;
+    OP_REQUIRES(ctx, out.CopyFrom(tmp_out, helper.out_shape()),
+                errors::Internal("Error during reduction copy."));
+    ctx->set_output(0, out);
+  }
+
+ private:
+  // True if the number of dimensions should be maintained.
+  bool keep_dims_;
+};
+
+namespace functor {
+
+template <typename Device, typename Reducer>
+struct ReduceFunctorBase {
+  template <typename OUT_T, typename IN_T, typename ReductionAxes>
+  static void Reduce(OpKernelContext* ctx, OUT_T out, IN_T in,
+                     const ReductionAxes& reduction_axes,
+                     const Reducer& reducer) {
+    const Device& d = ctx->eigen_device<Device>();
+    ReduceEigenImpl<Device, OUT_T, IN_T, ReductionAxes, Reducer> reducer_impl;
+    reducer_impl(d, out, in, reduction_axes, reducer);
+  }
+
+  template <typename OUT_T>
+  static void FillIdentity(const Device& d, OUT_T out, const Reducer& reducer) {
+    FillIdentityEigenImpl(d, out, reducer);
+  }
+};
+
+template <typename Reducer>
+struct ReduceFunctor<CPUDevice, Reducer>
+    : ReduceFunctorBase<CPUDevice, Reducer> {};
+
+}  // namespace functor
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_REDUCTION_OPS_COMMON_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/reduction_ops_common_gpu.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/reduction_ops_common_gpu.h
new file mode 100644
index 0000000000000000000000000000000000000000..b7bdb07c3b77b4bf94caa6c614d686b94b42596b
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/reduction_ops_common_gpu.h
@@ -0,0 +1,44 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_KERNELS_REDUCTION_OPS_COMMON_GPU_H_
+#define TENSORFLOW_CORE_KERNELS_REDUCTION_OPS_COMMON_GPU_H_
+
+#if !GOOGLE_CUDA && !TENSORFLOW_USE_ROCM
+#error This file must only be included when building with GPU support
+#endif
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/tensor_types.h"
+
+namespace tensorflow {
+namespace functor {
+
+template <typename Reducer>
+struct ReduceFunctor<Eigen::GpuDevice, Reducer> {
+  template <typename OUT_T, typename IN_T, typename ReductionAxes>
+  static void Reduce(OpKernelContext* ctx, OUT_T out, IN_T in,
+                     const ReductionAxes& reduction_axes,
+                     const Reducer& reducer);
+
+  template <typename OUT_T>
+  static void FillIdentity(const Eigen::GpuDevice& d, OUT_T out,
+                           const Reducer& reducer);
+};
+
+}  // namespace functor
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_REDUCTION_OPS_COMMON_GPU_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/redux_functor.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/redux_functor.h
new file mode 100644
index 0000000000000000000000000000000000000000..41ab917a746787dafe89bd8c09ecc12fab3e6535
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/redux_functor.h
@@ -0,0 +1,337 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_REDUX_FUNCTOR_H_
+#define TENSORFLOW_CORE_KERNELS_REDUX_FUNCTOR_H_
+
+#define EIGEN_USE_THREADS
+
+#include "Eigen/Core"  // from @eigen_archive
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/tensor_types.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+
+using CPUDevice = Eigen::ThreadPoolDevice;
+
+namespace functor {
+
+// Compute reduction over outer dimensions.
+// Example:
+//   input: [D1, D2, ... , DN]
+//   ->
+//   output: [Di, ... , DN] where i belongs to set [1,N]
+template <typename InputT, typename AccumT, typename OutputT,
+          typename BinaryFunctor>
+struct ReduceOuterDimensions {
+  ReduceOuterDimensions() {}
+
+  template <int num_dims>
+  void operator()(const CPUDevice& device,
+                  const Eigen::DSizes<Eigen::Index, num_dims>& input_dims,
+                  const Tensor& input, Tensor* output) const {
+    // Compute inner and outer dim after reshaping into 2d tensor.
+    const int num_output_dims = output->dims();
+    auto output_dims = output->template flat<OutputT>().dimensions();
+
+    Eigen::Index inner_dim = 1, outer_dim = 1;
+    for (int i = 0; i < num_dims - num_output_dims; ++i)
+      outer_dim *= input_dims[i];
+    for (int i = num_dims - num_output_dims; i < num_dims; ++i)
+      inner_dim *= input_dims[i];
+
+    if (1 == outer_dim) {
+      // Nothing to do but passing input to output.
+      output->template flat<OutputT>() =
+          input.template flat<InputT>().template cast<OutputT>().reshape(
+              output_dims);
+      return;
+    }
+
+    // Get device thread num.
+    const Eigen::Index num_threads = device.numThreads();
+
+    // If the inner dim parallelism is large enough
+    // TODO(ezhulenev): There seems to be no benefits in going this route. Check
+    // if this can be improved, or use better heuristic?
+    if (inner_dim > num_threads * 32) {
+      // Do not create more blocks than there are threads in a pool.
+      const Eigen::Index num_blocks = num_threads;
+
+      // Block size along the outer dimension.
+      const Eigen::Index inner_block_size = Eigen::divup(inner_dim, num_blocks);
+      const InputT* input_data = input.template flat<InputT>().data();
+
+      // Allocate temporary buffer for partial reductions.
+      Eigen::Tensor<AccumT, 1, Eigen::RowMajor, Eigen::Index> buffer(
+          {inner_dim});
+      buffer.setZero();
+      AccumT* buffer_data = buffer.data();
+
+      using Buffer = Eigen::TensorMap<
+          Eigen::Tensor<AccumT, 1, Eigen::RowMajor, Eigen::Index>,
+          Eigen::Unaligned>;
+
+      using Input = Eigen::TensorMap<
+          Eigen::Tensor<const InputT, 1, Eigen::RowMajor, Eigen::Index>,
+          Eigen::Unaligned>;
+
+      const auto compute = [inner_dim, outer_dim, num_blocks, inner_block_size,
+                            input_data, buffer_data](
+                               Eigen::Index start, Eigen::Index limit) -> void {
+        DCHECK(start >= 0 && limit <= num_blocks);
+        Eigen::Index inner_dim_start = start * inner_block_size;
+        Eigen::Index inner_dim_limit = limit * inner_block_size;
+        inner_dim_limit = std::min(inner_dim, inner_dim_limit);
+        Eigen::Index my_job_len = inner_dim_limit - inner_dim_start;
+
+        const InputT* my_job_start = input_data + inner_dim_start;
+        Buffer buf(buffer_data + inner_dim_start, my_job_len);
+
+        for (Eigen::Index i = 0; i < outer_dim; ++i) {
+          auto in = Input(my_job_start + i * inner_dim, my_job_len);
+          auto cast = in.template cast<AccumT>();
+          buf = Eigen::TensorCwiseBinaryOp<BinaryFunctor, const decltype(buf),
+                                           const decltype(cast)>(buf, cast);
+        }
+      };
+
+      // Compute cost of reducing a single block.
+      const Eigen::Index compute_size = outer_dim * inner_block_size;
+      const Eigen::Index compute_input_bytes = compute_size * sizeof(InputT);
+      const Eigen::TensorOpCost cost(
+          compute_input_bytes,
+          0,  // We'll be mostly writing to L1, assume store cost is 0
+          compute_size * Eigen::internal::functor_traits<BinaryFunctor>::Cost);
+
+      device.parallelFor(num_blocks, cost, compute);
+
+      // Write final result to the output.
+      output->template flat<OutputT>() =
+          buffer.template cast<OutputT>().reshape(output_dims);
+    } else {
+      // Compute block size along the outer dimension for efficiency.
+      const Eigen::Index parallel_cell_size = inner_dim;
+      const Eigen::Index total_workload = outer_dim * inner_dim;
+      const Eigen::Index max_parallelism = total_workload / parallel_cell_size;
+
+      const Eigen::Index min_block_workload = 2000;
+      const Eigen::Index min_block_size =
+          Eigen::divup(min_block_workload, parallel_cell_size);
+      const Eigen::Index max_num_blocks = std::min(
+          max_parallelism, Eigen::divup(total_workload, min_block_size));
+
+      // Do not create more blocks than there are threads in a pool.
+      const Eigen::Index num_blocks = std::min(max_num_blocks, num_threads);
+
+      // Block size along the outer dimension.
+      const Eigen::Index outer_block_size = Eigen::divup(outer_dim, num_blocks);
+
+      const InputT* input_data = input.template flat<InputT>().data();
+
+      // Allocate temporary buffer for partial reductions.
+      Tensor buffer(DataTypeToEnum<AccumT>::v(), {num_blocks, inner_dim});
+      buffer.template flat<AccumT>().setZero();
+      AccumT* buffer_data = buffer.template flat<AccumT>().data();
+
+      using Buffer = Eigen::TensorMap<
+          Eigen::Tensor<AccumT, 1, Eigen::RowMajor, Eigen::Index>,
+          Eigen::Unaligned>;
+
+      using Input = Eigen::TensorMap<
+          Eigen::Tensor<const InputT, 1, Eigen::RowMajor, Eigen::Index>,
+          Eigen::Unaligned>;
+
+      const auto compute = [inner_dim, num_blocks, outer_block_size,
+                            buffer_data, input_data, outer_dim](
+                               Eigen::Index start, Eigen::Index limit) -> void {
+        DCHECK(start >= 0 && limit <= num_blocks);
+        Eigen::Index outer_dim_start = start * outer_block_size;
+        Eigen::Index outer_dim_limit = limit * outer_block_size;
+        outer_dim_limit = std::min(outer_dim, outer_dim_limit);
+
+        Buffer buf(buffer_data + start * inner_dim, inner_dim);
+        for (Eigen::Index i = outer_dim_start; i < outer_dim_limit; ++i) {
+          auto in = Input(input_data + i * inner_dim, inner_dim);
+          auto cast = in.template cast<AccumT>();
+          buf = Eigen::TensorCwiseBinaryOp<BinaryFunctor, const decltype(buf),
+                                           const decltype(cast)>(buf, cast);
+        }
+      };
+
+      // Compute cost of reducing a single block.
+      const Eigen::Index compute_size = outer_block_size * inner_dim;
+      const Eigen::Index compute_input_bytes = compute_size * sizeof(InputT);
+      const Eigen::TensorOpCost cost(
+          compute_input_bytes,
+          0,  // We'll be mostly writing to L1, assume store cost is 0
+          compute_size * Eigen::internal::functor_traits<BinaryFunctor>::Cost);
+
+      device.parallelFor(num_blocks, cost, compute);
+
+      // Aggregate partial results from temporary buffer into first block.
+      auto buf0 = Buffer(buffer_data, inner_dim);
+      // Just sum the buffer up, as inner dimensions is not large in this case.
+      for (int i = 1; i < num_blocks; ++i) {
+        auto buf = Buffer(buffer_data + i * inner_dim, inner_dim);
+        buf0 = Eigen::TensorCwiseBinaryOp<BinaryFunctor, const decltype(buf0),
+                                          const decltype(buf)>(buf0, buf);
+      }
+      // Write final result to the output.
+      output->template flat<OutputT>() =
+          buf0.template cast<OutputT>().reshape(output_dims);
+    }
+  }
+};
+
+// Compute reduction to some serial middle dimensions (like a axis).
+// Example:
+//   input: [D1, D2, ... , DN]
+//   ->
+//   output: [Di, ... , Dj] where i & j belongs to set [1,N].
+template <typename InputT, typename AccumT, typename OutputT,
+          typename BinaryFunctor, typename Reducer>
+struct ReduceMiddleDimensions {
+  ReduceMiddleDimensions() {}
+
+  template <int num_dims>
+  void operator()(const CPUDevice& device,
+                  const Eigen::DSizes<Eigen::Index, num_dims>& input_dims,
+                  const Tensor& input, Tensor* output,
+                  const int axis_begin_dim) const {
+    // Compute dims after reshaping into 3d tensor.
+    const int num_output_dims = output->dims();
+    auto output_dims = output->template flat<OutputT>().dimensions();
+
+    Eigen::Index inner_dim = 1, middle_dim = 1, outer_dim = 1;
+    for (int i = 0; i < axis_begin_dim; ++i) outer_dim *= input_dims[i];
+    for (int i = axis_begin_dim; i < axis_begin_dim + num_output_dims; ++i)
+      middle_dim *= input_dims[i];
+    for (int i = axis_begin_dim + num_output_dims; i < num_dims; ++i)
+      inner_dim *= input_dims[i];
+
+    if ((1 == inner_dim * outer_dim)) {
+      // Nothing to do.
+      output->template flat<OutputT>() =
+          input.template flat<InputT>().template cast<OutputT>().reshape(
+              output_dims);
+      return;
+    }
+
+    // Compute block size along the outer dimension for efficiency.
+    const Eigen::Index parallel_cell_size = inner_dim;
+    const Eigen::Index max_parallelism = outer_dim * middle_dim;
+    const Eigen::Index total_workload = max_parallelism * inner_dim;
+
+    const Eigen::Index min_block_workload = 2000;
+    const Eigen::Index min_block_size =
+        Eigen::divup(min_block_workload, parallel_cell_size);
+    const Eigen::Index max_num_blocks =
+        std::min(max_parallelism, Eigen::divup(total_workload, min_block_size));
+
+    // Do not create more blocks than there are threads in a pool.
+    const Eigen::Index num_threads = device.numThreads();
+    const Eigen::Index num_blocks = std::min(max_num_blocks, num_threads);
+
+    // Block size along the outer dimension.
+    const Eigen::Index outer_block_size =
+        Eigen::divup(total_workload, num_blocks);
+
+    const InputT* input_data = input.template flat<InputT>().data();
+
+    // Allocate temporary buffer for partial reductions.
+    Eigen::Tensor<AccumT, 2> buffer(num_blocks, middle_dim);
+    buffer.setZero();
+    AccumT* buffer_data = buffer.data();
+
+    using Buffer = Eigen::TensorMap<Eigen::Tensor<AccumT, 1>>;
+    using Input = Eigen::TensorMap<Eigen::Tensor<const InputT, 1>>;
+
+    Eigen::array<Eigen::Index, 1> reduction_axis = {0};
+    Reducer reducer;
+    const BinaryFunctor binary_op;
+
+    const auto compute = [inner_dim, middle_dim, input_data, buffer_data,
+                          total_workload, num_blocks, outer_block_size,
+                          reduction_axis, reducer, binary_op](
+                             Eigen::Index start, Eigen::Index limit) -> void {
+      DCHECK(start >= 0 && limit <= num_blocks);
+      Eigen::Index block_start = start * outer_block_size;
+      Eigen::Index block_limit = limit * outer_block_size;
+      block_limit = std::min(total_workload, block_limit);
+      Buffer buf(buffer_data + start * middle_dim, middle_dim);
+
+      const int align_start =
+          ((block_start + inner_dim - 1) / inner_dim) * inner_dim;
+      const int align_end = (block_limit / inner_dim) * inner_dim;
+
+      Eigen::Index coordinate = block_start / inner_dim % middle_dim;
+      Eigen::Tensor<AccumT, 0> reduced =
+          Input(&input_data[block_start], align_start - block_start)
+              .reduce(reduction_axis, reducer)
+              .template cast<AccumT>();
+
+      buf(coordinate) = binary_op(buf(coordinate), reduced(0));
+
+      coordinate = align_start / inner_dim % middle_dim;
+      for (int i = align_start; i < align_end; i += inner_dim) {
+        reduced = Input(&input_data[i], inner_dim)
+                      .reduce(reduction_axis, reducer)
+                      .template cast<AccumT>();
+        buf(coordinate) = binary_op(buf(coordinate), reduced(0));
+        ++coordinate;
+        if (middle_dim == coordinate) coordinate = 0;
+      }
+
+      reduced = Input(&input_data[align_end], block_limit - align_end)
+                    .reduce(reduction_axis, reducer)
+                    .template cast<AccumT>();
+      buf(coordinate) = binary_op(buf(coordinate), reduced(0));
+    };
+
+    // Compute cost of reducing a single block.
+    const Eigen::Index compute_size = outer_block_size * inner_dim;
+    const Eigen::Index compute_input_bytes = compute_size * sizeof(InputT);
+    const Eigen::TensorOpCost cost(
+        compute_input_bytes,
+        0,  // We'll be mostly writing to L1, assume store cost is 0
+        compute_size * Eigen::internal::functor_traits<BinaryFunctor>::Cost);
+
+    device.parallelFor(num_blocks, cost, compute);
+
+    using Output = Eigen::TensorMap<
+        Eigen::Tensor<AccumT, 1, Eigen::RowMajor, Eigen::Index>,
+        Eigen::Unaligned>;
+    // Aggregate partial results from temporary buffer into first block.
+    auto buf0 = Output(buffer_data, middle_dim);
+    // TODO(ezhulenev): Parallelize this loop for large inner dimensions?
+    for (int i = 1; i < num_blocks; ++i) {
+      auto buf = Output(buffer_data + i * middle_dim, middle_dim);
+      buf0 = Eigen::TensorCwiseBinaryOp<BinaryFunctor, const decltype(buf0),
+                                        const decltype(buf)>(buf0, buf);
+    }
+
+    // Write final result to the output.
+    output->template flat<OutputT>() =
+        buf0.template cast<OutputT>().reshape(output_dims);
+  }
+};
+
+}  // namespace functor
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_REDUX_FUNCTOR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/reference_gemm.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/reference_gemm.h
new file mode 100644
index 0000000000000000000000000000000000000000..9d0bb60ed436b4ff9d6f1876f8d2f8273b59892d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/reference_gemm.h
@@ -0,0 +1,96 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_REFERENCE_GEMM_H_
+#define TENSORFLOW_CORE_KERNELS_REFERENCE_GEMM_H_
+
+#include <stdlib.h>
+
+#include "Eigen/Core"  // from @eigen_archive
+#include "tensorflow/core/platform/types.h"
+
+// This is an unoptimized but debuggable implementation of the GEMM matrix
+// multiply function, used to compare to faster but more opaque versions, or
+// for bit depths or argument combinations that aren't supported by optimized
+// code.
+// It assumes the row-major convention used by TensorFlow, and implements
+// C = A * B, like the standard BLAS GEMM interface. If the transpose flags are
+// true, then the relevant matrix is treated as stored in column-major order.
+
+namespace tensorflow {
+template <class T1, class T2, class T3>
+void ReferenceGemm(bool transpose_a, bool transpose_b, bool transpose_c,
+                   size_t m, size_t n, size_t k, const T1* a, int32_t offset_a,
+                   size_t lda, const T2* b, int32_t offset_b, size_t ldb, T3* c,
+                   int32_t shift_c, int32_t offset_c, int32_t mult_c,
+                   size_t ldc) {
+  int a_i_stride;
+  int a_l_stride;
+  if (transpose_a) {
+    a_i_stride = 1;
+    a_l_stride = lda;
+  } else {
+    a_i_stride = lda;
+    a_l_stride = 1;
+  }
+  int b_j_stride;
+  int b_l_stride;
+  if (transpose_b) {
+    b_j_stride = ldb;
+    b_l_stride = 1;
+  } else {
+    b_j_stride = 1;
+    b_l_stride = ldb;
+  }
+  int c_i_stride;
+  int c_j_stride;
+  if (transpose_c) {
+    c_i_stride = 1;
+    c_j_stride = ldc;
+  } else {
+    c_i_stride = ldc;
+    c_j_stride = 1;
+  }
+
+  const int32_t highest = static_cast<int32>(Eigen::NumTraits<T3>::highest());
+  const int32_t lowest = static_cast<int32>(Eigen::NumTraits<T3>::lowest());
+  const int32_t rounding = (shift_c < 1) ? 0 : (1 << (shift_c - 1));
+
+  int i, j, l;
+  for (j = 0; j < n; j++) {
+    for (i = 0; i < m; i++) {
+      int32_t total = 0;
+      for (l = 0; l < k; l++) {
+        const size_t a_index = ((i * a_i_stride) + (l * a_l_stride));
+        const int32_t a_value = static_cast<int32>(a[a_index]) - offset_a;
+        const size_t b_index = ((j * b_j_stride) + (l * b_l_stride));
+        const int32_t b_value = static_cast<int32>(b[b_index]) - offset_b;
+        total += (a_value * b_value);
+      }
+      const size_t c_index = ((i * c_i_stride) + (j * c_j_stride));
+      int32_t output = ((((total + offset_c) * mult_c) + rounding) >> shift_c);
+      if (output > highest) {
+        output = highest;
+      }
+      if (output < lowest) {
+        output = lowest;
+      }
+      c[c_index] = static_cast<T3>(output);
+    }
+  }
+}
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_REFERENCE_GEMM_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/relu_op.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/relu_op.h
new file mode 100644
index 0000000000000000000000000000000000000000..4b64a69fb0889b93a77e8d860e5175f3900b1779
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/relu_op.h
@@ -0,0 +1,283 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// See docs in ../ops/nn_ops.cc.
+
+#ifndef TENSORFLOW_CORE_KERNELS_RELU_OP_H_
+#define TENSORFLOW_CORE_KERNELS_RELU_OP_H_
+
+#define EIGEN_USE_THREADS
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/framework/numeric_op.h"
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/register_types.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/kernels/relu_op_functor.h"
+#include "tensorflow/core/lib/core/errors.h"
+
+namespace tensorflow {
+
+template <typename Device, typename T>
+class ReluOp : public UnaryElementWiseOp<T, ReluOp<Device, T>> {
+ public:
+  using UnaryElementWiseOp<T, ReluOp<Device, T>>::UnaryElementWiseOp;
+
+  void Operate(OpKernelContext* context, const Tensor& input, Tensor* output) {
+    functor::Relu<Device, T> functor;
+    functor(context->eigen_device<Device>(), input.flat<T>(),
+            output->flat<T>());
+  }
+};
+
+// Out of line check to save code space (we have this code once, rather
+// than once for every NDIMS * NumTypes * Num_different_relu_variants
+// functions.
+struct ReluHelpers {
+  static void ValidateSameSizeHelper(OpKernelContext* context, const Tensor& g,
+                                     const Tensor& a) {
+    OP_REQUIRES(context, a.IsSameSize(g),
+                errors::InvalidArgument("g and a must be the same size"));
+  }
+  static bool ValidateSameSize(OpKernelContext* context, const Tensor& g,
+                               const Tensor& a) {
+    ValidateSameSizeHelper(context, g, a);
+    return context->status().ok();
+  }
+};
+
+template <typename Device, typename T>
+class ReluGradOp : public BinaryElementWiseOp<T, ReluGradOp<Device, T>> {
+ public:
+  using BinaryElementWiseOp<T, ReluGradOp<Device, T>>::BinaryElementWiseOp;
+
+  void OperateNoTemplate(OpKernelContext* context, const Tensor& g,
+                         const Tensor& a, Tensor* output);
+
+  // INPUTS:
+  //   g (gradients): backpropagated gradients
+  //   a (inputs): either the inputs that were passed to ReluOp(), or its
+  //               outputs (using either one yields the same result here).
+  // OUTPUT:
+  //   gradients to backprop
+  template <int NDIMS>
+  void Operate(OpKernelContext* context, const Tensor& g, const Tensor& a,
+               Tensor* output) {
+    OperateNoTemplate(context, g, a, output);
+  }
+};
+
+template <typename Device, typename T>
+void ReluGradOp<Device, T>::OperateNoTemplate(OpKernelContext* context,
+                                              const Tensor& g, const Tensor& a,
+                                              Tensor* output) {
+  if (!ReluHelpers::ValidateSameSize(context, g, a)) return;
+  functor::ReluGrad<Device, T> functor;
+  functor(context->eigen_device<Device>(), g.flat<T>(), a.flat<T>(),
+          output->flat<T>());
+}
+
+template <typename Device, typename T>
+class Relu6Op : public UnaryElementWiseOp<T, Relu6Op<Device, T>> {
+ public:
+  using UnaryElementWiseOp<T, Relu6Op<Device, T>>::UnaryElementWiseOp;
+
+  void Operate(OpKernelContext* context, const Tensor& input, Tensor* output) {
+    functor::Relu6<Device, T> functor;
+    functor(context->eigen_device<Device>(), input.flat<T>(),
+            output->flat<T>());
+  }
+};
+
+template <typename Device, typename T>
+class Relu6GradOp : public BinaryElementWiseOp<T, Relu6GradOp<Device, T>> {
+ public:
+  using BinaryElementWiseOp<T, Relu6GradOp<Device, T>>::BinaryElementWiseOp;
+
+  void OperateNoTemplate(OpKernelContext* context, const Tensor& g,
+                         const Tensor& a, Tensor* output);
+
+  // INPUTS:
+  //   g (gradients): backpropagated gradients
+  //   a (inputs): inputs that were passed to Relu6Op()
+  // OUTPUT:
+  //   gradients to backprop
+  template <int NDIMS>
+  void Operate(OpKernelContext* context, const Tensor& g, const Tensor& a,
+               Tensor* output) {
+    OperateNoTemplate(context, g, a, output);
+  }
+};
+
+template <typename Device, typename T>
+void Relu6GradOp<Device, T>::OperateNoTemplate(OpKernelContext* context,
+                                               const Tensor& g, const Tensor& a,
+                                               Tensor* output) {
+  if (!ReluHelpers::ValidateSameSize(context, g, a)) return;
+  functor::Relu6Grad<Device, T> functor;
+  functor(context->eigen_device<Device>(), g.flat<T>(), a.flat<T>(),
+          output->flat<T>());
+}
+
+template <typename Device, typename T>
+class LeakyReluOp : public UnaryElementWiseOp<T, LeakyReluOp<Device, T>> {
+ public:
+  explicit LeakyReluOp(OpKernelConstruction* context)
+      : UnaryElementWiseOp<T, LeakyReluOp<Device, T>>(context) {
+    float alpha_tmp;
+    OP_REQUIRES_OK(context, context->GetAttr("alpha", &alpha_tmp));
+    alpha_ = T(alpha_tmp);
+  }
+
+  void Operate(OpKernelContext* context, const Tensor& input, Tensor* output) {
+    functor::LeakyRelu<Device, T> functor;
+    functor({context->eigen_device<Device>(), input.flat<T>(), alpha_,
+             output->flat<T>()});
+  }
+
+ private:
+  T alpha_;
+};
+
+template <typename Device, typename T>
+class LeakyReluGradOp
+    : public BinaryElementWiseOp<T, LeakyReluGradOp<Device, T>> {
+ public:
+  explicit LeakyReluGradOp(OpKernelConstruction* context)
+      : BinaryElementWiseOp<T, LeakyReluGradOp<Device, T>>(context) {
+    float alpha_tmp;
+    OP_REQUIRES_OK(context, context->GetAttr("alpha", &alpha_tmp));
+    alpha_ = T(alpha_tmp);
+  }
+
+  void OperateNoTemplate(OpKernelContext* context, const Tensor& g,
+                         const Tensor& a, T alpha, Tensor* output);
+
+  // INPUTS:
+  //   g (gradients): backpropagated gradients
+  //   a (inputs): either the inputs that were passed to LeakyReluOp(), or its
+  //               outputs (using either one yields the same result here).
+  // OUTPUT:
+  //   gradients to backprop
+  template <int NDIMS>
+  void Operate(OpKernelContext* context, const Tensor& g, const Tensor& a,
+               Tensor* output) {
+    OperateNoTemplate(context, g, a, alpha_, output);
+  }
+
+ private:
+  T alpha_;
+};
+
+template <typename Device, typename T>
+void LeakyReluGradOp<Device, T>::OperateNoTemplate(OpKernelContext* context,
+                                                   const Tensor& g,
+                                                   const Tensor& a, T alpha,
+                                                   Tensor* output) {
+  if (!ReluHelpers::ValidateSameSize(context, g, a)) return;
+  functor::LeakyReluGrad<Device, T> functor;
+  functor(context->eigen_device<Device>(), g.flat<T>(), a.flat<T>(), alpha,
+          output->flat<T>());
+};
+
+template <typename Device, typename T>
+class EluOp : public UnaryElementWiseOp<T, EluOp<Device, T>> {
+ public:
+  using UnaryElementWiseOp<T, EluOp<Device, T>>::UnaryElementWiseOp;
+
+  void Operate(OpKernelContext* context, const Tensor& input, Tensor* output) {
+    functor::Elu<Device, T> functor;
+    functor(context->eigen_device<Device>(), input.flat<T>(),
+            output->flat<T>());
+  }
+};
+
+template <typename Device, typename T>
+class EluGradOp : public BinaryElementWiseOp<T, EluGradOp<Device, T>> {
+ public:
+  using BinaryElementWiseOp<T, EluGradOp<Device, T>>::BinaryElementWiseOp;
+
+  void OperateNoTemplate(OpKernelContext* context, const Tensor& g,
+                         const Tensor& a, Tensor* output);
+
+  // INPUTS:
+  //   g (gradients): backpropagated gradients
+  //   a (outputs): outputs of the EluOp()
+  // OUTPUT:
+  //   gradients to backprop
+  template <int NDIMS>
+  void Operate(OpKernelContext* context, const Tensor& g, const Tensor& a,
+               Tensor* output) {
+    OperateNoTemplate(context, g, a, output);
+  }
+};
+
+template <typename Device, typename T>
+void EluGradOp<Device, T>::OperateNoTemplate(OpKernelContext* context,
+                                             const Tensor& g, const Tensor& a,
+                                             Tensor* output) {
+  if (!ReluHelpers::ValidateSameSize(context, g, a)) return;
+  functor::EluGrad<Device, T> functor;
+  functor(context->eigen_device<Device>(), g.flat<T>(), a.flat<T>(),
+          output->flat<T>());
+}
+
+template <typename Device, typename T>
+class SeluOp : public UnaryElementWiseOp<T, SeluOp<Device, T>> {
+ public:
+  using UnaryElementWiseOp<T, SeluOp<Device, T>>::UnaryElementWiseOp;
+
+  void Operate(OpKernelContext* context, const Tensor& input, Tensor* output) {
+    functor::Selu<Device, T> functor;
+    functor(context->eigen_device<Device>(), input.flat<T>(),
+            output->flat<T>());
+  }
+};
+
+template <typename Device, typename T>
+class SeluGradOp : public BinaryElementWiseOp<T, SeluGradOp<Device, T>> {
+ public:
+  using BinaryElementWiseOp<T, SeluGradOp<Device, T>>::BinaryElementWiseOp;
+
+  void OperateNoTemplate(OpKernelContext* context, const Tensor& g,
+                         const Tensor& a, Tensor* output);
+
+  // INPUTS:
+  //   g (gradients): backpropagated gradients
+  //   a (outputs): outputs of the SeluOp()
+  // OUTPUT:
+  //   gradients to backprop
+  template <int NDIMS>
+  void Operate(OpKernelContext* context, const Tensor& g, const Tensor& a,
+               Tensor* output) {
+    OperateNoTemplate(context, g, a, output);
+  }
+};
+
+template <typename Device, typename T>
+void SeluGradOp<Device, T>::OperateNoTemplate(OpKernelContext* context,
+                                              const Tensor& g, const Tensor& a,
+                                              Tensor* output) {
+  if (!ReluHelpers::ValidateSameSize(context, g, a)) return;
+  functor::SeluGrad<Device, T> functor;
+  functor(context->eigen_device<Device>(), g.flat<T>(), a.flat<T>(),
+          output->flat<T>());
+}
+
+}  // namespace tensorflow
+
+#undef EIGEN_USE_THREADS
+
+#endif  // TENSORFLOW_CORE_KERNELS_RELU_OP_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/relu_op_functor.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/relu_op_functor.h
new file mode 100644
index 0000000000000000000000000000000000000000..cacef94994313564b2db8836ade4e514fc7b17fa
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/relu_op_functor.h
@@ -0,0 +1,215 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_RELU_OP_FUNCTOR_H_
+#define TENSORFLOW_CORE_KERNELS_RELU_OP_FUNCTOR_H_
+// Functor definition for ReluOp and ReluGradOp, must be compilable by nvcc.
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/framework/tensor_types.h"
+
+namespace tensorflow {
+namespace functor {
+
+// Functor used by ReluOp to do the computations.
+template <typename Device, typename T>
+struct Relu {
+  // Computes Relu activation.
+  //
+  // features: any shape.
+  // activations: same shape as "features".
+  void operator()(const Device& d, typename TTypes<T>::ConstTensor features,
+                  typename TTypes<T>::Tensor activations) {
+    activations.device(d) =
+        features.template cwiseMax<Eigen::PropagateNaN>(static_cast<T>(0));
+  }
+};
+
+// Functor used by ReluGradOp to do the computations.
+template <typename Device, typename T>
+struct ReluGrad {
+  // Computes ReluGrad backprops.
+  //
+  // gradients: gradients backpropagated to the Relu op.
+  // features: either the inputs that were passed to the Relu or, or its
+  //           outputs (using either one yields the same result here).
+  // backprops: gradients to backpropagate to the Relu inputs.
+  void operator()(const Device& d, typename TTypes<T>::ConstTensor gradients,
+                  typename TTypes<T>::ConstTensor features,
+                  typename TTypes<T>::Tensor backprops) {
+    // NOTE: When the activation is exactly zero, we do not propagate the
+    // associated gradient value. This allows the output of the Relu to be used,
+    // as well as its input.
+    backprops.device(d) =
+        gradients * (features > static_cast<T>(0)).template cast<T>();
+  }
+};
+
+// Functor used by Relu6Op to do the computations.
+template <typename Device, typename T>
+struct Relu6 {
+  // Computes Relu6 activation.
+  //
+  // features: any shape.
+  // activations: same shape as "features".
+  void operator()(const Device& d, typename TTypes<T>::ConstTensor features,
+                  typename TTypes<T>::Tensor activations) {
+    activations.device(d) =
+        features.template cwiseMax<Eigen::PropagateNaN>(static_cast<T>(0))
+            .template cwiseMin<Eigen::PropagateNaN>(static_cast<T>(6));
+  }
+};
+
+// Functor used by ReluGradOp to do the computations.
+template <typename Device, typename T>
+struct Relu6Grad {
+  // Computes Relu6Grad backprops.
+  //
+  // gradients: gradients backpropagated to the Relu6 op.
+  // features: inputs that where passed to the Relu6 op, or its outputs.
+  // backprops: gradients to backpropagate to the Relu6 inputs.
+  void operator()(const Device& d, typename TTypes<T>::ConstTensor gradients,
+                  typename TTypes<T>::ConstTensor features,
+                  typename TTypes<T>::Tensor backprops) {
+    // NOTE: When the activation is exactly zero or six, we
+    // make sure not to propagate the associated gradient
+    // value. This allows "features" to be either the input or the output of
+    // the relu6.
+    backprops.device(d) = gradients * ((features > static_cast<T>(0)) *
+                                       (features < static_cast<T>(6)))
+                                          .template cast<T>();
+  }
+};
+
+// Functor used by LeakyReluOp to do the computations.
+template <typename Device, typename T>
+struct LeakyRelu {
+  // Computes LeakyRelu activation.
+  //
+  // features: any shape.
+  // activations: same shape as "features".
+
+  // Need to bundle the args (to the LeakyRelu functor) within a struct
+  // Not doing so leads to Eigen kernel args not getting populated
+  // corretly for Eigen::half type (when building on the ROCM platform)
+  struct LeakyReluArgs {
+    const Device& d;
+    typename TTypes<T>::ConstTensor features;
+    T alpha;
+    typename TTypes<T>::Tensor activations;
+  };
+  void operator()(LeakyReluArgs args) {
+    // Note that alpha might be > 1 or < 0, so we don't use cwiseMax here.
+    args.activations.device(args.d) =
+        (args.features > static_cast<T>(0))
+            .select(args.features, args.features * args.alpha);
+  }
+};
+
+// Functor used by LeakyReluGradOp to do the computations.
+template <typename Device, typename T>
+struct LeakyReluGrad {
+  // Computes LeakyReluGrad backprops.
+  //
+  // gradients: gradients backpropagated to the LeakyRelu op.
+  // features: either the inputs that were passed to the LeakyRelu or, or its
+  //           outputs (using either one yields the same result here).
+  // backprops: gradients to backpropagate to the LeakyRelu inputs.
+  void operator()(const Device& d, typename TTypes<T>::ConstTensor gradients,
+                  typename TTypes<T>::ConstTensor features, T alpha,
+                  typename TTypes<T>::Tensor backprops) {
+    backprops.device(d) =
+        (features > static_cast<T>(0)).select(gradients, gradients * alpha);
+  }
+};
+
+// Functor used by EluOp to do the computations.
+template <typename Device, typename T>
+struct Elu {
+  // Computes Elu activation.
+  //
+  // features: any shape.
+  // activations: same shape as "features".
+  void operator()(const Device& d, typename TTypes<T>::ConstTensor features,
+                  typename TTypes<T>::Tensor activations) {
+    // features.constant(?)
+    activations.device(d) =
+        (features < static_cast<T>(0))
+            .select(features.exp() - features.constant(static_cast<T>(1)),
+                    features);
+  }
+};
+
+// Functor used by EluGradOp to do the computations.
+template <typename Device, typename T>
+struct EluGrad {
+  // Computes EluGrad backprops.
+  //
+  // gradients: gradients backpropagated to the Elu op.
+  // activations: outputs of the Elu op.
+  // backprops: gradients to backpropagate to the Elu inputs.
+  void operator()(const Device& d, typename TTypes<T>::ConstTensor gradients,
+                  typename TTypes<T>::ConstTensor activations,
+                  typename TTypes<T>::Tensor backprops) {
+    backprops.device(d) =
+        (activations < static_cast<T>(0))
+            .select((activations + static_cast<T>(1)) * gradients, gradients);
+  }
+};
+
+// Functor used by SeluOp to do the computations.
+template <typename Device, typename T>
+struct Selu {
+  // Computes Selu activation.
+  //
+  // features: any shape.
+  // activations: same shape as "features".
+  void operator()(const Device& d, typename TTypes<T>::ConstTensor features,
+                  typename TTypes<T>::Tensor activations) {
+    // features.constant(?)
+    const auto scale = static_cast<T>(1.0507009873554804934193349852946);
+    const auto scale_alpha = static_cast<T>(1.7580993408473768599402175208123);
+    const auto one = static_cast<T>(1);
+    const auto zero = static_cast<T>(0);
+    activations.device(d) =
+        (features < zero)
+            .select(scale_alpha * (features.exp() - features.constant(one)),
+                    scale * features);
+  }
+};
+
+// Functor used by SeluGradOp to do the computations.
+template <typename Device, typename T>
+struct SeluGrad {
+  // Computes SeluGrad backprops.
+  //
+  // gradients: gradients backpropagated to the Selu op.
+  // activations: outputs of the Selu op.
+  // backprops: gradients to backpropagate to the Selu inputs.
+  void operator()(const Device& d, typename TTypes<T>::ConstTensor gradients,
+                  typename TTypes<T>::ConstTensor activations,
+                  typename TTypes<T>::Tensor backprops) {
+    const auto scale = static_cast<T>(1.0507009873554804934193349852946);
+    const auto scale_alpha = static_cast<T>(1.7580993408473768599402175208123);
+    backprops.device(d) =
+        (activations < static_cast<T>(0))
+            .select(gradients * (activations + scale_alpha), gradients * scale);
+  }
+};
+
+}  // namespace functor
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_RELU_OP_FUNCTOR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/reshape_op.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/reshape_op.h
new file mode 100644
index 0000000000000000000000000000000000000000..099678c94324b88a34b9b894cce9265e38186187
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/reshape_op.h
@@ -0,0 +1,168 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_RESHAPE_OP_H_
+#define TENSORFLOW_CORE_KERNELS_RESHAPE_OP_H_
+
+#include <memory>
+
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/register_types.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/tensor_shape.h"
+#include "tensorflow/core/framework/types.h"
+#include "tensorflow/core/lib/core/errors.h"
+#include "tensorflow/core/lib/core/status.h"
+#include "tensorflow/core/platform/logging.h"
+#include "tensorflow/core/util/overflow.h"
+
+namespace tensorflow {
+
+// Note that this op is subclassed for QuantizedReshapeOp.
+class ReshapeOp : public OpKernel {
+ public:
+  explicit ReshapeOp(OpKernelConstruction* context) : OpKernel(context) {}
+
+  void Compute(OpKernelContext* context) override {
+    const Tensor& input = context->input(0);
+    const Tensor& sizes = context->input(1);
+    // Preliminary validation of sizes.
+    OP_REQUIRES(
+        context,
+        (TensorShapeUtils::IsVector(sizes.shape()) ||
+         // TODO(rmlarsen): Disallow legacy use of scalars to represent shape.
+         TensorShapeUtils::IsScalar(sizes.shape())),
+        errors::InvalidArgument("sizes input must be 1-D, not ",
+                                sizes.shape().DebugString()));
+    OP_REQUIRES(
+        context, sizes.NumElements() < TensorShape::MaxDimensions(),
+        errors::InvalidArgument("too many dimensions: must be < ",
+                                TensorShape::MaxDimensions(), ", but received ",
+                                sizes.NumElements()));
+
+    // Compute the output shape.  Determine product of specified
+    // dimensions, and find the index of the unspecified one.
+    TensorShape shape;
+    int64_t product = 1;
+    int unknown_index = -1;
+    bool sizes_has_zero_dim;
+    switch (sizes.dtype()) {
+      case DT_INT32:
+        OP_REQUIRES_OK(context,
+                       ValidateSizes<int32>(sizes, &product, &unknown_index,
+                                            &shape, &sizes_has_zero_dim));
+        break;
+      case DT_INT64:
+        OP_REQUIRES_OK(context,
+                       ValidateSizes<int64_t>(sizes, &product, &unknown_index,
+                                              &shape, &sizes_has_zero_dim));
+        break;
+      default:
+        context->CtxFailure(errors::InvalidArgument(
+            "desired shape must be a DT_INT32 or DT_INT64 vector, not a ",
+            DataTypeString(sizes.dtype())));
+        return;
+    }
+    if (unknown_index != -1) {
+      int64_t input_num_elements = 1;
+      bool input_has_zero_dim = false;
+      for (int dim = 0; dim < input.dims(); dim++) {
+        // For zero dimension, we don't count it into `input_num_elements`
+        // unless `sizes` has no zero dimension, so we are still able to
+        // infer shapes for other dimensions.
+        if (input.dim_size(dim) > 0 || !sizes_has_zero_dim) {
+          input_num_elements *= input.dim_size(dim);
+        } else {
+          input_has_zero_dim = true;
+        }
+      }
+
+      const int64_t missing = input_num_elements / product;
+      if (!input_has_zero_dim) {
+        OP_REQUIRES(
+            context, product * missing == input_num_elements,
+            errors::InvalidArgument(
+                "Input to reshape is a tensor with ", input_num_elements,
+                " values, but the requested shape requires a multiple of ",
+                product));
+      }
+      shape.set_dim(unknown_index, missing);
+    }
+    OP_REQUIRES(context, shape.num_elements() == input.NumElements(),
+                errors::InvalidArgument("Input to reshape is a tensor with ",
+                                        input.NumElements(),
+                                        " values, but the requested shape has ",
+                                        shape.num_elements()));
+
+    // Actually produce the reshaped output.
+    Tensor output(input.dtype());
+    CHECK(output.CopyFrom(input, shape));
+    context->set_output(0, output);
+  }
+
+  bool IsExpensive() override { return false; }
+
+ private:
+  template <typename Tshape>
+  Status ValidateSizes(const Tensor& sizes, int64_t* product,
+                       int* unknown_index, TensorShape* shape,
+                       bool* has_zero_dim) {
+    *product = 1;
+    *unknown_index = -1;
+    *has_zero_dim = false;
+    const int64_t num_dims = sizes.NumElements();
+    auto Svec = sizes.flat<Tshape>();
+    for (int d = 0; d < num_dims; ++d) {
+      const Tshape size = Svec(d);
+      if (size == -1) {
+        if (*unknown_index != -1) {
+          return errors::InvalidArgument(
+              "Only one input size may be -1, not both ", *unknown_index,
+              " and ", d);
+        }
+        *unknown_index = d;
+        TF_RETURN_IF_ERROR(shape->AddDimWithStatus(1));
+      } else if (size < 0) {
+        return errors::InvalidArgument("Size ", d,
+                                       " must be non-negative, not ", size);
+      } else if (size == 0) {
+        // We don't include zero-sized dimension in product, so that we can
+        // still calculate number of elements for non-zero-sized dimensions and
+        // therefore infer their shapes.
+        TF_RETURN_IF_ERROR(shape->AddDimWithStatus(size));
+        *has_zero_dim = true;
+      } else {
+        if (MultiplyWithoutOverflow(shape->num_elements(), size) < 0) {
+          string msg;
+          for (int ii = 0; ii < num_dims; ++ii) {
+            if (ii != 0) {
+              strings::StrAppend(&msg, ", ");
+            }
+            strings::StrAppend(&msg, Svec(ii));
+          }
+          return errors::InvalidArgument("Shape [", msg,
+                                         "] has too many elements");
+        }
+        TF_RETURN_IF_ERROR(shape->AddDimWithStatus(size));
+        (*product) *= size;
+      }
+    }
+    return OkStatus();
+  }
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_RESHAPE_OP_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/reshape_util.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/reshape_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..28d1909c07bda11f1989a268223af20f11788436
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/reshape_util.h
@@ -0,0 +1,51 @@
+
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_KERNELS_RESHAPE_UTIL_H_
+#define TENSORFLOW_CORE_KERNELS_RESHAPE_UTIL_H_
+
+#include "tensorflow/core/framework/tensor_shape.h"
+#include "tensorflow/core/framework/tensor_types.h"
+#include "tensorflow/core/lib/core/status.h"
+
+namespace tensorflow {
+
+class OpKernelContext;
+class Tensor;
+
+// Reshapes the input indices and input shape to the target shape.
+// Note: This template is explicitly instantiated for CPU and GPU devices.
+template <typename Device>
+void ReshapeSparseTensor(OpKernelContext *context,
+                         const Tensor &input_indices_in,
+                         const Tensor &input_shape_in,
+                         const Tensor &target_shape_in, int output_indices_idx,
+                         int output_shape_idx);
+
+namespace functor {
+
+template <typename Device>
+struct ReshapeSparseTensorFunctor {
+  Status operator()(OpKernelContext *context, const TensorShape &input_shape,
+                    const TensorShape &output_shape,
+                    typename TTypes<int64_t>::ConstMatrix input_indices,
+                    typename TTypes<int64_t>::Matrix output_indices) const;
+};
+
+}  // namespace functor
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_RESHAPE_UTIL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/resource_variable_ops.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/resource_variable_ops.h
new file mode 100644
index 0000000000000000000000000000000000000000..1c8d79988a2457d4a13acec9872b6eceebbfad05
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/resource_variable_ops.h
@@ -0,0 +1,99 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_CORE_KERNELS_RESOURCE_VARIABLE_OPS_H_
+#define TENSORFLOW_CORE_KERNELS_RESOURCE_VARIABLE_OPS_H_
+
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/resource_mgr.h"
+#include "tensorflow/core/framework/resource_var.h"
+
+namespace tensorflow {
+
+class VarHandleOp : public OpKernel {
+ public:
+  explicit VarHandleOp(OpKernelConstruction* c);
+  void Compute(OpKernelContext* ctx) override;
+  const Tensor* const_tensor() const override {
+    return is_anonymous_ ? nullptr : &const_tensor_;
+  }
+
+ private:
+  // Same fields as in ResourceHandleOp.
+  bool is_anonymous_;
+  string container_;
+  string name_;
+  string debug_name_;
+  Tensor const_tensor_;
+
+  DtypeAndPartialTensorShape dtype_and_shape_;
+};
+
+class ReadVariableOp : public OpKernel {
+ public:
+  explicit ReadVariableOp(OpKernelConstruction* c);
+  void Compute(OpKernelContext* ctx) override;
+
+ private:
+  DataType dtype_;
+};
+
+class ReadVariablesOp : public OpKernel {
+ public:
+  explicit ReadVariablesOp(OpKernelConstruction* c);
+  void Compute(OpKernelContext* ctx) override;
+  bool IsExpensive() override { return false; }
+
+ private:
+  DataTypeVector dtypes_;
+};
+
+class DestroyResourceOp : public OpKernel {
+ public:
+  explicit DestroyResourceOp(OpKernelConstruction* ctx);
+  void Compute(OpKernelContext* ctx) override;
+
+ private:
+  bool ignore_lookup_error_;
+};
+
+class DisableCopyOnReadOp : public OpKernel {
+ public:
+  explicit DisableCopyOnReadOp(OpKernelConstruction* c) : OpKernel(c) {}
+  void Compute(OpKernelContext* ctx) override;
+};
+
+template <typename T>
+class VariableShapeOp : public OpKernel {
+ public:
+  explicit VariableShapeOp(OpKernelConstruction* c) : OpKernel(c) {}
+
+  void Compute(OpKernelContext* ctx) override {
+    core::RefCountPtr<Var> variable;
+    OP_REQUIRES_OK(ctx,
+                   LookupResource(ctx, HandleFromInput(ctx, 0), &variable));
+    variable->mu()->lock_shared();
+    TensorShape shape = variable->tensor()->shape();
+    variable->mu()->unlock_shared();
+    Tensor* output;
+    OP_REQUIRES_OK(ctx, ctx->allocate_output(0, {shape.dims()}, &output));
+    for (int i = 0; i < shape.dims(); ++i) {
+      output->flat<T>()(i) = shape.dim_size(i);
+    }
+  }
+};
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_RESOURCE_VARIABLE_OPS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/resource_variable_util.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/resource_variable_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..72ffd4b5028fb1ec555293d16f427839fb2ffe54
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/resource_variable_util.h
@@ -0,0 +1,28 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_RESOURCE_VARIABLE_UTIL_H_
+#define TENSORFLOW_CORE_KERNELS_RESOURCE_VARIABLE_UTIL_H_
+
+#include "tensorflow/core/framework/tensor_shape.h"
+
+namespace tensorflow {
+
+Status ValidateAssignUpdateVariableOpShapes(const TensorShape& variable_shape,
+                                            const TensorShape& value_shape);
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_RESOURCE_VARIABLE_UTIL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/reverse_op.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/reverse_op.h
new file mode 100644
index 0000000000000000000000000000000000000000..a2de766a818224322acc5566f8cd80c7e8dbc3a0
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/reverse_op.h
@@ -0,0 +1,48 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_REVERSE_OP_H_
+#define TENSORFLOW_CORE_KERNELS_REVERSE_OP_H_
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/framework/tensor_types.h"
+
+namespace tensorflow {
+namespace functor {
+
+// Functor used by ReverseOp to do the computations.
+template <typename Device, typename T, int Dims>
+struct Reverse {
+  void operator()(const Device& d, typename TTypes<T, Dims>::ConstTensor input,
+                  const Eigen::array<bool, Dims>& reverse_dims,
+                  typename TTypes<T, Dims>::Tensor output) {
+    output.device(d) = input.reverse(reverse_dims);
+  }
+};
+
+template <typename Device, typename T>
+struct Reverse<Device, T, 0> {
+  void operator()(const Device& d, typename TTypes<T, 0>::ConstTensor input,
+                  const Eigen::array<bool, 0>& reverse_dims,
+                  typename TTypes<T, 0>::Tensor output) {
+    // Reversing a scalar is copying it.
+    output.device(d) = input;
+  }
+};
+
+}  // namespace functor
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_REVERSE_OP_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/reverse_sequence_op.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/reverse_sequence_op.h
new file mode 100644
index 0000000000000000000000000000000000000000..f25794f3a2ad3993c83777f1887fb996fbd2ec50
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/reverse_sequence_op.h
@@ -0,0 +1,78 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_REVERSE_SEQUENCE_OP_H_
+#define TENSORFLOW_CORE_KERNELS_REVERSE_SEQUENCE_OP_H_
+// Generator definition for ReverseSequenceOp, must be compilable by nvcc.
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/framework/tensor_types.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+
+namespace generator {
+
+template <typename T, typename Tlen, size_t Dims>
+class ReverseGenerator {
+ public:
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE ReverseGenerator(
+      typename TTypes<T, Dims>::ConstTensor input, int32_t batch_dim,
+      int32_t seq_dim, typename TTypes<Tlen>::ConstVec seq_lengths)
+      : input_(input),
+        batch_dim_(batch_dim),
+        seq_dim_(seq_dim),
+        seq_lengths_(seq_lengths) {}
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T
+  operator()(const Eigen::array<Eigen::DenseIndex, Dims>& coords) const {
+    Eigen::array<Eigen::DenseIndex, Dims> new_coords = coords;
+    if (coords[seq_dim_] < seq_lengths_(coords[batch_dim_])) {
+      new_coords[seq_dim_] =
+          seq_lengths_(coords[batch_dim_]) - coords[seq_dim_] - 1;
+    }
+
+    return input_(new_coords);
+  }
+
+ private:
+  typename TTypes<T, Dims>::ConstTensor input_;
+  int32 batch_dim_;
+  int32 seq_dim_;
+  typename TTypes<Tlen>::ConstVec seq_lengths_;
+};
+
+}  // namespace generator
+
+namespace functor {
+
+template <typename Device, typename T, typename Tlen, size_t Dims>
+struct ReverseSequence {
+  EIGEN_ALWAYS_INLINE static void Compute(
+      const Device& d, typename TTypes<T, Dims>::ConstTensor input,
+      int32_t batch_dim, int32_t seq_dim,
+      typename TTypes<Tlen>::ConstVec seq_lengths,
+      typename TTypes<T, Dims>::Tensor output) {
+    generator::ReverseGenerator<T, Tlen, Dims> generator(input, batch_dim,
+                                                         seq_dim, seq_lengths);
+    output.device(d) = input.generate(generator);
+  }
+};
+
+}  // namespace functor
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_REVERSE_SEQUENCE_OP_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/roll_op.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/roll_op.h
new file mode 100644
index 0000000000000000000000000000000000000000..69fbe3c366b59a92de9c4a595c923fae261aa011
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/roll_op.h
@@ -0,0 +1,46 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_ROLL_OP_H_
+#define TENSORFLOW_CORE_KERNELS_ROLL_OP_H_
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/framework/numeric_types.h"
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/tensor_types.h"
+
+namespace tensorflow {
+namespace functor {
+
+template <typename Device, typename T>
+struct Roll {
+  // dim_size - the size of each dimension
+  // dim_range - the number of indices over in the flattened tensor
+  //    you need to skip in order to make it over from one side of a dimension
+  //    to the other. Used to make the shifts wrap around after a threshold.
+  // threshold - the index for each dimension that the roll starts to wrap
+  //    back to the front
+  // isd - inner shift dimension
+  void operator()(const OpKernelContext* context, const int64_t num_elements,
+                  const int num_dims, const gtl::ArraySlice<int32> dim_size,
+                  const T* input, T* output,
+                  const gtl::ArraySlice<int32> threshold,
+                  const gtl::ArraySlice<int64_t> dim_range, const int64_t isd);
+};
+
+}  // namespace functor
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_ROLL_OP_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/save_restore_tensor.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/save_restore_tensor.h
new file mode 100644
index 0000000000000000000000000000000000000000..be7f4b889e78fd116734d6dcc9aad40fab8ddcd5
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/save_restore_tensor.h
@@ -0,0 +1,73 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_SAVE_RESTORE_TENSOR_H_
+#define TENSORFLOW_CORE_KERNELS_SAVE_RESTORE_TENSOR_H_
+
+#include "tensorflow/core/util/tensor_slice_reader.h"
+#include "tensorflow/core/util/tensor_slice_writer.h"
+
+namespace tensorflow {
+
+class OpKernelContext;
+
+// Legacy / V1 checkpoint format.
+
+// Save input tensors in *context to a writer built from builder_func().
+// context must have the following inputs:
+//  0: a single element string tensor that contains the file name.
+//  1: names for the remaining tensors
+// If save_slices is true:
+//  2: shape and slice specifications.
+//  rest: tensors to save
+void SaveTensors(
+    OpKernelContext* context,
+    checkpoint::TensorSliceWriter::CreateBuilderFunction builder_func,
+    bool save_slices);
+
+// Reads a single tensor from the reader built from open_func() and produces
+// it as context->output(restore_index).  "preferred_shard" is the same the
+// TensorSliceReader preferred_shard parameter.
+//
+// context must have the following inputs:
+//  0: a single element string tensor that contains the file name.
+//  1: string tensor that names the outputs to be restored.
+// If restore_slice is true:
+//  2: shape and slice specification of the tensors to restore.
+//
+// restore_index indicates the variable name and slice to lookup
+// in context(1) and (2).
+void RestoreTensor(OpKernelContext* context,
+                   checkpoint::TensorSliceReader::OpenTableFunction open_func,
+                   int preferred_shard, bool restore_slice, int restore_index);
+
+// V2 checkpoint format.
+
+// Invokes the V2 checkpoint read path to read tensors.
+//
+// "context" is only used for allocating outputs.  In particular, the inputs are
+// explicitly provided and not accessed via the "input(i)" methods.
+// REQUIRES:
+//   * "prefix" has 1 element, DT_STRING.
+//   * "tensor_names" and "shape_and_slices" shaped {N}, both DT_STRING.
+//   * "dtypes" has N elements, the datatypes of the to-restore tensors.
+Status RestoreTensorsV2(OpKernelContext* context, const Tensor& prefix,
+                        const Tensor& tensor_names,
+                        const Tensor& shape_and_slices,
+                        gtl::ArraySlice<DataType> dtypes);
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_SAVE_RESTORE_TENSOR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/scan_ops.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/scan_ops.h
new file mode 100644
index 0000000000000000000000000000000000000000..ad3f2e1e5546d09dc000ea324614274f7690f854
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/scan_ops.h
@@ -0,0 +1,146 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_SCAN_OPS_H_
+#define TENSORFLOW_CORE_KERNELS_SCAN_OPS_H_
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/framework/tensor_types.h"
+
+namespace tensorflow {
+namespace functor {
+
+typedef Eigen::Index Index;
+
+// TODO(b/154339590): Needs to be vectorized.
+template <typename Device, typename Reducer, typename T>
+struct Scan {
+  void operator()(const Device& d, typename TTypes<T, 3>::ConstTensor in,
+                  typename TTypes<T, 3>::Tensor out, const Reducer& reducer,
+                  const bool reverse, const bool exclusive) {
+    // Perform the reverse ops directly with Eigen, which avoids copying the
+    // tensor twice compared to using individual ops.
+    Eigen::array<bool, 3> dims;
+    dims[0] = false;
+    dims[1] = reverse;
+    dims[2] = false;
+    MaybeWith32BitIndexing<Device>(
+        [&](auto in32, auto out32) {
+          out32.device(d) =
+              in32.reverse(dims).scan(1, reducer, exclusive).reverse(dims);
+        },
+        in, out);
+  }
+};
+
+template <typename T>
+struct LogSumExp {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T operator()(const T& a,
+                                                     const T& b) const {
+    auto mi = Eigen::internal::scalar_min_op<T>()(a, b);
+    auto ma = Eigen::internal::scalar_max_op<T>()(a, b);
+
+    auto sub = Eigen::internal::scalar_difference_op<T>();
+    auto add = Eigen::internal::scalar_sum_op<T>();
+    auto exp = Eigen::internal::scalar_exp_op<T>();
+    auto log1p = Eigen::internal::scalar_log1p_op<T>();
+    auto cmp_lt =
+        Eigen::internal::scalar_cmp_op<T, T, Eigen::internal::cmp_LT>();
+
+    auto logsumexp = add(log1p(exp(sub(mi, ma))), ma);
+    return cmp_lt(ma, Eigen::NumTraits<T>::lowest()) ? ma : logsumexp;
+  }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T packetOp(const T& a,
+                                                   const T& b) const {
+    auto mi = Eigen::internal::pmin(a, b);
+    auto ma = Eigen::internal::pmax(a, b);
+    using Eigen::internal::padd;
+    using Eigen::internal::pcmp_lt;
+    using Eigen::internal::pexp;
+    using Eigen::internal::plog1p;
+    using Eigen::internal::pset1;
+    using Eigen::internal::psub;
+
+    auto logsumexp = padd(plog1p(pexp(psub(mi, ma))), ma);
+    return pselect(pcmp_lt(ma, pset1(Eigen::NumTraits<T>::lowest())), ma,
+                   logsumexp);
+  }
+};
+
+template <typename T>
+struct LogSumExpReducer {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void reduce(const T t, T* accum) const {
+    LogSumExp<T> logsumexp;
+    *accum = logsumexp(*accum, t);
+  }
+
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void reducePacket(const Packet& p,
+                                                          Packet* accum) const {
+    LogSumExp<T> logsumexp;
+    *accum = logsumexp.packetOp(*accum, p);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T initialize() const {
+    return -Eigen::NumTraits<T>::infinity();
+  }
+
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet initializePacket() const {
+    return Eigen::internal::pset1(initialize());
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T finalize(const T accum) const {
+    return accum;
+  }
+
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet
+  finalizePacket(const Packet& vaccum) const {
+    return vaccum;
+  }
+
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T
+  finalizeBoth(const T saccum, const Packet& vaccum) const {
+    auto max_reducer = Eigen::internal::MaxReducer<T, Eigen::PropagateNaN>();
+    auto sum_reducer = Eigen::internal::SumReducer<T>();
+    auto exp = Eigen::internal::scalar_exp_op<T>();
+    auto cmp_lt =
+        Eigen::internal::scalar_cmp_op<T, T, Eigen::internal::cmp_LT>();
+    auto log = Eigen::internal::scalar_log_op<T>();
+    auto add = Eigen::internal::scalar_sum_op<T>();
+
+    using Eigen::internal::pexp;
+    using Eigen::internal::psub;
+
+    // `ma = max(x1, ..., xn)`
+    // If the max of all of the `xi` is `-infinity` then the result is
+    // -infinity. If the max is larger than `-infinity` then it's safe to use
+    // for normalization even if the other elements are `-infinity`.
+    //
+    // `logsumexp(x1, ..., xn) = ma + log (exp(x1 - ma) + ... + exp(xn - ma))`
+    auto ma = max_reducer.finalizeBoth(saccum, vaccum);
+    auto logsumexp = add(log(sum_reducer.finalizeBoth(
+                             exp(saccum - ma), pexp(psub(vaccum, pset1(ma))))),
+                         ma);
+    return cmp_lt(ma, Eigen::NumTraits<T>::lowest()) ? initialize() : logsumexp;
+  }
+};
+
+}  // namespace functor
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_SCAN_OPS_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/scan_ops_gpu.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/scan_ops_gpu.h
new file mode 100644
index 0000000000000000000000000000000000000000..15b4e5e1ecf343f6529e907e4a2d5559a915c0a9
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/scan_ops_gpu.h
@@ -0,0 +1,334 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_SCAN_OPS_GPU_H_
+#define TENSORFLOW_CORE_KERNELS_SCAN_OPS_GPU_H_
+
+#if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+
+#define EIGEN_USE_GPU
+
+#define CUB_USE_COOPERATIVE_GROUPS
+
+#include "tensorflow/core/framework/numeric_types.h"
+#include "tensorflow/core/framework/register_types.h"
+#include "tensorflow/core/kernels/gpu_prim.h"
+#include "tensorflow/core/kernels/scan_ops.h"
+#include "tensorflow/core/util/gpu_kernel_helper.h"
+#include "tensorflow/core/util/gpu_launch_config.h"
+#include "tensorflow/core/util/permutation_input_iterator.h"
+#include "tensorflow/core/util/permutation_output_iterator.h"
+
+namespace tensorflow {
+
+typedef Eigen::GpuDevice GPUDevice;
+typedef Eigen::Index Index;
+
+namespace functor {
+
+// Map a contiguous range to the actual memory locations depending on which
+// axis the scan is taking place over and whether or not reversed.
+struct MapIndexToLocation {
+  __host__ __device__ MapIndexToLocation(int dimx, int dimy, int dimz,
+                                         bool reverse = false)
+      : dimx_(dimx), dimy_(dimy), dimz_(dimz), reverse_(reverse) {}
+
+  __host__ __device__ int operator()(int id) const {
+    if (dimx_ == 1) {
+      int row = id % dimy_;
+      int col = id / dimy_;
+
+      if (reverse_) return (dimy_ - row - 1) * dimz_ + col;
+
+      return row * dimz_ + col;
+    } else if (dimz_ == 1) {
+      if (reverse_) {
+        int row = id / dimy_;
+        int col = id % dimy_;
+        return row * dimy_ + (dimy_ - col - 1);
+      }
+      return id;
+    } else {
+      int col = id % dimy_;
+      int tmp = id / dimy_;
+
+      int row1 = id / (dimy_ * dimz_);
+      int col1 = tmp % dimz_;
+
+      if (reverse_)
+        return row1 * dimy_ * dimz_ + (dimy_ - col - 1) * dimz_ + col1;
+
+      return row1 * dimy_ * dimz_ + col * dimz_ + col1;
+    }
+  }
+
+  int dimx_;
+  int dimy_;
+  int dimz_;
+  bool reverse_;
+};
+
+template <typename T, typename Op>
+struct BlockPrefixCallbackOp {
+  // Running prefix
+  T running_total_;
+  Op op_;
+
+  __device__ BlockPrefixCallbackOp(T running_total, Op op)
+      : running_total_(running_total), op_(op) {}
+
+  // Callback operator to be entered by the first warp of threads in the block.
+  // tid 0 is responsible for returning a value for seeding the block-wide scan.
+  __device__ T operator()(T block_aggregate) {
+    T old_prefix = running_total_;
+    running_total_ = op_(old_prefix, block_aggregate);
+    return old_prefix;
+  }
+};
+
+template <typename T>
+struct Sum {
+  __host__ __device__ T operator()(const T& a, const T& b) const {
+    return a + b;
+  }
+};
+
+template <typename T>
+struct Prod {
+  __host__ __device__ T operator()(const T& a, const T& b) const {
+    return a * b;
+  }
+};
+
+template <typename T, typename Op>
+struct IsSum {
+  constexpr static bool value =
+      (std::is_same<Op, Sum<T>>::value ||
+       std::is_same<Op, Eigen::internal::SumReducer<T>>::value);
+};
+
+template <typename T, typename Op>
+struct IsProd {
+  constexpr static bool value =
+      (std::is_same<Op, Prod<T>>::value ||
+       std::is_same<Op, Eigen::internal::ProdReducer<T>>::value);
+};
+
+template <typename T, typename Op>
+struct IsLogSumExp {
+  constexpr static bool value = (std::is_same<Op, LogSumExp<T>>::value ||
+                                 std::is_same<Op, LogSumExpReducer<T>>::value);
+};
+
+template <typename T, typename Op>
+struct IdentityValue {
+  static_assert(IsSum<T, Op>::value || IsProd<T, Op>::value ||
+                    IsLogSumExp<T, Op>::value,
+                "IdentityValue not yet defined for this type.");
+
+  template <typename U = T, typename OpCopy = Op>
+  __host__ __device__ U operator()(
+      typename std::enable_if<IsSum<U, OpCopy>::value, U>::type t = U(0)) {
+    return t;
+  }
+
+  template <typename U = T, typename OpCopy = Op>
+  __host__ __device__ U operator()(
+      typename std::enable_if<IsProd<U, OpCopy>::value, U>::type t = U(1)) {
+    return t;
+  }
+
+  template <typename U = T, typename OpCopy = Op>
+  __host__ __device__ U
+  operator()(typename std::enable_if<IsLogSumExp<U, OpCopy>::value, U>::type t =
+                 U(Eigen::NumTraits<U>::lowest())) {
+    return t;
+  }
+};
+
+// Each block is mapped to one sequence.  A contiguous range is mapped to the
+// appropriate locations in memory by the permutation iterators.  This is
+// ideal for 1-D and row based scans.  Column scans would be better if they
+// did a block load and then locally transposed.  CUB's device wide scan is not
+// used in the large 1D case, even though it would be more efficient, because
+// it is not deterministic.
+template <typename T, typename Op, int BlockDim = 128, int ItemsPerThread = 4>
+__launch_bounds__(BlockDim) __global__
+    void scan_kernel(const T* in, T* out, int dimx, int dimy, int dimz,
+                     bool exclusive, bool reverse, Op op) {
+  typedef gpuprim::BlockLoad<T, BlockDim, ItemsPerThread,
+                             gpuprim::BLOCK_LOAD_TRANSPOSE>
+      BlockLoad;
+  typedef gpuprim::BlockStore<T, BlockDim, ItemsPerThread,
+                              gpuprim::BLOCK_STORE_TRANSPOSE>
+      BlockStore;
+  typedef gpuprim::BlockScan<T, BlockDim> BlockScan;
+
+  // Allocate aliased shared memory for BlockLoad, BlockStore, and BlockScan
+  __shared__ union {
+    typename BlockLoad::TempStorage load;
+    typename BlockScan::TempStorage scan;
+    typename BlockStore::TempStorage store;
+  } temp_storage;
+
+  int problem_length = dimy;
+
+  // Initialize running total
+  BlockPrefixCallbackOp<T, Op> prefix_op(IdentityValue<T, Op>()(), op);
+
+  MapIndexToLocation map_op(dimx, dimy, dimz, reverse);
+  int block_start = problem_length * blockIdx.x;
+  // Have the block iterate over segments of items
+  for (int block_offset = block_start;
+       block_offset < block_start + problem_length;
+       block_offset += BlockDim * ItemsPerThread) {
+    int valid_items = min(BlockDim * ItemsPerThread,
+                          problem_length - (block_offset % problem_length));
+
+    // first construct a counting iterator that has the desired start point
+    typedef gpuprim::TransformInputIterator<int, MapIndexToLocation,
+                                            gpuprim::CountingInputIterator<int>>
+        MapIterType;
+
+    gpuprim::CountingInputIterator<int> counting_iter(block_offset);
+
+    // Next map the iterator to the actual locations in memory
+    MapIterType map_iter(counting_iter, map_op);
+
+    PermutationInputIterator<T, const T*, MapIterType> permutein_iter(in,
+                                                                      map_iter);
+    PermutationOutputIterator<T, T*, MapIterType> permuteout_iter(out,
+                                                                  map_iter);
+
+    // Load a segment of consecutive items that are blocked across threads
+    T thread_data[ItemsPerThread];
+    BlockLoad(temp_storage.load).Load(permutein_iter, thread_data, valid_items);
+    __syncthreads();
+
+    // Collectively compute the block-wide scan
+    if (exclusive) {
+      BlockScan(temp_storage.scan)
+          .ExclusiveScan(thread_data, thread_data, op, prefix_op);
+    } else {
+      BlockScan(temp_storage.scan)
+          .InclusiveScan(thread_data, thread_data, op, prefix_op);
+    }
+    __syncthreads();
+
+    // Store scanned items to output segment
+    BlockStore(temp_storage.store)
+        .Store(permuteout_iter, thread_data, valid_items);
+    __syncthreads();
+  }
+}
+
+template <typename T, typename Op>
+void LaunchScan(const GPUDevice& d, typename TTypes<T, 3>::ConstTensor in,
+                typename TTypes<T, 3>::Tensor out, Op op, const bool reverse,
+                const bool exclusive) {
+  const int items_per_thread = 4;
+
+  int dimx = in.dimension(0);
+  int dimy = in.dimension(1);
+  int dimz = in.dimension(2);
+  int num_blocks = dimx * dimz;
+
+  int ideal_block_size = dimy / items_per_thread;
+  const int rocm_threads_per_warp = 64;
+  ideal_block_size = std::max(ideal_block_size, rocm_threads_per_warp);
+
+  // There seems to be a bug when the type is not float and block_size 1024.
+  // Launch on the smallest power of 2 block size that we can.
+  if (ideal_block_size >= 1024 && std::is_same<T, float>::value) {
+    const int block_size = 1024;
+    TF_CHECK_OK(
+        GpuLaunchKernel(scan_kernel<T, Op, block_size, items_per_thread>,
+                        num_blocks, block_size, 0, d.stream(), in.data(),
+                        out.data(), dimx, dimy, dimz, exclusive, reverse, op));
+  } else if (ideal_block_size >= 512) {
+    const int block_size = 512;
+    TF_CHECK_OK(
+        GpuLaunchKernel(scan_kernel<T, Op, block_size, items_per_thread>,
+                        num_blocks, block_size, 0, d.stream(), in.data(),
+                        out.data(), dimx, dimy, dimz, exclusive, reverse, op));
+  } else if (ideal_block_size >= 256) {
+    const int block_size = 256;
+    TF_CHECK_OK(
+        GpuLaunchKernel(scan_kernel<T, Op, block_size, items_per_thread>,
+                        num_blocks, block_size, 0, d.stream(), in.data(),
+                        out.data(), dimx, dimy, dimz, exclusive, reverse, op));
+  } else if (ideal_block_size >= 128) {
+    const int block_size = 128;
+    TF_CHECK_OK(
+        GpuLaunchKernel(scan_kernel<T, Op, block_size, items_per_thread>,
+                        num_blocks, block_size, 0, d.stream(), in.data(),
+                        out.data(), dimx, dimy, dimz, exclusive, reverse, op));
+#if TENSORFLOW_COMPILER_IS_HIP_CLANG
+    // HIP-CLANG has some kind of problem here with 32 threads (possibly because
+    // the warpsize is 64). Reenable when working properly
+  } else if (true) {
+#else
+  } else if (ideal_block_size >= 64) {
+#endif
+    const int block_size = 64;
+    TF_CHECK_OK(
+        GpuLaunchKernel(scan_kernel<T, Op, block_size, items_per_thread>,
+                        num_blocks, block_size, 0, d.stream(), in.data(),
+                        out.data(), dimx, dimy, dimz, exclusive, reverse, op));
+  } else {
+    const int block_size = 32;
+    TF_CHECK_OK(
+        GpuLaunchKernel(scan_kernel<T, Op, block_size, items_per_thread>,
+                        num_blocks, block_size, 0, d.stream(), in.data(),
+                        out.data(), dimx, dimy, dimz, exclusive, reverse, op));
+  }
+}
+
+template <typename T>
+struct Scan<GPUDevice, Eigen::internal::SumReducer<T>, T> {
+  void operator()(const GPUDevice& d, typename TTypes<T, 3>::ConstTensor in,
+                  typename TTypes<T, 3>::Tensor out,
+                  const Eigen::internal::SumReducer<T>& reducer,
+                  const bool reverse, const bool exclusive) {
+    LaunchScan<T, Sum<T>>(d, in, out, Sum<T>(), reverse, exclusive);
+  }
+};
+
+template <typename T>
+struct Scan<GPUDevice, Eigen::internal::ProdReducer<T>, T> {
+  void operator()(const GPUDevice& d, typename TTypes<T, 3>::ConstTensor in,
+                  typename TTypes<T, 3>::Tensor out,
+                  const Eigen::internal::ProdReducer<T>& reducer,
+                  const bool reverse, const bool exclusive) {
+    LaunchScan<T, Prod<T>>(d, in, out, Prod<T>(), reverse, exclusive);
+  }
+};
+
+template <typename T>
+struct Scan<GPUDevice, LogSumExpReducer<T>, T> {
+  void operator()(const GPUDevice& d, typename TTypes<T, 3>::ConstTensor in,
+                  typename TTypes<T, 3>::Tensor out,
+                  const LogSumExpReducer<T>& reducer, const bool reverse,
+                  const bool exclusive) {
+    LaunchScan<T, LogSumExp<T>>(d, in, out, LogSumExp<T>(), reverse, exclusive);
+  }
+};
+
+}  // namespace functor
+}  // end namespace tensorflow
+
+#endif  // GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+
+#endif  // TENSORFLOW_CORE_KERNELS_SCAN_OPS_GPU_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/scatter_functor.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/scatter_functor.h
new file mode 100644
index 0000000000000000000000000000000000000000..dcfae9b77626100a95f1365350113a6c8c56b9af
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/scatter_functor.h
@@ -0,0 +1,414 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_SCATTER_FUNCTOR_H_
+#define TENSORFLOW_CORE_KERNELS_SCATTER_FUNCTOR_H_
+
+#include <type_traits>
+
+#include "Eigen/Core"  // from @eigen_archive
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+#include "tensorflow/core/framework/bounds_check.h"
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/variant_op_registry.h"
+#include "tensorflow/core/kernels/dense_update_functor.h"
+#include "tensorflow/core/platform/types.h"
+#include "tensorflow/core/util/determinism.h"
+#include "tensorflow/core/util/work_sharder.h"
+
+namespace tensorflow {
+
+class OpKernelContext;
+typedef Eigen::ThreadPoolDevice CPUDevice;
+typedef Eigen::GpuDevice GPUDevice;
+
+namespace scatter_op {
+
+enum class UpdateOp { ASSIGN, ADD, SUB, MUL, DIV, MIN, MAX };
+
+namespace internal {
+
+template <scatter_op::UpdateOp Op>
+struct Assign {};
+template <>
+struct Assign<scatter_op::UpdateOp::ASSIGN> {
+  template <typename Params, typename Update>
+  static void Run(Params p, Update u) {
+    p = u;
+  }
+  template <typename Params, typename Update>
+  static void RunScalar(Params p, Update u) {
+    p.setConstant(u);
+  }
+};
+template <>
+struct Assign<scatter_op::UpdateOp::ADD> {
+  template <typename Params, typename Update>
+  static void Run(Params p, Update u) {
+    p += u;
+  }
+  template <typename Params, typename Update>
+  static void RunScalar(Params p, Update u) {
+    p = p + u;
+  }
+};
+template <>
+struct Assign<scatter_op::UpdateOp::SUB> {
+  template <typename Params, typename Update>
+  static void Run(Params p, Update u) {
+    p -= u;
+  }
+  template <typename Params, typename Update>
+  static void RunScalar(Params p, Update u) {
+    p = p + static_cast<Update>(-u);
+  }
+};
+template <>
+struct Assign<scatter_op::UpdateOp::MUL> {
+  template <typename Params, typename Update>
+  static void Run(Params p, Update u) {
+    p *= u;
+  }
+  template <typename Params, typename Update>
+  static void RunScalar(Params p, Update u) {
+    p = p * u;
+  }
+};
+template <>
+struct Assign<scatter_op::UpdateOp::DIV> {
+  template <typename Params, typename Update>
+  static void Run(Params p, Update u) {
+    p /= u;
+  }
+  template <typename Params, typename Update>
+  static void RunScalar(Params p, Update u) {
+    p = p / u;
+  }
+};
+template <>
+struct Assign<scatter_op::UpdateOp::MIN> {
+  // This method requires that Params and Update are tensor types.
+  template <typename Params, typename Update>
+  static void Run(Params p, Update u) {
+    p = p.cwiseMin(u);
+  }
+  // Same thing, but for Update being a scalar type.
+  template <typename Params, typename Update>
+  static void RunScalar(Params p, Update u) {
+    p = p.cwiseMin(u);
+  }
+};
+template <>
+struct Assign<scatter_op::UpdateOp::MAX> {
+  template <typename Params, typename Update>
+  static void Run(Params p, Update u) {
+    p = p.cwiseMax(u);
+  }
+  template <typename Params, typename Update>
+  static void RunScalar(Params p, Update u) {
+    p = p.cwiseMax(u);
+  }
+};
+
+
+}  // namespace internal
+}  // namespace scatter_op
+
+namespace functor {
+template <typename Device, typename T, typename Index, scatter_op::UpdateOp op>
+struct ScatterFunctor {
+  Index operator()(OpKernelContext* c, const Device& d,
+                   typename TTypes<T>::Matrix params,
+                   typename TTypes<T>::ConstMatrix updates,
+                   typename TTypes<Index>::ConstFlat indices);
+};
+
+template <typename Device, typename T, typename Index, scatter_op::UpdateOp op>
+struct ScatterFunctorBase {
+  Index ParallelExecute(OpKernelContext* c, const Device& d,
+                        typename TTypes<T>::Matrix params,
+                        typename TTypes<T>::ConstMatrix updates,
+                        typename TTypes<Index>::ConstFlat indices) {
+    const Index N = static_cast<Index>(indices.size());
+    const Index limit = static_cast<Index>(params.dimension(0));
+    const Index kMaxLocks = 1024;
+    const Index entries_per_lock = (limit + kMaxLocks - 1) / kMaxLocks;
+    // To reduce the number of locks and the memory usage, we divide the whole
+    // index space into kMaxLocks regions with each lock serializing access to
+    // a region.
+    mutex accessed[kMaxLocks];
+    std::atomic<Index> bad_index(-1);
+    auto ParallelScatter = [&](Index start, Index end) {
+      for (Index i = start; i < end; ++i) {
+        // Grab the index and check its validity.  Do this carefully,
+        // to avoid checking the value and grabbing it again from
+        // memory a second time (a security risk since it may change in
+        // between).
+        const Index index = ::tensorflow::internal::SubtleMustCopy(indices(i));
+        if (!FastBoundsCheck(index, limit)) {
+          bad_index = i;
+          return;
+        }
+        const Index lock_id = index / entries_per_lock;
+        // Copy last Ndim-1 dimensions of updates[i] to params[index]
+        {
+          mutex_lock l(accessed[lock_id]);
+          scatter_op::internal::Assign<op>::Run(params.template chip<0>(index),
+                                                updates.template chip<0>(i));
+        }
+      }
+    };
+    const float kMovingCost = 2.5f;
+    float shard_cost = kMovingCost * params.dimension(1);
+    const DeviceBase::CpuWorkerThreads& worker_threads =
+        *(c->device()->tensorflow_cpu_worker_threads());
+    Shard(worker_threads.num_threads, worker_threads.workers, N, shard_cost,
+          ParallelScatter);  // TODO: Come up with a good cost estimate.
+    return bad_index;
+  }
+  Index SerialExecute(OpKernelContext* c, const Device& d,
+                      typename TTypes<T>::Matrix params,
+                      typename TTypes<T>::ConstMatrix updates,
+                      typename TTypes<Index>::ConstFlat indices) {
+    const Index N = static_cast<Index>(indices.size());
+    const Index limit = static_cast<Index>(params.dimension(0));
+    for (Index i = 0; i < N; ++i) {
+      // Grab the index and check its validity.  Do this carefully,
+      // to avoid checking the value and grabbing it again from
+      // memory a second time (a security risk since it may change in
+      // between).
+      const Index index = ::tensorflow::internal::SubtleMustCopy(indices(i));
+      if (!FastBoundsCheck(index, limit)) return i;
+      // Copy last Ndim-1 dimensions of updates[i] to params[index]
+      scatter_op::internal::Assign<op>::Run(params.template chip<0>(index),
+                                            updates.template chip<0>(i));
+    }
+    return -1;
+  }
+
+  Index operator()(OpKernelContext* c, const Device& d,
+                   typename TTypes<T>::Matrix params,
+                   typename TTypes<T>::ConstMatrix updates,
+                   typename TTypes<Index>::ConstFlat indices) {
+#ifdef PLATFORM_GOOGLE
+    // The parallel version is significantly slower internally. Only call the
+    // serial version for now.
+    // TODO(penporn): Avoid locking in parallelization (sort beforehand).
+    return SerialExecute(c, d, params, updates, indices);
+#else
+    // indices and params sizes were validated in DoCompute().
+    const Index N = static_cast<Index>(indices.size());
+    const Index limit = static_cast<Index>(params.dimension(0));
+    const Index min_n_threshold = 1024;
+    const Index ser_par_ratio = 10000;
+    // For parallelizing the updates, duplicate entries need to be handled
+    // correctly. Multiple updates to the same index has to be serialized.
+    // This can lead to lock contention which may nullify the benefits of
+    // parallelization. Assuming uniform random distribution of the indices, we
+    // come up with a rough heuristic and determine whether the updates execute
+    // serially or parallelly. Also if 'N' is small, overheads of parallel
+    // execution outweigh its benefits and hence we check the value of N.
+    const bool execute_serial = N < min_n_threshold ||
+                                (N / limit) > ser_par_ratio ||
+                                OpDeterminismRequired();
+    if (execute_serial)
+      return SerialExecute(c, d, params, updates, indices);
+    else
+      return ParallelExecute(c, d, params, updates, indices);
+#endif  // PLATFORM_GOOGLE
+  }
+};
+
+template <typename Device, typename Index>
+struct ScatterFunctorVariantAssignBase {
+  Index operator()(OpKernelContext* c, const Device& d,
+                   typename TTypes<Variant>::Matrix params,
+                   typename TTypes<Variant>::ConstMatrix updates,
+                   typename TTypes<Index>::ConstFlat indices) {
+    // indices and params sizes were validated in DoCompute().
+    const Index N = static_cast<Index>(indices.size());
+    const Index limit = static_cast<Index>(params.dimension(0));
+    const Index cols = static_cast<Index>(params.dimension(1));
+    DCHECK_EQ(N, updates.dimension(0));
+    DCHECK_EQ(cols, updates.dimension(1));
+    for (Index i = 0; i < N; i++) {
+      // Grab the index and check its validity.  Do this carefully,
+      // to avoid checking the value and grabbing it again from
+      // memory a second time (a security risk since it may change in between).
+      const Index index = ::tensorflow::internal::SubtleMustCopy(indices(i));
+      if (!FastBoundsCheck(index, limit)) return i;
+      // Copy last Ndim-1 dimensions of updates[i] to params[index]
+      for (int j = 0; j < cols; ++j) {
+        const Variant& to_scatter = updates(i, j);
+        params(index, j) = to_scatter;
+      }
+    }
+    return -1;
+  }
+};
+
+template <typename Index>
+struct ScatterFunctor<CPUDevice, Variant, Index, scatter_op::UpdateOp::ASSIGN>
+    : ScatterFunctorVariantAssignBase<CPUDevice, Index> {};
+
+template <typename Index>
+struct ScatterFunctor<GPUDevice, Variant, Index, scatter_op::UpdateOp::ASSIGN>
+    : ScatterFunctorVariantAssignBase<GPUDevice, Index> {};
+
+
+template <typename T, typename Index>
+struct ScatterFunctorBase<CPUDevice, T, Index, scatter_op::UpdateOp::ASSIGN> {
+  Index operator()(OpKernelContext* c, const CPUDevice& d,
+                   typename TTypes<T>::Matrix params,
+                   typename TTypes<T>::ConstMatrix updates,
+                   typename TTypes<Index>::ConstFlat indices) {
+    // indices and params sizes were validated in DoCompute().
+    const Index N = static_cast<Index>(indices.size());
+    const Index limit = static_cast<Index>(params.dimension(0));
+    if (!std::is_same<T, tstring>::value) {
+      for (Index i = 0; i < N; i++) {
+        // Grab the index and check its validity.  Do this carefully,
+        // to avoid checking the value and grabbing it again from
+        // memory a second time (a security risk since it may change in
+        // between).
+        const Index index = ::tensorflow::internal::SubtleMustCopy(indices(i));
+        if (!FastBoundsCheck(index, limit)) return i;
+        memmove(params.data() + index * params.dimension(1),
+                updates.data() + i * updates.dimension(1),
+                updates.dimension(1) * sizeof(T));
+      }
+    } else {
+      for (Index i = 0; i < N; i++) {
+        // Grab the index and check its validity.  Do this carefully,
+        // to avoid checking the value and grabbing it again from
+        // memory a second time (a security risk since it may change in
+        // between).
+        const Index index = ::tensorflow::internal::SubtleMustCopy(indices(i));
+        if (!FastBoundsCheck(index, limit)) return i;
+        // Copy last Ndim-1 dimensions of updates[i] to params[index]
+        scatter_op::internal::Assign<scatter_op::UpdateOp::ASSIGN>::Run(
+            params.template chip<0>(index), updates.template chip<0>(i));
+      }
+    }
+    return -1;
+  }
+};
+
+template <typename T, typename Index, scatter_op::UpdateOp op>
+struct ScatterFunctor<CPUDevice, T, Index, op>
+    : ScatterFunctorBase<CPUDevice, T, Index, op> {};
+
+
+template <typename Device, typename T, typename Index, scatter_op::UpdateOp op>
+struct ScatterScalarFunctor {
+  Index operator()(OpKernelContext* c, const Device& d,
+                   typename TTypes<T>::Matrix params,
+                   const typename TTypes<T>::ConstScalar update,
+                   typename TTypes<Index>::ConstFlat indices);
+};
+
+template <typename Device, typename T, typename Index, scatter_op::UpdateOp op>
+struct ScatterScalarFunctorBase {
+  Index operator()(OpKernelContext* c, const Device& d,
+                   typename TTypes<T>::Matrix params,
+                   const typename TTypes<T>::ConstScalar update,
+                   typename TTypes<Index>::ConstFlat indices) {
+    // indices and params sizes were validated in DoCompute().
+    const Index N = static_cast<Index>(indices.size());
+    const Index limit = static_cast<Index>(params.dimension(0));
+    for (Index i = 0; i < N; i++) {
+      // Grab the index and check its validity.  Do this carefully,
+      // to avoid checking the value and grabbing it again from
+      // memory a second time (a security risk since it may change in between).
+      const Index index = ::tensorflow::internal::SubtleMustCopy(indices(i));
+      if (!FastBoundsCheck(index, limit)) return i;
+      // Broadcast update to params[index]
+      scatter_op::internal::Assign<op>::RunScalar(
+          params.template chip<0>(index), update());
+    }
+    return -1;
+  }
+};
+
+template <typename Device, typename Index>
+struct ScatterScalarFunctorVariantAssignBase {
+  Index operator()(OpKernelContext* c, const Device& d,
+                   typename TTypes<Variant>::Matrix params,
+                   const typename TTypes<Variant>::ConstScalar update,
+                   typename TTypes<Index>::ConstFlat indices) {
+    // indices and params sizes were validated in DoCompute().
+    const Index N = static_cast<Index>(indices.size());
+    const Index limit = static_cast<Index>(params.dimension(0));
+    const Index cols = static_cast<Index>(params.dimension(1));
+    const Variant& to_scatter = update();
+    for (Index i = 0; i < N; i++) {
+      // Grab the index and check its validity.  Do this carefully,
+      // to avoid checking the value and grabbing it again from
+      // memory a second time (a security risk since it may change in between).
+      const Index index = ::tensorflow::internal::SubtleMustCopy(indices(i));
+      if (!FastBoundsCheck(index, limit)) return i;
+      // Broadcast update to params[index]
+      for (Index j = 0; j < cols; ++j) {
+        params(index, j) = to_scatter;
+      }
+    }
+    return -1;
+  }
+};
+
+template <typename Index>
+struct ScatterScalarFunctor<CPUDevice, Variant, Index,
+                            scatter_op::UpdateOp::ASSIGN>
+    : ScatterScalarFunctorVariantAssignBase<CPUDevice, Index> {};
+template <typename Index>
+struct ScatterScalarFunctor<GPUDevice, Variant, Index,
+                            scatter_op::UpdateOp::ASSIGN>
+    : ScatterScalarFunctorVariantAssignBase<GPUDevice, Index> {};
+
+
+template <typename T, typename Index>
+struct ScatterScalarFunctorBase<CPUDevice, T, Index,
+                                scatter_op::UpdateOp::ASSIGN> {
+  Index operator()(OpKernelContext* c, const CPUDevice& d,
+                   typename TTypes<T>::Matrix params,
+                   const typename TTypes<T>::ConstScalar update,
+                   typename TTypes<Index>::ConstFlat indices) {
+    // indices and params sizes were validated in DoCompute().
+    const Index N = static_cast<Index>(indices.size());
+    const Index limit = static_cast<Index>(params.dimension(0));
+    for (Index i = 0; i < N; i++) {
+      // Grab the index and check its validity.  Do this carefully,
+      // to avoid checking the value and grabbing it again from
+      // memory a second time (a security risk since it may change in between).
+      const Index index = ::tensorflow::internal::SubtleMustCopy(indices(i));
+      if (!FastBoundsCheck(index, limit)) return i;
+      // Broadcast update to params[index]
+      scatter_op::internal::Assign<scatter_op::UpdateOp::ASSIGN>::RunScalar(
+          params.template chip<0>(index), update());
+    }
+    return -1;
+  }
+};
+
+template <typename T, typename Index, scatter_op::UpdateOp op>
+struct ScatterScalarFunctor<CPUDevice, T, Index, op>
+    : ScatterScalarFunctorBase<CPUDevice, T, Index, op> {};
+
+
+}  // namespace functor
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_SCATTER_FUNCTOR_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/scatter_functor_gpu.cu.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/scatter_functor_gpu.cu.h
new file mode 100644
index 0000000000000000000000000000000000000000..61868b7853e4000e020f6f1bb62f7ad46e32d90d
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/scatter_functor_gpu.cu.h
@@ -0,0 +1,179 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_SCATTER_FUNCTOR_GPU_CU_H_
+#define TENSORFLOW_CORE_KERNELS_SCATTER_FUNCTOR_GPU_CU_H_
+
+#if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+
+#define EIGEN_USE_GPU
+
+#include "tensorflow/core/framework/tensor_types.h"
+#include "tensorflow/core/kernels/scatter_functor.h"
+#include "tensorflow/core/platform/types.h"
+#include "tensorflow/core/util/gpu_kernel_helper.h"
+
+namespace tensorflow {
+
+typedef Eigen::GpuDevice GPUDevice;
+
+namespace scatter_op_gpu {
+
+template <typename T, scatter_op::UpdateOp op>
+struct ScatterOpKernelBody;
+
+template <typename T>
+struct ScatterOpKernelBody<T, scatter_op::UpdateOp::ASSIGN> {
+  __device__ void operator()(T* __restrict__ dest, T src) const { *dest = src; }
+};
+
+template <typename T>
+struct ScatterOpKernelBody<T, scatter_op::UpdateOp::ADD> {
+  __device__ void operator()(T* __restrict__ dest, T src) const {
+    GpuAtomicAdd(dest, src);
+  }
+};
+
+template <typename T>
+struct ScatterOpKernelBody<T, scatter_op::UpdateOp::SUB> {
+  __device__ void operator()(T* __restrict__ dest, T src) const {
+    GpuAtomicSub(dest, src);
+  }
+};
+
+template <typename T>
+struct ScatterOpKernelBody<T, scatter_op::UpdateOp::MUL> {
+  __device__ void operator()(T* __restrict__ dest, T src) const {
+    GpuAtomicMul(dest, src);
+  }
+};
+
+template <typename T>
+struct ScatterOpKernelBody<T, scatter_op::UpdateOp::DIV> {
+  __device__ void operator()(T* __restrict__ dest, T src) const {
+    GpuAtomicDiv(dest, src);
+  }
+};
+
+template <typename T>
+struct ScatterOpKernelBody<T, scatter_op::UpdateOp::MIN> {
+  __device__ void operator()(T* __restrict__ dest, T src) const {
+    GpuAtomicMin(dest, src);
+  }
+};
+
+template <typename T>
+struct ScatterOpKernelBody<T, scatter_op::UpdateOp::MAX> {
+  __device__ void operator()(T* __restrict__ dest, T src) const {
+    GpuAtomicMax(dest, src);
+  }
+};
+
+template <typename T, typename Index, scatter_op::UpdateOp op>
+__global__ void ScatterOpCustomKernel(T* __restrict__ params,
+                                      const T* __restrict__ updates,
+                                      const Index* __restrict__ indices,
+                                      Index first_dim_size, Index updates_size,
+                                      Index indices_size) {
+  Index update_block = updates_size / indices_size;
+  ScatterOpKernelBody<T, op> body;
+  GPU_1D_KERNEL_LOOP(i, updates_size) {
+    int indices_i = i / update_block;
+    int updates_i = i;
+    int param_first_index = indices[indices_i];
+    if (!(param_first_index >= 0 && param_first_index < first_dim_size)) {
+      // Ignore indices that are out of range.
+      continue;
+    }
+    int64 params_i = param_first_index * update_block + (i % update_block);
+    body(&params[params_i], ldg(updates + updates_i));
+  }
+}
+
+template <typename T, typename Index, scatter_op::UpdateOp op>
+__global__ void ScatterScalarOpCustomKernel(T* __restrict__ params,
+                                            const T* __restrict__ update,
+                                            const Index* __restrict__ indices,
+                                            Index first_dim_size,
+                                            Index indices_size,
+                                            Index synthesized_updates_size) {
+  Index update_block = synthesized_updates_size / indices_size;
+  ScatterOpKernelBody<T, op> body;
+  GPU_1D_KERNEL_LOOP(i, synthesized_updates_size) {
+    int indices_i = i / update_block;
+    int param_first_index = indices[indices_i];
+    const T update_val = *update;
+    if (!(param_first_index >= 0 && param_first_index < first_dim_size)) {
+      // Ignore indices that are out of range.
+      continue;
+    }
+    int params_i = param_first_index * update_block + (i % update_block);
+    body(&params[params_i], update_val);
+  }
+}
+
+}  // namespace scatter_op_gpu
+
+namespace functor {
+// Specialization for a GPU device.
+template <typename T, typename Index, scatter_op::UpdateOp op>
+struct ScatterFunctor<GPUDevice, T, Index, op> {
+  Index operator()(OpKernelContext* c, const GPUDevice& d,
+                   typename TTypes<T>::Matrix params,
+                   typename TTypes<T>::ConstMatrix updates,
+                   typename TTypes<Index>::ConstFlat indices) {
+    // TODO(b/31801742): Implement indices range check. The hardest part is
+    // with returning a value after the range check, as we do not want to do
+    // device to host memcpy during a stream.
+    const Index first_dim_size = params.dimension(0);
+    const Index indices_size = indices.size();
+    const Index updates_size = updates.size();
+    GpuLaunchConfig config = GetGpuLaunchConfig(updates_size, d);
+    TF_CHECK_OK(GpuLaunchKernel(
+        scatter_op_gpu::ScatterOpCustomKernel<T, Index, op>, config.block_count,
+        config.thread_per_block, 0, d.stream(), params.data(), updates.data(),
+        indices.data(), first_dim_size, updates_size, indices_size));
+    return -1;
+  }
+};
+
+template <typename T, typename Index, scatter_op::UpdateOp op>
+struct ScatterScalarFunctor<GPUDevice, T, Index, op> {
+  Index operator()(OpKernelContext* c, const GPUDevice& d,
+                   typename TTypes<T>::Matrix params,
+                   const typename TTypes<T>::ConstScalar update,
+                   typename TTypes<Index>::ConstFlat indices) {
+    // TODO(b/31801742): Implement indices range check. The hardest part is
+    // with returning a value after the range check, as we do not want to do
+    // device to host memcpy during a stream.
+    const Index first_dim_size = params.dimension(0);
+    const Index indices_size = indices.size();
+    const Index synthesized_updates_size = indices_size * params.dimension(1);
+    GpuLaunchConfig config = GetGpuLaunchConfig(synthesized_updates_size, d);
+    TF_CHECK_OK(GpuLaunchKernel(
+        scatter_op_gpu::ScatterScalarOpCustomKernel<T, Index, op>,
+        config.block_count, config.thread_per_block, 0, d.stream(),
+        params.data(), update.data(), indices.data(), first_dim_size,
+        indices_size, synthesized_updates_size));
+    return -1;
+  }
+};
+
+}  // namespace functor
+}  // namespace tensorflow
+
+#endif  // GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+
+#endif  // TENSORFLOW_CORE_KERNELS_SCATTER_FUNCTOR_GPU_CU_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/scatter_nd_op.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/scatter_nd_op.h
new file mode 100644
index 0000000000000000000000000000000000000000..f9a2ce0ed6e12baba756dd4986e415f7502cc39f
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/scatter_nd_op.h
@@ -0,0 +1,74 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_SCATTER_ND_OP_H_
+#define TENSORFLOW_CORE_KERNELS_SCATTER_ND_OP_H_
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+
+#include "tensorflow/core/framework/bounds_check.h"
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/register_types.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/tensor_shape.h"
+#include "tensorflow/core/kernels/fill_functor.h"
+#include "tensorflow/core/platform/mutex.h"
+#include "tensorflow/core/platform/types.h"
+#include "tensorflow/core/util/util.h"
+
+namespace tensorflow {
+
+typedef Eigen::ThreadPoolDevice CPUDevice;
+
+class OpKernelContext;
+
+namespace scatter_nd_op {
+
+enum class UpdateOp { ASSIGN, ADD, SUB, MIN, MAX };
+
+}  // namespace scatter_nd_op
+
+namespace functor {
+
+// Functor used by ScatterOp to do the computations.
+template <typename Device, typename T, typename Index,
+          scatter_nd_op::UpdateOp op, int IXDIM>
+struct ScatterNdFunctor {
+  // Returns -1 on success or a nonnegative i s.t. indices[i] is a bad index.
+  Index operator()(
+      const Device& d, const Index slice_size,
+      const Eigen::array<Eigen::DenseIndex, IXDIM> output_shape_prefix,
+      typename TTypes<T, 2>::Tensor Tparams,
+      typename TTypes<Index, 2>::ConstTensor Tindices,
+      typename TTypes<T, 2>::ConstTensor Tupdates,
+      typename TTypes<T, 2>::Tensor Toutput);
+};
+
+// Scatter updates into indices in Tensor out.  The argument allocate
+// controls whether 'out' should be created.  If allocate is true,
+// *out will be updated to the scattered tensor upon successful completion.
+// If allocate is false, out must point to a Tensor allocated with the
+// right type (T) and shape.  This tensor will not be zeroed out
+// before the scatter is executed.
+template <typename Device, typename T, typename Index,
+          scatter_nd_op::UpdateOp Op>
+Status DoScatterNd(OpKernelContext* c, const Tensor& indices,
+                   const Tensor& updates, const TensorShape& shape, Tensor* out,
+                   bool allocate);
+
+}  // namespace functor
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_SCATTER_ND_OP_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/scatter_nd_op_cpu_impl.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/scatter_nd_op_cpu_impl.h
new file mode 100644
index 0000000000000000000000000000000000000000..b0123780cc6406a80abccaaafc51b42ba29ec694
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/scatter_nd_op_cpu_impl.h
@@ -0,0 +1,197 @@
+/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_SCATTER_ND_OP_CPU_IMPL_H_
+#define TENSORFLOW_CORE_KERNELS_SCATTER_ND_OP_CPU_IMPL_H_
+
+// Functor definitions for ScatterND ops, must be compilable by nvcc.
+
+#define EIGEN_USE_THREADS
+
+#include <atomic>
+
+#include "unsupported/Eigen/CXX11/Tensor"  // from @eigen_archive
+
+#include "tensorflow/core/framework/bounds_check.h"
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/register_types.h"
+#include "tensorflow/core/framework/tensor.h"
+#include "tensorflow/core/framework/tensor_shape.h"
+#include "tensorflow/core/kernels/fill_functor.h"
+#include "tensorflow/core/kernels/scatter_nd_op.h"
+#include "tensorflow/core/platform/mutex.h"
+#include "tensorflow/core/platform/types.h"
+#include "tensorflow/core/util/util.h"
+
+namespace tensorflow {
+
+typedef Eigen::ThreadPoolDevice CPUDevice;
+
+class OpKernelContext;
+
+// Specialization of UpdateExecutor to CPU
+namespace update_executor {
+
+template <typename T, typename Input, typename Update, typename Output,
+          scatter_nd_op::UpdateOp OP>
+class UpdateExecutor {
+ public:
+  EIGEN_STRONG_INLINE static void Execute(const T& device, Input value,
+                                          Update update, Output output);
+};
+
+template <typename T, typename Input, typename Update, typename Output>
+class UpdateExecutor<T, Input, Update, Output,
+                     scatter_nd_op::UpdateOp::ASSIGN> {
+ public:
+  EIGEN_STRONG_INLINE static void Execute(const T& device, Input /* input */,
+                                          Update update, Output output) {
+    output.device(device) = update;
+  }
+};
+
+template <typename T, typename Input, typename Update, typename Output>
+class UpdateExecutor<T, Input, Update, Output, scatter_nd_op::UpdateOp::ADD> {
+ public:
+  EIGEN_STRONG_INLINE static void Execute(const T& device, Input /* input */,
+                                          Update update, Output output) {
+    output.device(device) += update;
+  }
+};
+
+template <typename T, typename Input, typename Update, typename Output>
+class UpdateExecutor<T, Input, Update, Output, scatter_nd_op::UpdateOp::SUB> {
+ public:
+  EIGEN_STRONG_INLINE static void Execute(const T& device, Input /* input */,
+                                          Update update, Output output) {
+    output.device(device) -= update;
+  }
+};
+
+template <typename T, typename Input, typename Update, typename Output>
+class UpdateExecutor<T, Input, Update, Output, scatter_nd_op::UpdateOp::MIN> {
+ public:
+  EIGEN_STRONG_INLINE static void Execute(const T& device, Input /* input */,
+                                          Update update, Output output) {
+    output.device(device) = output.cwiseMin(update);
+  }
+};
+
+template <typename T, typename Input, typename Update, typename Output>
+class UpdateExecutor<T, Input, Update, Output, scatter_nd_op::UpdateOp::MAX> {
+ public:
+  EIGEN_STRONG_INLINE static void Execute(const T& device, Input /* input */,
+                                          Update update, Output output) {
+    output.device(device) = output.cwiseMax(update);
+  }
+};
+
+}  // namespace update_executor
+
+namespace functor {
+
+// Implementation of update functor for CPU.
+template <typename T, typename Index, scatter_nd_op::UpdateOp OP, int IXDIM>
+struct ScatterNdFunctor<CPUDevice, T, Index, OP, IXDIM> {
+  Index operator()(
+      const CPUDevice& d, const Index slice_size,
+      const Eigen::array<Eigen::DenseIndex, IXDIM> output_shape_prefix,
+      typename TTypes<T, 2>::Tensor Tparams,
+      typename TTypes<Index, 2>::ConstTensor Tindices,
+      typename TTypes<T, 2>::ConstTensor Tupdates,
+      typename TTypes<T, 2>::Tensor Toutput) {
+    // error_loc is -1 if there's no out-of-bounds index,
+    // otherwise it is the location of an OOB index in Tindices.
+    Index error_loc = -1;
+
+    const Eigen::DenseIndex batch_size = Tindices.dimension(0);
+
+    Index batch_strides[IXDIM];
+    if (IXDIM > 0) {
+      batch_strides[IXDIM - 1] = 1;
+    }
+    for (int dim = IXDIM - 2; dim >= 0; --dim) {
+      batch_strides[dim] =
+          batch_strides[dim + 1] * output_shape_prefix[dim + 1];
+    }
+
+    for (Eigen::DenseIndex loc = 0; loc < batch_size; ++loc) {
+      Index i = 0;
+      bool out_of_bounds = false;
+      for (int dim = 0; dim < IXDIM; ++dim) {
+        const Index ix_d = internal::SubtleMustCopy(Tindices(loc, dim));
+        out_of_bounds |= !FastBoundsCheck(ix_d, output_shape_prefix[dim]);
+        i += ix_d * batch_strides[dim];
+      }
+      if (TF_PREDICT_FALSE(out_of_bounds)) {
+        error_loc = loc;
+        break;
+      } else {
+        auto input_chip = Toutput.template chip<0>(i);
+        auto output_chip = input_chip;
+        auto update_chip = Tupdates.template chip<0>(loc);
+        update_executor::UpdateExecutor<
+            CPUDevice, decltype(input_chip), decltype(update_chip),
+            decltype(output_chip), OP>::Execute(d, input_chip, update_chip,
+                                                output_chip);
+      }
+    }
+
+    return error_loc;
+  }
+};
+
+#define REGISTER_SCATTER_ND_FULL(T, Index, op)                               \
+  template Index                                                             \
+  ScatterNdFunctor<CPUDevice, T, Index, op, CPU_PROVIDED_IXDIM>::operator()( \
+      const CPUDevice& d, const Index slice_size,                            \
+      const Eigen::array<Eigen::DenseIndex, CPU_PROVIDED_IXDIM>              \
+          output_shape_prefix,                                               \
+      typename TTypes<T, 2>::Tensor Tparams,                                 \
+      typename TTypes<Index, 2>::ConstTensor Tindices,                       \
+      typename TTypes<T, 2>::ConstTensor Tupdates,                           \
+      typename TTypes<T, 2>::Tensor Toutput)
+
+#define REGISTER_SCATTER_ND_INDEX(type, op)  \
+  REGISTER_SCATTER_ND_FULL(type, int32, op); \
+  REGISTER_SCATTER_ND_FULL(type, int64, op)
+
+#define REGISTER_SCATTER_ND_UPDATE(type) \
+  REGISTER_SCATTER_ND_INDEX(type, scatter_nd_op::UpdateOp::ASSIGN);
+
+#define REGISTER_SCATTER_ND_MATH(type)                           \
+  REGISTER_SCATTER_ND_INDEX(type, scatter_nd_op::UpdateOp::ADD); \
+  REGISTER_SCATTER_ND_INDEX(type, scatter_nd_op::UpdateOp::SUB);
+
+#define REGISTER_SCATTER_ND_MIN_MAX(type)                        \
+  REGISTER_SCATTER_ND_INDEX(type, scatter_nd_op::UpdateOp::MAX); \
+  REGISTER_SCATTER_ND_INDEX(type, scatter_nd_op::UpdateOp::MIN);
+
+TF_CALL_ALL_TYPES(REGISTER_SCATTER_ND_UPDATE);
+REGISTER_SCATTER_ND_INDEX(tstring, scatter_nd_op::UpdateOp::ADD);
+TF_CALL_NUMBER_TYPES(REGISTER_SCATTER_ND_MATH);
+TF_CALL_REAL_NUMBER_TYPES(REGISTER_SCATTER_ND_MIN_MAX);
+TF_CALL_bool(REGISTER_SCATTER_ND_MATH);
+
+#undef REGISTER_SCATTER_ND_MATH
+#undef REGISTER_SCATTER_ND_MIN_MAX
+#undef REGISTER_SCATTER_ND_UPDATE
+#undef REGISTER_SCATTER_ND_INDEX
+#undef REGISTER_SCATTER_ND_FULL
+}  // namespace functor
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_SCATTER_ND_OP_CPU_IMPL_H_
diff --git a/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/scatter_nd_util.h b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/scatter_nd_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..ae78a6abad3a0db15db74564a8c30907ca321486
--- /dev/null
+++ b/miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/core/kernels/scatter_nd_util.h
@@ -0,0 +1,47 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CORE_KERNELS_SCATTER_ND_UTIL_H_
+#define TENSORFLOW_CORE_KERNELS_SCATTER_ND_UTIL_H_
+
+#include "tensorflow/core/framework/tensor_shape.h"
+#include "tsl/util/env_var.h"
+
+namespace tensorflow {
+
+// Validates the input shapes for the ScatterNdUpdateOp<scatter_nd_op::UpdateOp>
+Status ValidateScatterNdUpdateShape(const TensorShape& params_shape,
+                                    const TensorShape& indices_shape,
+                                    const TensorShape& updates_shape);
+
+inline bool DisableScatterOpDeterminism() {
+  static bool cached_disable = [] {
+    bool disable = false;
+    // When determinism is enabled, the kernels for various scatter ops like
+    // ScatterNdAdd will still use the faster non-deterministic versions if this
+    // environmental variable is true. This is useful if the user is certain the
+    // scatter inputs don't have duplicate indices (in which cases scatter ops
+    // are always deterministic), since the deterministic implementations are
+    // currently slow.
+    TF_CHECK_OK(tsl::ReadBoolFromEnvVar("TF_DISABLE_SCATTER_OP_DETERMINISM",
+                                        /*default_val=*/false, &disable));
+    return disable;
+  }();
+  return cached_disable;
+}
+
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CORE_KERNELS_SCATTER_ND_UTIL_H_